Scheduler.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SCHEDULER_INTERFACE_H_
#define _SCHEDULER_INTERFACE_H_
 
#include "../Network/Network.h"
#include "../Utils/Threads/ThreadsPool.h"
 
namespace Schedulers
{

template <typename Time = Types::time_type> struct CircuitInfo : ExecuteCircuit<Time>
{
    using BitMapping = typename Circuits::Circuit<Time>::BitMapping;
 
    CircuitInfo() = default;
 
    CircuitInfo(const std::shared_ptr<Circuits::Circuit<Time>> &circuit, size_t shots, size_t id, size_t gatesDepth, Time timeDepth, size_t qubits)
        : ExecuteCircuit<Time>(circuit, shots), id(id), gatesDepth(gatesDepth), timeDepth(timeDepth), qubits(qubits)
    {
    }
 
    bool operator==(const CircuitInfo<Time> &other) const
    {
        if (ExecuteCircuit<Time>::operator==(other))
        {
            return id == other.id && gatesDepth == other.gatesDepth && timeDepth == other.timeDepth && qubits == other.qubits && hostId == other.hostId;
        }
 
        return false;
    }
 
    size_t id = 0;
    size_t gatesDepth = 0;
    Time timeDepth = 0;
    size_t qubits = 0;
    BitMapping bitMapping;
 
    // those are redundant, but I set them anyway for convenience and easier usage
    // in python
    size_t hostId = 0;
    size_t startQubits = 0;
};

template <typename Time = Types::time_type> struct ExecuteJob
{
    using NetworkClass = typename Network::INetwork<Time>;
    using ExecuteResults = typename NetworkClass::ExecuteResults;
 
    std::shared_ptr<NetworkClass> hostNetwork;
    size_t h = 0;
    std::shared_ptr<Circuits::Circuit<Time>> circ;
    size_t nrShots = 0;
    ExecuteResults results;
 
    void DoWork()
    {
        if (!hostNetwork || !circ || nrShots == 0)
            return;
 
        results = hostNetwork->RepeatedExecuteOnHost(circ, h, nrShots);
    }
 
    size_t GetJobCount() const
    {
        return 1;
    }
};

template <typename Time = Types::time_type> class IScheduler : public std::enable_shared_from_this<IScheduler<Time>>
{
  public:
    using NetworkClass = typename Network::INetwork<Time>;
    using ExecuteResults = typename NetworkClass::ExecuteResults;
 
    virtual ~IScheduler() = default;
 
    virtual void SetNetwork(const std::shared_ptr<NetworkClass> &n)
    {
        network = n;
    }
 
    std::shared_ptr<NetworkClass> GetNetwork() const
    {
        return network;
    }

    virtual std::vector<ExecuteResults> ExecuteScheduled(const std::vector<ExecuteCircuit<Time>> &circuits) = 0;
 
    virtual std::shared_ptr<Circuits::Circuit<Time>> GetScheduledCircuit() const = 0;
 
    virtual std::vector<ExecuteResults> ExecuteScheduledSteps() = 0;
 
    virtual const std::vector<std::vector<CircuitInfo<Time>>> &GetScheduledSteps() const = 0;
 
    virtual void SetScheduledSteps(const std::vector<std::vector<CircuitInfo<Time>>> &steps) = 0;
 
    virtual bool SetCurrentStep(size_t step) = 0;
 
    virtual std::shared_ptr<Circuits::Circuit<Time>> GetScheduledCircuitForHost(size_t hostId) const = 0;
 
    virtual size_t GetCurrentShots() const = 0;
 
    virtual void ExecuteCurrentStep() = 0;
 
    virtual void SetDepthEstimationMethod(bool useSteps = true) = 0;
 
    virtual bool GetDepthEstimationMethod() const = 0;
 
    virtual void SetUseCost(bool useCost = true) = 0;
 
    virtual bool GetUseCost() const = 0;
 
    virtual void SetAddResetsAtEnd(bool addResets = true) = 0;
 
    virtual bool GetAddResetsAtEnd() const = 0;
 
    virtual void SetAddResetsAtStart(bool addResets = true) = 0;
 
    virtual bool GetAddResetsAtStart() const = 0;
 
    virtual std::vector<ExecuteResults> GetResults() const = 0;
 
    virtual void CollectResults(const ExecuteResults &res, size_t nrShots) = 0;
 
    virtual void CollectResultsForHost(const ExecuteResults &res, size_t hostId, size_t nrShots) = 0;
 
    virtual Network::SchedulerType GetType() const = 0;
 
  private:
    std::shared_ptr<NetworkClass> network; 
};
} // namespace Schedulers
 
#endif