SERVER-19189: Remove counters from WT session cache

(cherry picked from commit 47b6b1a8fd60b0365f72c0550269c0dc0322acfd)

2 files changed, 15 insertions, 41 deletions

diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
index fdccda23848..0c10f877786 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.cpp
@@ -108,7 +108,7 @@ namespace mongo {
     void WiredTigerSession::closeAllCursors() {
         invariant(_session);
         for (CursorCache::iterator i = _cursors.begin(); i != _cursors.end(); ++i) {
-            WT_CURSOR *cursor = i->_cursor;
+            WT_CURSOR* cursor = i->_cursor;
             if (cursor) {
                 invariantWTOK(cursor->close(cursor));
             }
@@ -118,7 +118,6 @@ namespace mongo {
 
     namespace {
         AtomicUInt64 nextCursorId(1);
-        AtomicUInt64 sessionsInCache(0);
     }
     // static
     uint64_t WiredTigerSession::genCursorId() {
@@ -128,14 +127,10 @@ namespace mongo {
     // -----------------------
 
     WiredTigerSessionCache::WiredTigerSessionCache(WiredTigerKVEngine* engine)
-        : _engine(engine), _conn(engine->getConnection()),
-          _shuttingDown(0), _sessionsOut(0), _highWaterMark(1) {
-    }
+        : _engine(engine), _conn(engine->getConnection()), _shuttingDown(0) {}
 
     WiredTigerSessionCache::WiredTigerSessionCache(WT_CONNECTION* conn)
-        : _engine(NULL), _conn(conn),
-          _shuttingDown(0), _sessionsOut(0), _highWaterMark(1) {
-    }
+        : _engine(NULL), _conn(conn), _shuttingDown(0) {}
 
     WiredTigerSessionCache::~WiredTigerSessionCache() {
         shuttingDown();
@@ -161,7 +156,7 @@ namespace mongo {
 
         {
             boost::lock_guard<SpinLock> lock(_cacheLock);
-            _epoch++;
+            _epoch.fetchAndAdd(1);
             _sessions.swap(swap);
         }
 
@@ -177,11 +172,6 @@ namespace mongo {
         // operations should be allowed to start.
         invariant(!_shuttingDown.loadRelaxed());
 
-        // Set the high water mark if we need to
-        if (_sessionsOut.fetchAndAdd(1) > _highWaterMark.load()) {
-            _highWaterMark.store(_sessionsOut.load());
-        }
-
         {
             boost::lock_guard<SpinLock> lock(_cacheLock);
             if (!_sessions.empty()) {
@@ -189,13 +179,12 @@ namespace mongo {
                 // discarding older ones
                 WiredTigerSession* cachedSession = _sessions.back();
                 _sessions.pop_back();
-                sessionsInCache.fetchAndSubtract(1);
                 return cachedSession;
             }
        }
 
         // Outside of the cache partition lock, but on release will be put back on the cache
-        return new WiredTigerSession(_conn, _epoch);
+        return new WiredTigerSession(_conn, _epoch.load());
     }
 
     void WiredTigerSessionCache::releaseSession(WiredTigerSession* session) {
@@ -220,30 +209,22 @@ namespace mongo {
             invariant(range == 0);
         }
 
-        _sessionsOut.fetchAndSubtract(1);
- 
         bool returnedToCache = false;
-        invariant(session->_getEpoch() <= _epoch);
+        uint64_t currentEpoch = _epoch.load();
 
-        // Only return sessions until we hit the maximum number of sessions we have ever seen demand
-        // for concurrently. We also want to immediately delete any session that is from a
-        // non-current epoch.
-        if (sessionsInCache.load() < _highWaterMark.load()) {
+        if (session->_getEpoch() == currentEpoch) {  // check outside of lock to reduce contention
             boost::lock_guard<SpinLock> lock(_cacheLock);
-            if (session->_getEpoch() == _epoch) {
+            if (session->_getEpoch() == _epoch.load()) {  // recheck inside the lock for correctness
                 returnedToCache = true;
                 _sessions.push_back(session);
             }
-        }
+        } else
+            invariant(session->_getEpoch() < currentEpoch);
 
-        if (returnedToCache) {
-            sessionsInCache.fetchAndAdd(1);
-        } else {
+        if (!returnedToCache)
             delete session;
-        }
 
-        if (_engine && _engine->haveDropsQueued()) {
+        if (_engine && _engine->haveDropsQueued())
             _engine->dropAllQueued();
-        }
     }
 }
diff --git a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h
index 5e2358aae9e..de69ed79dae 100644
--- a/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h
+++ b/src/mongo/db/storage/wiredtiger/wiredtiger_session_cache.h
@@ -104,9 +104,9 @@ namespace mongo {
         typedef std::list<WiredTigerCachedCursor> CursorCache;
 
         // Used internally by WiredTigerSessionCache
-        int _getEpoch() const { return _epoch; }
+        uint64_t _getEpoch() const { return _epoch; }
 
-        const int _epoch;
+        const uint64_t _epoch;
         WT_SESSION* _session; // owned
         CursorCache _cursors; // owned
         uint64_t _cursorGen;
@@ -144,13 +144,6 @@ namespace mongo {
         SessionCache _sessions;
 
         // Bumped when all open sessions need to be closed
-        int _epoch;
-
-        // How many sessions are in use concurrently
-        AtomicUInt32 _sessionsOut;
-
-        // The most sessions we have ever in use concurrently.
-        AtomicUInt32 _highWaterMark;
+        AtomicUInt64 _epoch;  // atomic so we can check it outside of the lock
     };
-
 }