Example #1
0
        private static void MoveNextBenchSeries(Spreads.Collections.Experimental.Series <int, int> sm, int count, int mult)
        {
            // warm up
            for (int _ = 0; _ < 1; _++)
            {
                var cSM = sm.GetCursor();

                for (int i = 0; i < count; i++)
                {
                    cSM.MoveNext();
                }
            }

            using (Benchmark.Run("Series", count * mult))
            {
                long sum = 1L;
                for (int _ = 0; _ < mult; _++)
                {
                    var cSM = sm.GetCursor();

                    for (int i = 0; i < count; i++)
                    {
                        cSM.MoveNext();
                        sum = cSM.CurrentValue;
                    }
                }
                Assert.IsTrue(sum != 0);
            }
        }
Example #2
0
        public void CouldMoveNextBench()
        {
            var count  = 1000_000;
            var rounds = 20;
            var mult   = 1_00;

            var bcImm = CreateIntBaseContainer(count, count);

            bcImm._flags = new Flags((byte)Mutability.ReadOnly | (byte)KeySorting.Strong);

            var bcMut = CreateIntBaseContainer(count, count);

            bcMut._flags = new Flags((byte)Mutability.Mutable | (byte)KeySorting.Strong);

            BlockCursor <int, object, BaseContainer <int> >[] useMut = new BlockCursor <int, object, BaseContainer <int> > [count];
            var rng = new Random(42);

            var sm  = new SortedMap <int, int>(count);
            var scm = new SortedChunkedMap <int, int>();
            var sl  = new SortedList <int, int>(count);

            for (int i = 0; i < count; i++)
            {
                var x = rng.NextDouble();
                // if ((i & 1) == 0) // this is perfectly predicted on i7-8700, give ~300 MOPS
                if (x > 0.50) // this is not predicted at all, performance drops to ~130MOPS, but if we always use the Sync implementation the perf is the same ~300 MOPS, always NoSync ~360 MOPS
                {
                    useMut[i] = new BlockCursor <int, object, BaseContainer <int> >(bcMut);
                }
                else
                {
                    useMut[i] = new BlockCursor <int, object, BaseContainer <int> >(bcImm);
                }

                sm.Add(i, i);
                scm.Add(i, i);
                sl.Add(i, i);
            }

            var series = new Spreads.Collections.Experimental.Series <int, int>(Enumerable.Range(0, count).ToArray(),
                                                                                Enumerable.Range(0, count).ToArray());

            for (int r = 0; r < rounds; r++)
            {
                //MoveNextBenchBranch(useMut, count, mult);

                //MoveNextBenchMut(bcMut, count, mult);

                //MoveNextBenchImm(bcImm, count, mult);

                //MoveNextBenchSL(sl, count, mult);

                MoveNextBenchSM(sm, count, mult);

                // MoveNextBenchSCM(scm, count, mult);

                MoveNextBenchSeries(series, count, mult);
            }

            Benchmark.Dump();

            bcImm.Dispose();
            bcMut.Dispose();
        }