graph_scheduler.h

// SPDX-FileCopyrightText: © 2019-2021, 2024 Alexandros Theodotou <alex@zrythm.org>
// SPDX-License-Identifier: LicenseRef-ZrythmLicense
/*
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 * ---
 *
 * Copyright (C) 2017, 2019 Robin Gareus <robin@gareus.org>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * ---
 */
 
#pragma once
 
#include "dsp/graph_node.h"
#include "utils/mpmc_queue.h"
#include "utils/rt_thread_id.h"
 
#include <boost/unordered/concurrent_flat_set.hpp>
#include <juce_wrapper.h>
#include <moodycamel/lightweightsemaphore.h>
 
namespace zrythm::dsp::graph
{
 
class GraphThread;

class GraphScheduler
{
  friend class GraphThread;
  using GraphThreadPtr = std::unique_ptr<GraphThread>;
  static constexpr int MAX_GRAPH_THREADS = 128;
 
public:
  using RunOnMainThreadFunc = std::function<void (std::function<void ()>)>;

  GraphScheduler (
    RunOnMainThreadFunc                 run_on_main_thread_func,
    units::sample_rate_t                sample_rate,
    nframes_t                           max_block_length,
    bool                                realtime_threads = true,
    std::optional<juce::AudioWorkgroup> thread_workgroup = std::nullopt);
  ~GraphScheduler ();
  Z_DISABLE_COPY_MOVE (GraphScheduler); // copy/move don't make sense here

  void rechain_from_node_collection (
    GraphNodeCollection &&nodes,
    units::sample_rate_t  sample_rate,
    nframes_t             max_block_length);

  void start_threads (std::optional<int> num_threads = std::nullopt);

  void terminate_threads ();
 
  auto &get_nodes () { return graph_nodes_; }

  void run_cycle (
    EngineProcessTimeInfo  time_nfo,
    nframes_t              remaining_preroll_frames,
    const dsp::ITransport &transport);

  bool contains_thread (RTThreadId::IdType thread_id);
 
  auto get_time_nfo () const { return time_nfo_; }
  auto get_remaining_preroll_frames () const
  {
    return remaining_preroll_frames_;
  }

  auto &get_transport_for_this_cycle () const
  {
    assert (current_transport_.has_value ());
    return current_transport_->get ();
  }
 
private:
  [[gnu::hot]] void trigger_node (GraphNode &node);

  void prepare_nodes_for_processing ();

  void release_node_resources ();
 
private:
  boost::concurrent_flat_set<GraphThreadPtr> threads_;
  GraphThreadPtr                             main_thread_;

  EngineProcessTimeInfo time_nfo_;

  std::optional<std::reference_wrapper<const dsp::ITransport>> current_transport_;

  nframes_t remaining_preroll_frames_{};

  moodycamel::LightweightSemaphore callback_start_sem_{ 0 };
  moodycamel::LightweightSemaphore callback_done_sem_{ 0 };

  std::atomic<int> idle_thread_cnt_ = 0;

  // This is not a std::counting_semaphore due to issues on MSVC/Windows.
  moodycamel::LightweightSemaphore trigger_sem_{ 0 };

  MPMCQueue<GraphNode *> trigger_queue_;

  GraphNodeCollection graph_nodes_;

  std::atomic<int> terminal_refcnt_ = 0;

  std::optional<juce::Thread::RealtimeOptions> realtime_thread_options_;

  std::optional<juce::AudioWorkgroup> thread_workgroup_;
 
  units::sample_rate_t sample_rate_;
  nframes_t            max_block_length_;
 
  RunOnMainThreadFunc run_on_main_thread_func_;
};
 
} // namespace zrythm::dsp::graph