dbms.track_query_allocation and dbms.track_query_cpu_time are now dyn…

…amic settings

community/kernel/src/main/java/org/neo4j/graphdb/factory/GraphDatabaseSettings.java

@@ -299,8 +299,11 @@ public class GraphDatabaseSettings implements LoadableConfig
                     Boolean.toString( Configuration.DEFAULT_LEGACY_STYLE_QUOTING ) );
 
     @Description( "Enables or disables tracking of how much time a query spends actively executing on the CPU." )
+    @Dynamic
     public static Setting<Boolean> track_query_cpu_time = setting( "dbms.track_query_cpu_time", BOOLEAN, TRUE );
+
     @Description( "Enables or disables tracking of how many bytes are allocated by the execution of a query." )
+    @Dynamic
     public static Setting<Boolean> track_query_allocation = setting( "dbms.track_query_allocation", BOOLEAN, TRUE );
 
     @Description( "The size of the morsels" )

community/kernel/src/main/java/org/neo4j/kernel/NeoStoreDataSource.java

@@ -25,14 +25,17 @@
 import java.util.HashMap;
 import java.util.Map;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.LockSupport;
+import java.util.function.BiConsumer;
 import java.util.function.Supplier;
 
 import org.neo4j.graphdb.DependencyResolver;
 import org.neo4j.graphdb.ResourceIterator;
 import org.neo4j.graphdb.config.Setting;
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.helpers.Exceptions;
+import org.neo4j.helpers.Reference;
 import org.neo4j.index.internal.gbptree.RecoveryCleanupWorkCollector;
 import org.neo4j.internal.kernel.api.TokenNameLookup;
 import org.neo4j.internal.kernel.api.exceptions.KernelException;
@@ -643,16 +646,8 @@ private NeoStoreKernelModule buildKernel( LogFiles logFiles, TransactionAppender
             StorageEngine storageEngine, IndexConfigStore indexConfigStore, TransactionIdStore transactionIdStore,
             AvailabilityGuard availabilityGuard, SystemNanoClock clock, PropertyAccessor propertyAccessor ) throws KernelException, IOException
     {
-        CpuClock cpuClock = CpuClock.NOT_AVAILABLE;
-        if ( config.get( GraphDatabaseSettings.track_query_cpu_time ) )
-        {
-            cpuClock = CpuClock.CPU_CLOCK;
-        }
-        HeapAllocation heapAllocation = HeapAllocation.NOT_AVAILABLE;
-        if ( config.get( GraphDatabaseSettings.track_query_allocation ) )
-        {
-            heapAllocation = HeapAllocation.HEAP_ALLOCATION;
-        }
+        AtomicReference<CpuClock> cpuClockRef = setupCpuClockAtomicReference();
+        AtomicReference<HeapAllocation> heapAllocationRef = setupHeapAllocationAtomicReference();
 
         TransactionCommitProcess transactionCommitProcess = commitProcessFactory.create( appender, storageEngine,
                 config );
@@ -671,14 +666,14 @@ private NeoStoreKernelModule buildKernel( LogFiles logFiles, TransactionAppender
 
         StatementOperationParts statementOperationParts = dependencies.satisfyDependency(
                 buildStatementOperations( storeLayer, autoIndexing,
-                        constraintIndexCreator, databaseSchemaState, explicitIndexStore, cpuClock, heapAllocation ) );
+                        constraintIndexCreator, databaseSchemaState, explicitIndexStore, cpuClockRef, heapAllocationRef ) );
 
         TransactionHooks hooks = new TransactionHooks();
         KernelTransactions kernelTransactions = life.add( new KernelTransactions( statementLocksFactory,
                 constraintIndexCreator, statementOperationParts, schemaWriteGuard, transactionHeaderInformationFactory,
                 transactionCommitProcess, indexConfigStore, explicitIndexProviderLookup, hooks, transactionMonitor,
                 availabilityGuard, tracers, storageEngine, procedures, transactionIdStore, clock,
-                cpuClock, heapAllocation, accessCapability, new Cursors(), autoIndexing, explicitIndexStore ) );
+                cpuClockRef, heapAllocationRef, accessCapability, new Cursors(), autoIndexing, explicitIndexStore ) );
 
         buildTransactionMonitor( kernelTransactions, clock, config );
 
@@ -694,6 +689,50 @@ private NeoStoreKernelModule buildKernel( LogFiles logFiles, TransactionAppender
         return new NeoStoreKernelModule( transactionCommitProcess, kernel, kernelTransactions, fileListing );
     }
 
+    private AtomicReference<CpuClock> setupCpuClockAtomicReference()
+    {
+        AtomicReference<CpuClock> cpuClock = new AtomicReference<>( CpuClock.NOT_AVAILABLE );
+        if ( config.get( GraphDatabaseSettings.track_query_cpu_time ) )
+        {
+            cpuClock.set( CpuClock.CPU_CLOCK );
+        }
+        BiConsumer<Boolean,Boolean> cpuClockUpdater = ( before, after ) ->
+        {
+            if ( after )
+            {
+                cpuClock.set( CpuClock.CPU_CLOCK );
+            }
+            else
+            {
+                cpuClock.set( CpuClock.NOT_AVAILABLE );
+            }
+        };
+        config.registerDynamicUpdateListener( GraphDatabaseSettings.track_query_cpu_time, cpuClockUpdater );
+        return cpuClock;
+    }
+
+    private AtomicReference<HeapAllocation> setupHeapAllocationAtomicReference()
+    {
+        AtomicReference<HeapAllocation> heapAllocation = new AtomicReference<>( HeapAllocation.NOT_AVAILABLE );
+        if ( config.get( GraphDatabaseSettings.track_query_allocation ) )
+        {
+            heapAllocation.set( HeapAllocation.HEAP_ALLOCATION );
+        }
+        BiConsumer<Boolean,Boolean> heapAllocationUpdater = ( before, after ) ->
+        {
+            if ( after )
+            {
+                heapAllocation.set( HeapAllocation.HEAP_ALLOCATION );
+            }
+            else
+            {
+                heapAllocation.set( HeapAllocation.NOT_AVAILABLE );
+            }
+        };
+        config.registerDynamicUpdateListener( GraphDatabaseSettings.track_query_allocation, heapAllocationUpdater );
+        return heapAllocation;
+    }
+
     private void buildTransactionMonitor( KernelTransactions kernelTransactions, Clock clock, Config config )
     {
         KernelTransactionTimeoutMonitor kernelTransactionTimeoutMonitor =
@@ -801,7 +840,7 @@ public DependencyResolver getDependencyResolver()
 
     private StatementOperationParts buildStatementOperations( StoreReadLayer storeReadLayer, AutoIndexing autoIndexing,
             ConstraintIndexCreator constraintIndexCreator, DatabaseSchemaState databaseSchemaState,
-            ExplicitIndexStore explicitIndexStore, CpuClock cpuClock, HeapAllocation heapAllocation )
+            ExplicitIndexStore explicitIndexStore, AtomicReference<CpuClock> cpuClockRef, AtomicReference<HeapAllocation> heapAllocationRef )
     {
         // The passed in StoreReadLayer is the bottom most layer: Read-access to committed data.
         // To it we add:
@@ -810,7 +849,7 @@ private StatementOperationParts buildStatementOperations( StoreReadLayer storeRe
                 autoIndexing, constraintIndexCreator, explicitIndexStore );
 
         QueryRegistrationOperations queryRegistrationOperations =
-                new StackingQueryRegistrationOperations( clock, cpuClock, heapAllocation );
+                new StackingQueryRegistrationOperations( clock, cpuClockRef, heapAllocationRef );
 
         StatementOperationParts parts = new StatementOperationParts( stateHandlingContext, stateHandlingContext,
                 stateHandlingContext, stateHandlingContext, stateHandlingContext, stateHandlingContext,

community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactionImplementation.java

@@ -27,6 +27,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.Lock;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Supplier;
@@ -176,7 +177,7 @@ public KernelTransactionImplementation( StatementOperationParts statementOperati
             TransactionHooks hooks, ConstraintIndexCreator constraintIndexCreator, Procedures procedures,
             TransactionHeaderInformationFactory headerInformationFactory, TransactionCommitProcess commitProcess,
             TransactionMonitor transactionMonitor, Supplier<ExplicitIndexTransactionState> explicitIndexTxStateSupplier,
-            Pool<KernelTransactionImplementation> pool, Clock clock, CpuClock cpuClock, HeapAllocation heapAllocation,
+            Pool<KernelTransactionImplementation> pool, Clock clock, AtomicReference<CpuClock> cpuClockRef, AtomicReference<HeapAllocation> heapAllocationRef,
             TransactionTracer transactionTracer, LockTracer lockTracer, PageCursorTracerSupplier cursorTracerSupplier,
             StorageEngine storageEngine, AccessCapability accessCapability, Cursors cursors, AutoIndexing autoIndexing,
             ExplicitIndexStore explicitIndexStore )
@@ -199,7 +200,7 @@ public KernelTransactionImplementation( StatementOperationParts statementOperati
         this.currentStatement = new KernelStatement( this, this, storageStatement,
                 procedures, accessCapability, lockTracer, statementOperations );
         this.accessCapability = accessCapability;
-        this.statistics = new Statistics( this, cpuClock, heapAllocation );
+        this.statistics = new Statistics( this, cpuClockRef, heapAllocationRef );
         this.userMetaData = new HashMap<>();
         AllStoreHolder allStoreHolder =
                 new AllStoreHolder( storageEngine, storageStatement, this, cursors, explicitIndexStore );
@@ -956,20 +957,25 @@ public static class Statistics
         private volatile long heapAllocatedBytesWhenQueryStarted;
         private volatile long waitingTimeNanos;
         private volatile long transactionThreadId;
-        private final KernelTransactionImplementation transaction;
-        private final CpuClock cpuClock;
-        private final HeapAllocation heapAllocation;
         private volatile PageCursorTracer pageCursorTracer = PageCursorTracer.NULL;
+        private final KernelTransactionImplementation transaction;
+        private final AtomicReference<CpuClock> cpuClockRef;
+        private final AtomicReference<HeapAllocation> heapAllocationRef;
+        private CpuClock cpuClock;
+        private HeapAllocation heapAllocation;
 
-        public Statistics( KernelTransactionImplementation transaction, CpuClock cpuClock, HeapAllocation heapAllocation )
+        public Statistics( KernelTransactionImplementation transaction, AtomicReference<CpuClock> cpuClockRef,
+                AtomicReference<HeapAllocation> heapAllocationRef )
         {
             this.transaction = transaction;
-            this.cpuClock = cpuClock;
-            this.heapAllocation = heapAllocation;
+            this.cpuClockRef = cpuClockRef;
+            this.heapAllocationRef = heapAllocationRef;
         }
 
-        void init( long threadId, PageCursorTracer pageCursorTracer )
+        protected void init( long threadId, PageCursorTracer pageCursorTracer )
         {
+            this.cpuClock = cpuClockRef.get();
+            this.heapAllocation = heapAllocationRef.get();
             this.transactionThreadId = threadId;
             this.pageCursorTracer = pageCursorTracer;
             this.cpuTimeNanosWhenQueryStarted = cpuClock.cpuTimeNanos( transactionThreadId );

community/kernel/src/main/java/org/neo4j/kernel/impl/api/KernelTransactions.java

@@ -22,6 +22,7 @@
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.ReentrantReadWriteLock;
 import java.util.function.Supplier;
 
@@ -45,7 +46,6 @@
 import org.neo4j.kernel.impl.locking.StatementLocks;
 import org.neo4j.kernel.impl.locking.StatementLocksFactory;
 import org.neo4j.kernel.impl.newapi.Cursors;
-import org.neo4j.kernel.impl.newapi.KernelToken;
 import org.neo4j.kernel.impl.proc.Procedures;
 import org.neo4j.kernel.impl.store.TransactionId;
 import org.neo4j.kernel.impl.transaction.TransactionHeaderInformationFactory;
@@ -85,8 +85,8 @@ public class KernelTransactions extends LifecycleAdapter implements Supplier<Ker
     private final StorageEngine storageEngine;
     private final Procedures procedures;
     private final TransactionIdStore transactionIdStore;
-    private final CpuClock cpuClock;
-    private final HeapAllocation heapAllocation;
+    private final AtomicReference<CpuClock> cpuClockRef;
+    private final AtomicReference<HeapAllocation> heapAllocationRef;
     private final AccessCapability accessCapability;
     private final Supplier<ExplicitIndexTransactionState> explicitIndexTxStateSupplier;
     private final SystemNanoClock clock;
@@ -132,7 +132,7 @@ public KernelTransactions( StatementLocksFactory statementLocksFactory,
             TransactionMonitor transactionMonitor, AvailabilityGuard availabilityGuard, Tracers tracers,
             StorageEngine storageEngine, Procedures procedures, TransactionIdStore transactionIdStore,
             SystemNanoClock clock,
-            CpuClock cpuClock, HeapAllocation heapAllocation, AccessCapability accessCapability, Cursors cursors,
+            AtomicReference<CpuClock> cpuClockRef, AtomicReference<HeapAllocation> heapAllocationRef, AccessCapability accessCapability, Cursors cursors,
             AutoIndexing autoIndexing,
             ExplicitIndexStore explicitIndexStore )
     {
@@ -149,8 +149,8 @@ public KernelTransactions( StatementLocksFactory statementLocksFactory,
         this.storageEngine = storageEngine;
         this.procedures = procedures;
         this.transactionIdStore = transactionIdStore;
-        this.cpuClock = cpuClock;
-        this.heapAllocation = heapAllocation;
+        this.cpuClockRef = cpuClockRef;
+        this.heapAllocationRef = heapAllocationRef;
         this.accessCapability = accessCapability;
         this.autoIndexing = autoIndexing;
         this.explicitIndexStore = explicitIndexStore;
@@ -345,7 +345,7 @@ public KernelTransactionImplementation newInstance()
                     new KernelTransactionImplementation( statementOperations, schemaWriteGuard, hooks,
                             constraintIndexCreator, procedures, transactionHeaderInformationFactory,
                             transactionCommitProcess, transactionMonitor, explicitIndexTxStateSupplier, localTxPool,
-                            clock, cpuClock, heapAllocation, tracers.transactionTracer, tracers.lockTracer,
+                            clock, cpuClockRef, heapAllocationRef, tracers.transactionTracer, tracers.lockTracer,
                             tracers.pageCursorTracerSupplier, storageEngine, accessCapability, cursors, autoIndexing, explicitIndexStore );
             this.transactions.add( tx );
             return tx;

community/kernel/src/main/java/org/neo4j/kernel/impl/api/StackingQueryRegistrationOperations.java

@@ -19,6 +19,7 @@
  */
 package org.neo4j.kernel.impl.api;
 
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.stream.Stream;
 
 import org.neo4j.kernel.api.query.ExecutingQuery;
@@ -34,17 +35,17 @@ public class StackingQueryRegistrationOperations implements QueryRegistrationOpe
 {
     private final MonotonicCounter lastQueryId = MonotonicCounter.newAtomicMonotonicCounter();
     private final SystemNanoClock clock;
-    private final CpuClock cpuClock;
-    private final HeapAllocation heapAllocation;
+    private final AtomicReference<CpuClock> cpuClockRef;
+    private final AtomicReference<HeapAllocation> heapAllocationRef;
 
     public StackingQueryRegistrationOperations(
             SystemNanoClock clock,
-            CpuClock cpuClock,
-            HeapAllocation heapAllocation )
+            AtomicReference<CpuClock> cpuClockRef,
+            AtomicReference<HeapAllocation> heapAllocationRef )
     {
         this.clock = clock;
-        this.cpuClock = cpuClock;
-        this.heapAllocation = heapAllocation;
+        this.cpuClockRef = cpuClockRef;
+        this.heapAllocationRef = heapAllocationRef;
     }
 
     @Override
@@ -75,7 +76,7 @@ public ExecutingQuery startQueryExecution(
                 new ExecutingQuery( queryId, clientConnection, statement.username(), queryText, queryParameters,
                         statement.getTransaction().getMetaData(), () -> statement.locks().activeLockCount(),
                         statement.getPageCursorTracer(),
-                        threadId, threadName, clock, cpuClock, heapAllocation );
+                        threadId, threadName, clock, cpuClockRef.get(), heapAllocationRef.get() );
         registerExecutingQuery( statement, executingQuery );
         return executingQuery;
     }

community/kernel/src/test/java/org/neo4j/kernel/api/KernelTransactionFactory.java

@@ -19,6 +19,7 @@
  */
 package org.neo4j.kernel.api;
 
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 
 import org.neo4j.collection.pool.Pool;
@@ -96,7 +97,7 @@ static Instances kernelTransactionWithInternals( SecurityContext securityContext
                 mock( TransactionRepresentationCommitProcess.class ), mock( TransactionMonitor.class ),
                 mock( Supplier.class ),
                 mock( Pool.class ),
-                Clocks.systemClock(), CpuClock.NOT_AVAILABLE, HeapAllocation.NOT_AVAILABLE, NULL,
+                Clocks.systemClock(), new AtomicReference<>( CpuClock.NOT_AVAILABLE ), new AtomicReference<>( HeapAllocation.NOT_AVAILABLE ), NULL,
                 LockTracer.NONE,
                 PageCursorTracerSupplier.NULL,
                 storageEngine, new CanWrite(), new Cursors(), AutoIndexing.UNSUPPORTED, mock(

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelStatementTest.java

@@ -22,6 +22,7 @@
 import org.junit.Test;
 
 import java.util.Optional;
+import java.util.concurrent.atomic.AtomicReference;
 
 import org.neo4j.graphdb.NotInTransactionException;
 import org.neo4j.graphdb.TransactionTerminatedException;
@@ -106,7 +107,7 @@ public void reportQueryWaitingTimeToTransactionStatisticWhenFinishQueryExecution
         Procedures procedures = mock( Procedures.class );
 
         KernelTransactionImplementation.Statistics statistics = new KernelTransactionImplementation.Statistics( transaction,
-                CpuClock.NOT_AVAILABLE, HeapAllocation.NOT_AVAILABLE );
+                new AtomicReference<>( CpuClock.NOT_AVAILABLE ), new AtomicReference<>( HeapAllocation.NOT_AVAILABLE ) );
         when( transaction.getStatistics() ).thenReturn( statistics );
         when( transaction.executingQueries() ).thenReturn( ExecutingQueryList.EMPTY );
 

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionImplementationTest.java

@@ -31,6 +31,7 @@
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
 import org.neo4j.graphdb.TransactionTerminatedException;
@@ -721,8 +722,8 @@ public void reportTransactionStatistics()
     {
         KernelTransactionImplementation transaction = newTransaction( 100 );
         KernelTransactionImplementation.Statistics statistics =
-                new KernelTransactionImplementation.Statistics( transaction, new ThreadBasedCpuClock(),
-                        new ThreadBasedAllocation() );
+                new KernelTransactionImplementation.Statistics( transaction, new AtomicReference<>( new ThreadBasedCpuClock() ),
+                        new AtomicReference<>( new ThreadBasedAllocation() ) );
         PredictablePageCursorTracer tracer = new PredictablePageCursorTracer();
         statistics.init( 2, tracer );
 

community/kernel/src/test/java/org/neo4j/kernel/impl/api/KernelTransactionTerminationTest.java

@@ -26,6 +26,7 @@
 import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
 import org.neo4j.collection.pool.Pool;
@@ -339,7 +340,8 @@ private static class TestKernelTransaction extends KernelTransactionImplementati
             super( mock( StatementOperationParts.class ), mock( SchemaWriteGuard.class ), new TransactionHooks(),
                     mock( ConstraintIndexCreator.class ), new Procedures(), TransactionHeaderInformationFactory.DEFAULT,
                     mock( TransactionCommitProcess.class ), monitor, () -> mock( ExplicitIndexTransactionState.class ),
-                    mock( Pool.class ), Clocks.fakeClock(), CpuClock.NOT_AVAILABLE, HeapAllocation.NOT_AVAILABLE,
+                    mock( Pool.class ), Clocks.fakeClock(),
+                    new AtomicReference<>( CpuClock.NOT_AVAILABLE ), new AtomicReference<>( HeapAllocation.NOT_AVAILABLE ),
                     TransactionTracer.NULL,
                     LockTracer.NONE, PageCursorTracerSupplier.NULL,
                     mock( StorageEngine.class, RETURNS_MOCKS ), new CanWrite(), mock( Cursors.class ),