//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countFlushesAndBytesWritten()
internal virtual void CountFlushesAndBytesWritten()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
{
PageFaultEvent faultEvent = pinEvent.BeginPageFault();
{
EvictionEvent evictionEvent = faultEvent.BeginEviction();
{
FlushEventOpportunity flushEventOpportunity = evictionEvent.FlushEventOpportunity();
{
FlushEvent flushEvent = flushEventOpportunity.BeginFlush(0, 0, _swapper);
flushEvent.AddBytesWritten(27);
flushEvent.Done();
FlushEvent flushEvent1 = flushEventOpportunity.BeginFlush(0, 1, _swapper);
flushEvent1.AddBytesWritten(13);
flushEvent1.Done();
}
}
evictionEvent.Close();
}
faultEvent.Done();
}
pinEvent.Done();
assertEquals(1, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
assertEquals(1, _pageCursorTracer.faults());
assertEquals(1, _pageCursorTracer.evictions());
assertEquals(2, _pageCursorTracer.flushes());
assertEquals(40, _pageCursorTracer.bytesWritten());
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private long cooperativelyEvict(org.neo4j.io.pagecache.tracing.PageFaultEvent faultEvent) throws java.io.IOException
private long CooperativelyEvict(PageFaultEvent faultEvent)
{
int iterations = 0;
int pageCount = Pages.PageCount;
int clockArm = ThreadLocalRandom.current().Next(pageCount);
bool evicted = false;
long pageRef;
do
{
AssertHealthy();
if (FreelistHead != null)
{
return(0);
}
if (clockArm == pageCount)
{
if (iterations == _cooperativeEvictionLiveLockThreshold)
{
throw CooperativeEvictionLiveLock();
}
iterations++;
clockArm = 0;
}
pageRef = Pages.deref(clockArm);
if (Pages.isLoaded(pageRef) && Pages.decrementUsage(pageRef))
{
evicted = Pages.tryEvict(pageRef, faultEvent);
}
clockArm++;
} while (!evicted);
return(pageRef);
}
private void PinFaultAndHit()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
PageFaultEvent pageFaultEvent = pinEvent.BeginPageFault();
pinEvent.Hit();
pageFaultEvent.Done();
pinEvent.Done();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: private long pageFault(long filePageId, org.neo4j.io.pagecache.PageSwapper swapper, long chunkOffset, int[] chunk, LatchMap.Latch latch) throws java.io.IOException
private long PageFault(long filePageId, PageSwapper swapper, long chunkOffset, int[] chunk, LatchMap.Latch latch)
{
// We are page faulting. This is a critical time, because we currently have the given latch in the chunk array
// slot that we are faulting into. We MUST make sure to release that latch, and remove it from the chunk, no
// matter what happens. Otherwise other threads will get stuck waiting forever for our page fault to finish.
// If we manage to get a free page to fault into, then we will also be taking a write lock on that page, to
// protect it against concurrent eviction as we assigning a binding to the page. If anything goes wrong, then
// we must make sure to release that write lock as well.
PageFaultEvent faultEvent = PinEvent.beginPageFault();
long pageRef;
try
{
// The grabFreePage method might throw.
pageRef = PagedFile.grabFreeAndExclusivelyLockedPage(faultEvent);
// We got a free page, and we know that we have race-free access to it. Well, it's not entirely race
// free, because other paged files might have it in their translation tables (or rather, their reads of
// their translation tables might race with eviction) and try to pin it.
// However, they will all fail because when they try to pin, because the page will be exclusively locked
// and possibly bound to our page.
}
catch (Exception throwable)
{
// Make sure to unstuck the page fault latch.
AbortPageFault(throwable, chunk, chunkOffset, latch, faultEvent);
throw throwable;
}
try
{
// Check if we're racing with unmapping. We have the page lock
// here, so the unmapping would have already happened. We do this
// check before page.fault(), because that would otherwise reopen
// the file channel.
AssertPagedFileStillMappedAndGetIdOfLastPage();
PagedFile.initBuffer(pageRef);
PagedFile.fault(pageRef, swapper, PagedFile.swapperId, filePageId, faultEvent);
}
catch (Exception throwable)
{
// Make sure to unlock the page, so the eviction thread can pick up our trash.
PagedFile.unlockExclusive(pageRef);
// Make sure to unstuck the page fault latch.
AbortPageFault(throwable, chunk, chunkOffset, latch, faultEvent);
throw throwable;
}
// Put the page in the translation table before we undo the exclusive lock, as we could otherwise race with
// eviction, and the onEvict callback expects to find a MuninnPage object in the table.
UnsafeUtil.putIntVolatile(chunk, chunkOffset, PagedFile.toId(pageRef));
// Once we page has been published to the translation table, we can convert our exclusive lock to whatever we
// need for the page cursor.
ConvertPageFaultLock(pageRef);
latch.Release();
faultEvent.Done();
return(pageRef);
}
private void GenerateEventSet()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(false, 0, _swapper);
{
PageFaultEvent pageFaultEvent = pinEvent.BeginPageFault();
pageFaultEvent.AddBytesRead(150);
{
EvictionEvent evictionEvent = pageFaultEvent.BeginEviction();
{
FlushEventOpportunity flushEventOpportunity = evictionEvent.FlushEventOpportunity();
FlushEvent flushEvent = flushEventOpportunity.BeginFlush(0, 0, _swapper);
flushEvent.AddBytesWritten(10);
flushEvent.Done();
}
evictionEvent.ThrewException(new IOException("eviction exception"));
evictionEvent.Close();
}
pageFaultEvent.Done();
}
pinEvent.Done();
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countPageEvictions()
internal virtual void CountPageEvictions()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
{
PageFaultEvent faultEvent = pinEvent.BeginPageFault();
{
EvictionEvent evictionEvent = faultEvent.BeginEviction();
evictionEvent.FilePageId = 0;
evictionEvent.CachePageId = 0;
evictionEvent.ThrewException(new IOException("exception"));
evictionEvent.Close();
}
faultEvent.Done();
}
pinEvent.Done();
assertEquals(1, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
assertEquals(1, _pageCursorTracer.faults());
assertEquals(1, _pageCursorTracer.evictions());
assertEquals(1, _pageCursorTracer.evictionExceptions());
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @Test void countPageFaultsAndBytesRead()
internal virtual void CountPageFaultsAndBytesRead()
{
PinEvent pinEvent = _pageCursorTracer.beginPin(true, 0, _swapper);
{
PageFaultEvent pageFaultEvent = pinEvent.BeginPageFault();
{
pageFaultEvent.AddBytesRead(42);
}
pageFaultEvent.Done();
pageFaultEvent = pinEvent.BeginPageFault();
{
pageFaultEvent.AddBytesRead(42);
}
pageFaultEvent.Done();
}
pinEvent.Done();
assertEquals(1, _pageCursorTracer.pins());
assertEquals(1, _pageCursorTracer.unpins());
assertEquals(2, _pageCursorTracer.faults());
assertEquals(84, _pageCursorTracer.bytesRead());
}
private void AbortPageFault(Exception throwable, int[] chunk, long chunkOffset, LatchMap.Latch latch, PageFaultEvent faultEvent)
{
UnsafeUtil.putIntVolatile(chunk, chunkOffset, UNMAPPED_TTE);
latch.Release();
faultEvent.Done(throwable);
PinEvent.done();
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: void fault(long pageRef, org.neo4j.io.pagecache.PageSwapper swapper, int swapperId, long filePageId, org.neo4j.io.pagecache.tracing.PageFaultEvent event) throws java.io.IOException
internal virtual void Fault(long pageRef, PageSwapper swapper, int swapperId, long filePageId, PageFaultEvent @event)
{
if (swapper == null)
{
throw SwapperCannotBeNull();
}
int currentSwapper = GetSwapperId(pageRef);
long currentFilePageId = GetFilePageId(pageRef);
if (filePageId == PageCursor.UNBOUND_PAGE_ID || !IsExclusivelyLocked(pageRef) || currentSwapper != 0 || currentFilePageId != PageCursor.UNBOUND_PAGE_ID)
{
throw CannotFaultException(pageRef, swapper, swapperId, filePageId, currentSwapper, currentFilePageId);
}
// Note: It is important that we assign the filePageId before we swap
// the page in. If the swapping fails, the page will be considered
// loaded for the purpose of eviction, and will eventually return to
// the freelist. However, because we don't assign the swapper until the
// swapping-in has succeeded, the page will not be considered bound to
// the file page, so any subsequent thread that finds the page in their
// translation table will re-do the page fault.
SetFilePageId(pageRef, filePageId); // Page now considered isLoaded()
long bytesRead = swapper.Read(filePageId, GetAddress(pageRef), _cachePageSize);
@event.AddBytesRead(bytesRead);
@event.CachePageId = ToId(pageRef);
SetSwapperId(pageRef, swapperId); // Page now considered isBoundTo( swapper, filePageId )
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: long grabFreeAndExclusivelyLockedPage(org.neo4j.io.pagecache.tracing.PageFaultEvent faultEvent) throws java.io.IOException
internal virtual long GrabFreeAndExclusivelyLockedPage(PageFaultEvent faultEvent)
{
// Review the comment on the freelist field before making changes to
// this part of the code.
// Whatever the case, we're going to the head-pointer of the freelist,
// and in doing so, we can discover a number of things.
// We can discover a MuninnPage object, in which case we can try to
// CAS the freelist pointer to the value of the MuninnPage.nextFree
// pointer, and if this succeeds then we've grabbed that page.
// We can discover a FreePage object, in which case we'll do a similar
// dance by attempting to CAS the freelist to the FreePage objects next
// pointer, and again, if we succeed then we've grabbed the MuninnPage
// given by the FreePage object.
// We can discover a null-pointer, in which case the freelist has just
// been emptied for whatever it contained before. New FreePage objects
// are eventually going to be added to the freelist, but we are not
// going to wait around for that to happen. If the freelist is empty,
// then we do our own eviction to get a free page.
// If we find a FreePage object on the freelist, then it is important
// to check and see if it is the shutdownSignal instance. If that's the
// case, then the page cache has been shut down, and we should throw an
// exception from our page fault routine.
object current;
for ( ;;)
{
AssertHealthy();
current = FreelistHead;
if (current == null)
{
UnparkEvictor();
long pageRef = CooperativelyEvict(faultEvent);
if (pageRef != 0)
{
return(pageRef);
}
}
else if (current is AtomicInteger)
{
int pageCount = Pages.PageCount;
AtomicInteger counter = ( AtomicInteger )current;
int pageId = counter.get();
if (pageId < pageCount && counter.compareAndSet(pageId, pageId + 1))
{
return(Pages.deref(pageId));
}
if (pageId >= pageCount)
{
CompareAndSetFreelistHead(current, null);
}
}
else if (current is FreePage)
{
FreePage freePage = ( FreePage )current;
if (freePage == _shutdownSignal)
{
throw new System.InvalidOperationException("The PageCache has been shut down.");
}
if (CompareAndSetFreelistHead(freePage, freePage.NextConflict))
{
return(freePage.PageRef);
}
}
}
}