[Node] Do all block index writes in a batch

sipa · Warrows · commit e515b1e9f230 · 2019-06-19T12:50:31.000+02:00
Backport from bitcoin bitcoin#5367
diff --git a/src/chain.h b/src/chain.h
@@ -175,11 +175,11 @@ class CBlockIndex
 
     //! (memory only) Sequential id assigned to distinguish order in which blocks are received.
     uint32_t nSequenceId;
-    
+
     //! zerocoin specific fields
     std::map<libzerocoin::CoinDenomination, int64_t> mapZerocoinSupply;
     std::vector<libzerocoin::CoinDenomination> vMintDenominationsInBlock;
-    
+
     void SetNull()
     {
         phashBlock = NULL;
@@ -251,7 +251,7 @@ class CBlockIndex
             nStakeTime = 0;
         }
     }
-    
+
 
     CDiskBlockPos GetBlockPos() const
     {
@@ -393,7 +393,7 @@ class CBlockIndex
 
     /**
      * Returns true if there are nRequired or more blocks of minVersion or above
-     * in the last Params().ToCheckBlockUpgradeMajority() blocks, starting at pstart 
+     * in the last Params().ToCheckBlockUpgradeMajority() blocks, starting at pstart
      * and going backwards.
      */
     static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned int nRequired);
@@ -450,9 +450,9 @@ class CDiskBlockIndex : public CBlockIndex
         hashNext = uint256();
     }
 
-    explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)
+    explicit CDiskBlockIndex(const CBlockIndex* pindex) : CBlockIndex(*pindex)
     {
-        hashPrev = (pprev ? pprev->GetBlockHash() : uint256());
+        hashPrev = (pprev ? pprev->GetBlockHash() : uint256(0));
     }
 
     ADD_SERIALIZE_METHODS;
diff --git a/src/main.cpp b/src/main.cpp
@@ -3538,25 +3538,23 @@ bool static FlushStateToDisk(CValidationState& state, FlushStateMode mode)
             // First make sure all block and undo data is flushed to disk.
             FlushBlockFile();
             // Then update all block file information (which may refer to block and undo files).
-            bool fileschanged = false;
-            for (set<int>::iterator it = setDirtyFileInfo.begin(); it != setDirtyFileInfo.end();) {
-                if (!pblocktree->WriteBlockFileInfo(*it, vinfoBlockFile[*it])) {
-                    return state.Abort("Failed to write to block index");
+            {
+                std::vector<std::pair<int, const CBlockFileInfo*> > vFiles;
+                vFiles.reserve(setDirtyFileInfo.size());
+                for (set<int>::iterator it = setDirtyFileInfo.begin(); it != setDirtyFileInfo.end(); ) {
+                    vFiles.push_back(make_pair(*it, &vinfoBlockFile[*it]));
+                    setDirtyFileInfo.erase(it++);
                 }
-                fileschanged = true;
-                setDirtyFileInfo.erase(it++);
-            }
-            if (fileschanged && !pblocktree->WriteLastBlockFile(nLastBlockFile)) {
-                return state.Abort("Failed to write to block index");
-            }
-            for (set<CBlockIndex*>::iterator it = setDirtyBlockIndex.begin(); it != setDirtyBlockIndex.end();) {
-                if (!pblocktree->WriteBlockIndex(CDiskBlockIndex(*it))) {
-                    return state.Abort("Failed to write to block index");
+                std::vector<const CBlockIndex*> vBlocks;
+                vBlocks.reserve(setDirtyBlockIndex.size());
+                for (set<CBlockIndex*>::iterator it = setDirtyBlockIndex.begin(); it != setDirtyBlockIndex.end(); ) {
+                    vBlocks.push_back(*it);
+                    setDirtyBlockIndex.erase(it++);
+                }
+                if (!pblocktree->WriteBatchSync(vFiles, nLastBlockFile, vBlocks)) {
+                    return state.Abort("Files to write to block index database");
                 }
-                setDirtyBlockIndex.erase(it++);
             }
-
-            pblocktree->Sync();
             // Finally flush the chainstate (which may refer to block index entries).
             if (!pcoinsTip->Flush())
                 return state.Abort("Failed to write to coin database");
diff --git a/src/txdb.cpp b/src/txdb.cpp
@@ -83,21 +83,11 @@ bool CBlockTreeDB::WriteBlockIndex(const CDiskBlockIndex& blockindex)
     return Write(make_pair('b', blockindex.GetBlockHash()), blockindex);
 }
 
-bool CBlockTreeDB::WriteBlockFileInfo(int nFile, const CBlockFileInfo& info)
-{
-    return Write(make_pair('f', nFile), info);
-}
-
 bool CBlockTreeDB::ReadBlockFileInfo(int nFile, CBlockFileInfo& info)
 {
     return Read(make_pair('f', nFile), info);
 }
 
-bool CBlockTreeDB::WriteLastBlockFile(int nFile)
-{
-    return Write('l', nFile);
-}
-
 bool CBlockTreeDB::WriteReindexing(bool fReindexing)
 {
     if (fReindexing)
@@ -171,6 +161,18 @@ bool CCoinsViewDB::GetStats(CCoinsStats& stats) const
     return true;
 }
 
+bool CBlockTreeDB::WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo) {
+    CLevelDBBatch batch;
+    for (std::vector<std::pair<int, const CBlockFileInfo*> >::const_iterator it=fileInfo.begin(); it != fileInfo.end(); it++) {
+        batch.Write(make_pair('f', it->first), *it->second);
+    }
+    batch.Write('l', nLastFile);
+    for (std::vector<const CBlockIndex*>::const_iterator it=blockinfo.begin(); it != blockinfo.end(); it++) {
+        batch.Write(make_pair('b', (*it)->GetBlockHash()), CDiskBlockIndex(*it));
+    }
+    return WriteBatch(batch, true);
+}
+
 bool CBlockTreeDB::ReadTxIndex(const uint256& txid, CDiskTxPos& pos)
 {
     return Read(make_pair('t', txid), pos);
diff --git a/src/txdb.h b/src/txdb.h
@@ -54,10 +54,9 @@ class CBlockTreeDB : public CLevelDBWrapper
 
 public:
     bool WriteBlockIndex(const CDiskBlockIndex& blockindex);
+    bool WriteBatchSync(const std::vector<std::pair<int, const CBlockFileInfo*> >& fileInfo, int nLastFile, const std::vector<const CBlockIndex*>& blockinfo);
     bool ReadBlockFileInfo(int nFile, CBlockFileInfo& fileinfo);
-    bool WriteBlockFileInfo(int nFile, const CBlockFileInfo& fileinfo);
     bool ReadLastBlockFile(int& nFile);
-    bool WriteLastBlockFile(int nFile);
     bool WriteReindexing(bool fReindex);
     bool ReadReindexing(bool& fReindex);
     bool ReadTxIndex(const uint256& txid, CDiskTxPos& pos);

Original file line number	Diff line number	Diff line change
`@@ -175,11 +175,11 @@ class CBlockIndex`
`175`	`175`
`176`	`176`	`//! (memory only) Sequential id assigned to distinguish order in which blocks are received.`
`177`	`177`	`uint32_t nSequenceId;`
`178`		`-`
	`178`	`+`
`179`	`179`	`//! zerocoin specific fields`
`180`	`180`	`std::map<libzerocoin::CoinDenomination, int64_t> mapZerocoinSupply;`
`181`	`181`	`std::vector<libzerocoin::CoinDenomination> vMintDenominationsInBlock;`
`182`		`-`
	`182`	`+`
`183`	`183`	`void SetNull()`
`184`	`184`	`{`
`185`	`185`	`phashBlock = NULL;`
`@@ -251,7 +251,7 @@ class CBlockIndex`
`251`	`251`	`nStakeTime = 0;`
`252`	`252`	`}`
`253`	`253`	`}`
`254`		`-`
	`254`	`+`
`255`	`255`
`256`	`256`	`CDiskBlockPos GetBlockPos() const`
`257`	`257`	`{`
`@@ -393,7 +393,7 @@ class CBlockIndex`
`393`	`393`
`394`	`394`	`/**`
`395`	`395`	`* Returns true if there are nRequired or more blocks of minVersion or above`
`396`		`- * in the last Params().ToCheckBlockUpgradeMajority() blocks, starting at pstart`
	`396`	`+ * in the last Params().ToCheckBlockUpgradeMajority() blocks, starting at pstart`
`397`	`397`	`* and going backwards.`
`398`	`398`	`*/`
`399`	`399`	`static bool IsSuperMajority(int minVersion, const CBlockIndex* pstart, unsigned int nRequired);`
`@@ -450,9 +450,9 @@ class CDiskBlockIndex : public CBlockIndex`
`450`	`450`	`hashNext = uint256();`
`451`	`451`	`}`
`452`	`452`
`453`		`- explicit CDiskBlockIndex(CBlockIndex* pindex) : CBlockIndex(*pindex)`
	`453`	`+ explicit CDiskBlockIndex(const CBlockIndex* pindex) : CBlockIndex(*pindex)`
`454`	`454`	`{`
`455`		`- hashPrev = (pprev ? pprev->GetBlockHash() : uint256());`
	`455`	`+ hashPrev = (pprev ? pprev->GetBlockHash() : uint256(0));`
`456`	`456`	`}`
`457`	`457`
`458`	`458`	`ADD_SERIALIZE_METHODS;`