SimpleController.h

Go to the documentation of this file.

 
#pragma once
 
#ifndef _SIMPLE_CONTROLLER_H_
#define _SIMPLE_CONTROLLER_H_
 
#include "../Distribution/Remapper.h"
#include "../Scheduler/Scheduler.h"
#include "../graph/Optimiser.h"
#include "Controller.h"
 
namespace Network
{

template <typename Time = Types::time_type> class SimpleController : public IController<Time>
{
  public:
    std::shared_ptr<Circuits::Circuit<Time>> DistributeCircuit(const std::shared_ptr<INetwork<Time>> &network,
                                                               const std::shared_ptr<Circuits::Circuit<Time>> &circuit) override
    {
        if (!remapper)
            return nullptr; // maybe throw an exception?
 
        // don't destroy the passed one, make a copy
        std::shared_ptr<Circuits::Circuit<Time>> distCirc = std::static_pointer_cast<Circuits::Circuit<Time>>(circuit->Clone());
 
        // this is a different optimization than below, that one is for qubits
        // layout in the network this one simpifies the circuit by merging gates
        // could be done after the distribution, perhaps, I'll think about it...
        // might change some things that would break up the netqasm conversion, so
        // for now it's here
 
        // also if it merges three cnots into a swap, for example, it shouldn't be
        // done after 'ConvertForDistribution' because the swap is converted to 3
        // cnots
        if (optimize)
            distCirc->Optimize(optimizeRotationGates);
 
        // this converts the 3 qubit gates and swap to 2-qubit gates (the swap to 3
        // cnots)
        distCirc->ConvertForDistribution();
 
        // virtual, by default does nothing, but in derived classes it can do
        // something for example, for netqasm it arranges the measurements in the
        // proper order for conversion
        distCirc = this->DoNetworkSpecificConversionsForDistribution(network, distCirc);
 
        if (optimiser)
        {
            // optimise the circuit
            optimiser->SetNetworkAndCircuit(network, distCirc);
            optimiser->Optimise();
            const auto &qubitsMap = optimiser->GetQubitsMap();
            distCirc = std::dynamic_pointer_cast<Circuits::Circuit<Time>>(distCirc->Remap(qubitsMap, qubitsMap));
        }
 
        // now distribute
 
        // the first thing to do is to adjust the qubits indexes in the circuit
        // according to the network topology walk over the network hosts and add one
        // qubit per host for the entangled one (as it's the case for the 'simple
        // network') and one cbit per host for measuring the entangled qubit for now
        // they will be added at the end of the registers, to be easier to convert
        // the circuit for distribution
 
        return remapper->Remap(network, distCirc);
    }

    std::shared_ptr<Circuits::Circuit<Time>> SplitCompositeOperations(const std::shared_ptr<INetwork<Time>> &network,
                                                                      const std::shared_ptr<Circuits::Circuit<Time>> &circuit) override
    {
        if (!remapper)
            return nullptr; // maybe throw an exception?
 
        return remapper->SplitCompositeOperations(network, circuit);
    }

    size_t GetId() const override
    {
        return std::numeric_limits<size_t>::max();
    }

    size_t GetNumQubits() const override
    {
        return 0;
    }

    size_t GetNumNetworkEntangledQubits() const override
    {
        return 0;
    }

    size_t GetNumClassicalBits() const override
    {
        return 0;
    }

    bool IsQubitOnHost(size_t qubitId) const override
    {
        return false;
    }

    bool IsClassicalBitOnHost(size_t qubitId) const override
    {
        return false;
    }

    bool IsEntangledQubitOnHost(size_t qubitId) const override
    {
        return false;
    }

    bool AreQubitsOnSameHost(size_t qubitId1, size_t qubitId2) const override
    {
        return false;
    }

    bool AreCbitsOnSameHost(size_t qubitId1, size_t qubitId2) const override
    {
        return false;
    }

    std::vector<size_t> GetQubitsIds() const override
    {
        return {};
    }

    std::vector<size_t> GetNetworkEntangledQubitsIds() const override
    {
        return {};
    }

    std::vector<size_t> GetClassicalBitsIds() const override
    {
        return {};
    }

    std::vector<size_t> GetEntangledQubitMeasurementBitIds() const override
    {
        return {};
    }

    void SetRemapper(const std::shared_ptr<Distribution::IRemapper<Time>> &r) override
    {
        remapper = r;
    }

    std::shared_ptr<Distribution::IRemapper<Time>> GetRemapper() const override
    {
        return remapper;
    }

    bool SendPacketToHost(size_t hostId, const std::vector<uint8_t> &packet) override
    {
        return false;
    }

    bool RecvPacketFromHost(size_t hostId, const std::vector<uint8_t> &packet) override
    {
        return false;
    }

    size_t GetStartQubitId() const override
    {
        return 0;
    }

    size_t GetStartClassicalBitId() const override
    {
        return 0;
    }

    std::shared_ptr<Graphs::IOptimiser<Time>> GetOptimiser() const override
    {
        return optimiser;
    }

    void CreateOptimiser(Graphs::OptimiserType type) override
    {
        throw std::runtime_error("SimpleController::CreateOptimiser: not "
                                 "implemented for this type of network controller");
    }

    std::shared_ptr<Circuits::Circuit<Time>> DoNetworkSpecificConversionsForDistribution(const std::shared_ptr<INetwork<Time>> &network,
                                                                                         const std::shared_ptr<Circuits::Circuit<Time>> &circuit) override
    {
        return circuit;
    }

    void CreateScheduler(const std::shared_ptr<INetwork<Time>> &network, SchedulerType schType = SchedulerType::kNoEntanglementQubitsParallel) override
    {
        throw std::runtime_error("SimpleController::CreateScheduler: not "
                                 "implemented for this type of network controller");
    }

    std::shared_ptr<Schedulers::IScheduler<Time>> GetScheduler() const override
    {
        return scheduler;
    }
 
    bool GetOptimizeRotationGates() const override
    {
        return optimizeRotationGates;
    }
 
    void SetOptimizeRotationGates(bool val = true) override
    {
        optimizeRotationGates = val;
    }

    void SetOptimizeCircuit(bool o = true) override
    {
        optimize = o;
    }

    bool GetOptimizeCircuit() const override
    {
        return optimize;
    }
 
  protected:
    std::shared_ptr<Distribution::IRemapper<Time>> remapper; 
 
    // the problem with setting a default optimiser here is that everywhere where
    // amplitudes are checked in tests for some network distributions, the tests
    // will fail
    // because the qubits are scrambled by the optimiser, they are rearranged so
    // the number of distributions is reduced so better set it explicitly only
    // when tests for results are checked!
    std::shared_ptr<Graphs::IOptimiser<Time>> optimiser; // =
                                                         // Graphs::Factory<Time>::Create(Graphs::OptimiserType::kMonteCarlo);
                                                         // /**< The optimiser used to optimise the circuit. */
 
    std::shared_ptr<Schedulers::IScheduler<Time>> scheduler; 
 
  private:
    bool optimize = true;
    bool optimizeRotationGates = true; 
};
} // namespace Network
 
#endif // !_SIMPLE_CONTROLLER_H_