coroutine_test.cpp

// Minimal dispatcher + coroutine example using folly

#include <folly/init/Init.h>
#include <folly/coro/Task.h>
#include <folly/coro/BlockingWait.h>
#include <folly/executors/GlobalExecutor.h>
#include <folly/coro/Collect.h>
#include <folly/executors/CPUThreadPoolExecutor.h>

#include <fmt/core.h>

#include <chrono>
#include <string>
#include <thread>
#include <sstream>

using folly::coro::Task;
using namespace std::chrono_literals;

// Helper to convert thread ID to string for fmt
inline std::string thread_id_str() {
  std::ostringstream oss;
  oss << std::this_thread::get_id();
  return oss.str();
}

struct Pulse {
  std::string name;
  std::chrono::milliseconds duration;
};

class Dispatcher {
  public:
    void submit(const Pulse& pulse) const {
      fmt::print("[tid={}] Dispatching pulse '{}' for {} ms\n",
                 thread_id_str(),
                 pulse.name,
                 pulse.duration.count());
    }
  };
  
template<typename T>
folly::coro::Task<T> submit_cpu(folly::Executor* executor, 
                                folly::coro::Task<T>&& task) {
  co_return co_await std::move(task).scheduleOn(executor);
}
  

Task<int> measure(int milliseconds) {
  fmt::print("[tid={}] measure start\n", thread_id_str());
  std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
  fmt::print("[tid={}] Measured: {}\n", thread_id_str(), milliseconds);
  co_return milliseconds + 1;
}
  
/// Some other sequence of pulses
Task<int> sequence(Dispatcher& dispatcher) {
  std::this_thread::sleep_for(std::chrono::milliseconds(1));
  dispatcher.submit(Pulse{"A", 5ms});
  dispatcher.submit(Pulse{"B", 5ms});
  dispatcher.submit(Pulse{"C", 5ms});
  dispatcher.submit(Pulse{"D", 5ms});
  co_return 3;
}

Task<int> program(Dispatcher& dispatcher, folly::CPUThreadPoolExecutor* cpuPool) {
  auto [result1, result2] = 
      co_await folly::coro::collectAll(measure(2).scheduleOn(cpuPool), 
                                       sequence(dispatcher));
  
  int result3{0};                                      
  if (result1 == 3) { result3 = co_await sequence(dispatcher); }
  co_return result1 + result2 + result3;
}

int main(int argc, char** argv) {
  folly::init(&argc, &argv);

  Dispatcher dispatcher;
  folly::CPUThreadPoolExecutor cpuPool{3};

  /// This is the main entrypoint for the coroutine.
  int result = folly::coro::blockingWait(program(dispatcher, &cpuPool));
  fmt::print("Result: {}\n", result);
  return 0;
}