DataCellCache.cs

Go to the documentation of this file.

// 
//  Copyright 2010-2014 Deveel
// 
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
// 
//        http://www.apache.org/licenses/LICENSE-2.0
// 
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.

using System;

using Deveel.Data.DbSystem;
using Deveel.Diagnostics;

namespace Deveel.Data.Caching {
    public sealed class DataCellCache {
        private static readonly int[] PRIME_LIST = new int[]
                                                   {
                                                    3001, 4799, 13999, 15377, 21803, 24247, 35083, 40531, 43669, 44263, 47387,
                                                    50377, 57059, 57773, 59399, 59999, 75913, 96821, 140551, 149011, 175633,
                                                    176389, 183299, 205507, 209771, 223099, 240259, 258551, 263909, 270761,
                                                    274679, 286129, 290531, 296269, 298021, 300961, 306407, 327493, 338851,
                                                    351037, 365489, 366811, 376769, 385069, 410623, 430709, 433729, 434509,
                                                    441913, 458531, 464351, 470531, 475207, 479629, 501703, 510709, 516017,
                                                    522211, 528527, 536311, 539723, 557567, 593587, 596209, 597451, 608897,
                                                    611069, 642547, 670511, 677827, 679051, 688477, 696743, 717683, 745931,
                                                    757109, 760813, 763957, 766261, 781559, 785597, 788353, 804493, 813559,
                                                    836917, 854257, 859973, 883217, 884789, 891493, 902281, 910199, 915199,
                                                    930847, 939749, 940483, 958609, 963847, 974887, 983849, 984299, 996211,
                                                    999217, 1007519, 1013329, 1014287, 1032959, 1035829, 1043593, 1046459,
                                                    1076171, 1078109, 1081027, 1090303, 1095613, 1098847, 1114037, 1124429,
                                                    1125017, 1130191, 1159393, 1170311, 1180631, 1198609, 1200809, 1212943,
                                                    1213087, 1226581, 1232851, 1287109, 1289867, 1297123, 1304987, 1318661,
                                                    1331107, 1343161, 1345471, 1377793, 1385117, 1394681, 1410803, 1411987,
                                                    1445261, 1460497, 1463981, 1464391, 1481173, 1488943, 1491547, 1492807,
                                                    1528993, 1539961, 1545001, 1548247, 1549843, 1551001, 1553023, 1571417,
                                                    1579099, 1600259, 1606153, 1606541, 1639751, 1649587, 1657661, 1662653,
                                                    1667051, 1675273, 1678837, 1715537, 1718489, 1726343, 1746281, 1749107,
                                                    1775489, 1781881, 1800157, 1806859, 1809149, 1826753, 1834607, 1846561,
                                                    1849241, 1851991, 1855033, 1879931, 1891133, 1893737, 1899137, 1909513,
                                                    1916599, 1917749, 1918549, 1919347, 1925557, 1946489, 1961551, 1965389,
                                                    2011073, 2033077, 2039761, 2054047, 2060171, 2082503, 2084107, 2095099,
                                                    2096011, 2112193, 2125601, 2144977, 2150831, 2157401, 2170141, 2221829,
                                                    2233019, 2269027, 2270771, 2292449, 2299397, 2303867, 2309891, 2312407,
                                                    2344301, 2348573, 2377007, 2385113, 2386661, 2390051, 2395763, 2422999,
                                                    2448367, 2500529, 2508203, 2509841, 2513677, 2516197, 2518151, 2518177,
                                                    2542091, 2547469, 2549951, 2556991, 2563601, 2575543, 2597629, 2599577,
                                                    2612249, 2620003, 2626363, 2626781, 2636773, 2661557, 2674297, 2691571,
                                                    2718269, 2725691, 2729381, 2772199, 2774953, 2791363, 2792939, 2804293,
                                                    2843021, 2844911, 2851313, 2863519, 2880797, 2891821, 2897731, 2904887,
                                                    2910251, 2928943, 2958341, 2975389
                                                   };

        private readonly DCCache cache;

        private readonly SystemContext context;

        private long currentCacheSize;

        private int maxCellSize;

        internal DataCellCache(SystemContext context, ICache systemCache, int maxCacheSize, int maxCellSize, int hashSize) {
            this.context = context;
            this.maxCellSize = maxCellSize;

            cache = new DCCache(this, systemCache, hashSize, maxCacheSize);
        }

        internal DataCellCache(SystemContext context, ICache systemCache, int maxCacheSize, int maxCellSize)
            : this(context, systemCache, maxCacheSize, maxCellSize, 88547) {
            // Good prime number hash size
        }

        public long CurrentCacheSize {
            get {
                lock (this) {
                    return currentCacheSize;
                }
            }
        }

        public void AlterCacheDynamics(int maxCacheSize, int maxCellSize) {
            lock (this) {
                this.maxCellSize = maxCellSize;
                cache.SetCacheSize(maxCacheSize);
            }
        }

        private static int AmountMemory(DataObject cell) {
            return 16 + cell.SizeOf();
        }

        public void Set(int tableKey, int row, int column, DataObject cell) {
            lock (this) {
                int memoryUse = AmountMemory(cell);
                if (memoryUse <= maxCellSize) {
                    // Generate the key
                    var key = new DCCacheKey(tableKey, (short)column, row);
                    // If there is an existing object here, remove it from the cache and
                    // update the current_cache_size.
                    var removedCell = (DataObject)cache.Remove(key);
                    if (removedCell != null) {
                        currentCacheSize -= AmountMemory(removedCell);
                    }
                    // Put the new entry in the cache
                    cache.Set(key, cell);
                    currentCacheSize += memoryUse;
                } else {
                    // If the object is larger than the minimum object size that can be
                    // cached, remove any existing entry (possibly smaller) from the cache.
                    Remove(tableKey, row, column);
                }
            }
        }

        public DataObject Get(int tableKey, int row, int column) {
            lock (this) {
                return (DataObject) cache.Get(new DCCacheKey(tableKey, (short) column, row));
            }
        }

        public DataObject Remove(int tableKey, int row, int column) {
            lock (this) {
                var cell = (DataObject)cache.Remove(new DCCacheKey(tableKey, (short) column, row));
                if (cell != null)
                    currentCacheSize -= AmountMemory(cell);
                return cell;
            }
        }

        public void Clear() {
            lock (this) {
                if (cache.NodeCount == 0 && currentCacheSize != 0) {
                    context.Logger.Error(this, "Assertion failed - if nodeCount = 0 then current_cache_size must also be 0.");
                }
                if (cache.NodeCount != 0) {
                    cache.Clear();
                    context.Stats.Increment(StatsDefaultKeys.DataCellCacheTotalWipes);
                }
                currentCacheSize = 0;
            }
        }

        private void ReduceCacheSize(long val) {
            currentCacheSize -= val;
        }

        // ---------- Primes ----------

        internal static int ClosestPrime(int value) {
            for (int i = 0; i < PRIME_LIST.Length; ++i) {
                if (PRIME_LIST[i] >= value) {
                    return PRIME_LIST[i];
                }
            }
            // Return the last prime
            return PRIME_LIST[PRIME_LIST.Length - 1];
        }

        #region DCCache

        private sealed class DCCache : CacheWrapper {
            private readonly DataCellCache cache;

            private int maxCacheSize;

            public DCCache(DataCellCache cache, ICache systemCache, int cache_hash_size, int max_cache_size)
                : base(systemCache, cache_hash_size) {
                this.cache = cache;
                maxCacheSize = max_cache_size;
            }


            public void SetCacheSize(int cache_size) {
                maxCacheSize = cache_size;
                CheckClean();
            }

            // ----- Overwritten from Cache -----

            protected override void CheckClean() {
                if (cache.CurrentCacheSize >= maxCacheSize) {
                    // Update the current cache size (before we wiped).
                    cache.context.Stats.Set(StatsDefaultKeys.DataCellCacheCurrentSize, (int) cache.CurrentCacheSize);
                    Clean();

                    // The number of times we've cleared away old data cell nodes.
                    cache.context.Stats.Increment(StatsDefaultKeys.DataCellCacheClean);
                }
            }

            protected override bool WipeMoreNodes() {
                return (cache.CurrentCacheSize >= (int) ((maxCacheSize*100L)/115L));
            }

            protected override void OnWipingNode(Object ob) {
                base.OnWipingNode(ob);

                // Update our memory indicator accordingly.
                var cell = (DataObject)ob;
                cache.ReduceCacheSize(AmountMemory(cell));
            }

            protected override void OnGetWalks(long totalWalks, long totalGetOps) {
                int avg = (int) ((totalWalks*1000000L)/totalGetOps);
                cache.context.Stats.Set("DataCellCache.avg_hash_get_mul_1000000", avg);
                cache.context.Stats.Set("DataCellCache.current_cache_size", (int) cache.CurrentCacheSize);
                cache.context.Stats.Set("DataCellCache.current_node_count", NodeCount);
            }
        }

        #endregion

        #region DCCacheKey

        private struct DCCacheKey {
            private readonly short column;
            private readonly int row;
            private readonly int tableId;

            internal DCCacheKey(int tableId, short column, int row) {
                this.tableId = tableId;
                this.column = column;
                this.row = row;
            }

            public override bool Equals(Object ob) {
                DCCacheKey destKey = (DCCacheKey)ob;
                return row == destKey.row &&
                       column == destKey.column &&
                       tableId == destKey.tableId;
            }

            public override int GetHashCode() {
                // Yicks - this one is the best by far!
                return (((int) column + tableId + (row*189977))*50021) << 4;
            }
        }

        #endregion
    }
}