Function checkThread

flow/Platform.actor.cpp:3757–3845

}

void* checkThread(void* arg) {
#ifdef __linux__
	pthread_t mainThread = *(pthread_t*)arg;
	free(arg);

	int64_t lastRunLoopIterations = net2RunLoopIterations.load();
	int64_t lastRunLoopSleeps = net2RunLoopSleeps.load();

	double slowTaskStart = 0;
	double lastSlowTaskSignal = 0;
	double lastSaturatedSignal = 0;
	double lastSlowTaskBlockedLog = 0;

	const double minSlowTaskLogInterval =
	    std::max(FLOW_KNOBS->SLOWTASK_PROFILING_LOG_INTERVAL, FLOW_KNOBS->RUN_LOOP_PROFILING_INTERVAL);
	const double minSaturationLogInterval =
	    std::max(FLOW_KNOBS->SATURATION_PROFILING_LOG_INTERVAL, FLOW_KNOBS->RUN_LOOP_PROFILING_INTERVAL);

	double slowTaskLogInterval = minSlowTaskLogInterval;
	double saturatedLogInterval = minSaturationLogInterval;

	while (true) {
		threadSleep(FLOW_KNOBS->RUN_LOOP_PROFILING_INTERVAL);

		int64_t currentRunLoopIterations = net2RunLoopIterations.load();
		int64_t currentRunLoopSleeps = net2RunLoopSleeps.load();

		bool slowTask = lastRunLoopIterations == currentRunLoopIterations;
		bool saturated = lastRunLoopSleeps == currentRunLoopSleeps;

		if (slowTask) {
			double t = timer();
			bool newSlowTask = lastSlowTaskSignal == 0;

			if (newSlowTask) {
				slowTaskStart = t;
			} else if (t - std::max(slowTaskStart, lastSlowTaskBlockedLog) > FLOW_KNOBS->SLOWTASK_BLOCKED_INTERVAL) {
				lastSlowTaskBlockedLog = t;
				// When this gets logged, it will be with a current timestamp (using timer()). If the network thread
				// unblocks, it will log any slow task related events at an earlier timestamp. That means the order of
				// events during this sequence will not match their timestamp order.
				TraceEvent(SevWarnAlways, "RunLoopBlocked").detail("Duration", t - slowTaskStart);
			}

			if (newSlowTask || t - lastSlowTaskSignal >= slowTaskLogInterval) {
				if (lastSlowTaskSignal > 0) {
					slowTaskLogInterval = std::min(FLOW_KNOBS->SLOWTASK_PROFILING_MAX_LOG_INTERVAL,
					                               FLOW_KNOBS->SLOWTASK_PROFILING_LOG_BACKOFF * slowTaskLogInterval);
				}

				lastSlowTaskSignal = t;
				checkThreadTime.store(lastSlowTaskSignal);
				pthread_kill(mainThread, SIGPROF);
			}
		} else {
			slowTaskStart = 0;
			lastSlowTaskSignal = 0;
			lastRunLoopIterations = currentRunLoopIterations;