Beispiel #1
0
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @VisibleForTesting void monitor() throws InterruptedException
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
        internal virtual void Monitor()
        {
            GcStats lastGcStats    = GetGcStats();
            long    nextCheckPoint = nanoTime() + _measurementDurationNs;

            while (!Stopped)
            {
                NANOSECONDS.sleep(_measurementDurationNs);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long now = nanoTime();
                long now = nanoTime();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final long pauseNs = max(0L, now - nextCheckPoint);
                long pauseNs = max(0L, now - nextCheckPoint);
                nextCheckPoint = now + _measurementDurationNs;

//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final GcStats gcStats = getGcStats();
                GcStats gcStats = GetGcStats();
                if (pauseNs >= _stallAlertThresholdNs)
                {
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final VmPauseInfo pauseInfo = new VmPauseInfo(NANOSECONDS.toMillis(pauseNs), gcStats.time - lastGcStats.time, gcStats.count - lastGcStats.count);
                    VmPauseInfo pauseInfo = new VmPauseInfo(NANOSECONDS.toMillis(pauseNs), gcStats.Time - lastGcStats.Time, gcStats.Count - lastGcStats.Count);
                    _listener.accept(pauseInfo);
                }
                lastGcStats = gcStats;
            }
        }
Beispiel #2
0
 public override void Success(ExecutingQuery query)
 {
     if (NANOSECONDS.toMillis(query.ElapsedNanos()) >= _thresholdMillis)
     {
         QuerySnapshot snapshot = query.Snapshot();
         _log.info(LogEntry(snapshot));
     }
 }
Beispiel #3
0
        public TransactionExecutionStatistic(KernelTransactionImplementation tx, SystemNanoClock clock, long startTimeMillis)
        {
            long nowMillis = clock.Millis();
            long nowNanos  = clock.Nanos();

            KernelTransactionImplementation.Statistics statistics = tx.GetStatistics();
            this._waitTimeMillis       = NANOSECONDS.toMillis(statistics.GetWaitingTimeNanos(nowNanos));
            this._heapAllocatedBytes   = NullIfNegative(statistics.HeapAllocatedBytes());
            this._directAllocatedBytes = NullIfNegative(statistics.DirectAllocatedBytes());
            this._cpuTimeMillis        = NullIfNegative(statistics.CpuTimeMillis());
            this._pageFaults           = statistics.TotalTransactionPageCacheFaults();
            this._pageHits             = statistics.TotalTransactionPageCacheHits();
            this._elapsedTimeMillis    = nowMillis - startTimeMillis;
            this._idleTimeMillis       = this._cpuTimeMillis != null ? _elapsedTimeMillis - this._cpuTimeMillis - _waitTimeMillis : null;
        }
Beispiel #4
0
        // snapshot state

        public virtual QuerySnapshot Snapshot()
        {
            // capture a consistent snapshot of the "live" state
            ExecutingQueryStatus status;
            long waitTimeNanos;
            long currentTimeNanos;
            long cpuTimeNanos;

            do
            {
                status           = this._status;               // read barrier, must be first
                waitTimeNanos    = this._waitTimeNanos;        // the reason for the retry loop: don't count the wait time twice
                cpuTimeNanos     = _cpuClock.cpuTimeNanos(_threadExecutingTheQueryId);
                currentTimeNanos = _clock.nanos();             // capture the time as close to the snapshot as possible
            } while (this._status != status);
            // guarded by barrier - unused if status is planning, stable otherwise
            long compilationCompletedNanos = this._compilationCompletedNanos;
            // guarded by barrier - like compilationCompletedNanos
            CompilerInfo       planner        = status.Planning ? null : this._compilerInfo;
            IList <ActiveLock> waitingOnLocks = status.WaitingOnLocks ? status.WaitingOnLocks() : Collections.emptyList();
            // activeLockCount is not atomic to capture, so we capture it after the most sensitive part.
            long totalActiveLocks = this._activeLockCount.AsLong;
            // just needs to be captured at some point...
            long heapAllocatedBytes        = _heapAllocation.allocatedBytes(_threadExecutingTheQueryId);
            PageCounterValues pageCounters = new PageCounterValues(_pageCursorCounters);

            // - at this point we are done capturing the "live" state, and can start computing the snapshot -
            long compilationTimeNanos = (status.Planning ? currentTimeNanos : compilationCompletedNanos) - _startTimeNanos;
            long elapsedTimeNanos     = currentTimeNanos - _startTimeNanos;

            cpuTimeNanos  -= _cpuTimeNanosWhenQueryStarted;
            waitTimeNanos += status.WaitTimeNanos(currentTimeNanos);
            // TODO: when we start allocating native memory as well during query execution,
            // we should have a tracer that keeps track of how much memory we have allocated for the query,
            // and get the value from that here.
            heapAllocatedBytes = _heapAllocatedBytesWhenQueryStarted < 0 ? -1 : heapAllocatedBytes - _heapAllocatedBytesWhenQueryStarted;

            return(new QuerySnapshot(this, planner, pageCounters, NANOSECONDS.toMicros(compilationTimeNanos), NANOSECONDS.toMicros(elapsedTimeNanos), cpuTimeNanos == 0 && _cpuTimeNanosWhenQueryStarted == -1 ? -1 : NANOSECONDS.toMicros(cpuTimeNanos), NANOSECONDS.toMicros(waitTimeNanos), status.Name(), status.ToMap(currentTimeNanos), waitingOnLocks, totalActiveLocks - _initialActiveLocks, heapAllocatedBytes));
        }
Beispiel #5
0
 public ParkStrategy_Park(long time, TimeUnit unit)
 {
     this.Nanos = NANOSECONDS.convert(time, unit);
 }