/// <summary> /// Set a new track position marker. </summary> /// <param name="marker"> Marker </param> /// <param name="currentTimecode"> Current timecode of the track when this marker is set </param> public virtual void set(TrackMarker marker, long currentTimecode) { TrackMarker previous = current.getAndSet(marker); if (previous != null) { previous.handler.handle(marker != null ? OVERWRITTEN : REMOVED); } if (marker != null && currentTimecode >= marker.timecode) { trigger(marker, LATE); } }
/// <summary> /// Called by the appender that just appended a transaction to the log. /// </summary> /// <param name="logForceEvents"> A trace event for the given log append operation. </param> /// <returns> {@code true} if we got lucky and were the ones forcing the log. </returns> //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: protected boolean forceAfterAppend(org.neo4j.kernel.impl.transaction.tracing.LogForceEvents logForceEvents) throws java.io.IOException protected internal virtual bool ForceAfterAppend(LogForceEvents logForceEvents) { // There's a benign race here, where we add our link before we update our next pointer. // This is okay, however, because unparkAll() spins when it sees a null next pointer. ThreadLink threadLink = new ThreadLink(Thread.CurrentThread); threadLink.Next = _threadLinkHead.getAndSet(threadLink); bool attemptedForce = false; using (LogForceWaitEvent logForceWaitEvent = logForceEvents.BeginLogForceWait()) { do { if (_forceLock.tryLock()) { attemptedForce = true; try { ForceLog(logForceEvents); // In the event of any failure a database panic will be raised and thrown here } finally { _forceLock.unlock(); // We've released the lock, so unpark anyone who might have decided park while we were working. // The most recently parked thread is the one most likely to still have warm caches, so that's // the one we would prefer to unpark. Luckily, the stack nature of the ThreadLinks makes it easy // to get to. ThreadLink nextWaiter = _threadLinkHead.get(); nextWaiter.Unpark(); } } else { WaitForLogForce(); } } while (!threadLink.Done); // If there were many threads committing simultaneously and I wasn't the lucky one // actually doing the forcing (where failure would throw panic exception) I need to // explicitly check if everything is OK before considering this transaction committed. if (!attemptedForce) { _databaseHealth.assertHealthy(typeof(IOException)); } } return(attemptedForce); }
public override long Receive(long ticket, T batch) { long time = nanoTime(); while (QueuedBatches.get() >= _maxQueueLength) { Park.park(_receiverThread = Thread.CurrentThread); } // It is of importance that all items in the queue at the same time agree on the number of processors. We take this lock in order to make sure that we // do not interfere with another thread trying to drain the queue in order to change the processor count. long @lock = ApplyProcessorCount(_stripingLock.readLock()); QueuedBatches.incrementAndGet(); Unit unit = new Unit(this, ticket, batch, _numberOfForkedProcessors); // [old head] [unit] // ^ // head Unit myHead = _head.getAndSet(unit); // [old head] -next-> [unit] myHead.Next = unit; _stripingLock.unlock(@lock); return(nanoTime() - time); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void stressLatch() internal virtual void StressLatch() { assertTimeout(ofSeconds(60), () => { AtomicReference <BinaryLatch> latchRef = new AtomicReference <BinaryLatch>(new BinaryLatch()); ThreadStart awaiter = () => { BinaryLatch latch; while ((latch = latchRef.get()) != null) { latch.Await(); } }; int awaiters = 6; Future <object>[] futures = new Future <object> [awaiters]; for (int i = 0; i < awaiters; i++) { futures[i] = _executor.submit(awaiter); } ThreadLocalRandom rng = ThreadLocalRandom.current(); for (int i = 0; i < 500000; i++) { latchRef.getAndSet(new BinaryLatch()).release(); Spin(rng.nextLong(0, 10)); } latchRef.getAndSet(null).release(); // None of the tasks we started should get stuck, e.g. miss a release signal: foreach (Future <object> future in futures) { future.get(); } }); }
public static LogProvider setLogProvider(LogProvider newLogProvider) { return(_logProvider.getAndSet(newLogProvider)); }
/// <summary> /// Set the <seealso cref="Level"/> that logging should be enabled at /// </summary> /// <param name="level"> the new logging level </param> /// <returns> the previous logging level </returns> public virtual Level setLevel(Level level) { return(_levelRef.getAndSet(level)); }