scheduler.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// Copyright (C) 2021 CERN & University of Surrey for the benefit of the
// BioDynaMo collaboration. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
//
// See the LICENSE file distributed with this work for details.
// See the NOTICE file distributed with this work for additional information
// regarding copyright ownership.
//
// -----------------------------------------------------------------------------
 
#ifndef CORE_SCHEDULER_H_
#define CORE_SCHEDULER_H_
 
#include <algorithm>
#include <chrono>
#include <functional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "core/functor.h"
#include "core/operation/operation.h"
#include "core/param/param.h"
#include "core/util/progress_bar.h"
#include "core/util/timing_aggregator.h"
 
namespace bdm {
 
class SchedulerTest;
class Agent;
class SimulationBackup;
class VisualizationAdaptor;
class RootAdaptor;
struct BoundSpace;
class MechanicalForcesOp;
class DiffusionOp;
 
enum OpType { kSchedule, kPreSchedule, kPostSchedule };
 
class Scheduler {
 public:
  using Clock = std::chrono::high_resolution_clock;
 
  Scheduler();
 
  virtual ~Scheduler();
 
  void Simulate(uint64_t steps);
 
  void SimulateUntil(const std::function<bool()>& exit_condition);
 
  void FinalizeInitialization() const;
 
  uint64_t GetSimulatedSteps() const;
 
  real_t GetSimulatedTime() const;
 
  void ScheduleOp(Operation* op, OpType op_type = OpType::kSchedule);
 
  void UnscheduleOp(Operation* op);
 
  std::vector<Operation*> GetOps(const std::string& name);
 
  void SetAgentFilters(const std::vector<Functor<bool, Agent*>*>& filters);
 
  const std::vector<Functor<bool, Agent*>*>& GetAgentFilters() const;
 
  RootAdaptor* GetRootVisualization() { return root_visualization_; }
 
  TimingAggregator* GetOpTimes();
 
  void PrintInfo(std::ostream& out) const;
 
 protected:
  uint64_t total_steps_ = 0;
  real_t simulated_time_ = 0.0;
 
  virtual void Execute();
 
 private:
  friend void RunAgentsTest(Param::MappedDataArrayMode, uint64_t, bool, bool);
  friend SchedulerTest;
 
  SimulationBackup* backup_ = nullptr;
  uint64_t restore_point_;
  std::chrono::time_point<Clock> last_backup_ = Clock::now();
  RootAdaptor* root_visualization_ = nullptr;  
  ProgressBar* progress_bar_ = nullptr;
 
  std::vector<Operation*> all_ops_;  
  std::vector<std::pair<OpType, Operation*>> schedule_ops_;  
  std::vector<Operation*> unschedule_ops_;  
  std::vector<Operation*> scheduled_standalone_ops_;  
  std::vector<Operation*> scheduled_agent_ops_;  
  std::vector<std::string> protected_op_names_;  
  // Operations that are run before setting up, running and tearing down
  // scheduled operations
  std::vector<Operation*> pre_scheduled_ops_;
  // Operations that are run after setting up, running and tearing down
  // scheduled operations
  std::vector<Operation*> post_scheduled_ops_;
  TimingAggregator op_times_;
 
  std::vector<Functor<bool, Agent*>*> agent_filters_;  
 
  void Backup();
 
  bool Restore(uint64_t* steps);
 
  void UpdateSimulatedTime();
 
  // TODO(lukas, ahmad) After https://trello.com/c/0D6sHCK4 has been resolved
  // think about a better solution, because some operations are executed twice
  // if Simulate is called with one timestep.
  void Initialize(uint64_t steps = 0);
 
  template <typename Lambda>
  void ForEachOperationInList(const std::vector<Operation*>& operations,
                              Lambda lambda) const {
    for (auto* op : operations) {
      lambda(op);
    }
  }
 
  template <typename Lambda>
  void ForEachScheduledOperation(Lambda lambda) {
    ForEachOperationInList(scheduled_agent_ops_, lambda);
    ForEachOperationInList(scheduled_standalone_ops_, lambda);
  }
 
  template <typename Lambda>
  void ForEachOperation(Lambda lambda) {
    ForEachScheduledOperation(lambda);
    ForEachOperationInList(pre_scheduled_ops_, lambda);
    ForEachOperationInList(post_scheduled_ops_, lambda);
  }
 
  std::vector<std::string> GetListOfScheduledAgentOps() const;
 
  std::vector<std::string> GetListOfScheduledStandaloneOps() const;
 
  // Run the Operation::SetUp() call for each scheduled operation
  void SetUpOps();
 
  void TearDownOps();
 
  // Run the operations in scheduled_*_ops_
  void RunScheduledOps();
 
  // Run the operations in pre_scheduled_ops_ (executed before RunScheduledOps)
  void RunPreScheduledOps() const;
 
  void RunAgentOps(Functor<bool, Agent*>* filter) const;
 
  // Run the operations in post_scheduled_ops_ (executed after RunScheduledOps)
  void RunPostScheduledOps() const;
 
  void ScheduleOps();
};
 
}  // namespace bdm
 
#endif  // CORE_SCHEDULER_H_