public void testConfigureCache_Limits1() { // This test is just to force coverage over some lower bounds for // the table. We don't want the table to wind up with too small // of a size. This is highly dependent upon the table allocation // algorithm actually implemented in WindowCache. // var cfg = new WindowCacheConfig { PackedGitLimit = 6 * 4096 / 5, PackedGitWindowSize = 4096 }; WindowCache.reconfigure(cfg); }
static UnpackedObjectCache() { Dead = new WeakReference<Entry>(null); _maxByteCount = new WindowCacheConfig().DeltaBaseCacheLimit; Cache = new Slot[CacheSize]; for (int i = 0; i < CacheSize; i++) { Cache[i] = new Slot(); } }
public void testCache_Defaults() { var cfg = new WindowCacheConfig(); WindowCache.reconfigure(cfg); DoCacheTests(); CheckLimits(cfg); WindowCache cache = WindowCache.Instance; Assert.AreEqual(6, cache.getOpenFiles()); Assert.AreEqual(17346, cache.getOpenBytes()); }
public static void Reconfigure(WindowCacheConfig cfg) { lock (locker) { int dbLimit = cfg.DeltaBaseCacheLimit; if (_maxByteCount != dbLimit) { _maxByteCount = dbLimit; ReleaseMemory(); } } }
public static void reconfigure(int packedGitLimit, int packedGitWindowSize, bool packedGitMMAP, int deltaBaseCacheLimit) { var c = new WindowCacheConfig { PackedGitLimit = packedGitLimit, PackedGitWindowSize = packedGitWindowSize, PackedGitMMAP = packedGitMMAP, DeltaBaseCacheLimit = deltaBaseCacheLimit }; reconfigure(c); }
public void testConfigureCache_PackedGitWindowSize_512() { try { var cfg = new WindowCacheConfig { PackedGitWindowSize = 512 }; WindowCache.reconfigure(cfg); Assert.Fail("incorrectly permitted PackedGitWindowSize = 512"); } catch (ArgumentException e) { Assert.AreEqual("Invalid window size", e.Message); } }
public void testConfigureCache_PackedGitOpenFiles_0() { try { var cfg = new WindowCacheConfig { PackedGitOpenFiles = 0 }; WindowCache.reconfigure(cfg); Assert.Fail("incorrectly permitted PackedGitOpenFiles = 0"); } catch (ArgumentException e) { Assert.AreEqual("Open files must be >= 1", e.Message); } }
/// <summary> /// Modify the configuration of the window cache. /// <para /> /// The new configuration is applied immediately. If the new limits are /// smaller than what what is currently cached, older entries will be purged /// as soon as possible to allow the cache to meet the new limit. /// </summary> /// <param name="cfg"> /// The new window cache configuration. /// </param> public static void reconfigure(WindowCacheConfig cfg) { var newCache = new WindowCache(cfg); WindowCache oldCache = _cache; if (oldCache != null) { oldCache.removeAll(); } _cache = newCache; UnpackedObjectCache.Reconfigure(cfg); }
public static void Reconfigure(WindowCacheConfig cfg) { if (cfg == null) throw new ArgumentNullException ("cfg"); lock(locker) { int dbLimit = cfg.DeltaBaseCacheLimit; if (_maxByteCount != dbLimit) { _maxByteCount = dbLimit; ReleaseMemory(); } } }
public static void Reconfigure(WindowCacheConfig cfg) { if (cfg == null) { throw new ArgumentNullException("cfg"); } lock (locker) { int dbLimit = cfg.DeltaBaseCacheLimit; if (_maxByteCount != dbLimit) { _maxByteCount = dbLimit; ReleaseMemory(); } } }
private static int TableSize(WindowCacheConfig cfg) { int wsz = cfg.PackedGitWindowSize; long limit = cfg.PackedGitLimit; if (wsz <= 0) { throw new ArgumentException("Invalid window size"); } if (limit < wsz) { throw new ArgumentException("Window size must be < limit"); } return((int)Math.Min(5 * (limit / wsz) / 2, 2000000000)); }
private WindowCache(WindowCacheConfig cfg) : base(TableSize(cfg), LockCount(cfg)) { _maxFiles = cfg.PackedGitOpenFiles; _maxBytes = cfg.PackedGitLimit; _memoryMap = cfg.PackedGitMMAP; _windowSizeShift = Bits(cfg.PackedGitWindowSize); _windowSize = 1 << _windowSizeShift; _openFiles = new AtomicInteger(); _openBytes = new AtomicLong(); if (_maxFiles < 1) { throw new ArgumentException("Open files must be >= 1"); } if (_maxBytes < _windowSize) { throw new ArgumentException("Window size must be < limit"); } }
public void testCache_TooFewFiles() { var cfg = new WindowCacheConfig { PackedGitOpenFiles = 2 }; WindowCache.reconfigure(cfg); DoCacheTests(); CheckLimits(cfg); }
public override void tearDown() { base.tearDown(); var windowCacheConfig = new WindowCacheConfig(); WindowCache.reconfigure(windowCacheConfig); }
public override void setUp() { var windowCacheConfig = new WindowCacheConfig { PackedGitOpenFiles = 1 }; WindowCache.reconfigure(windowCacheConfig); base.setUp(); }
private static void WhackCache() { var config = new WindowCacheConfig { PackedGitOpenFiles = 1 }; WindowCache.reconfigure(config); }
public void testConfigureCache_PackedGitWindowSize_4097() { try { var cfg = new WindowCacheConfig { PackedGitWindowSize = 4097 }; WindowCache.reconfigure(cfg); Assert.Fail("incorrectly permitted PackedGitWindowSize = 4097"); } catch (ArgumentException e) { Assert.AreEqual("Window size must be power of 2", e.Message); } }
public void testConfigureCache_PackedGitLimit_0() { var cfg = new WindowCacheConfig { PackedGitLimit = 0 }; AssertHelper.Throws<ArgumentException>(() => WindowCache.reconfigure(cfg)); }
public void testConfigureCache_PackedGitWindowSizeAbovePackedGitLimit() { try { var cfg = new WindowCacheConfig { PackedGitLimit = 1024, PackedGitWindowSize = 8192 }; WindowCache.reconfigure(cfg); Assert.Fail("incorrectly permitted PackedGitWindowSize > PackedGitLimit"); } catch (ArgumentException e) { Assert.AreEqual("Window size must be < limit", e.Message); } }
private static void CheckLimits(WindowCacheConfig cfg) { WindowCache cache = WindowCache.Instance; Assert.IsTrue(cache.getOpenFiles() <= cfg.PackedGitOpenFiles); Assert.IsTrue(cache.getOpenBytes() <= cfg.PackedGitLimit); Assert.IsTrue(0 < cache.getOpenFiles()); Assert.IsTrue(0 < cache.getOpenBytes()); }
private static int LockCount(WindowCacheConfig cfg) { return(Math.Max(cfg.PackedGitOpenFiles, 32)); }
public virtual void setUp(){ recursiveDelete(testName() + " (SetUp)", trash, false, true); mockSystemReader = new MockSystemReader(); mockSystemReader.userGitConfig = new FileBasedConfig(new FileInfo(Path.Combine(trash.FullName, "usergitconfig"))); SystemReader.setInstance(mockSystemReader); long now = mockSystemReader.getCurrentTime(); int tz = mockSystemReader.getTimezone(now); author = new PersonIdent("J. Author", "*****@*****.**"); author = new PersonIdent(author, now, tz); committer = new PersonIdent("J. Committer", "*****@*****.**"); committer = new PersonIdent(committer, now, tz); WindowCacheConfig c = new WindowCacheConfig(); c.PackedGitLimit = (128 * WindowCacheConfig.Kb); c.PackedGitWindowSize = (8 * WindowCacheConfig.Kb); c.PackedGitMMAP = (useMMAP); c.DeltaBaseCacheLimit = (8 * WindowCacheConfig.Kb); WindowCache.reconfigure(c); }
public static void Reconfigure(WindowCacheConfig cfg) { lock(locker) { int dbLimit = cfg.DeltaBaseCacheLimit; if (_maxByteCount != dbLimit) { _maxByteCount = dbLimit; ReleaseMemory(); } } }
public void testCache_TooSmallLimit() { var cfg = new WindowCacheConfig { PackedGitWindowSize = 4096, PackedGitLimit = 4096 }; WindowCache.reconfigure(cfg); DoCacheTests(); CheckLimits(cfg); }
public void test029_mapObject_using_memory_mapped_file() { WindowCacheConfig c = new WindowCacheConfig(); c.PackedGitLimit = (128 * WindowCacheConfig.Kb); c.PackedGitWindowSize = (8 * WindowCacheConfig.Kb); c.PackedGitMMAP = (true); c.DeltaBaseCacheLimit = (8 * WindowCacheConfig.Kb); WindowCache.reconfigure(c); var repo = createWorkRepository(); Assert.AreEqual((new byte[0].GetType()), repo.MapObject(ObjectId.FromString("5b6e7c66c276e7610d4a73c70ec1a1f7c1003259"), null).GetType()); Assert.AreEqual(typeof(global::GitSharp.Core.Commit), repo.MapObject(ObjectId.FromString("540a36d136cf413e4b064c2b0e0a4db60f77feab"), null).GetType()); Assert.AreEqual(typeof(global::GitSharp.Core.Tree), repo.MapObject(ObjectId.FromString("aabf2ffaec9b497f0950352b3e582d73035c2035"), null).GetType()); Assert.AreEqual(typeof(global::GitSharp.Core.Tag), repo.MapObject(ObjectId.FromString("17768080a2318cd89bba4c8b87834401e2095703"), null).GetType()); }