petri.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <optional>
#include <tuple>
 
#include "externals/blockingconcurrentqueue.h"
#include "externals/small_vector.hpp"
#include "symmetri/callback.h"
#include "symmetri/tasks.h"
#include "symmetri/types.h"
 
namespace symmetri {
 
using AugmentedToken = std::tuple<size_t, Token>;
 
struct SmallEvent {
  size_t transition;        
  Token state;              
  Clock::time_point stamp;  
};
 
using SmallLog = std::vector<SmallEvent>;
 
using SmallVector = gch::small_vector<size_t, 4>;
 
using SmallVectorInput = gch::small_vector<AugmentedToken, 4>;
 
size_t toIndex(const std::vector<std::string> &m, const std::string &s);
 
gch::small_vector<size_t, 32> possibleTransitions(
    const std::vector<AugmentedToken> &tokens,
    const std::vector<SmallVectorInput> &input_n,
    const std::vector<SmallVector> &p_to_ts_n);
 
bool canFire(const SmallVectorInput &pre,
             const std::vector<AugmentedToken> &tokens);
 
struct Petri;
 
using Reducer = std::function<void(Petri &)>;
 
Reducer scheduleCallback(
    size_t t_idx, const Callback &task,
    const std::shared_ptr<moodycamel::BlockingConcurrentQueue<Reducer>>
        &reducer_queue);
 
void deductMarking(std::vector<AugmentedToken> &tokens,
                   const SmallVectorInput &inputs);
 
struct Petri {
  explicit Petri(const Net &_net, const PriorityTable &_priority,
                 const Marking &_initial_tokens, const Marking &_final_marking,
                 const std::string &_case_id,
                 std::shared_ptr<TaskSystem> threadpool);
  ~Petri() noexcept = default;
  Petri(Petri const &) = delete;
  Petri(Petri &&) noexcept = delete;
  Petri &operator=(Petri const &) = delete;
  Petri &operator=(Petri &&) noexcept = delete;
 
  std::vector<AugmentedToken> toTokens(const Marking &marking) const noexcept;
 
  Marking getMarking() const;
 
  Eventlog getLogInternal() const;
 
  void tryFire(const Transition &t);
 
  void fireTransitions();
 
  struct {
    std::vector<std::string> transition;
 
    std::vector<std::string> place;
 
    std::vector<SmallVectorInput> input_n;
 
    std::vector<SmallVectorInput> output_n;
 
    std::vector<SmallVector> p_to_ts_n;
 
    std::vector<int8_t> priority;
 
    std::vector<Callback> store;
 
    void registerCallback(const std::string &t,
                          const Callback &callback) noexcept {
      if (std::find(transition.begin(), transition.end(), t) !=
          transition.end()) {
        store[toIndex(transition, t)] = callback;
      }
    }
  } net;  
 
  std::vector<AugmentedToken> initial_tokens;  
  std::vector<AugmentedToken> tokens;          
  std::vector<AugmentedToken> final_marking;   
  std::vector<size_t> scheduled_callbacks;     
  SmallLog log;         
  Token state;          
  std::string case_id;  
  std::atomic<std::optional<unsigned int>>
      thread_id_;  
 
  std::shared_ptr<moodycamel::BlockingConcurrentQueue<Reducer>>
      reducer_queue;  
  std::shared_ptr<TaskSystem>
      pool;  
 
 private:
  void fireSynchronous(const size_t t);
 
  void fireAsynchronous(const size_t t);
};
 
}  // namespace symmetri