dispatcher.h

// Copyright 2023 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
#pragma once
 
#include "pw_async2/context.h"
#include "pw_async2/dispatcher_native.h"
#include "pw_async2/lock.h"
#include "pw_async2/task.h"
#include "pw_async2/waker.h"
 
namespace pw::async2 {
namespace internal {
 
template <typename Pendable>
class PendableAsTaskWithOutput : public Task {
 public:
  using OutputType = PendOutputOf<Pendable>;
  PendableAsTaskWithOutput(Pendable& pendable)
      : pendable_(pendable), output_(Pending()) {}
 
  Poll<OutputType> TakePoll() { return std::move(output_); }
 
 private:
  Poll<> DoPend(Context& cx) final {
    output_ = pendable_.Pend(cx);
    return output_.Readiness();
  }
  Pendable& pendable_;
  Poll<OutputType> output_;
};
 
}  // namespace internal
 
class Dispatcher {
 public:
  Dispatcher() = default;
  Dispatcher(Dispatcher&) = delete;
  Dispatcher(Dispatcher&&) = delete;
  Dispatcher& operator=(Dispatcher&) = delete;
  Dispatcher& operator=(Dispatcher&&) = delete;
  ~Dispatcher() { native_.Deregister(); }
 
  void Post(Task& task) PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    native_.Post(task);
  }
 
  Poll<> RunUntilStalled() PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    return native_.DoRunUntilStalled(*this, nullptr);
  }
 
  Poll<> RunUntilStalled(Task& task)
      PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    return native_.DoRunUntilStalled(*this, &task);
  }
 
  template <typename Pendable>
  Poll<PendOutputOf<Pendable>> RunPendableUntilStalled(Pendable& pendable)
      PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    internal::PendableAsTaskWithOutput<Pendable> task(pendable);
    Post(task);
    if (RunUntilStalled(task).IsReady()) {
      return task.TakePoll();
    }
    // Ensure that the task is no longer registered, as it will be destroyed
    // once we return.
    //
    // This operation will not block because we are on the dispatcher thread
    // and the dispatcher is not currently running (we just ran it).
    task.Deregister();
    return Pending();
  }
 
  void RunToCompletion() PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    native_.DoRunToCompletion(*this, nullptr);
  }
 
  void RunToCompletion(Task& task) PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    native_.DoRunToCompletion(*this, &task);
  }
 
  template <typename Pendable>
  PendOutputOf<Pendable> RunPendableToCompletion(Pendable& pendable)
      PW_LOCKS_EXCLUDED(impl::dispatcher_lock()) {
    internal::PendableAsTaskWithOutput<Pendable> task(pendable);
    Post(task);
    native_.DoRunToCompletion(*this, &task);
    return task.TakePoll().value();
  }
 
  void LogRegisteredTasks() { native_.LogRegisteredTasks(); }
 
  uint32_t tasks_polled() const { return native_.tasks_polled(); }
 
  uint32_t tasks_completed() const { return native_.tasks_completed(); }
 
  pw::async2::backend::NativeDispatcher& native() { return native_; }
 
 private:
  pw::async2::backend::NativeDispatcher native_;
};
 
}  // namespace pw::async2