Пример #1
0
        public void NestedWriteLocking2()
        {
            var d = new SnapDictionary <int, string>();

            d.Test.CollectAuto = false;

            Assert.AreEqual(0, d.CreateSnapshot().Gen);

            // scope context: writers enlist

            var scopeContext  = new ScopeContext();
            var scopeProvider = GetScopeProvider(scopeContext);

            using (var w1 = d.GetScopedWriteLock(scopeProvider))
            {
                // This one is interesting, although we don't allow recursive locks, since this is
                // using the same ScopeContext/key, the lock acquisition is only done once

                using (var w2 = d.GetScopedWriteLock(scopeProvider))
                {
                    Assert.AreSame(w1, w2);

                    d.SetLocked(1, "one");
                }
            }
        }
Пример #2
0
        public void WriteLocking()
        {
            var d = new SnapDictionary <int, string>();

            d.Test.CollectAuto = false;

            // gen 1
            d.Set(1, "one");
            Assert.AreEqual(1, d.Test.GetValues(1).Length);

            Assert.AreEqual(1, d.Test.LiveGen);
            Assert.IsTrue(d.Test.NextGen);

            var s1 = d.CreateSnapshot();

            Assert.AreEqual(1, s1.Gen);
            Assert.AreEqual(1, d.Test.LiveGen);
            Assert.IsFalse(d.Test.NextGen);
            Assert.AreEqual("one", s1.Get(1));

            // gen 2
            Assert.AreEqual(1, d.Test.GetValues(1).Length);
            d.Set(1, "uno");
            Assert.AreEqual(2, d.Test.GetValues(1).Length);

            Assert.AreEqual(2, d.Test.LiveGen);
            Assert.IsTrue(d.Test.NextGen);

            var s2 = d.CreateSnapshot();

            Assert.AreEqual(2, s2.Gen);
            Assert.AreEqual(2, d.Test.LiveGen);
            Assert.IsFalse(d.Test.NextGen);
            Assert.AreEqual("uno", s2.Get(1));

            using (d.GetScopedWriteLock(GetScopeProvider()))
            {
                // gen 3
                Assert.AreEqual(2, d.Test.GetValues(1).Length);
                d.SetLocked(1, "ein");
                Assert.AreEqual(3, d.Test.GetValues(1).Length);

                Assert.AreEqual(3, d.Test.LiveGen);
                Assert.IsTrue(d.Test.NextGen);

                var s3 = d.CreateSnapshot();

                Assert.AreEqual(2, s3.Gen);
                Assert.AreEqual(3, d.Test.LiveGen);
                Assert.IsTrue(d.Test.NextGen); // has NOT changed when (non) creating snapshot
                Assert.AreEqual("uno", s3.Get(1));
            }

            var s4 = d.CreateSnapshot();

            Assert.AreEqual(3, s4.Gen);
            Assert.AreEqual(3, d.Test.LiveGen);
            Assert.IsFalse(d.Test.NextGen);
            Assert.AreEqual("ein", s4.Get(1));
        }
Пример #3
0
 internal static void Set <TKey, TValue>(this SnapDictionary <TKey, TValue> d, TKey key, TValue value)
     where TValue : class
 {
     using (d.GetScopedWriteLock(GetScopeProvider()))
     {
         d.SetLocked(key, value);
     }
 }
Пример #4
0
        public void ScopeLocking1()
        {
            var d = new SnapDictionary <int, string>();

            d.Test.CollectAuto = false;

            // gen 1
            d.Set(1, "one");
            var s1 = d.CreateSnapshot();

            Assert.AreEqual(1, s1.Gen);
            Assert.AreEqual("one", s1.Get(1));

            d.Set(1, "uno");
            var s2 = d.CreateSnapshot();

            Assert.AreEqual(2, s2.Gen);
            Assert.AreEqual("uno", s2.Get(1));

            var scopeContext  = new ScopeContext();
            var scopeProvider = GetScopeProvider(scopeContext);

            using (d.GetScopedWriteLock(scopeProvider))
            {
                // creating a snapshot in a write-lock does NOT return the "current" content
                // it uses the previous snapshot, so new snapshot created only on release
                d.SetLocked(1, "ein");
                var s3 = d.CreateSnapshot();
                Assert.AreEqual(2, s3.Gen);
                Assert.AreEqual("uno", s3.Get(1));

                // but live snapshot contains changes
                var ls = d.Test.LiveSnapshot;
                Assert.AreEqual("ein", ls.Get(1));
                Assert.AreEqual(3, ls.Gen);
            }

            var s4 = d.CreateSnapshot();

            Assert.AreEqual(2, s4.Gen);
            Assert.AreEqual("uno", s4.Get(1));

            scopeContext.ScopeExit(true);

            var s5 = d.CreateSnapshot();

            Assert.AreEqual(3, s5.Gen);
            Assert.AreEqual("ein", s5.Get(1));
        }
Пример #5
0
        public void DontPanic()
        {
            var d = new SnapDictionary <int, string>();

            d.Test.CollectAuto = false;

            Assert.IsNull(d.Test.GenObj);

            // gen 1
            d.Set(1, "one");
            Assert.IsTrue(d.Test.NextGen);
            Assert.AreEqual(1, d.Test.LiveGen);
            Assert.IsNull(d.Test.GenObj);

            var s1 = d.CreateSnapshot();

            Assert.IsFalse(d.Test.NextGen);
            Assert.AreEqual(1, d.Test.LiveGen);
            Assert.IsNotNull(d.Test.GenObj);
            Assert.AreEqual(1, d.Test.GenObj.Gen);

            Assert.AreEqual(1, s1.Gen);
            Assert.AreEqual("one", s1.Get(1));

            d.Set(1, "uno");
            Assert.IsTrue(d.Test.NextGen);
            Assert.AreEqual(2, d.Test.LiveGen);
            Assert.IsNotNull(d.Test.GenObj);
            Assert.AreEqual(1, d.Test.GenObj.Gen);

            var scopeContext  = new ScopeContext();
            var scopeProvider = GetScopeProvider(scopeContext);

            // scopeProvider.Context == scopeContext -> writer is scoped
            // writer is scope contextual and scoped
            //  when disposed, nothing happens
            //  when the context exists, the writer is released

            using (d.GetScopedWriteLock(scopeProvider))
            {
                d.SetLocked(1, "ein");
                Assert.IsTrue(d.Test.NextGen);
                Assert.AreEqual(3, d.Test.LiveGen);
                Assert.IsNotNull(d.Test.GenObj);
                Assert.AreEqual(2, d.Test.GenObj.Gen);
            }

            // writer has not released
            Assert.IsTrue(d.Test.IsLocked);
            Assert.IsNotNull(d.Test.GenObj);
            Assert.AreEqual(2, d.Test.GenObj.Gen);

            // nothing changed
            Assert.IsTrue(d.Test.NextGen);
            Assert.AreEqual(3, d.Test.LiveGen);

            // panic!
            var s2 = d.CreateSnapshot();

            Assert.IsTrue(d.Test.IsLocked);
            Assert.IsNotNull(d.Test.GenObj);
            Assert.AreEqual(2, d.Test.GenObj.Gen);
            Assert.AreEqual(3, d.Test.LiveGen);
            Assert.IsTrue(d.Test.NextGen);

            // release writer
            scopeContext.ScopeExit(true);

            Assert.IsFalse(d.Test.IsLocked);
            Assert.IsNotNull(d.Test.GenObj);
            Assert.AreEqual(2, d.Test.GenObj.Gen);
            Assert.AreEqual(3, d.Test.LiveGen);
            Assert.IsTrue(d.Test.NextGen);

            var s3 = d.CreateSnapshot();

            Assert.IsFalse(d.Test.IsLocked);
            Assert.IsNotNull(d.Test.GenObj);
            Assert.AreEqual(3, d.Test.GenObj.Gen);
            Assert.AreEqual(3, d.Test.LiveGen);
            Assert.IsFalse(d.Test.NextGen);
        }
Пример #6
0
        public void ScopeLocking2()
        {
            var d = new SnapDictionary <int, string>();
            var t = d.Test;

            t.CollectAuto = false;

            // gen 1
            d.Set(1, "one");
            var s1 = d.CreateSnapshot();

            Assert.AreEqual(1, s1.Gen);
            Assert.AreEqual("one", s1.Get(1));

            d.Set(1, "uno");
            var s2 = d.CreateSnapshot();

            Assert.AreEqual(2, s2.Gen);
            Assert.AreEqual("uno", s2.Get(1));

            Assert.AreEqual(2, t.LiveGen);
            Assert.IsFalse(t.NextGen);

            var scopeContext  = new ScopeContext();
            var scopeProvider = GetScopeProvider(scopeContext);

            using (d.GetScopedWriteLock(scopeProvider))
            {
                // creating a snapshot in a write-lock does NOT return the "current" content
                // it uses the previous snapshot, so new snapshot created only on release
                d.SetLocked(1, "ein");
                var s3 = d.CreateSnapshot();
                Assert.AreEqual(2, s3.Gen);
                Assert.AreEqual("uno", s3.Get(1));

                // we made some changes, so a next gen is required
                Assert.AreEqual(3, t.LiveGen);
                Assert.IsTrue(t.NextGen);
                Assert.IsTrue(t.IsLocked);

                // but live snapshot contains changes
                var ls = t.LiveSnapshot;
                Assert.AreEqual("ein", ls.Get(1));
                Assert.AreEqual(3, ls.Gen);
            }

            // nothing is committed until scope exits
            Assert.AreEqual(3, t.LiveGen);
            Assert.IsTrue(t.NextGen);
            Assert.IsTrue(t.IsLocked);

            // no changes until exit
            var s4 = d.CreateSnapshot();

            Assert.AreEqual(2, s4.Gen);
            Assert.AreEqual("uno", s4.Get(1));

            scopeContext.ScopeExit(false);

            // now things have changed
            Assert.AreEqual(2, t.LiveGen);
            Assert.IsFalse(t.NextGen);
            Assert.IsFalse(t.IsLocked);

            // no changes since not completed
            var s5 = d.CreateSnapshot();

            Assert.AreEqual(2, s5.Gen);
            Assert.AreEqual("uno", s5.Get(1));
        }