From b0f0939ead969f88fe014e36776dac7b11a40cc0 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Tue, 24 Oct 2023 18:47:15 +0000 Subject: [PATCH 01/11] commitChanges async api --- src/IStorage.h | 10 ++++++++++ src/StorageCache.cpp | 3 ++- src/StorageCache.h | 2 ++ src/db.cpp | 18 +++++++++++++++++- src/storage/rocksdb.cpp | 15 +++++++++++++++ src/storage/rocksdb.h | 2 ++ 6 files changed, 48 insertions(+), 2 deletions(-) diff --git a/src/IStorage.h b/src/IStorage.h index 79726daf5..82f8087a0 100644 --- a/src/IStorage.h +++ b/src/IStorage.h @@ -7,6 +7,13 @@ #define METADATA_DB_IDENTIFIER "c299fde0-6d42-4ec4-b939-34f680ffe39f" struct StorageToken { + enum class TokenType { + SingleRead, + SingleWrite, + Delete, + BatchWrite, + }; + TokenType type; std::unordered_set setc; struct redisDbPersistentData *db; virtual ~StorageToken() {} @@ -46,6 +53,9 @@ class IStorage virtual StorageToken *begin_retrieve(struct aeEventLoop *, aePostFunctionTokenProc, sds *, size_t) {return nullptr;}; virtual void complete_retrieve(StorageToken * /*tok*/, callbackSingle /*fn*/) {}; + virtual StorageToken* begin_endWriteBatch(struct aeEventLoop *, aePostFunctionTokenProc*) {} // NOP + virtual void complete_endWriteBatch(StorageToken * /*tok*/) {}; + virtual void bulkInsert(char **rgkeys, size_t *rgcbkeys, char **rgvals, size_t *rgcbvals, size_t celem) { beginWriteBatch(); for (size_t ielem = 0; ielem < celem; ++ielem) { diff --git a/src/StorageCache.cpp b/src/StorageCache.cpp index c0ff305b1..51d2e8c1f 100644 --- a/src/StorageCache.cpp +++ b/src/StorageCache.cpp @@ -233,4 +233,5 @@ void StorageCache::emergencyFreeCache() { dictRelease(d); }); } -} \ No newline at end of file +} + diff --git a/src/StorageCache.h b/src/StorageCache.h index 614f8c27b..828c657df 100644 --- a/src/StorageCache.h +++ b/src/StorageCache.h @@ -45,6 +45,8 @@ class StorageCache void retrieve(sds key, IStorage::callbackSingle fn) const; StorageToken *begin_retrieve(struct aeEventLoop *el, aePostFunctionTokenProc proc, sds *rgkey, size_t ckey); void complete_retrieve(StorageToken *tok, IStorage::callbackSingle fn); + StorageToken* begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* proc) {m_spstorage->begin_endWriteBatch(el,proc);} // NOP + void complete_endWriteBatch(StorageToken *tok) {m_spstorage->complete_endWriteBatch(tok);}; bool erase(sds key); void emergencyFreeCache(); bool keycacheIsEnabled() const { return m_pdict != nullptr; } diff --git a/src/db.cpp b/src/db.cpp index 013473163..21961a6af 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3072,6 +3072,8 @@ void redisDbPersistentData::bulkDirectStorageInsert(char **rgKeys, size_t *rgcbK void redisDbPersistentData::commitChanges(const redisDbPersistentDataSnapshot **psnapshotFree) { + + std::unordered_set setcBlocked; if (m_pdbSnapshotStorageFlush) { dictIterator *di = dictGetIterator(m_dictChangedStorageFlush); @@ -3086,8 +3088,22 @@ void redisDbPersistentData::commitChanges(const redisDbPersistentDataSnapshot ** *psnapshotFree = m_pdbSnapshotStorageFlush; m_pdbSnapshotStorageFlush = nullptr; } + if (m_spstorage != nullptr) - m_spstorage->endWriteBatch(); + { + auto tok = m_spstorage->begin_endWriteBatch(serverTL->el, storageLoadCallback); + if (tok != nullptr) + { + for (client *c : setcBlocked) //need to check how to push client to blocked list + { + if (!(c->flags & CLIENT_BLOCKED)) + blockClient(c, BLOCKED_STORAGE); + } + // tok->setc = std::move(setcBlocked); + tok->db = this; + tok->type = StorageToken::TokenType::BatchWrite; + } + } } redisDbPersistentData::~redisDbPersistentData() diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index 16aed43b7..1bae69d8c 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -255,6 +255,21 @@ void RocksDBStorageProvider::endWriteBatch() m_lock.unlock(); } +StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback) +{ + StorageToken *tok = new StorageToken(); + auto pbatch = m_spbatch.get(); + (*m_pfactory->m_wqueue)->AddWorkFunction([this, el,callback,tok,&pbatch]{ + m_spdb->Write(WriteOptions(),pbatch); + aePostFunction(el,callback,tok); + }); +} + +void RocksDBStorageProvider::complete_endWriteBatch(StorageToken* tok){ + // m_spbatch = nullptr; + m_lock.unlock(); +} + void RocksDBStorageProvider::batch_lock() { m_lock.lock(); diff --git a/src/storage/rocksdb.h b/src/storage/rocksdb.h index 01edb4975..d5587c9e9 100644 --- a/src/storage/rocksdb.h +++ b/src/storage/rocksdb.h @@ -42,6 +42,8 @@ class RocksDBStorageProvider : public IStorage virtual void beginWriteBatch() override; virtual void endWriteBatch() override; + virtual StorageToken* begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* proc); + virtual void complete_endWriteBatch(StorageToken *tok); virtual void bulkInsert(char **rgkeys, size_t *rgcbkeys, char **rgvals, size_t *rgcbvals, size_t celem) override; From c08568f6f5167ae787460c9c4cdd7925d3a92fd9 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Tue, 24 Oct 2023 18:54:18 +0000 Subject: [PATCH 02/11] missed changes --- src/db.cpp | 32 +++++++++++++++++++++++++++----- 1 file changed, 27 insertions(+), 5 deletions(-) diff --git a/src/db.cpp b/src/db.cpp index 21961a6af..8d23af067 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3436,7 +3436,13 @@ void redisDbPersistentData::prefetchKeysFlash(std::unordered_set &setc) void redisDbPersistentData::processStorageToken(StorageToken *tok) { auto setc = std::move(tok->setc); - tok->db->m_spstorage->complete_retrieve(tok, [&](const char *szKey, size_t cbKey, const void *data, size_t cb) { + switch (tok->type) + { + + case StorageToken::TokenType::SingleRead: + { + tok->db->m_spstorage->complete_retrieve(tok, [&](const char *szKey, size_t cbKey, const void *data, size_t cb) + { auto *db = tok->db; size_t offset = 0; sds key = sdsnewlen(szKey, -((ssize_t)cbKey)); @@ -3467,11 +3473,27 @@ void redisDbPersistentData::processStorageToken(StorageToken *tok) { serverAssert(db->m_setexpire->find(key) != db->m_setexpire->end()); } serverAssert(o->FExpires() == (db->m_setexpire->find(key) != db->m_setexpire->end())); - } - }); - tok = nullptr; // Invalid past this point + } }); + break; + } + case StorageToken::TokenType::BatchWrite: + { + tok->db->m_spstorage->complete_endWriteBatch(tok); + break; + } + case StorageToken::TokenType::SingleWrite: + { + tok->db->m_spstorage->complete_insert(tok); + break; + } + default: + break; + } //switch end - for (client *c : setc) { + tok = nullptr; // Invalid past this point + + for (client *c : setc) + { std::unique_lock ul(c->lock); if (c->flags & CLIENT_BLOCKED) unblockClient(c); From 1239d56e5af35e9c7768c3956bd29bfcdb914e1f Mon Sep 17 00:00:00 2001 From: a00817524 Date: Wed, 25 Oct 2023 02:02:44 +0000 Subject: [PATCH 03/11] some fixes --- src/StorageCache.h | 2 +- src/db.cpp | 2 +- src/storage/rocksdb.cpp | 32 +++++++++++++++++++++++++------- 3 files changed, 27 insertions(+), 9 deletions(-) diff --git a/src/StorageCache.h b/src/StorageCache.h index 828c657df..18fd7f7e4 100644 --- a/src/StorageCache.h +++ b/src/StorageCache.h @@ -45,7 +45,7 @@ class StorageCache void retrieve(sds key, IStorage::callbackSingle fn) const; StorageToken *begin_retrieve(struct aeEventLoop *el, aePostFunctionTokenProc proc, sds *rgkey, size_t ckey); void complete_retrieve(StorageToken *tok, IStorage::callbackSingle fn); - StorageToken* begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* proc) {m_spstorage->begin_endWriteBatch(el,proc);} // NOP + StorageToken* begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* proc) {return m_spstorage->begin_endWriteBatch(el,proc);} // NOP void complete_endWriteBatch(StorageToken *tok) {m_spstorage->complete_endWriteBatch(tok);}; bool erase(sds key); void emergencyFreeCache(); diff --git a/src/db.cpp b/src/db.cpp index 8d23af067..387fbdcdb 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3091,7 +3091,7 @@ void redisDbPersistentData::commitChanges(const redisDbPersistentDataSnapshot ** if (m_spstorage != nullptr) { - auto tok = m_spstorage->begin_endWriteBatch(serverTL->el, storageLoadCallback); + auto *tok = m_spstorage->begin_endWriteBatch(serverTL->el, storageLoadCallback); if (tok != nullptr) { for (client *c : setcBlocked) //need to check how to push client to blocked list diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index 1bae69d8c..6c84ccad8 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -255,21 +255,39 @@ void RocksDBStorageProvider::endWriteBatch() m_lock.unlock(); } -StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback) +struct BatchStorageToken : public StorageToken { + std::shared_ptr tspdb; // Note: This must be first so it is deleted last + rocksdb::WriteBatch* tspbatch; + ~BatchStorageToken(){ + tspdb.reset(); + tspdb = nullptr; + tspbatch = nullptr; + } +}; + +StorageToken* RocksEncoderStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback) { - StorageToken *tok = new StorageToken(); - auto pbatch = m_spbatch.get(); - (*m_pfactory->m_wqueue)->AddWorkFunction([this, el,callback,tok,&pbatch]{ - m_spdb->Write(WriteOptions(),pbatch); + // serverLog(LL_WARNING, "RocksEncoderStorageProvider::begin_endWriteBatch"); + BatchStorageToken *tok = new BatchStorageToken(); + tok->tspbatch = m_spbatch.get(); + tok->tspdb = m_spdb; + (*m_pfactory->m_wqueue)->AddWorkFunction([this, el,callback,tok]{ + // serverAssert(db); + serverAssert(tok->tspdb); + tok->tspdb->Write(WriteOptions(),tok->tspbatch); aePostFunction(el,callback,tok); }); + return tok; } -void RocksDBStorageProvider::complete_endWriteBatch(StorageToken* tok){ - // m_spbatch = nullptr; +void RocksEncoderStorageProvider::complete_endWriteBatch(StorageToken* tok){ + // serverLog(LL_WARNING, "RocksEncoderStorageProvider::complete_endWriteBatch"); m_lock.unlock(); + delete tok; + tok = nullptr; } + void RocksDBStorageProvider::batch_lock() { m_lock.lock(); From d20c5a4404110626f66a9ff214779ec27a49cb9d Mon Sep 17 00:00:00 2001 From: a00817524 Date: Wed, 25 Oct 2023 02:13:10 +0000 Subject: [PATCH 04/11] build fixes --- src/db.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/db.cpp b/src/db.cpp index 387fbdcdb..a20ea0a3f 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3483,7 +3483,6 @@ void redisDbPersistentData::processStorageToken(StorageToken *tok) { } case StorageToken::TokenType::SingleWrite: { - tok->db->m_spstorage->complete_insert(tok); break; } default: From dc4dc2f819d1b10cf1cbc4826ccea5376e3275a8 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Mon, 30 Oct 2023 13:49:51 +0000 Subject: [PATCH 05/11] correcting classname --- src/storage/rocksdb.cpp | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index 6c84ccad8..3ed94be60 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -257,7 +257,7 @@ void RocksDBStorageProvider::endWriteBatch() struct BatchStorageToken : public StorageToken { std::shared_ptr tspdb; // Note: This must be first so it is deleted last - rocksdb::WriteBatch* tspbatch; + std::unique_ptr tspbatch; ~BatchStorageToken(){ tspdb.reset(); tspdb = nullptr; @@ -265,23 +265,23 @@ struct BatchStorageToken : public StorageToken { } }; -StorageToken* RocksEncoderStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback) +StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback) { - // serverLog(LL_WARNING, "RocksEncoderStorageProvider::begin_endWriteBatch"); + serverLog(LL_WARNING, "RocksDBStorageProvider::begin_endWriteBatch"); BatchStorageToken *tok = new BatchStorageToken(); - tok->tspbatch = m_spbatch.get(); + tok->tspbatch = std::move(m_spbatch); tok->tspdb = m_spdb; (*m_pfactory->m_wqueue)->AddWorkFunction([this, el,callback,tok]{ - // serverAssert(db); - serverAssert(tok->tspdb); - tok->tspdb->Write(WriteOptions(),tok->tspbatch); + tok->tspdb->Write(WriteOptions(),tok->tspbatch.get()); aePostFunction(el,callback,tok); }); + m_spbatch = nullptr; + m_lock.unlock(); return tok; } -void RocksEncoderStorageProvider::complete_endWriteBatch(StorageToken* tok){ - // serverLog(LL_WARNING, "RocksEncoderStorageProvider::complete_endWriteBatch"); +void RocksDBStorageProvider::complete_endWriteBatch(StorageToken* tok){ + // serverLog(LL_WARNING, "RocksDBStorageProvider::complete_endWriteBatch"); m_lock.unlock(); delete tok; tok = nullptr; From c77419def94c84cfa6d12fcc52059e53aa802260 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Tue, 31 Oct 2023 03:41:38 +0000 Subject: [PATCH 06/11] missed changes --- src/storage/rocksdb.cpp | 11 +++++------ 1 file changed, 5 insertions(+), 6 deletions(-) diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index 3ed94be60..3b7b9ec18 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -265,24 +265,23 @@ struct BatchStorageToken : public StorageToken { } }; -StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback) -{ +StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback){ serverLog(LL_WARNING, "RocksDBStorageProvider::begin_endWriteBatch"); BatchStorageToken *tok = new BatchStorageToken(); tok->tspbatch = std::move(m_spbatch); tok->tspdb = m_spdb; + m_spbatch = nullptr; + m_lock.unlock(); (*m_pfactory->m_wqueue)->AddWorkFunction([this, el,callback,tok]{ tok->tspdb->Write(WriteOptions(),tok->tspbatch.get()); aePostFunction(el,callback,tok); }); - m_spbatch = nullptr; - m_lock.unlock(); + return tok; } void RocksDBStorageProvider::complete_endWriteBatch(StorageToken* tok){ - // serverLog(LL_WARNING, "RocksDBStorageProvider::complete_endWriteBatch"); - m_lock.unlock(); + serverLog(LL_WARNING, "RocksDBStorageProvider::complete_endWriteBatch"); delete tok; tok = nullptr; } From 82aa1aaf746ad7477bf1f0b9a8a80ab88ae4a3b2 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Fri, 3 Nov 2023 20:35:27 +0000 Subject: [PATCH 07/11] fixed some errors --- src/storage/rocksdb.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index 3b7b9ec18..e4c1d45ca 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -257,7 +257,7 @@ void RocksDBStorageProvider::endWriteBatch() struct BatchStorageToken : public StorageToken { std::shared_ptr tspdb; // Note: This must be first so it is deleted last - std::unique_ptr tspbatch; + std::unique_ptr tspbatch; ~BatchStorageToken(){ tspdb.reset(); tspdb = nullptr; @@ -273,7 +273,7 @@ StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el m_spbatch = nullptr; m_lock.unlock(); (*m_pfactory->m_wqueue)->AddWorkFunction([this, el,callback,tok]{ - tok->tspdb->Write(WriteOptions(),tok->tspbatch.get()); + tok->tspdb->Write(WriteOptions(),tok->tspbatch.get()->GetWriteBatch()); aePostFunction(el,callback,tok); }); @@ -322,7 +322,7 @@ StorageToken *RocksDBStorageProvider::begin_retrieve(struct aeEventLoop *el, aeP } auto opts = ReadOptions(); - opts.async_io = true; + //opts.async_io = true; (*m_pfactory->m_wqueue)->AddWorkFunction([this, el, callback, tok, opts]{ std::vector veckeysStr; std::vector veckeys; @@ -362,4 +362,4 @@ void RocksDBStorageProvider::complete_retrieve(StorageToken *tok, callbackSingle } } delete rtok; -} \ No newline at end of file +} From b7ae81d712c37a7ea84251527e6619edcdb8067a Mon Sep 17 00:00:00 2001 From: a00817524 Date: Mon, 6 Nov 2023 18:23:45 +0000 Subject: [PATCH 08/11] reverting changes of async io rocksdb option as this is version dependent --- src/storage/rocksdb.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index e4c1d45ca..8c4429f3b 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -322,7 +322,7 @@ StorageToken *RocksDBStorageProvider::begin_retrieve(struct aeEventLoop *el, aeP } auto opts = ReadOptions(); - //opts.async_io = true; + opts.async_io = true; (*m_pfactory->m_wqueue)->AddWorkFunction([this, el, callback, tok, opts]{ std::vector veckeysStr; std::vector veckeys; From 0eca302c75912a27406e948998ba93146c636d05 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Wed, 8 Nov 2023 20:15:56 +0000 Subject: [PATCH 09/11] removing unwanted loc --- src/db.cpp | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/db.cpp b/src/db.cpp index a20ea0a3f..383637454 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3072,8 +3072,6 @@ void redisDbPersistentData::bulkDirectStorageInsert(char **rgKeys, size_t *rgcbK void redisDbPersistentData::commitChanges(const redisDbPersistentDataSnapshot **psnapshotFree) { - - std::unordered_set setcBlocked; if (m_pdbSnapshotStorageFlush) { dictIterator *di = dictGetIterator(m_dictChangedStorageFlush); @@ -3094,12 +3092,6 @@ void redisDbPersistentData::commitChanges(const redisDbPersistentDataSnapshot ** auto *tok = m_spstorage->begin_endWriteBatch(serverTL->el, storageLoadCallback); if (tok != nullptr) { - for (client *c : setcBlocked) //need to check how to push client to blocked list - { - if (!(c->flags & CLIENT_BLOCKED)) - blockClient(c, BLOCKED_STORAGE); - } - // tok->setc = std::move(setcBlocked); tok->db = this; tok->type = StorageToken::TokenType::BatchWrite; } From d2a5bef31f7364c06f169a39bad16ad47f009ce8 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Wed, 8 Nov 2023 20:17:12 +0000 Subject: [PATCH 10/11] whitespace removed --- src/db.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/src/db.cpp b/src/db.cpp index 383637454..a04b5700e 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3086,7 +3086,6 @@ void redisDbPersistentData::commitChanges(const redisDbPersistentDataSnapshot ** *psnapshotFree = m_pdbSnapshotStorageFlush; m_pdbSnapshotStorageFlush = nullptr; } - if (m_spstorage != nullptr) { auto *tok = m_spstorage->begin_endWriteBatch(serverTL->el, storageLoadCallback); From 59719a8fc332f6e67b409cc5a288fc5a74437898 Mon Sep 17 00:00:00 2001 From: a00817524 Date: Wed, 8 Nov 2023 20:52:23 +0000 Subject: [PATCH 11/11] review rework, added serverassert default switch case,removed debug prints, removed unwanted reset of pointers --- src/db.cpp | 5 +---- src/storage/rocksdb.cpp | 7 ------- 2 files changed, 1 insertion(+), 11 deletions(-) diff --git a/src/db.cpp b/src/db.cpp index a04b5700e..9a0f35684 100644 --- a/src/db.cpp +++ b/src/db.cpp @@ -3472,11 +3472,8 @@ void redisDbPersistentData::processStorageToken(StorageToken *tok) { tok->db->m_spstorage->complete_endWriteBatch(tok); break; } - case StorageToken::TokenType::SingleWrite: - { - break; - } default: + serverAssert((tok->type == StorageToken::TokenType::SingleRead) || (tok->type == StorageToken::TokenType::BatchWrite)); break; } //switch end diff --git a/src/storage/rocksdb.cpp b/src/storage/rocksdb.cpp index 8c4429f3b..56f00821f 100644 --- a/src/storage/rocksdb.cpp +++ b/src/storage/rocksdb.cpp @@ -258,15 +258,9 @@ void RocksDBStorageProvider::endWriteBatch() struct BatchStorageToken : public StorageToken { std::shared_ptr tspdb; // Note: This must be first so it is deleted last std::unique_ptr tspbatch; - ~BatchStorageToken(){ - tspdb.reset(); - tspdb = nullptr; - tspbatch = nullptr; - } }; StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el, aePostFunctionTokenProc* callback){ - serverLog(LL_WARNING, "RocksDBStorageProvider::begin_endWriteBatch"); BatchStorageToken *tok = new BatchStorageToken(); tok->tspbatch = std::move(m_spbatch); tok->tspdb = m_spdb; @@ -281,7 +275,6 @@ StorageToken* RocksDBStorageProvider::begin_endWriteBatch(struct aeEventLoop *el } void RocksDBStorageProvider::complete_endWriteBatch(StorageToken* tok){ - serverLog(LL_WARNING, "RocksDBStorageProvider::complete_endWriteBatch"); delete tok; tok = nullptr; }