Runtime.h

Go to the documentation of this file.

#pragma once
#include <cassert>
#include <cstddef>
#include <deque>
#include <iostream>
#include <stdexcept>
#include <tuple>
#include <unordered_map>
#include <variant>
#include <vector>
 
#include "InstructionVisitor.h"
#include "RuleSet.h"
#include "macro_utils.h"
 
#include "Value.h"
#include "opcode.h"
#include "types.h"
 
namespace quisp::runtime {
struct Register {
  int32_t value = 0;
};
 
using QubitResources = std::multimap<std::pair<QNodeAddr, RuleId>, IQubitRecord*>;
 
using QubitResourcesWithSequenceNumbers = std::map<std::tuple<QNodeAddr, RuleId, SequenceNumber>, IQubitRecord*>;
using SequenceNumberTracker = std::map<IQubitRecord*, std::tuple<QNodeAddr, RuleId, SequenceNumber>>;
 
using SequenceNumberCounter = std::map<std::pair<QNodeAddr, RuleId>, SequenceNumber>;
 
using MessageResources = std::map<RuleId, std::deque<MessageRecord>>;
 
using QubitNameMap = std::unordered_map<QubitId, IQubitRecord*>;
 
using Memory = std::unordered_map<MemoryKey, MemoryValue>;
 
class Runtime {
 public:
  struct ICallBack {
    virtual ~ICallBack() {}
 
    // Resource Management
    virtual void freeAndResetQubit(IQubitRecord*) = 0;
    virtual bool isQubitLocked(IQubitRecord* const) = 0;
    virtual void lockQubit(IQubitRecord* const, unsigned long rs_id, int rule_id, int action_index) = 0;
    virtual int getActionIndex(IQubitRecord* const) = 0;
 
    // Quantum Operations
    virtual MeasurementOutcome measureQubitRandomly(IQubitRecord*) = 0;
    virtual MeasurementOutcome measureQubitX(IQubitRecord*) = 0;
    virtual MeasurementOutcome measureQubitZ(IQubitRecord*) = 0;
    virtual MeasurementOutcome measureQubitY(IQubitRecord*) = 0;
    virtual void gateX(IQubitRecord*) = 0;
    virtual void gateZ(IQubitRecord*) = 0;
    virtual void gateY(IQubitRecord*) = 0;
    virtual void gateCNOT(IQubitRecord* control_qubit_rec, IQubitRecord* target_qubit_rec) = 0;
    virtual int purifyX(IQubitRecord* qubit_rec, IQubitRecord* trash_qubit_rec) = 0;
    virtual int purifyZ(IQubitRecord* qubit_rec, IQubitRecord* trash_qubit_rec) = 0;
    virtual int purifyY(IQubitRecord* qubit_rec, IQubitRecord* trash_qubit_rec) = 0;
 
    // Messaging
    virtual void sendLinkTomographyResult(const unsigned long ruleset_id, const Rule& rule, const int action_index, const QNodeAddr partner_addr, int count,
                                          MeasurementOutcome outcome, int max_count, Time start_time) = 0;
    // TODO: change to this
    // virtual void sendTomographyResult(const QNodeAddr partner_addr, const int shared_rule_tag, const int sequence_number, const int measurement_result, const basis) = 0;
    virtual void sendPurificationResult(const unsigned long ruleset_id, const QNodeAddr partner_addr, const int shared_rule_tag, const int sequence_number,
                                        const int measurement_result, PurType protocol) = 0;
    virtual void sendSwappingResult(const unsigned long ruleset_id, const QNodeAddr partner_addr, const QNodeAddr new_partner_addr, const int shared_rule_tag,
                                    const int sequence_number, const int frame_correction) = 0;
    // Debugging
    virtual std::string getNodeInfo() { return ""; };
  };
 
  Runtime();
  Runtime(const RuleSet& ruleset, ICallBack* callback);
  Runtime(const Runtime&);
  Runtime& operator=(Runtime&& runtime);
  ~Runtime();
 
  void assignRuleSet(const RuleSet& ruleset);
 
  void cleanup();
 
  void exec();
 
  void execProgram(const Program& program);
 
  void execInstruction(const InstructionTypes& op);
 
  void assignMessageToRuleSet(int shared_rule_tag, MessageRecord& msg_content);
 
  void assignQubitToRuleSet(QNodeAddr partner_addr, IQubitRecord* qubit_record);
 
  void assignQubitToRule(QNodeAddr partner_addr, RuleId rule_id, IQubitRecord* qubit_record);
 
  QubitResources::iterator findQubit(IQubitRecord*);
 
  const Register& getReg(RegId reg_id) const;
 
  int32_t getRegVal(RegId reg_id) const;
 
  void setRegVal(RegId reg_id, int32_t val);
 
  void jumpTo(const Label& label);
 
 
 
  void storeVal(MemoryKey key, MemoryValue val);
 
  void loadVal(MemoryKey key, RegId reg_id);
 
  MemoryValue loadVal(MemoryKey key);
 
 
  bool isQubitLocked(IQubitRecord* const);
 
  IQubitRecord* getQubitBySequenceNumber(QNodeAddr, RuleId, SequenceNumber);
 
  IQubitRecord* getQubitByPartnerAddr(QNodeAddr, int index);
 
  IQubitRecord* getQubitByQubitId(QubitId qubit_id) const;
 
  void setQubit(IQubitRecord* qubit_record, QubitId qubit_id);
 
  void promoteQubit(IQubitRecord* qubit_record);
 
  void promoteQubitWithNewPartner(IQubitRecord* qubit_record, QNodeAddr new_partner_addr);
 
 
  void measureQubit(QubitId qubit_id, MemoryKey result_key, Basis basis);
  void measureQubit(QubitId qubit_id, RegId result_reg, Basis basis);
  void measureQubit(QubitId qubit_id, RegId result_reg, int bitset_index, Basis basis);
 
  void freeQubit(QubitId);
 
  void gateX(QubitId);
 
  void gateZ(QubitId);
 
  void gateY(QubitId);
 
  void gateCNOT(QubitId control_qubit_id, QubitId target_qubit_id);
 
  void purifyX(RegId result, int bitset_index, QubitId qubit_id, QubitId trash_qubit_id);
 
  void purifyZ(RegId result, int bitset_index, QubitId qubit_id, QubitId trash_qubit_id);
 
  void purifyY(RegId result, int bitset_index, QubitId qubit_id, QubitId trash_qubit_id);
 
  void debugRuntimeState();
  void debugSource(const Program& program) const;
  std::string debugInstruction(const InstructionTypes& instr) const;
 
  InstructionVisitor visitor;
 
  ICallBack* callback;
 
  RuleId rule_id = -1;
 
  int send_tag = -1;
  int receive_tag = -1;
 
  unsigned int pc = 0;
 
  Register registers[5];
 
  QubitResources qubits;
 
  MessageResources messages;
 
  QubitResourcesWithSequenceNumbers sequence_number_to_qubit;
  SequenceNumberTracker qubit_to_sequence_number;
  SequenceNumberCounter resource_counter;
 
  std::unordered_map<int, RuleId> shared_tag_to_rule_id;
  std::unordered_map<RuleId, int> rule_id_to_shared_tag;
 
  QubitNameMap named_qubits;
 
  Memory memory;
 
  RuleSet ruleset;
 
  std::set<QNodeAddr> partners;
 
  LabelMap const* label_map = nullptr;
 
  ReturnCode return_code = ReturnCode::NONE;
 
  bool should_exit = false;
 
  bool terminated = false;
 
  bool qubit_found = false;
 
  bool message_found = false;
 
  bool debugging = false;
};
}  // namespace quisp::runtime