Method reclaimTask

bolt/exec/Task.cpp:3192–3250

}

uint64_t Task::MemoryReclaimer::reclaimTask(
    const std::shared_ptr<Task>& task,
    uint64_t targetBytes,
    uint64_t maxWaitMs,
    memory::MemoryReclaimer::Stats& stats) {
  BOLT_CHECK(
      !isAsyncPreloadThread(),
      "Memory reclamation should not be called from async load thread {}, id {}, task id {}, stack {}",
      folly::getCurrentThreadName().value(),
      std::this_thread::get_id(),
      task->taskId(),
      google::GetStackTrace());

  auto resumeGuard = folly::makeGuard([&]() {
    try {
      Task::resume(task);
    } catch (const BoltRuntimeError& exception) {
      LOG(WARNING) << "Failed to resume task " << task->taskId_
                   << " after memory reclamation: " << exception.message();
    }
  });

  uint64_t reclaimWaitTimeUs{0};
  bool paused{true};
  {
    MicrosecondTimer timer{&reclaimWaitTimeUs};
    if (maxWaitMs == 0) {
      task->requestPause().wait();
    } else {
      paused = task->requestPause().wait(std::chrono::milliseconds(maxWaitMs));
    }
  }
  BOLT_CHECK(paused || maxWaitMs != 0);
  if (!paused) {
    RECORD_METRIC_VALUE(kMetricTaskMemoryReclaimWaitTimeoutCount, 1);
    BOLT_FAIL(
        "Memory reclaim failed to wait for task {} to pause after {} with max timeout {}",
        task->taskId(),
        succinctMicros(reclaimWaitTimeUs),
        succinctMillis(maxWaitMs));
  }

  stats.reclaimWaitTimeUs += reclaimWaitTimeUs;
  RECORD_METRIC_VALUE(kMetricTaskMemoryReclaimCount, 1);
  RECORD_HISTOGRAM_METRIC_VALUE(
      kMetricTaskMemoryReclaimWaitTimeMs, reclaimWaitTimeUs / 1'000);

  // Don't reclaim from a cancelled task as it will terminate soon.
  if (task->isCancelled()) {
    return 0;
  }

  task->recordMemoryPressureWatermarkBytes(task->pool()->currentBytes());

  uint64_t reclaimedBytes{0};
  reclaimedBytes = memory::MemoryReclaimer::reclaim(
      task->pool(), targetBytes, maxWaitMs, stats);
  return reclaimedBytes;