make lock scope of size_ in cache smaller

src/cache/cache.cpp

@@ -254,14 +254,14 @@ bool Cache::get_table_settings(const std::string& tbn, TableSettings& tbs)
 
 bool Cache::must_evict()
 {
-    ScopedMutex lock(&nodes_mtx_);
+    ScopedMutex lock(&size_mtx_);
 
     return size_ >= options_.cache_limit;
 }
 
 bool Cache::need_evict()
 {
-    ScopedMutex lock(&nodes_mtx_);
+    ScopedMutex lock(&size_mtx_);
 
     size_t threshold = (options_.cache_limit * 
         options_.cache_evict_high_watermark) / 100;
@@ -328,8 +328,11 @@ void Cache::evict()
             }
         }
     }
+
+    ScopedMutex size_lock(&size_mtx_);
     // update size
     size_ = total_size;
+    size_lock.unlock();
 
     LRUComparator comp;
     sort(clean_nodes.begin(), clean_nodes.end(), comp);
@@ -358,9 +361,11 @@ void Cache::evict()
         delete node;
     }
 
+    size_lock.lock();
     // update size
     assert(size_ >= evicted_size);
     size_ -= evicted_size;
+    size_lock.unlock();
 
     lock.unlock();
 
@@ -437,8 +442,11 @@ void Cache::write_back()
                 }
             }
         }
+
+        ScopedMutex size_lock(&size_mtx_);
         // update size
         size_ = total_size;
+        size_lock.unlock();
 
         vector<Node*> flushed_nodes;
         size_t flushed_size = 0;

src/cache/cache.h

@@ -88,11 +88,12 @@ class Cache {
 
     Mutex tables_mtx_;
     std::map<std::string, TableSettings> tables_;
-
-    Mutex nodes_mtx_;
+
+    // TODO make me atomic
+    Mutex size_mtx_;
     // total memory size occupied by nodes,
     // updated everytime the flusher thread runs
-    size_t size_;
+    size_t size_;   
 
     class CacheKey {
     public:
@@ -109,6 +110,8 @@ class Cache {
         bid_t nid;
     };
 
+    Mutex nodes_mtx_;
+
     std::map<CacheKey, Node*> nodes_;
 
     // ensure there is only one thread is doing evict/flush