Artifact aebde2f4a22e5bb508582cc8be138954ea059f02:
- File System.Data.SQLite/SQLiteConnectionPool.cs — part of check-in [7b3fe92dcb] at 2012-05-03 13:44:30 on branch trunk — Do not attempt to reset a connection if it has been closed. Also, prevent any potential GC race while resetting a connection. Keep track of the total number of connections successfully opened and closed from any of the pools. Enhance test for ticket [996d13cd87] to make sure that at least one connection was opened and closed from a connection pool. (user: mistachkin size: 10412)
/******************************************************** * ADO.NET 2.0 Data Provider for SQLite Version 3.X * Written by Robert Simpson (robert@blackcastlesoft.com) * * Released to the public domain, use at your own risk! ********************************************************/ namespace System.Data.SQLite { using System; using System.Collections.Generic; using System.Threading; internal static class SQLiteConnectionPool { /// <summary> /// Keeps track of connections made on a specified file. The PoolVersion dictates whether old objects get /// returned to the pool or discarded when no longer in use. /// </summary> internal class Pool { internal readonly Queue<WeakReference> Queue = new Queue<WeakReference>(); internal int PoolVersion; internal int MaxPoolSize; internal Pool(int version, int maxSize) { PoolVersion = version; MaxPoolSize = maxSize; } } /// <summary> /// The connection pool object /// </summary> private static SortedList<string, Pool> _connections = new SortedList<string, Pool>(StringComparer.OrdinalIgnoreCase); /// <summary> /// The default version number new pools will get /// </summary> private static int _poolVersion = 1; /// <summary> /// The number of connections successfully opened from any pool. /// This value is incremented by the Remove method. /// </summary> private static int _poolOpened = 0; /// <summary> /// The number of connections successfully closed from any pool. /// This value is incremented by the Add method. /// </summary> private static int _poolClosed = 0; /// <summary> /// Counts the number of pool entries matching the specified file name. /// </summary> /// <param name="fileName">The file name to match or null to match all files.</param> /// <param name="counts">The pool entry counts for each matching file.</param> /// <param name="openCount">The total number of connections successfully opened from any pool.</param> /// <param name="closeCount">The total number of connections successfully closed from any pool.</param> /// <param name="totalCount">The total number of pool entries for all matching files.</param> internal static void GetCounts( string fileName, ref Dictionary<string, int> counts, ref int openCount, ref int closeCount, ref int totalCount ) { lock (_connections) { openCount = _poolOpened; closeCount = _poolClosed; if (counts == null) { counts = new Dictionary<string, int>( StringComparer.OrdinalIgnoreCase); } if (fileName != null) { Pool queue; if (_connections.TryGetValue(fileName, out queue)) { Queue<WeakReference> poolQueue = queue.Queue; int count = (poolQueue != null) ? poolQueue.Count : 0; counts.Add(fileName, count); totalCount += count; } } else { foreach (KeyValuePair<string, Pool> pair in _connections) { if (pair.Value == null) continue; Queue<WeakReference> poolQueue = pair.Value.Queue; int count = (poolQueue != null) ? poolQueue.Count : 0; counts.Add(pair.Key, count); totalCount += count; } } } } /// <summary> /// Attempt to pull a pooled connection out of the queue for active duty /// </summary> /// <param name="fileName">The filename for a desired connection</param> /// <param name="maxPoolSize">The maximum size the connection pool for the filename can be</param> /// <param name="version">The pool version the returned connection will belong to</param> /// <returns>Returns NULL if no connections were available. Even if none are, the poolversion will still be a valid pool version</returns> internal static SQLiteConnectionHandle Remove(string fileName, int maxPoolSize, out int version) { lock (_connections) { Pool queue; // Default to the highest pool version version = _poolVersion; // If we didn't find a pool for this file, create one even though it will be empty. // We have to do this here because otherwise calling ClearPool() on the file will not work for active connections // that have never seen the pool yet. if (_connections.TryGetValue(fileName, out queue) == false) { queue = new Pool(_poolVersion, maxPoolSize); _connections.Add(fileName, queue); return null; } // We found a pool for this file, so use its version number version = queue.PoolVersion; queue.MaxPoolSize = maxPoolSize; ResizePool(queue, false); // Try and get a pooled connection from the queue Queue<WeakReference> poolQueue = queue.Queue; if (poolQueue == null) return null; while (poolQueue.Count > 0) { WeakReference cnn = poolQueue.Dequeue(); SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle; if ((hdl != null) && !hdl.IsClosed && !hdl.IsInvalid) { Interlocked.Increment(ref _poolOpened); return hdl; } GC.KeepAlive(hdl); } return null; } } /// <summary> /// Clears out all pooled connections and rev's up the default pool version to force all old active objects /// not in the pool to get discarded rather than returned to their pools. /// </summary> internal static void ClearAllPools() { lock (_connections) { foreach (KeyValuePair<string, Pool> pair in _connections) { if (pair.Value == null) continue; Queue<WeakReference> poolQueue = pair.Value.Queue; while (poolQueue.Count > 0) { WeakReference cnn = poolQueue.Dequeue(); SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle; if (hdl != null) { hdl.Dispose(); } GC.KeepAlive(hdl); } // Keep track of the highest revision so we can go one higher when we're finished if (_poolVersion <= pair.Value.PoolVersion) _poolVersion = pair.Value.PoolVersion + 1; } // All pools are cleared and we have a new highest version number to force all old version active items to get discarded // instead of going back to the queue when they are closed. // We can get away with this because we've pumped up the _poolVersion out of range of all active connections, so they // will all get discarded when they try to put themselves back in their pool. _connections.Clear(); } } /// <summary> /// Clear a given pool for a given filename. Discards anything in the pool for the given file, and revs the pool /// version so current active objects on the old version of the pool will get discarded rather than be returned to the pool. /// </summary> /// <param name="fileName">The filename of the pool to clear</param> internal static void ClearPool(string fileName) { lock (_connections) { Pool queue; if (_connections.TryGetValue(fileName, out queue) == true) { queue.PoolVersion++; Queue<WeakReference> poolQueue = queue.Queue; if (poolQueue == null) return; while (poolQueue.Count > 0) { WeakReference cnn = poolQueue.Dequeue(); SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle; if (hdl != null) { hdl.Dispose(); } GC.KeepAlive(hdl); } } } } /// <summary> /// Return a connection to the pool for someone else to use. /// </summary> /// <param name="fileName">The filename of the pool to use</param> /// <param name="hdl">The connection handle to pool</param> /// <param name="version">The pool version the handle was created under</param> /// <remarks> /// If the version numbers don't match between the connection and the pool, then the handle is discarded. /// </remarks> internal static void Add(string fileName, SQLiteConnectionHandle hdl, int version) { lock (_connections) { // If the queue doesn't exist in the pool, then it must've been cleared sometime after the connection was created. Pool queue; if (_connections.TryGetValue(fileName, out queue) == true && version == queue.PoolVersion) { ResizePool(queue, true); Queue<WeakReference> poolQueue = queue.Queue; if (poolQueue == null) return; poolQueue.Enqueue(new WeakReference(hdl, false)); Interlocked.Increment(ref _poolClosed); GC.KeepAlive(hdl); } else { hdl.Close(); } } } /// <summary> /// We don't have to thread-lock anything in this function, because it's only called by other functions above /// which already have a thread-safe lock. /// </summary> /// <param name="queue">The queue to resize</param> /// <param name="forAdding">If a function intends to add to the pool, this is true, which forces the resize /// to take one more than it needs from the pool</param> private static void ResizePool(Pool queue, bool forAdding) { int target = queue.MaxPoolSize; if (forAdding && target > 0) target--; Queue<WeakReference> poolQueue = queue.Queue; if (poolQueue == null) return; while (poolQueue.Count > target) { WeakReference cnn = poolQueue.Dequeue(); SQLiteConnectionHandle hdl = cnn.Target as SQLiteConnectionHandle; if (hdl != null) { hdl.Dispose(); } GC.KeepAlive(hdl); } } } }