petri.h

Go to the documentation of this file.

#pragma once

 
#include <stddef.h>
#include <stdint.h>
 
#include <algorithm>
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
#include "externals/blockingconcurrentqueue.h"
#include "externals/small_vector.hpp"
#include "symmetri/callback.h"
#include "symmetri/colors.hpp"
#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&)>;

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;

  std::vector<Transition> getActiveTransitions() const;

  Eventlog getLogInternal() const;

  void fireTransitions();
 
  struct PTNet {
    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;
    std::vector<AugmentedToken> initial_tokens;  
 
    void registerCallback(const std::string& t, Callback&& callback) noexcept {
      if (std::find(transition.begin(), transition.end(), t) !=
          transition.end()) {
        store[toIndex(transition, t)] = std::move(callback);
      }
    }
  } net;  
 
  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;  

  void fireAsynchronous(const size_t t);
 
 private:
  void fireSynchronous(const size_t t);
};
 
std::tuple<std::vector<std::string>, std::vector<std::string>,
           std::vector<Callback>>
convert(const Net& _net);
std::tuple<std::vector<SmallVectorInput>, std::vector<SmallVectorInput>>
populateIoLookups(const Net& _net, const std::vector<Place>& ordered_places);
std::vector<SmallVector> createReversePlaceToTransitionLookup(
    size_t place_count, size_t transition_count,
    const std::vector<SmallVectorInput>& input_transitions);
 
std::vector<int8_t> createPriorityLookup(
    const std::vector<Transition> transition, const PriorityTable& _priority);
}  // namespace symmetri