精华内容
下载资源
问答
  • 音标:英[ˈkʌstəməri]美[ˈkʌstəmeri]adj.习惯;通常;照惯例n.习惯法;风俗志网络习惯;通常;...sealed the deal with the customary handshake2.commonly used or practiced; usua...

    音标:英[ˈkʌstəməri]美[ˈkʌstəmeri]

    adj.习惯的;通常的;照惯例的

    n.习惯法;风俗志

    网络习惯的;通常的;习惯性的;习惯上

    英英释义

    noun

    1.in accordance with convention or custom;

    sealed the deal with the customary handshake

    2.commonly used or practiced; usual;

    his accustomed thoroughness

    网络释义

    1 . 习惯的

    ...curve 曲线,弯曲(物);弄弯,成曲线customary习惯的,惯例的cylinder 圆筒,圆柱体,汽缸

    2 . 通常的

    词性变化 word-activitycustomaryadj. 习惯的,通常的It is customaryto give people gifts on their birt.

    3 . 习惯性的

    custom 习惯;风俗customary习惯性的customer 顾客

    4 . 习惯上

    It is customaryto bring a gift ., 习惯上 , 要带来一件礼物.

    展开全文
  • git --help(中文翻译

    2019-06-24 20:36:58
    翻译一下git帮助文档,帮助记忆 首先在命令行输入 git --help 会得到下面帮助信息 下面是逐行翻译 These are common Git commands used in various situations: 下面是各种情况下比较常见git命令 ...

    翻译一下git的帮助文档,帮助记忆

    首先在命令行输入

    git --help

    会得到下面的帮助信息

     

    下面是逐行翻译

    These are common Git commands used in various situations:

    下面是各种情况下比较常见的git命令

    start a working area (see also: git help tutorial)

    开始工作(同样可以使用git help tutorial查看)
       clone      Clone a repository into a new directory

                      克隆一个仓库到新的文件夹
       init       Create an empty Git repository or reinitialize an existing one

                   创建一个空的git仓库或者重置已经存在的仓库

    work on the current change (see also: git help everyday)

    和当前更改相关的(同样可以使用git help everyday查看)
       add        Add file contents to the index

                     将文件内容添加到索引
       mv         Move or rename a file, a directory, or a symlink

                     移动或者重命名文件、文件夹、链接
       reset      Reset current HEAD to the specified state

                     重置当前的HEAD为指定状态
       rm         Remove files from the working tree and from the index

                    从当前的工作树和索引中删除文件

    examine the history and state (see also: git help revisions)

    查看历史记录和状态(同样可以使用git help revisions查看)
       bisect     Use binary search to find the commit that introduced a bug

                      使用二分查找来锁定哪次提交引入的bug  /*看起来有点麻烦。*/
       grep       Print lines matching a pattern

                     打印复合正则的文件行
       log        Show commit logs

                    展示提交的日志信息
       show       Show various types of objects

                      展示各种各样的对象信息  /*支持提交、标签、文件等对象*/
       status     Show the working tree status

                      展示当前工作树的状态信息

    grow, mark and tweak your common history

    对于常见的历史信息的一系列操作
       branch     List, create, or delete branches

                         列出、创建或者删除分支
       checkout   Switch branches or restore working tree files

                        切换分支或者恢复工作树的文件
       commit     Record changes to the repository

                        记录对仓库的更改
       diff       Show changes between commits, commit and working tree, etc

                   展示不同提交、不同工作树之间的区别
       merge      Join two or more development histories together

                        合并两个或更多的开发历史
       rebase     Reapply commits on top of another base tip

                      在另一个基本提示上重新应用提交   /*不是很懂 */
       tag        Create, list, delete or verify a tag object signed with GPG

                    新建、列出、删除或者确认一个使用GPG签名的标签对象  /*GPG是什么?*/

    collaborate (see also: git help workflows)

    协作(同样可以使用git help workflows查看)
       fetch      Download objects and refs from another repository

                     从另一个仓库下载对象和指针
       pull       Fetch from and integrate with another repository or a local branch

                    从另一个仓库或者本地分支拉取并合并
       push       Update remote refs along with associated objects

                      使用相关的对象更新远程引用

    'git help -a' and 'git help -g' list available subcommands and some concept guides.

    使用git help -a 和git help -g 来列出可用的子命令和一些概念指导

    See 'git help <command>' or 'git help <concept>' to read about a specific subcommand or concept.

    使用 git help <command> 或者 git help <concept> 来查看关于指定的命令或者概念的说明
     

     

    展开全文
  • The JPEG method is more often used for photographs, while the GIF method is commonly used for line art and other images in which geometric shapes are relatively simple. 图像压缩是指在不影响图像质量,...
  • 另外, 对核心库的中文化是个工作量更大的挑战, 因为包括文档的翻译, 而且可能会有不可能汉化的部分(比如无法用一个新interface取代Iterable的问题). 这里是尝试对Java核心库的汉化. 比如ArrayList汉化成"数组...
  • 用户打开一份word文档内嵌pdf文件时弹出这个提示:The program used to create this object is AcroExch. That program is not installed on your computeror ...翻译中文是:用于创建此对象程序是AcroExch,...

    用户打开一份word文档内嵌的pdf文件时弹出这个提示:The program used to create this object is AcroExch. That program is not installed on your computer or it is not responding.翻译成中文是:用于创建此对象的程序是AcroExch,此程序在你电脑上没有安装或没有反应。

    解决方法很简单:

    Disabling Protected Mode in Adobe Reader X

    Open Adobe Reader X.

    From Edit menu select Preferences, Preferences dialog box appears.

    Select General category on the list, uncheck or remove tick mark for “Enable protected mode at startup”

    Simply Close and reopen the application and the embedded object should now open perfectly

     

    参考:http://forums.adobe.com/thread/452958



















    本文转simmy51CTO博客,原文链接:http://blog.51cto.com/helpdesk/566915,如需转载请自行联系原作者

    展开全文
  • Gas 翻译中文就是“燃气”,是以太坊世界燃料,它决定了以太坊网络生态系统正常运行。Gas 用来衡量执行某些动作需要多少“工作量”,这些“工作量”就是为了执行该动作支付给网络费用额。通俗理解,Gas 是...

    1. gas是什么。

         Gas 翻译成中文就是“燃气”,是以太坊世界的燃料,它决定了以太坊网络生态系统的正常运行。Gas 用来衡量执行某些动作需要多少“工作量”,这些“工作量”就是为了执行该动作支付给网络的费用额。通俗理解,Gas 是给矿工的佣金,并以 ETH 支付,无论是交易、执行智能合约并启动 DApps,还是支付数据存储费用,都需要用到 Gas。

         以太坊在区块链上实现了一个运行环境,被称为以太坊虚拟机(EVM)。每个参与到网络的节点都会运行都会运行EVM作为区块验证协议的一部分。他们会验证区块中涵盖的每个交易并在EVM中运行交易所触发的代码。每个网络中的全节点都会进行相同的计算并储存相同的值。合约执行会在所有节点中被多次重复,这个事实得使得合约执行的消耗变得昂贵,所以这也促使大家将能在链下进行的运算都不放到区块链上进行。对于每个被执行的命令都会有一个特定的消耗,用单位gas计数。每个合约可以利用的命令都会有一个相应的gas值。gas使用ETH来支付。

          以太坊的黄皮书gas消耗规则如下图:

    • Gzero:0字节消耗4个gas
    • Gtxdatanonzero:非0的字节消耗68个gas
    • Gtransaction:每个交易要支付的21000个gas

         gas、gasPrice都能由用户指定的,在测试私链中,这两个值的默认值会按照发送交易设置的最大值填充下一次交易值,若不指定,gas会默认最小值21000,gasprice决定交易被打包的优先级,一般根据自己的数据量和合约内容估计填写。

    每个指令价目表https://docs.google.com/spreadsheets/d/1m89CVujrQe5LAFJ8-YAUCcNK950dUzMQPMJBxRtGCqs/edit#gid=0

    gasPrice 以Gwei为单位默认0.05 Gwei 当前区块GasPrice:60Gwei,见https://ethstats.net/

    2. Gas的费用(fee)组成

          由两个部分组成: Gas limit(限制)* Gas Price(价格)

    []      Gas Price 是 Gwei 的数量,是指用户愿意花费于每个 Gas 单位的价钱,frontier版 默认为 0.05 Gwei。

    []      Gas Limit根据扮演角色的主客观区分,分为用户交易gaslimit(代码中通常记tx.Gas())与旷工区块gaslimit(代码中通常记herader.GasLimit)。

    • 用户交易gaslimit:用户愿意为执行某个操作或确认交易支付的最大Gas量(最少21,000),至于花费这些Gas量是否能完成工作是不确定的。

             每笔交易都被要求包括一个gas limit(有的时候被称为startGas)和一个gas。矿工可以有选择的打包这些交易并收取这些费用。在现实中,今天所有的交易最终都是由矿工选择的,但是用户所选择支付的交易费用多少会影响到该交易被打包所需等待的时长。如果该交易由于计算,包括原始消息和一些触发的其他消息,需要使用的gas数量小于或等于所设置的gas limit,那么这个交易会被处理。如果gas总消耗超过gas limit,那么所有的操作都会被复原,但交易是成立的并且交易费任会被矿工收取。区块链会显示这笔交易完成尝试,但因为没有提供足够的gas导致所有的合约命令都被复原。所以交易里没有被使用的超量gas都会以以太币的形式打回给交易发起者。因为gas消耗一般只是一个大致估算,所以许多用户会超额支付gas来保证他们的交易会被接受。这没什么问题,因为多余的gas会被退回给你。

    以太坊关于交易的结构体,和其包含的Price、GasLimit:

    type Transaction struct {
    	data txdata
    	// caches
    	hash atomic.Value
    	size atomic.Value
    	from atomic.Value
    }
    
    type txdata struct {
    	AccountNonce uint64          `json:"nonce"    gencodec:"required"`
    	Price        *big.Int        `json:"gasPrice" gencodec:"required"`//用户为每个gas出单价
    	GasLimit     uint64          `json:"gas"      gencodec:"required"`//用户愿意支付的最大gas量
    	Recipient    *common.Address `json:"to"       rlp:"nil"` // nil means contract creation
    	Amount       *big.Int        `json:"value"    gencodec:"required"`
    	Payload      []byte          `json:"input"    gencodec:"required"`
    
    	// Signature values
    	V *big.Int `json:"v" gencodec:"required"`
    	R *big.Int `json:"r" gencodec:"required"`
    	S *big.Int `json:"s" gencodec:"required"`
    
    	// This is only used when marshaling to JSON.
    	Hash *common.Hash `json:"hash" rlp:"-"`
    }
    • 旷工区块gaslimit:区块gas limit是单个区块允许的最多gas总量,以此可以用来决定单个区块中能打包多少笔交易。

             例如,我们有5笔交易的gas limit分别是10、20、30、40和50.如果区块gas limit是100,那么前4笔交易就能被成功打包进入这个区块。矿工有权决定将哪些交易打包入区块。所以,另一个矿工可以选择打包最后两笔交易进入这个区块(50+40),然后再将第一笔交易打包(10)。如果你尝试将一个会使用超过当前区块gas limit的交易打包,这个交易会被网络拒绝,你的以太坊客户端会反馈错误"交易超过区块gas limit"。

    假如目前区块的gas limit是 4,712,357 gas,这表示着大约224笔转账交易(gas limit为21000)可以被塞进一个区块(区块时间大约在15-20秒间波动)。这个协议允许每个区块的矿工调整区块gas limit,任意加减 1/20240.0976%)。

    以太坊关于区块gaslimit,包含在Header结构体中:

    type Header struct {
    	ParentHash  common.Hash    `json:"parentHash"       gencodec:"required"`
    	UncleHash   common.Hash    `json:"sha3Uncles"       gencodec:"required"`
    	Coinbase    common.Address `json:"miner"            gencodec:"required"`
    	Root        common.Hash    `json:"stateRoot"        gencodec:"required"`
    	TxHash      common.Hash    `json:"transactionsRoot" gencodec:"required"`
    	ReceiptHash common.Hash    `json:"receiptsRoot"     gencodec:"required"`
    	Bloom       Bloom          `json:"logsBloom"        gencodec:"required"`
    	Difficulty  *big.Int       `json:"difficulty"       gencodec:"required"`
    	Number      *big.Int       `json:"number"           gencodec:"required"`
    	GasLimit    uint64         `json:"gasLimit"         gencodec:"required"`//区块gaslimit
    	GasUsed     uint64         `json:"gasUsed"          gencodec:"required"`//区块已用gas
    	Time        *big.Int       `json:"timestamp"        gencodec:"required"`
    	Extra       []byte         `json:"extraData"        gencodec:"required"`
    	MixDigest   common.Hash    `json:"mixHash"          gencodec:"required"`
    	Nonce       BlockNonce     `json:"nonce"            gencodec:"required"`
    }

     

    3. 实际交易消耗估算

        一个交易的实际交易费由两个因素组成:

    • gasUsed:每个EVM中的命令都被设置了相应的gas消耗值。gasUsed是所有被执行的命令的gas消耗值总和。

    • gasPrice:该交易中单位gas的价格(用以太币计算)

           交易费 = gasUsed * gasPrice

    4.区块gas limit为什么要改变

    1.     让区块大小可以根据网络交易多寡,自由调整区块大小。在网络交易量大时,可自动实现扩容。
    2.     防止恶意用户的恶意for循环攻击使网络瘫痪。

             因恶意用户不断的转移额度非常小的帐目,使得整个网络瘫痪,当交易的费用非常低时,可以忽略不计,因此以太坊引入了gas的概念,任何转账以及智能合约的执行,都要消耗一定的费用即gas,如果gas消耗完毕,则代码不再继续执行,这样防止恶意代码的for循环不停的执行,以至于整个网络无法继续向下一个状态迁移。因此我们知道任何计算,存储都是需要付出成本的,这样杜绝恶意攻击代码。

    5.区块gas limit是怎样改变的

       首先改变gas limit的途径有:

    •    代码自动调整设定。最新以太坊代打包时根据父区块gas使用情况封装到下一个block的header中。
    •    矿工通过命令行设定。这里设定的是targetgaslimit,不过大多数矿工的targetgaslimit的值为最初始时的4,712,388。

    代码的的自动设定

    每次开始打包的时候都会确定当前包Gaslimit的大小,以下函数确定大小

    // CalcGasLimit computes the gas limit of the next block after parent.
    // This is miner strategy, not consensus protocol.
    func CalcGasLimit(parent *types.Block) uint64 {
    	// contrib = (parentGasUsed * 3 / 2) / 1024
    	contrib := (parent.GasUsed() + parent.GasUsed()/2) / params.GasLimitBoundDivisor
    
    	// decay = parentGasLimit / 1024 -1
    
    	decay := parent.GasLimit()/params.GasLimitBoundDivisor - 1
    
    	/*
    		strategy: gasLimit of block-to-mine is set based on parent's
    		gasUsed value.  if parentGasUsed > parentGasLimit * (2/3) then we
    		increase it, otherwise lower it (or leave it unchanged if it's right
    		at that usage) the amount increased/decreased depends on how far away
    		from parentGasLimit * (2/3) parentGasUsed is.
    	*/
        //当父区块Gas使用量>2/3的时候,会较上次加大gaslimit,反之减小
    	limit := parent.GasLimit() - decay + contrib
    	if limit < params.MinGasLimit {
    		limit = params.MinGasLimit
    	}
    	// however, if we're now below the target (TargetGasLimit) we increase the
    	// limit as much as we can (parentGasLimit / 1024 -1)
    	if limit < params.TargetGasLimit {
    		limit = parent.GasLimit() + decay
    		if limit > params.TargetGasLimit {
    			limit = params.TargetGasLimit
    		}
    	}
    	return limit
    }


    其中,targetGasLimit是代码中配置的GenesisGasLimit(现在是4712388)

    从代码中的注释描述看意思是当父区块Gas使用量>2/3的时候,会较上次加大gaslimit,反之减小

    根据这个公式Gaslimit是会缓慢增加的(当每次使用量都超过2/3的话),从etherscan上也可以看出现在的Gaslimit是800万左右,明显比GenesisGasLimit大了不少。

    矿工通过命令行设定

         以太坊上的矿工需要用一个挖矿软件,例如ethminer。它会连接到一个geth或者Parity以太坊客户端。Geth和Pairty都有让矿工可以更改配置的选项。这里是geth挖矿命令行选项以及Parity的选项,例如下:

          Geth --gasprice 4000000000 --targetgaslimit 4712388

          Parity --gas-floor-target 4712388 --gas-cap 9000000 --gasprice 4000000000

          一个重要需要注意的事情是内部交易或者消息不包含gasLimit。因为gas limit是由原始交易的外部创建者决定的(也就是外部拥有账户)。外部拥有账户设置的gas limit必须要高到足够将交易完成,包括由于此交易而产生的任何”子执行”,例如合约到合约的消息。如果,在一个交易或者信息链中,其中一个消息执行使gas已不足,那么这个消息的执行会被还原,包括任何被此执行触发的子消息。不过,父执行没必要被还原。 

    6. 设置用户交易Gas limit 需要考虑的问题

    • 不同的操作会产生不同的 Gas 成本。

    • Gas 用完时,矿工将停止执行。

    • 如果有剩余 Gas,将立即退还给发起交易的人员或智能合约创建者。但是,如果用户设置的限制值太低,那么ta的交易被认为是无效的,并且会因为“Gas不足”错误而被取消,并且其中用于计算的 Gas 不会退到账户。所以无论交易是否通过,发送者总需要向矿工支付计算费用。

    7.用到gaslimit的代码解析注释

    worker.go中:

    
    func (self *worker) commitNewWork() {
    	self.mu.Lock()
    	defer self.mu.Unlock()
    	self.uncleMu.Lock()
    	defer self.uncleMu.Unlock()
    	self.currentMu.Lock()
    	defer self.currentMu.Unlock()
    
    	tstart := time.Now()
    	parent := self.chain.CurrentBlock()
    
    	tstamp := tstart.Unix()
    	if parent.Time().Cmp(new(big.Int).SetInt64(tstamp)) >= 0 {
    		tstamp = parent.Time().Int64() + 1
    	}
    	// this will ensure we're not going off too far in the future
    	if now := time.Now().Unix(); tstamp > now+1 {
    		wait := time.Duration(tstamp-now) * time.Second
    		log.Info("Mining too far in the future", "wait", common.PrettyDuration(wait))
    		time.Sleep(wait)
    	}
    
    	num := parent.Number()
    	header := &types.Header{
    		ParentHash: parent.Hash(),
    		Number:     num.Add(num, common.Big1),
    		GasLimit:   core.CalcGasLimit(parent),//打包区块时,根据父块的gas使用情况调整此次区块gaslimit大小
    		Extra:      self.extra,
    		Time:       big.NewInt(tstamp),
    	}
    	// Only set the coinbase if we are mining (avoid spurious block rewards)
    	if atomic.LoadInt32(&self.mining) == 1 {
    		header.Coinbase = self.coinbase
    	}
    	if err := self.engine.Prepare(self.chain, header); err != nil {
    		log.Error("Failed to prepare header for mining", "err", err)
    		return
    	}
    	// If we are care about TheDAO hard-fork check whether to override the extra-data or not
    	if daoBlock := self.config.DAOForkBlock; daoBlock != nil {
    		// Check whether the block is among the fork extra-override range
    		limit := new(big.Int).Add(daoBlock, params.DAOForkExtraRange)
    		if header.Number.Cmp(daoBlock) >= 0 && header.Number.Cmp(limit) < 0 {
    			// Depending whether we support or oppose the fork, override differently
    			if self.config.DAOForkSupport {
    				header.Extra = common.CopyBytes(params.DAOForkBlockExtra)
    			} else if bytes.Equal(header.Extra, params.DAOForkBlockExtra) {
    				header.Extra = []byte{} // If miner opposes, don't let it use the reserved extra-data
    			}
    		}
    	}
    	// Could potentially happen if starting to mine in an odd state.
    	err := self.makeCurrent(parent, header)
    	if err != nil {
    		log.Error("Failed to create mining context", "err", err)
    		return
    	}
    	// Create the current work task and check any fork transitions needed
    	work := self.current
    	if self.config.DAOForkSupport && self.config.DAOForkBlock != nil && self.config.DAOForkBlock.Cmp(header.Number) == 0 {
    		misc.ApplyDAOHardFork(work.state)
    	}
    	pending, err := self.eth.TxPool().Pending()
    	if err != nil {
    		log.Error("Failed to fetch pending transactions", "err", err)
    		return
    	}
    	txs := types.NewTransactionsByPriceAndNonce(self.current.signer, pending)
    	work.commitTransactions(self.mux, txs, self.chain, self.coinbase)
    
    	// compute uncles for the new block.
    	var (
    		uncles    []*types.Header
    		badUncles []common.Hash
    	)
    	for hash, uncle := range self.possibleUncles {
    		if len(uncles) == 2 {
    			break
    		}
    		if err := self.commitUncle(work, uncle.Header()); err != nil {
    			log.Trace("Bad uncle found and will be removed", "hash", hash)
    			log.Trace(fmt.Sprint(uncle))
    
    			badUncles = append(badUncles, hash)
    		} else {
    			log.Debug("Committing new uncle to block", "hash", hash)
    			uncles = append(uncles, uncle.Header())
    		}
    	}
    	for _, hash := range badUncles {
    		delete(self.possibleUncles, hash)
    	}
    	// Create the new block to seal with the consensus engine
    	if work.Block, err = self.engine.Finalize(self.chain, header, work.state, work.txs, uncles, work.receipts); err != nil {
    		log.Error("Failed to finalize block for sealing", "err", err)
    		return
    	}
    	// We only care about logging if we're actually mining.
    	if atomic.LoadInt32(&self.mining) == 1 {
    		log.Info("Commit new mining work", "number", work.Block.Number(), "txs", work.tcount, "uncles", len(uncles), "elapsed", common.PrettyDuration(time.Since(tstart)))
    		self.unconfirmed.Shift(work.Block.NumberU64() - 1)
    	}
    	self.push(work)
    }
    func (env *Work) commitTransactions(mux *event.TypeMux, txs *types.TransactionsByPriceAndNonce, bc *core.BlockChain, coinbase common.Address) {
    	// 由于是打包新的区块中交易,所以将总 gasPool 初始化为 env.header.GasLimit
    	if env.gasPool == nil {
    		env.gasPool = new(core.GasPool).AddGas(env.header.GasLimit)
    	}
    
    	var coalescedLogs []*types.Log
    
    	for {
    		// If we don't have enough gas for any further transactions then we're done
    		// 如果当前区块中所有 Gas 消耗已经使用完,则退出打包交易
    		if env.gasPool.Gas() < params.TxGas {
    			log.Trace("Not enough gas for further transactions", "have", env.gasPool, "want", params.TxGas)
    			break
    		}
    				
    		// Retrieve the next transaction and abort if all done
    		// 检索下一笔交易,如果交易集合为空则退出 commit
    		tx := txs.Peek()
    		if tx == nil {
    			break
    		}
    		// Error may be ignored here. The error has already been checked
    		// during transaction acceptance is the transaction pool.
    		//
    		// We use the eip155 signer regardless of the current hf.
    		from, _ := types.Sender(env.signer, tx)
    		// Check whether the tx is replay protected. If we're not in the EIP155 hf
    		// phase, start ignoring the sender until we do.
    
    		if tx.Protected() && !env.config.IsEIP155(env.header.Number) {
    			log.Trace("Ignoring reply protected transaction", "hash", tx.Hash(), "eip155", env.config.EIP155Block)
    
    			txs.Pop()
    			continue
    		}
    		// Start executing the transaction
    		env.state.Prepare(tx.Hash(), common.Hash{}, env.tcount)
    		// 执行交易
    		err, logs := env.commitTransaction(tx, bc, coinbase, gp)
    		switch err {
    		case core.ErrGasLimitReached:
    			// Pop the current out-of-gas transaction without shifting in the next from the account
    			// 弹出整个账户的所有交易, 不处理用户的下一个交易。
    			log.Trace("Gas limit exceeded for current block", "sender", from)
    			txs.Pop()
    
    		case core.ErrNonceTooLow:
    			// New head notification data race between the transaction pool and miner, shift
    			// 移动到用户的下一个交易
    			log.Trace("Skipping transaction with low nonce", "sender", from, "nonce", tx.Nonce())
    			txs.Shift()
    
    		case core.ErrNonceTooHigh:
    			// Reorg notification data race between the transaction pool and miner, skip account =
    			// 跳过这个账户
    			log.Trace("Skipping account with hight nonce", "sender", from, "nonce", tx.Nonce())
    			txs.Pop()
    
    		case nil:
    			// Everything ok, collect the logs and shift in the next transaction from the same account
    			coalescedLogs = append(coalescedLogs, logs...)
    			env.tcount++
    			txs.Shift()
    
    		default:
    			// Strange error, discard the transaction and get the next in line (note, the
    			// nonce-too-high clause will prevent us from executing in vain).
    			// 其他奇怪的错误,跳过这个交易。
    			log.Debug("Transaction failed, account skipped", "hash", tx.Hash(), "err", err)
    			txs.Shift()
    		}
    	}
    
    	if len(coalescedLogs) > 0 || env.tcount > 0 {
    		// make a copy, the state caches the logs and these logs get "upgraded" from pending to mined
    		// logs by filling in the block hash when the block was mined by the local miner. This can
    		// cause a race condition if a log was "upgraded" before the PendingLogsEvent is processed.
    		// 因为需要把log发送出去,而这边在挖矿完成后需要对log进行修改,所以拷贝一份发送出去,避免争用。
    		cpy := make([]*types.Log, len(coalescedLogs))
    		for i, l := range coalescedLogs {
    			cpy[i] = new(types.Log)
    			*cpy[i] = *l
    		}
    		go func(logs []*types.Log, tcount int) {
    			if len(logs) > 0 {
    				mux.Post(core.PendingLogsEvent{Logs: logs})
    			}
    			if tcount > 0 {
    				mux.Post(core.PendingStateEvent{})
    			}
    		}(cpy, env.tcount)
    	}
    }

    consense.go中:

    // verifyHeader checks whether a header conforms to the consensus rules of the
    // stock Ethereum ethash engine.
    // See YP section 4.3.4. "Block Header Validity"
    func (ethash *Ethash) verifyHeader(chain consensus.ChainReader, header, parent *types.Header, uncle bool, seal bool) error {
    	// Ensure that the header's extra-data section is of a reasonable size
    	if uint64(len(header.Extra)) > params.MaximumExtraDataSize {
    		return fmt.Errorf("extra-data too long: %d > %d", len(header.Extra), params.MaximumExtraDataSize)
    	}
    	// Verify the header's timestamp
    	if uncle {
    		if header.Time.Cmp(math.MaxBig256) > 0 {
    			return errLargeBlockTime
    		}
    	} else {
    		if header.Time.Cmp(big.NewInt(time.Now().Add(allowedFutureBlockTime).Unix())) > 0 {
    			return consensus.ErrFutureBlock
    		}
    	}
    	if header.Time.Cmp(parent.Time) <= 0 {
    		return errZeroBlockTime
    	}
    	// Verify the block's difficulty based in it's timestamp and parent's difficulty
    	expected := ethash.CalcDifficulty(chain, header.Time.Uint64(), parent)
    
    	if expected.Cmp(header.Difficulty) != 0 {
    		return fmt.Errorf("invalid difficulty: have %v, want %v", header.Difficulty, expected)
    	}
    	// Verify that the gas limit is <= 2^63-1
    	//校验是否区块gaslimt取值范围的最大阀值
    	cap := uint64(0x7fffffffffffffff)
    	if header.GasLimit > cap {
    		return fmt.Errorf("invalid gasLimit: have %v, max %v", header.GasLimit, cap)
    	}
    	// Verify that the gasUsed is <= gasLimit
    
    	if header.GasUsed > header.GasLimit {
    		return fmt.Errorf("invalid gasUsed: have %d, gasLimit %d", header.GasUsed, header.GasLimit)
    	}
    
    	// Verify that the gas limit remains within allowed bounds
    	//校验是当前块的gaslimit在允许的范围内
    	diff := int64(parent.GasLimit) - int64(header.GasLimit)
    	if diff < 0 {
    		diff *= -1
    	}
    	limit := parent.GasLimit / params.GasLimitBoundDivisor
    
    	if uint64(diff) >= limit || header.GasLimit < params.MinGasLimit {
    		return fmt.Errorf("invalid gas limit: have %d, want %d += %d", header.GasLimit, parent.GasLimit, limit)
    	}
    	// Verify that the block number is parent's +1
    	if diff := new(big.Int).Sub(header.Number, parent.Number); diff.Cmp(big.NewInt(1)) != 0 {
    		return consensus.ErrInvalidNumber
    	}
    	// Verify the engine specific seal securing the block
    	if seal {
    		if err := ethash.VerifySeal(chain, header); err != nil {
    			return err
    		}
    	}
    	// If all checks passed, validate any special fields for hard forks
    	if err := misc.VerifyDAOHeaderExtraData(chain.Config(), header); err != nil {
    		return err
    	}
    	if err := misc.VerifyForkHashes(chain.Config(), header, uncle); err != nil {
    		return err
    	}
    	return nil
    }

     

    展开全文
  • 刚开始学Qt,没有好的中文教材,只好自己慢慢的翻译E文书了 正在翻译翻译来源:PyQt4自带的类参考手册类Qt:父类QtCore The Qt namespace contains miscellaneous identifiers used throughout the Qt library ...
  •  ts代码 前端实现多选框功能,借鉴了网上代码,...这个错误翻译中文就是 如果我ts代码里有多个 双向绑定 [{ngModel}],要给每个ngModel添加name,或者将控件定义为“”standalone“”,否则就会报错。...
  • Kafka 0.10.1 官方文档(中文版)-0

    万次阅读 热门讨论 2016-11-02 22:50:24
    由于在网上看到资料都是0.8x,最新文档没有找到,所以翻译下 kafka V0.10.1。JUST DO IT !Kafka™ is used for building real-time data pipelines and streaming apps. It is horizontally scalable, fault-...
  • 常见缓存淘汰策略

    2020-10-08 15:04:18
    LRU,意思是Least Recently Used中文翻译为最近很少使用,根据数据历史访问记录来进行淘汰,如果数据最近被访问过,那么将来被访问几率也就更高 新数据插入链表头部,每当缓存数据被访问,则数据移动到链表...
  • 翻译自ASP.NET Maker v2017.0.5原版语言包 english.xml Like that: <?xml version="1.0" encoding="gb2312" standalone="yes"?> 简体中文" desc="简体中文(GB2312)" author="Alan Chiang"> <!-- *** ...
  • LRU算法实现

    2020-04-10 23:42:29
    中文翻译叫最近最少使用。这个翻译太狗屁了,不好理解。不过可以看一下LRU算法数据插入规则,就知道到底什么是LRU了。 看这个应该很容易理解,大概就是按时间顺序排队,时间最近页面排在最前面,时间远排在...
  • Linux-0.11 [内核源代码带中文注释]

    热门讨论 2010-04-02 08:42:45
    以下是前面这些文字的翻译: ! bootsect.s (C) 1991 Linus Torvalds 版权所有 ! ! bootsect.s 被bios-启动子程序加载至0x7c00 (31k)处,并将自己 ! 移到了地址0x90000 (576k)处,并跳转至那里。 ! ! 它然后使用BIOS...
  • 更好的中文近义词:聊天机器人、智能问答工具包。 synonyms可以用于自然语言理解的很多任务:文本对齐,推荐算法,相似度计算,语义偏移,关键字提取,概念提取,自动摘要,搜索引擎等。 Table of Content: ...
  • 1. 前言 首先,看一下官方对HandlerThread解释: Handy class for starting a new thread that has a looper. The looper can then be used to create handler classes....翻译中文为:Handl...
  • LRU---基于Java实现

    2019-03-06 09:36:52
    Least recently used (LRU),中文翻译过来是最近最少使用,是一种容量受限缓存策略。当新加入一个键时,如果缓存容器已经满了,那么该建将替换最久没有被访问元素。因此缓存容器内都是最近被访问元素,这也是...
  • 目录一、原理和实现二、实例说明三、参考链接 一、原理和实现 解释器模式英文翻译是 Interpreter Design Pattern。在 GoF 《设计模式》一书中,它是这样定义: ...翻译中文就是: 解释器模式为某个语言定
  • C++ traits和enable_if实现

    千次阅读 2014-02-23 14:59:01
    C++ traits中trait在中文里好像没有特别好的翻译。引用C++之父Bjarne Stroustrup话来解释什么是C++ traits: "Think of a trait as a small object whose main purpose is to carry information used by another ...
  • 随着IronPython正式发布,在IronPython应用方面国外...有时间了我们团队成员一起把他翻译中文,先记录下来。IronTextBox - a TextBox and UserControl based console that may be used with IronPythonC
  • 关于Hessian matrix最好理解

    千次阅读 2018-01-01 15:16:35
    Hessian matrix翻译中文是黑塞矩阵或海森矩阵。这个在高等数学里没有提到,它有点类似于一元变量函数求其二阶导数判断极值问题。下面是转载过来英文解释,讲非常清楚了,和大家一起分享。...
  • CRUD 意思!

    2007-01-25 10:47:48
    In computing, CRUD is an acronym for create, retrieve, update, and delete. It is used to refer to the basic functions of a database or persistence layer in a ...翻译中文:) CRUD是指在做计算处理时...
  • Scala(3)-Traits

    2017-10-02 17:25:42
    在专业领域中,有些名词我建议直接使用英文而不翻译,因为一个单词往往有多个中文含义,不同的人翻译过来的中文有可能不一样,可能不利于其他人准确理解某个事物的本质意义。“Traits are used to share interfaces ...
  • 区分焊锡膏与助焊剂

    千次阅读 2020-02-14 16:49:27
    产品上的错误的中文翻译甚至是错误英文存在已久,不得不来“正个名”。 Solder paste (or solder cream) is a material used in the manufacture of printed circuit boards to connect surface mount components ...
  • 个人在学习5G标准3GPP TS 29244-g30过程中,也发现google机器翻译实在晦涩难懂,所以个人在借助百度翻译(中国人更懂中文同时,人工对每句话进行了校对。 在自己学习同时,也将翻译内容分享给给广大网友。...
  • 个人在学习5G标准3GPP TS 29244-g30过程中,也发现google机器翻译实在晦涩难懂,所以个人在借助百度翻译(中国人更懂中文同时,人工对每句话进行了校对。 在自己学习同时,也将翻译内容分享给给广大网友。...
  • 1 、请用英文简单介绍一下自己. 2、WEB SERVICE 名词解释。...3 、请把 http://tomcat.apache.org/  首页这一段话用中文翻译一下?  Apache Tomcat is the servlet container that is used
  • 十二.其他 1、请用英文简单介绍一下自己.4、WEB SERVICE 名词解释。...2、请把 http://tomcat.apache.org/ 首页这一段话用中文翻译一下? Apache Tomcat is the servlet container that is used in the offi...

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

used的中文翻译