Commit deafeb80 authored by Mccaskey, Alex's avatar Mccaskey, Alex
Browse files

setup pass manager placement to fall back to qpu specified placement if none provided 



Signed-off-by: Mccaskey, Alex's avatarAlex McCaskey <mccaskeyaj@ornl.gov>
parent 96b7e107

runtime/qrt/pass_manager.cpp

+30 −23
Original line number Diff line number Diff line 
#include "pass_manager.hpp"



#include <iomanip>

#include <numeric>



#include "InstructionIterator.hpp"

#include "xacc.hpp"

#include "xacc_service.hpp"

#include "xacc_internal_compiler.hpp"

#include <iomanip>

#include <numeric>

#include "xacc_service.hpp"

namespace {

std::string

printGateCountComparison(const std::unordered_map<std::string, int> &before,

std::string printGateCountComparison(

    const std::unordered_map<std::string, int> &before,

    const std::unordered_map<std::string, int> &after) {

  std::stringstream stream;

  const size_t nbColumns = 3;
@@ -46,22 +48,23 @@ PassManager::PassManager(int level, const std::vector<int> &qubitMap, 
                         const std::string &placementName)

    : m_level(level), m_qubitMap(qubitMap), m_placement(placementName) {}



PassStat PassManager::runPass(const std::string &passName, std::shared_ptr<xacc::CompositeInstruction> program) {

PassStat PassManager::runPass(

    const std::string &passName,

    std::shared_ptr<xacc::CompositeInstruction> program) {

  PassStat stat;

  stat.passName = passName;

  // Counts gate before:

  stat.gateCountBefore = PassStat::countGates(program);

  xacc::ScopeTimer timer(passName, false);



  if (!xacc::hasService<xacc::IRTransformation>(passName)

      && !xacc::hasContributedService<xacc::IRTransformation>(passName)) {

  if (!xacc::hasService<xacc::IRTransformation>(passName) &&

      !xacc::hasContributedService<xacc::IRTransformation>(passName)) {

    // Graciously ignores passes which cannot be located.

    // Returns empty stats

    return stat;

  }



  auto xaccOptTransform =

      xacc::getIRTransformation(passName);

  auto xaccOptTransform = xacc::getIRTransformation(passName);

  if (xaccOptTransform) {

    xaccOptTransform->apply(program, nullptr);

  }
@@ -94,7 +97,8 @@ std::vector<PassStat> PassManager::optimize( 
  return passData;

}



void PassManager::applyPlacement(std::shared_ptr<xacc::CompositeInstruction> program) const {

void PassManager::applyPlacement(

    std::shared_ptr<xacc::CompositeInstruction> program) const {

  const std::string placementName = [&]() -> std::string {

    // If the qubit-map was provided, always use default-placement

    if (!m_qubitMap.empty()) {
@@ -103,11 +107,13 @@ void PassManager::applyPlacement(std::shared_ptr<xacc::CompositeInstruction> pro 
    // Use the specified placement if any.

    // Note: placement will only be activated if the accelerator

    // has a connectivity graph.

    return m_placement.empty() ? DEFAULT_PLACEMENT : m_placement;

    return m_placement.empty()

               ? xacc::internal_compiler::qpu->defaultPlacementTransformation()

               : m_placement;

  }();



  if (!xacc::hasService<xacc::IRTransformation>(placementName)

      && !xacc::hasContributedService<xacc::IRTransformation>(placementName)) {

  if (!xacc::hasService<xacc::IRTransformation>(placementName) &&

      !xacc::hasContributedService<xacc::IRTransformation>(placementName)) {

    // Graciously ignores services which cannot be located.

    return;

  }
@@ -117,7 +123,8 @@ void PassManager::applyPlacement(std::shared_ptr<xacc::CompositeInstruction> pro 
      xacc::internal_compiler::qpu &&

      !xacc::internal_compiler::qpu->getConnectivity().empty()) {

    if (placementName == "default-placement") {

      irt->apply(program, xacc::internal_compiler::qpu, {{"qubit-map", m_qubitMap}});

      irt->apply(program, xacc::internal_compiler::qpu,

                 {{"qubit-map", m_qubitMap}});

    } else {

      irt->apply(program, xacc::internal_compiler::qpu);

    }