s.defaultWriteObject();
    s.writeLong(sum());
  }

  private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
    s.defaultReadObject();
    busy = 0;
    cells = null;
    base = s.readLong();
  }

            new CleanUpVirtualFileSystemAfterBuild(executorFactory, userHomeServiceRegistry),
            new ReturnResult(),
            new StartBuildOrRespondWithBusy(daemonDiagnostics), // from this point down, the daemon is 'busy'
            new EstablishBuildEnvironment(processEnvironment),
            new LogToClient(loggingManager, daemonDiagnostics), // from this point down, logging is sent back to the client

	driveWritesAwaitMD = NewGaugeMD(driveWritesAwait,
		"Average time for write requests served on a drive",
		allDriveLabels...)
	drivePercUtilMD = NewGaugeMD(drivePercUtil,
		"Percentage of time the disk was busy",
		allDriveLabels...)
)

func getCurrentDriveIOStats() map[string]madmin.DiskIOStats {
	var types madmin.MetricType = madmin.MetricsDisk
	driveRealtimeMetrics := collectLocalMetrics(types, collectMetricsOpts{

    s.defaultWriteObject();
    s.writeLong(sum());
  }

  private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
    s.defaultReadObject();
    busy = 0;
    cells = null;
    base = s.readLong();
  }

        run { doDaemonContext(foregroundDaemons[num], assertions) }
    }

    void doDaemonContext(gradleHandle, Closure assertions) {
        // poll here since even though the daemon has been marked as busy in the registry, the context may not have been
        // flushed to the log yet.
        DaemonContext context
        poll(5) {

        executer.requireDaemon()
        executer.requireIsolatedDaemons()

        buildFile << """
// This is a workaround to bust the JVM's file canonicalization cache
def f = file("delete-me")
f.createNewFile()
f.delete() // invalidates cache

task work {
    inputs.file('in.txt')
    inputs.dir('in-dir')
    def outTxt = file('out.txt')

		ctbInformer:        bundles.Informer(),
		ctbLister:          bundles.Lister(),
		normalizationCache: lrucache.NewLRUExpireCache(cacheSize),
		cacheTTL:           cacheTTL,
	}

	// Have the informer bust cache entries when it sees updates that could
	// apply to them.
	_, err := m.ctbInformer.AddEventHandler(cache.ResourceEventHandlerFuncs{
		AddFunc: func(obj any) {
			ctb, ok := obj.(*certificatesv1alpha1.ClusterTrustBundle)

            lock.unlock();
        }
    }

    @Override
    public void markState(final Address address, final State state) {
        lock.lock();
        try {
            LOGGER.debug("Marking busy by address: {}", address);
            cache.update(new ObjectHolder.UpdateAction<DaemonRegistryContent>() {
                @Override
                public DaemonRegistryContent update(DaemonRegistryContent oldValue) {

	}

	buf, err := r.MarshalMsg(nil)
	if err != nil {
		return nil, err
	}

	// We do not want Gets to take so much time, anything
	// beyond 250ms we should cut it, remote cache is too
	// busy already.
	ctx, cancel := context.WithTimeout(context.Background(), 250*time.Millisecond)
	defer cancel()

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.Endpoint+mcacheV1Check, bytes.NewReader(buf))

      if (activeTask == null && futureTasks.isEmpty()) {
        return CountDownLatch(0)
      }

      // If there's an existing AwaitIdleTask, use it. This is necessary when the executor is
      // shutdown but still busy as we can't enqueue in that case.
      val existingTask = activeTask
      if (existingTask is AwaitIdleTask) {
        return existingTask.latch
      }
      for (futureTask in futureTasks) {