public MuninnPageCache(PageSwapperFactory swapperFactory, MemoryAllocator memoryAllocator, int cachePageSize, PageCacheTracer pageCacheTracer, PageCursorTracerSupplier pageCursorTracerSupplier, VersionContextSupplier versionContextSupplier, JobScheduler jobScheduler)
{
VerifyHacks();
VerifyCachePageSizeIsPowerOfTwo(cachePageSize);
int maxPages = CalculatePageCount(memoryAllocator, cachePageSize);
// Expose the total number of pages
pageCacheTracer.MaxPages(maxPages);
MemoryAllocationTracker memoryTracker = GlobalMemoryTracker.INSTANCE;
this._pageCacheId = _pageCacheIdCounter.incrementAndGet();
this._swapperFactory = swapperFactory;
this._cachePageSize = cachePageSize;
this._keepFree = Math.Min(_pagesToKeepFree, maxPages / 2);
this._pageCacheTracer = pageCacheTracer;
this._pageCursorTracerSupplier = pageCursorTracerSupplier;
this._versionContextSupplier = versionContextSupplier;
this._printExceptionsOnClose = true;
long alignment = swapperFactory.RequiredBufferAlignment;
this.VictimPage = VictimPageReference.GetVictimPage(cachePageSize, memoryTracker);
this.Pages = new PageList(maxPages, cachePageSize, memoryAllocator, new SwapperSet(), VictimPage, alignment);
this._scheduler = jobScheduler;
FreelistHead = new AtomicInteger();
}
/// <summary>
/// Opens a new <seealso cref="PageCache"/> with the provided file system and config.
/// </summary>
/// <param name="fs"> <seealso cref="FileSystemAbstraction"/> to use for the <seealso cref="PageCache"/>. </param>
/// <param name="overriddenConfig"> specific <seealso cref="PageCacheConfig"/> overriding config provided in <seealso cref="PageCacheRule"/>
/// constructor, if any. </param>
/// <returns> the opened <seealso cref="PageCache"/>. </returns>
public virtual PageCache GetPageCache(FileSystemAbstraction fs, PageCacheConfig overriddenConfig)
{
CloseExistingPageCache();
int? pageSize = SelectConfig(BaseConfig.pageSize, overriddenConfig.PageSize, null);
PageCacheTracer cacheTracer = SelectConfig(BaseConfig.tracer, overriddenConfig.Tracer, PageCacheTracer.NULL);
PageCursorTracerSupplier cursorTracerSupplier = SelectConfig(BaseConfig.pageCursorTracerSupplier, overriddenConfig.PageCursorTracerSupplier, Org.Neo4j.Io.pagecache.tracing.cursor.PageCursorTracerSupplier_Fields.Null);
SingleFilePageSwapperFactory factory = new SingleFilePageSwapperFactory();
factory.Open(fs, Configuration.EMPTY);
VersionContextSupplier contextSupplier = EmptyVersionContextSupplier.EMPTY;
MemoryAllocator mman = MemoryAllocator.createAllocator(SelectConfig(BaseConfig.memory, overriddenConfig.Memory, "8 MiB"), new LocalMemoryTracker());
InitializeJobScheduler();
if (pageSize != null)
{
PageCache = new MuninnPageCache(factory, mman, pageSize.Value, cacheTracer, cursorTracerSupplier, contextSupplier, JobScheduler);
}
else
{
PageCache = new MuninnPageCache(factory, mman, cacheTracer, cursorTracerSupplier, contextSupplier, JobScheduler);
}
PageCachePostConstruct(overriddenConfig);
return(PageCache);
}
public ReplicatedTransactionStateMachine(CommandIndexTracker commandIndexTracker, ReplicatedLockTokenStateMachine lockStateMachine, int maxBatchSize, LogProvider logProvider, PageCursorTracerSupplier pageCursorTracerSupplier, VersionContextSupplier versionContextSupplier)
{
this._commandIndexTracker = commandIndexTracker;
this._lockTokenStateMachine = lockStateMachine;
this._maxBatchSize = maxBatchSize;
this._log = logProvider.getLog(this.GetType());
this._pageCursorTracerSupplier = pageCursorTracerSupplier;
this._versionContextSupplier = versionContextSupplier;
}
/// <summary>
/// Construct configuring page cache factory </summary>
/// <param name="fs"> fileSystem file system that page cache will be based on </param>
/// <param name="config"> page swapper configuration </param>
/// <param name="pageCacheTracer"> global page cache tracer </param>
/// <param name="pageCursorTracerSupplier"> supplier of thread local (transaction local) page cursor tracer that will provide
/// thread local page cache statistics </param>
/// <param name="log"> page cache factory log </param>
/// <param name="versionContextSupplier"> cursor context factory </param>
/// <param name="scheduler"> job scheduler to execute page cache jobs </param>
public ConfiguringPageCacheFactory(FileSystemAbstraction fs, Config config, PageCacheTracer pageCacheTracer, PageCursorTracerSupplier pageCursorTracerSupplier, Log log, VersionContextSupplier versionContextSupplier, JobScheduler scheduler)
{
this._fs = fs;
this._versionContextSupplier = versionContextSupplier;
this._config = config;
this._pageCacheTracer = pageCacheTracer;
this._log = log;
this._pageCursorTracerSupplier = pageCursorTracerSupplier;
this._scheduler = scheduler;
}
internal static PageCache PageCache(JobScheduler jobScheduler)
{
SingleFilePageSwapperFactory swapper = new SingleFilePageSwapperFactory();
DefaultFileSystemAbstraction fs = new DefaultFileSystemAbstraction();
swapper.Open(fs, EMPTY);
PageCursorTracerSupplier cursorTracerSupplier = Org.Neo4j.Io.pagecache.tracing.cursor.PageCursorTracerSupplier_Fields.Null;
return(new MuninnPageCache(swapper, 100, NULL, cursorTracerSupplier, EmptyVersionContextSupplier.EMPTY, jobScheduler));
}
public BatchingTxApplier(int maxBatchSize, System.Func <TransactionIdStore> txIdStoreSupplier, System.Func <TransactionCommitProcess> commitProcessSupplier, Monitors monitors, PageCursorTracerSupplier pageCursorTracerSupplier, VersionContextSupplier versionContextSupplier, CommandIndexTracker commandIndexTracker, LogProvider logProvider)
{
this._maxBatchSize = maxBatchSize;
this._txIdStoreSupplier = txIdStoreSupplier;
this._commitProcessSupplier = commitProcessSupplier;
this._pageCursorTracerSupplier = pageCursorTracerSupplier;
this._log = logProvider.getLog(this.GetType());
this._monitor = monitors.NewMonitor(typeof(PullRequestMonitor));
this._versionContextSupplier = versionContextSupplier;
this._commandIndexTracker = commandIndexTracker;
}
/// <summary>
/// Create a Tracers subsystem with the desired implementation, if it can be found and created.
///
/// Otherwise the default implementation is used, and a warning is logged to the given StringLogger. </summary>
/// <param name="desiredImplementationName"> The name of the desired {@link org.neo4j.kernel.monitoring.tracing
/// .TracerFactory} implementation, as given by its <seealso cref="TracerFactory.getImplementationName()"/> method. </param>
/// <param name="msgLog"> A <seealso cref="Log"/> for logging when the desired implementation cannot be created. </param>
/// <param name="monitors"> the monitoring manager </param>
/// <param name="jobScheduler"> a scheduler for async jobs </param>
public Tracers(string desiredImplementationName, Log msgLog, Monitors monitors, JobScheduler jobScheduler, SystemNanoClock clock)
{
if ("null".Equals(desiredImplementationName, StringComparison.OrdinalIgnoreCase))
{
PageCursorTracerSupplier = DefaultPageCursorTracerSupplier.NULL;
PageCacheTracer = PageCacheTracer.NULL;
TransactionTracer = Org.Neo4j.Kernel.impl.transaction.tracing.TransactionTracer_Fields.Null;
CheckPointTracer = Org.Neo4j.Kernel.impl.transaction.tracing.CheckPointTracer_Fields.Null;
LockTracer = LockTracer.NONE;
}
else
{
TracerFactory foundFactory = new DefaultTracerFactory();
bool found = string.ReferenceEquals(desiredImplementationName, null);
foreach (TracerFactory factory in Service.load(typeof(TracerFactory)))
{
try
{
if (factory.ImplementationName.Equals(desiredImplementationName, StringComparison.OrdinalIgnoreCase))
{
foundFactory = factory;
found = true;
break;
}
}
catch (Exception e)
{
msgLog.Warn("Failed to instantiate desired tracer implementations '" + desiredImplementationName + "'", e);
}
}
if (!found)
{
msgLog.Warn("Using default tracer implementations instead of '%s'", desiredImplementationName);
}
PageCursorTracerSupplier = foundFactory.CreatePageCursorTracerSupplier(monitors, jobScheduler);
PageCacheTracer = foundFactory.CreatePageCacheTracer(monitors, jobScheduler, clock, msgLog);
TransactionTracer = foundFactory.CreateTransactionTracer(monitors, jobScheduler);
CheckPointTracer = foundFactory.CreateCheckPointTracer(monitors, jobScheduler);
LockTracer = foundFactory.CreateLockTracer(monitors, jobScheduler);
}
}
public CoreStateMachinesModule(MemberId myself, PlatformModule platformModule, File clusterStateDirectory, Config config, RaftReplicator replicator, RaftMachine raftMachine, Dependencies dependencies, LocalDatabase localDatabase)
{
StateStorage <IdAllocationState> idAllocationState;
StateStorage <ReplicatedLockTokenState> lockTokenState;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.kernel.lifecycle.LifeSupport life = platformModule.life;
LifeSupport life = platformModule.Life;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.io.fs.FileSystemAbstraction fileSystem = platformModule.fileSystem;
FileSystemAbstraction fileSystem = platformModule.FileSystem;
LogService logging = platformModule.Logging;
LogProvider logProvider = logging.InternalLogProvider;
lockTokenState = life.Add(new DurableStateStorage <>(fileSystem, clusterStateDirectory, LOCK_TOKEN_NAME, new ReplicatedLockTokenState.Marshal(new MemberId.Marshal()), config.Get(replicated_lock_token_state_size), logProvider));
idAllocationState = life.Add(new DurableStateStorage <>(fileSystem, clusterStateDirectory, ID_ALLOCATION_NAME, new IdAllocationState.Marshal(), config.Get(id_alloc_state_size), logProvider));
ReplicatedIdAllocationStateMachine idAllocationStateMachine = new ReplicatedIdAllocationStateMachine(idAllocationState);
IDictionary <IdType, int> allocationSizes = GetIdTypeAllocationSizeFromConfig(config);
ReplicatedIdRangeAcquirer idRangeAcquirer = new ReplicatedIdRangeAcquirer(replicator, idAllocationStateMachine, allocationSizes, myself, logProvider);
IdTypeConfigurationProvider = new EnterpriseIdTypeConfigurationProvider(config);
CommandIndexTracker commandIndexTracker = dependencies.SatisfyDependency(new CommandIndexTracker());
FreeIdCondition = new IdReusabilityCondition(commandIndexTracker, raftMachine, myself);
this.IdGeneratorFactory = CreateIdGeneratorFactory(fileSystem, idRangeAcquirer, logProvider, IdTypeConfigurationProvider);
TokenRegistry relationshipTypeTokenRegistry = new TokenRegistry(Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_RELATIONSHIP_TYPE);
System.Func <StorageEngine> storageEngineSupplier = () => localDatabase.DataSource().DependencyResolver.resolveDependency(typeof(StorageEngine));
ReplicatedRelationshipTypeTokenHolder relationshipTypeTokenHolder = new ReplicatedRelationshipTypeTokenHolder(relationshipTypeTokenRegistry, replicator, this.IdGeneratorFactory, storageEngineSupplier);
TokenRegistry propertyKeyTokenRegistry = new TokenRegistry(Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_PROPERTY_KEY);
ReplicatedPropertyKeyTokenHolder propertyKeyTokenHolder = new ReplicatedPropertyKeyTokenHolder(propertyKeyTokenRegistry, replicator, this.IdGeneratorFactory, storageEngineSupplier);
TokenRegistry labelTokenRegistry = new TokenRegistry(Org.Neo4j.Kernel.impl.core.TokenHolder_Fields.TYPE_LABEL);
ReplicatedLabelTokenHolder labelTokenHolder = new ReplicatedLabelTokenHolder(labelTokenRegistry, replicator, this.IdGeneratorFactory, storageEngineSupplier);
ReplicatedLockTokenStateMachine replicatedLockTokenStateMachine = new ReplicatedLockTokenStateMachine(lockTokenState);
VersionContextSupplier versionContextSupplier = platformModule.VersionContextSupplier;
ReplicatedTokenStateMachine labelTokenStateMachine = new ReplicatedTokenStateMachine(labelTokenRegistry, logProvider, versionContextSupplier);
ReplicatedTokenStateMachine propertyKeyTokenStateMachine = new ReplicatedTokenStateMachine(propertyKeyTokenRegistry, logProvider, versionContextSupplier);
ReplicatedTokenStateMachine relationshipTypeTokenStateMachine = new ReplicatedTokenStateMachine(relationshipTypeTokenRegistry, logProvider, versionContextSupplier);
PageCursorTracerSupplier cursorTracerSupplier = platformModule.Tracers.pageCursorTracerSupplier;
ReplicatedTransactionStateMachine replicatedTxStateMachine = new ReplicatedTransactionStateMachine(commandIndexTracker, replicatedLockTokenStateMachine, config.Get(state_machine_apply_max_batch_size), logProvider, cursorTracerSupplier, versionContextSupplier);
dependencies.SatisfyDependencies(replicatedTxStateMachine);
LocksFactory lockFactory = createLockFactory(config, logging);
LocksSupplier = () => CreateLockManager(lockFactory, config, platformModule.Clock, replicator, myself, raftMachine, replicatedLockTokenStateMachine);
RecoverConsensusLogIndex consensusLogIndexRecovery = new RecoverConsensusLogIndex(localDatabase, logProvider);
CoreStateMachines = new CoreStateMachines(replicatedTxStateMachine, labelTokenStateMachine, relationshipTypeTokenStateMachine, propertyKeyTokenStateMachine, replicatedLockTokenStateMachine, idAllocationStateMachine, new DummyMachine(), localDatabase, consensusLogIndexRecovery);
CommitProcessFactory = (appender, applier, ignored) =>
{
localDatabase.RegisterCommitProcessDependencies(appender, applier);
return(new ReplicatedTransactionCommitProcess(replicator));
};
this.TokenHolders = new TokenHolders(propertyKeyTokenHolder, labelTokenHolder, relationshipTypeTokenHolder);
dependencies.SatisfyDependencies(TokenHolders);
}
public abstract T CreatePageCache(PageSwapperFactory swapperFactory, int maxPages, PageCacheTracer tracer, PageCursorTracerSupplier cursorTracerSupplier, VersionContextSupplier contextSupplier, JobScheduler jobScheduler);
protected internal T GetPageCache(FileSystemAbstraction fs, int maxPages, PageCacheTracer tracer, PageCursorTracerSupplier cursorTracerSupplier)
{
if (PageCache != null)
{
TearDownPageCache(PageCache);
}
PageCache = CreatePageCache(fs, maxPages, tracer, cursorTracerSupplier, EmptyVersionContextSupplier.EMPTY);
return(PageCache);
}
protected internal virtual T CreatePageCache(FileSystemAbstraction fs, int maxPages, PageCacheTracer tracer, PageCursorTracerSupplier cursorTracerSupplier)
{
return(CreatePageCache(fs, maxPages, tracer, cursorTracerSupplier, EmptyVersionContextSupplier.EMPTY));
}
protected internal virtual T CreatePageCache(FileSystemAbstraction fs, int maxPages, PageCacheTracer tracer, PageCursorTracerSupplier cursorTracerSupplier, VersionContextSupplier versionContextSupplier)
{
PageSwapperFactory swapperFactory = new SingleFilePageSwapperFactory();
swapperFactory.Open(fs, Configuration.EMPTY);
return(CreatePageCache(swapperFactory, maxPages, tracer, cursorTracerSupplier, versionContextSupplier));
}
protected internal T CreatePageCache(PageSwapperFactory swapperFactory, int maxPages, PageCacheTracer tracer, PageCursorTracerSupplier cursorTracerSupplier, VersionContextSupplier versionContextSupplier)
{
T pageCache = _fixture.createPageCache(swapperFactory, maxPages, tracer, cursorTracerSupplier, versionContextSupplier, JobScheduler);
PageCachePageSize = pageCache.PageSize();
RecordsPerFilePage = PageCachePageSize / RecordSize;
RecordCount = 5 * maxPages * RecordsPerFilePage;
FilePageSize = RecordsPerFilePage * RecordSize;
BufA = ByteBuffer.allocate(RecordSize);
return(pageCache);
}
/// <summary>
/// <seealso cref="PageCursorTracerSupplier"/> to use for this page cache. </summary>
/// <param name="tracerSupplier"> supplier of page cursors tracers </param>
/// <returns> this instance </returns>
public PageCacheConfig WithCursorTracerSupplier(PageCursorTracerSupplier tracerSupplier)
{
this.PageCursorTracerSupplier = tracerSupplier;
return(this);
}
/// <summary>
/// Create page cache. </summary>
/// <param name="swapperFactory"> page cache swapper factory </param>
/// <param name="memoryAllocator"> the source of native memory the page cache should use </param>
/// <param name="pageCacheTracer"> global page cache tracer </param>
/// <param name="pageCursorTracerSupplier"> supplier of thread local (transaction local) page cursor tracer that will provide
/// thread local page cache statistics </param>
/// <param name="versionContextSupplier"> supplier of thread local (transaction local) version context that will provide
/// access to thread local version context </param>
public MuninnPageCache(PageSwapperFactory swapperFactory, MemoryAllocator memoryAllocator, PageCacheTracer pageCacheTracer, PageCursorTracerSupplier pageCursorTracerSupplier, VersionContextSupplier versionContextSupplier, JobScheduler jobScheduler) : this(swapperFactory, memoryAllocator, org.neo4j.io.pagecache.PageCache_Fields.PAGE_SIZE, pageCacheTracer, pageCursorTracerSupplier, versionContextSupplier, jobScheduler)
{
}
/// <summary>
/// Create page cache. </summary>
/// <param name="swapperFactory"> page cache swapper factory </param>
/// <param name="maxPages"> maximum number of pages </param>
/// <param name="pageCacheTracer"> global page cache tracer </param>
/// <param name="pageCursorTracerSupplier"> supplier of thread local (transaction local) page cursor tracer that will provide
/// thread local page cache statistics </param>
/// <param name="versionContextSupplier"> supplier of thread local (transaction local) version context that will provide
/// access to thread local version context </param>
public MuninnPageCache(PageSwapperFactory swapperFactory, int maxPages, PageCacheTracer pageCacheTracer, PageCursorTracerSupplier pageCursorTracerSupplier, VersionContextSupplier versionContextSupplier, JobScheduler jobScheduler) : this(swapperFactory, MemoryAllocator.createAllocator("" + MemoryRequiredForPages(maxPages), GlobalMemoryTracker.INSTANCE), org.neo4j.io.pagecache.PageCache_Fields.PAGE_SIZE, pageCacheTracer, pageCursorTracerSupplier, versionContextSupplier, jobScheduler)
{
}
