void DoContinuousMeasurements() { if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)threadCount + 1); } else { Native32.AffinitizeThreadShardedTwoNuma((uint)threadCount + 1); } double totalThroughput, totalLatency, maximumLatency; double totalProgress; int ver = 0; using (var client = new WebClient()) { while (!allDone) { ver++; Thread.Sleep(measurementInterval); totalProgress = 0; totalThroughput = 0; totalLatency = 0; maximumLatency = 0; for (int i = 0; i < threadCount; i++) { writeStats[i] = true; } for (int i = 0; i < threadCount; i++) { statsWritten[i].WaitOne(); totalThroughput += threadThroughput[i]; totalProgress += threadProgress[i]; if (measureLatency) { totalLatency += threadAverageLatency[i]; if (threadMaximumLatency[i] > maximumLatency) { maximumLatency = threadMaximumLatency[i]; } } } if (measureLatency) { Console.WriteLine("{0} \t {1:0.000} \t {2} \t {3} \t {4} \t {5}", ver, totalThroughput / (double)1000000, totalLatency / threadCount, maximumLatency, store.LogTailAddress, totalProgress); } else { Console.WriteLine("{0} \t {1:0.000} \t {2} \t {3}", ver, totalThroughput / (double)1000000, store.LogTailAddress, totalProgress); } } } }
private void SetupYcsb(int thread_idx) { if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedNuma((uint)thread_idx, 2); // assuming two NUMA sockets } waiter.Wait(); var session = store.For(functions).NewSession <Functions>(null, YcsbConstants.kAffinitizedSession); #if DASHBOARD var tstart = Stopwatch.GetTimestamp(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif Value value = default; for (long chunk_idx = Interlocked.Add(ref idx_, YcsbConstants.kChunkSize) - YcsbConstants.kChunkSize; chunk_idx < kInitCount; chunk_idx = Interlocked.Add(ref idx_, YcsbConstants.kChunkSize) - YcsbConstants.kChunkSize) { for (long idx = chunk_idx; idx < chunk_idx + YcsbConstants.kChunkSize; ++idx) { if (idx % 256 == 0) { session.Refresh(); if (idx % 65536 == 0) { session.CompletePending(false); } } session.Upsert(ref init_keys_[idx], ref value, Empty.Default, 1); } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = Stopwatch.GetTimestamp(); threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } session.CompletePending(true); session.Dispose(); }
private void SetupYcsb(int thread_idx) { if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedNuma((uint)thread_idx, 2); // assuming two NUMA sockets } store.StartSession(); #if DASHBOARD var tstart = Stopwatch.GetTimestamp(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif Value value = default(Value); for (long chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize; chunk_idx < kInitCount; chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize) { for (long idx = chunk_idx; idx < chunk_idx + kChunkSize; ++idx) { if (idx % 256 == 0) { store.Refresh(); if (idx % 65536 == 0) { store.CompletePending(false); } } Key key = init_keys_[idx]; store.Upsert(&key, &value, null, 1); } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = Stopwatch.GetTimestamp(); threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } store.CompletePending(true); store.StopSession(); }
private void SetupYcsb(int thread_idx) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedNuma((uint)thread_idx, 2); // assuming two NUMA sockets } } #if DASHBOARD var tstart = Stopwatch.GetTimestamp(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif Value value = default; for (long chunk_idx = Interlocked.Add(ref idx_, YcsbConstants.kChunkSize) - YcsbConstants.kChunkSize; chunk_idx < testLoader.InitCount; chunk_idx = Interlocked.Add(ref idx_, YcsbConstants.kChunkSize) - YcsbConstants.kChunkSize) { for (long idx = chunk_idx; idx < chunk_idx + YcsbConstants.kChunkSize; ++idx) { Key key = init_keys_[idx]; store[key] = value; } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = Stopwatch.GetTimestamp(); threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } }
private void SetupYcsb(int thread_idx) { if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedTwoNuma((uint)thread_idx); } #if DASHBOARD var tstart = HiResTimer.Rdtsc(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif Value value = default(Value); for (long chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize; chunk_idx < kInitCount; chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize) { for (long idx = chunk_idx; idx < chunk_idx + kChunkSize; ++idx) { Key key = init_keys_[idx]; store[key] = value; } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = HiResTimer.Rdtsc(); threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } }
private void RunYcsb(int thread_idx) { RandomGenerator rng = new RandomGenerator((uint)(1 + thread_idx)); if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedNuma((uint)thread_idx, 2); // assuming two NUMA sockets } Stopwatch sw = new Stopwatch(); sw.Start(); Span <byte> value = stackalloc byte[kValueSize]; Span <byte> input = stackalloc byte[kValueSize]; Span <byte> output = stackalloc byte[kValueSize]; ref SpanByte _value = ref SpanByte.Reinterpret(value);
private void RunYcsb(int thread_idx) { RandomGenerator rng = new RandomGenerator((uint)(1 + thread_idx)); if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedNuma((uint)thread_idx, 2); // assuming two NUMA sockets } Stopwatch sw = new Stopwatch(); sw.Start(); Value value = default; Input input = default; Output output = default; long reads_done = 0; long writes_done = 0; #if DASHBOARD var tstart = Stopwatch.GetTimestamp(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif var session = store.For(functions).NewSession <Functions>(null, kAffinitizedSession); while (!done) { long chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize; while (chunk_idx >= kTxnCount) { if (chunk_idx == kTxnCount) { idx_ = 0; } chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize; } for (long idx = chunk_idx; idx < chunk_idx + kChunkSize && !done; ++idx) { Op op; int r = (int)rng.Generate(100); if (r < readPercent) { op = Op.Read; } else if (readPercent >= 0) { op = Op.Upsert; } else { op = Op.ReadModifyWrite; } if (idx % 512 == 0) { if (kAffinitizedSession) { session.Refresh(); } session.CompletePending(false); } switch (op) { case Op.Upsert: { session.Upsert(ref txn_keys_[idx], ref value, Empty.Default, 1); ++writes_done; break; } case Op.Read: { session.Read(ref txn_keys_[idx], ref input, ref output, Empty.Default, 1); ++reads_done; break; } case Op.ReadModifyWrite: { session.RMW(ref txn_keys_[idx], ref input_[idx & 0x7], Empty.Default, 1); ++writes_done; break; } default: throw new InvalidOperationException("Unexpected op: " + op); } } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = Stopwatch.GetTimestamp(); threadProgress[thread_idx] = count; threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } session.CompletePending(true); session.Dispose(); sw.Stop(); #if DASHBOARD statsWritten[thread_idx].Set(); #endif Console.WriteLine("Thread " + thread_idx + " done; " + reads_done + " reads, " + writes_done + " writes, in " + sw.ElapsedMilliseconds + " ms."); Interlocked.Add(ref total_ops_done, reads_done + writes_done); }
private void RunYcsb(int thread_idx) { RandomGenerator rng = new RandomGenerator((uint)(1 + thread_idx)); if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedTwoNuma((uint)thread_idx); } Stopwatch sw = new Stopwatch(); sw.Start(); Value value = default(Value); long reads_done = 0; long writes_done = 0; #if DASHBOARD var tstart = HiResTimer.Rdtsc(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif store.StartSession(); while (!done) { long chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize; while (chunk_idx >= kTxnCount) { if (chunk_idx == kTxnCount) { idx_ = 0; } chunk_idx = Interlocked.Add(ref idx_, kChunkSize) - kChunkSize; } var local_txn_keys_ptr = txn_keys_ptr + chunk_idx; for (long idx = chunk_idx; idx < chunk_idx + kChunkSize && !done; ++idx, ++local_txn_keys_ptr) { Op op; int r = (int)rng.Generate(100); if (r < readPercent) { op = Op.Read; } else if (readPercent >= 0) { op = Op.Upsert; } else { op = Op.ReadModifyWrite; } if (idx % 256 == 0) { store.Refresh(); if (idx % 65536 == 0) { store.CompletePending(false); } } switch (op) { case Op.Upsert: { store.Upsert(local_txn_keys_ptr, &value, null, 1); ++writes_done; break; } case Op.Read: { Status result = store.Read(local_txn_keys_ptr, null, (Output *)&value, null, 1); if (result == Status.OK) { ++reads_done; } break; } case Op.ReadModifyWrite: { Status result = store.RMW(local_txn_keys_ptr, input_ptr + (idx & 0x7), null, 1); if (result == Status.OK) { ++writes_done; } break; } default: throw new NotImplementedException("Unexpected op: " + op); } } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = HiResTimer.Rdtsc(); threadProgress[thread_idx] = count; threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } store.CompletePending(true); store.StopSession(); sw.Stop(); Console.WriteLine("Thread " + thread_idx + " done; " + reads_done + " reads, " + writes_done + " writes, in " + sw.ElapsedMilliseconds + " ms."); Interlocked.Add(ref total_ops_done, reads_done + writes_done); }
internal FasterSpanByteYcsbBenchmark(KeySpanByte[] i_keys_, KeySpanByte[] t_keys_, TestLoader testLoader) { // Affinize main thread to last core on first socket if not used by experiment var(numGrps, numProcs) = Native32.GetNumGroupsProcsPerGroup(); if ((testLoader.Options.NumaStyle == 0 && testLoader.Options.ThreadCount <= (numProcs - 1)) || (testLoader.Options.NumaStyle == 1 && testLoader.Options.ThreadCount <= numGrps * (numProcs - 1))) { Native32.AffinitizeThreadRoundRobin(numProcs - 1); } init_keys_ = i_keys_; txn_keys_ = t_keys_; numaStyle = testLoader.Options.NumaStyle; readPercent = testLoader.Options.ReadPercent; var lockImpl = testLoader.LockImpl; functions = new FunctionsSB(lockImpl != LockImpl.None); #if DASHBOARD statsWritten = new AutoResetEvent[threadCount]; for (int i = 0; i < threadCount; i++) { statsWritten[i] = new AutoResetEvent(false); } threadThroughput = new double[threadCount]; threadAverageLatency = new double[threadCount]; threadMaximumLatency = new double[threadCount]; threadProgress = new long[threadCount]; writeStats = new bool[threadCount]; freq = Stopwatch.Frequency; #endif input_ = new Input[8]; for (int i = 0; i < 8; i++) { input_[i].value = i; } device = Devices.CreateLogDevice(TestLoader.DevicePath, preallocateFile: true, deleteOnClose: true); if (YcsbConstants.kSmallMemoryLog) { store = new FasterKV <SpanByte, SpanByte> (YcsbConstants.kMaxKey / 2, new LogSettings { LogDevice = device, PreallocateLog = true, PageSizeBits = 22, SegmentSizeBits = 26, MemorySizeBits = 26 }, new CheckpointSettings { CheckPointType = CheckpointType.Snapshot, CheckpointDir = testLoader.BackupPath }); } else { store = new FasterKV <SpanByte, SpanByte> (YcsbConstants.kMaxKey / 2, new LogSettings { LogDevice = device, PreallocateLog = true, MemorySizeBits = 35 }, new CheckpointSettings { CheckPointType = CheckpointType.Snapshot, CheckpointDir = testLoader.BackupPath }); } }
private void RunYcsb(int thread_idx) { RandomGenerator rng = new RandomGenerator((uint)(1 + thread_idx)); if (numaStyle == 0) { Native32.AffinitizeThreadRoundRobin((uint)thread_idx); } else { Native32.AffinitizeThreadShardedNuma((uint)thread_idx, 2); // assuming two NUMA sockets } Stopwatch sw = new Stopwatch(); sw.Start(); Value value = default; long reads_done = 0; long writes_done = 0; #if DASHBOARD var tstart = Stopwatch.GetTimestamp(); var tstop1 = tstart; var lastWrittenValue = 0; int count = 0; #endif while (!done) { long chunk_idx = Interlocked.Add(ref idx_, YcsbConstants.kChunkSize) - YcsbConstants.kChunkSize; while (chunk_idx >= testLoader.TxnCount) { if (chunk_idx == testLoader.TxnCount) { idx_ = 0; } chunk_idx = Interlocked.Add(ref idx_, YcsbConstants.kChunkSize) - YcsbConstants.kChunkSize; } for (long idx = chunk_idx; idx < chunk_idx + YcsbConstants.kChunkSize && !done; ++idx) { Op op; int r = (int)rng.Generate(100); if (r < readPercent) { op = Op.Read; } else if (readPercent >= 0) { op = Op.Upsert; } else { op = Op.ReadModifyWrite; } switch (op) { case Op.Upsert: { store[txn_keys_[idx]] = value; ++writes_done; break; } case Op.Read: { if (store.TryGetValue(txn_keys_[idx], out value)) { ++reads_done; } break; } case Op.ReadModifyWrite: { store.AddOrUpdate(txn_keys_[idx], *(Value *)(input_ptr + (idx & 0x7)), (k, v) => new Value { value = v.value + (input_ptr + (idx & 0x7))->value }); ++writes_done; break; } default: throw new InvalidOperationException("Unexpected op: " + op); } } #if DASHBOARD count += (int)kChunkSize; //Check if stats collector is requesting for statistics if (writeStats[thread_idx]) { var tstart1 = tstop1; tstop1 = Stopwatch.GetTimestamp(); threadProgress[thread_idx] = count; threadThroughput[thread_idx] = (count - lastWrittenValue) / ((tstop1 - tstart1) / freq); lastWrittenValue = count; writeStats[thread_idx] = false; statsWritten[thread_idx].Set(); } #endif } sw.Stop(); Console.WriteLine("Thread " + thread_idx + " done; " + reads_done + " reads, " + writes_done + " writes, in " + sw.ElapsedMilliseconds + " ms."); Interlocked.Add(ref total_ops_done, reads_done + writes_done); }