Пример #1
0
        public async Task CouldWriteUsingDswAsync()
        {
#pragma warning disable 618
            Settings.DoAdditionalCorrectnessChecks = false;
#pragma warning restore 618

            var path          = TestUtils.GetPath();
            var repoName      = "CouldWriteAndReadLog";
            var processConfig = new ProcessConfig(path);

            StartupConfig.StreamLogBufferPoolFlags = LMDBEnvironmentFlags.NoSync;
            StartupConfig.StreamBlockIndexFlags    = LMDBEnvironmentFlags.NoSync;

            var slm = new StreamLogManager(processConfig, repoName, null, 20 * 1024, disableNotificationLog: false,
                                           disablePacker: false);

            var streamId = (StreamLogId)42L;

            var count      = TestUtils.GetBenchCount(50_000_000, 1_000);
            var countSlice = TestUtils.GetBenchCount(10_000_000, 100);

            short valueSize = (short)(Timestamp.Size + Unsafe.SizeOf <long>());

            var state = slm.StateStorage.GetState(streamId);
            state.CheckInit(streamId, valueSize, StreamLogFlags.IsBinary);

            var sl = new StreamLog(slm, state, 8_000_000, "test_stream");

            Marshal.WriteInt64(sl.State.StatePointer + StreamLogState.StreamLogStateRecord.LockerOffset, 0);

            slm.OpenStreams.TryAdd(42, sl);

            var writer = new DataStreamWriter <long>(sl, KeySorting.NotEnforced, WriteMode.BatchWrite);

            try
            {
                var bench = Benchmark.Run("Write", countSlice);
                for (long i = 0; i < count; i++)
                {
                    var addedVersion = await writer.TryAppend(100000L + i);

                    if (addedVersion == 0)
                    {
                        Assert.Fail();
                    }

                    if (i > 0 && i % countSlice == 0)
                    {
                        bench.Dispose();
                        bench = Benchmark.Run("Write", countSlice);
                    }
                }

                bench.Dispose();
            }
            catch (Exception ex)
            {
                Console.WriteLine($"EXCEPTION DURING WRITE: " + ex);
                throw;
            }

            for (int r = 0; r < 10; r++)
            {
                using (Benchmark.Run("Read", count))
                {
                    var slc = sl.GetCursor();
                    var dsc = new DataStreamCursor <long>(slc);
                    var ds  = dsc.Source;
                    var c   = ds.GetCursor();

                    var cnt = 0L;
                    while (c.MoveNext())
                    {
                        var cv = c.CurrentValue;
                        var ts = cv.Timestamp;
                        if (ts == default)
                        {
                            Assert.Fail("ts == default");
                        }

                        var value = cv.Value;

                        if (value != 100000L + cnt)
                        {
                            Assert.Fail($"value {value} != cnt {100000L + cnt}");
                        }
                        cnt++;
                    }
                    c.Dispose();
                    if (cnt != count)
                    {
                        Assert.Fail($"cnt {cnt } != count {count}");
                    }
                }
            }

            slm.BufferPool.PrintBuffersAfterPoolDispose = true;

            Thread.Sleep(500);

            // TODO (!) Fix disposal

            // sl.Dispose();

            // slm.Dispose();

            Benchmark.Dump();
        }