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

update main() to main(int, char**), add qrt initialization scheme, add finalization scheme 



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

mlir/dialect/quantum_dialect.cpp

+399 −197

File changed.

Preview size limit exceeded, changes collapsed.

mlir/dialect/quantum_dialect.hpp

+164 −55
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ class QallocOp; 
class DeallocOp;

class ExtractQubitOp;

class QRTInitOp;

class QRTFinalizeOp;

}  // namespace quantum

}  // namespace mlir
@@ -24,7 +25,8 @@ class QuantumDialect : public mlir::Dialect { 
};

class ExtractQubitOpAdaptor {

 public:

  ExtractQubitOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = nullptr);

  ExtractQubitOpAdaptor(::mlir::ValueRange values,

                        ::mlir::DictionaryAttr attrs = nullptr);

  ExtractQubitOpAdaptor(ExtractQubitOp &op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::ValueRange getODSOperands(unsigned index);
@@ -36,7 +38,11 @@ private: 
  ::mlir::ValueRange odsOperands;

  ::mlir::DictionaryAttr odsAttrs;

};

class ExtractQubitOp : public ::mlir::Op<ExtractQubitOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::NOperands<2>::Impl> {

class ExtractQubitOp

    : public ::mlir::Op<ExtractQubitOp, ::mlir::OpTrait::ZeroRegion,

                        ::mlir::OpTrait::OneResult,

                        ::mlir::OpTrait::ZeroSuccessor,

                        ::mlir::OpTrait::NOperands<2>::Impl> {

 public:

  using Op::Op;

  using Op::print;
@@ -51,9 +57,16 @@ public: 
  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  ::mlir::Operation::result_range getODSResults(unsigned index);

  ::mlir::Value qbit();

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type qbit, ::mlir::Value qreg, ::mlir::Value idx);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value qreg, ::mlir::Value idx);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState, ::mlir::Type qbit,

                    ::mlir::Value qreg, ::mlir::Value idx);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::Value qreg,

                    ::mlir::Value idx);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands,

                    ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  ::mlir::LogicalResult verify();

};

}  // namespace quantum
@@ -67,7 +80,8 @@ namespace quantum { 


class InstOpAdaptor {

 public:

  InstOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = nullptr);

  InstOpAdaptor(::mlir::ValueRange values,

                ::mlir::DictionaryAttr attrs = nullptr);

  InstOpAdaptor(InstOp &op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::ValueRange getODSOperands(unsigned index);
@@ -80,7 +94,10 @@ private: 
  ::mlir::ValueRange odsOperands;

  ::mlir::DictionaryAttr odsAttrs;

};

class InstOp : public ::mlir::Op<InstOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::VariadicResults, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::VariadicOperands> {

class InstOp

    : public ::mlir::Op<

          InstOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::VariadicResults,

          ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::VariadicOperands> {

 public:

  using Op::Op;

  using Op::print;
@@ -99,11 +116,29 @@ public: 
  ::llvm::Optional<::mlir::DenseElementsAttr> params();

  void nameAttr(::mlir::StringAttr attr);

  void paramsAttr(::mlir::DenseElementsAttr attr);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type bit, ::mlir::StringAttr name, ::mlir::ValueRange qubits, /*optional*/::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::StringAttr name, ::mlir::ValueRange qubits, /*optional*/::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, /*optional*/::mlir::Type bit, ::llvm::StringRef name, ::mlir::ValueRange qubits, /*optional*/::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::llvm::StringRef name, ::mlir::ValueRange qubits, /*optional*/::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    /*optional*/ ::mlir::Type bit, ::mlir::StringAttr name,

                    ::mlir::ValueRange qubits,

                    /*optional*/ ::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::StringAttr name,

                    ::mlir::ValueRange qubits,

                    /*optional*/ ::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    /*optional*/ ::mlir::Type bit, ::llvm::StringRef name,

                    ::mlir::ValueRange qubits,

                    /*optional*/ ::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::llvm::StringRef name,

                    ::mlir::ValueRange qubits,

                    /*optional*/ ::mlir::DenseElementsAttr params);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands,

                    ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  ::mlir::LogicalResult verify();

};

}  // namespace quantum
@@ -116,7 +151,8 @@ namespace quantum { 
//===----------------------------------------------------------------------===//

class QRTInitOpAdaptor {

 public:

  QRTInitOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = nullptr);

  QRTInitOpAdaptor(::mlir::ValueRange values,

                   ::mlir::DictionaryAttr attrs = nullptr);

  QRTInitOpAdaptor(QRTInitOp &op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::ValueRange getODSOperands(unsigned index);
@@ -128,7 +164,10 @@ private: 
  ::mlir::ValueRange odsOperands;

  ::mlir::DictionaryAttr odsAttrs;

};

class QRTInitOp : public ::mlir::Op<QRTInitOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::ZeroResult, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::NOperands<2>::Impl> {

class QRTInitOp

    : public ::mlir::Op<

          QRTInitOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::ZeroResult,

          ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::NOperands<2>::Impl> {

 public:

  using Op::Op;

  using Op::print;
@@ -142,14 +181,59 @@ public: 
  ::mlir::MutableOperandRange argvMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  ::mlir::Operation::result_range getODSResults(unsigned index);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value argc, ::mlir::Value argv);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value argc, ::mlir::Value argv);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState, ::mlir::Value argc,

                    ::mlir::Value argv);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::Value argc,

                    ::mlir::Value argv);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands,

                    ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  ::mlir::LogicalResult verify();

};

class QRTFinalizeOpAdaptor {

 public:

  QRTFinalizeOpAdaptor(::mlir::ValueRange values,

                       ::mlir::DictionaryAttr attrs = nullptr);

  QRTFinalizeOpAdaptor(QRTFinalizeOp &op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::ValueRange getODSOperands(unsigned index);

  ::mlir::LogicalResult verify(::mlir::Location loc);



 private:

  ::mlir::ValueRange odsOperands;

  ::mlir::DictionaryAttr odsAttrs;

};

class QRTFinalizeOp

    : public ::mlir::Op<QRTFinalizeOp, ::mlir::OpTrait::ZeroRegion,

                        ::mlir::OpTrait::ZeroResult,

                        ::mlir::OpTrait::ZeroSuccessor,

                        ::mlir::OpTrait::ZeroOperands> {

 public:

  using Op::Op;

  using Op::print;

  using Adaptor = QRTFinalizeOpAdaptor;

  static ::llvm::StringRef getOperationName();

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::Operation::operand_range getODSOperands(unsigned index);

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  ::mlir::Operation::result_range getODSResults(unsigned index);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands,

                    ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  ::mlir::LogicalResult verify();

};

class QallocOpAdaptor {

 public:

  QallocOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = nullptr);

  QallocOpAdaptor(::mlir::ValueRange values,

                  ::mlir::DictionaryAttr attrs = nullptr);

  QallocOpAdaptor(QallocOp &op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::ValueRange getODSOperands(unsigned index);
@@ -161,7 +245,10 @@ private: 
  ::mlir::ValueRange odsOperands;

  ::mlir::DictionaryAttr odsAttrs;

};

class QallocOp : public ::mlir::Op<QallocOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::OneResult, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::ZeroOperands> {

class QallocOp

    : public ::mlir::Op<

          QallocOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::OneResult,

          ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::ZeroOperands> {

 public:

  using Op::Op;

  using Op::print;
@@ -178,17 +265,31 @@ public: 
  ::llvm::StringRef name();

  void sizeAttr(::mlir::IntegerAttr attr);

  void nameAttr(::mlir::StringAttr attr);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type qubits, ::mlir::IntegerAttr size, ::mlir::StringAttr name);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr size, ::mlir::StringAttr name);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Type qubits, ::mlir::IntegerAttr size, ::llvm::StringRef name);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr size, ::llvm::StringRef name);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState, ::mlir::Type qubits,

                    ::mlir::IntegerAttr size, ::mlir::StringAttr name);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr size,

                    ::mlir::StringAttr name);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState, ::mlir::Type qubits,

                    ::mlir::IntegerAttr size, ::llvm::StringRef name);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::IntegerAttr size,

                    ::llvm::StringRef name);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands,

                    ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  ::mlir::LogicalResult verify();

  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser, ::mlir::OperationState &result);

  static ::mlir::ParseResult parse(::mlir::OpAsmParser &parser,

                                   ::mlir::OperationState &result);

};

class DeallocOpAdaptor {

 public:

  DeallocOpAdaptor(::mlir::ValueRange values, ::mlir::DictionaryAttr attrs = nullptr);

  DeallocOpAdaptor(::mlir::ValueRange values,

                   ::mlir::DictionaryAttr attrs = nullptr);

  DeallocOpAdaptor(DeallocOp &op);

  std::pair<unsigned, unsigned> getODSOperandIndexAndLength(unsigned index);

  ::mlir::ValueRange getODSOperands(unsigned index);
@@ -199,7 +300,10 @@ private: 
  ::mlir::ValueRange odsOperands;

  ::mlir::DictionaryAttr odsAttrs;

};

class DeallocOp : public ::mlir::Op<DeallocOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::ZeroResult, ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::OneOperand> {

class DeallocOp

    : public ::mlir::Op<

          DeallocOp, ::mlir::OpTrait::ZeroRegion, ::mlir::OpTrait::ZeroResult,

          ::mlir::OpTrait::ZeroSuccessor, ::mlir::OpTrait::OneOperand> {

 public:

  using Op::Op;

  using Op::print;
@@ -211,9 +315,14 @@ public: 
  ::mlir::MutableOperandRange qubitsMutable();

  std::pair<unsigned, unsigned> getODSResultIndexAndLength(unsigned index);

  ::mlir::Operation::result_range getODSResults(unsigned index);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::Value qubits);

  static void build(::mlir::OpBuilder &odsBuilder, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::Value qubits);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState, ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands, ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState, ::mlir::Value qubits);

  static void build(::mlir::OpBuilder &odsBuilder,

                    ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::Value qubits);

  static void build(::mlir::OpBuilder &, ::mlir::OperationState &odsState,

                    ::mlir::TypeRange resultTypes, ::mlir::ValueRange operands,

                    ::llvm::ArrayRef<::mlir::NamedAttribute> attributes = {});

  ::mlir::LogicalResult verify();

};

}  // namespace quantum

mlir/parsers/openqasm/openqasm_mlir_generator.cpp

+39 −16
Original line number Diff line number Diff line
@@ -23,10 +23,10 @@ void OpenQasmMLIRGenerator::initialize_mlirgen() { 
  auto argv_type =

      mlir::OpaqueType::get(dialect, llvm::StringRef("ArgvType"), &context);



  std::vector<mlir::Type> arg_types_vec;//{int_type, argv_type};

  llvm::SmallVector<mlir::Type, 4> arg_types;

  std::vector<mlir::Type> arg_types_vec{int_type, argv_type};

  // llvm::SmallVector<mlir::Type, 4> arg_types;

  auto func_type =

      builder.getFunctionType(llvm::makeArrayRef(arg_types_vec), llvm::None);//int_type);

      builder.getFunctionType(llvm::makeArrayRef(arg_types_vec), int_type);

  auto proto = mlir::FuncOp::create(builder.getUnknownLoc(), "main", func_type);

  mlir::FuncOp function(proto);

  main_entry_block = function.addEntryBlock();
@@ -34,15 +34,6 @@ void OpenQasmMLIRGenerator::initialize_mlirgen() { 
  builder.setInsertionPointToStart(&entryBlock);

  m_module.push_back(function);

  function_names.push_back("main");



  // call to quantum.init(argc, argv);

  std::vector<mlir::Value> main_args;

  for (auto arg : entryBlock.getArguments()) {

    main_args.push_back(arg);

  }



  // builder.create<mlir::quantum::QRTInitOp>(builder.getUnknownLoc(), main_args[0], main_args[1]);



}



void OpenQasmMLIRGenerator::mlirgen(const std::string &src) {
@@ -68,11 +59,14 @@ void OpenQasmMLIRGenerator::finalize_mlirgen() { 
                                             qalloc_op);

  }



  // auto integer_attr = mlir::IntegerAttr::get(builder.getI64Type(), 0);

  // mlir::Value ret_zero =

  //     builder.create<mlir::ConstantOp>(builder.getUnknownLoc(), integer_attr);

  builder.create<mlir::quantum::QRTFinalizeOp>(builder.getUnknownLoc());

  

  builder.create<mlir::ReturnOp>(builder.getUnknownLoc());//, ret_zero);

  auto integer_attr = mlir::IntegerAttr::get(builder.getI32Type(), 0);

  mlir::Value ret_zero =

      builder.create<mlir::ConstantOp>(builder.getUnknownLoc(),

      integer_attr);



  builder.create<mlir::ReturnOp>(builder.getUnknownLoc(), ret_zero);



  std::vector<llvm::StringRef> tmp(function_names.begin(),

                                   function_names.end());
@@ -145,6 +139,12 @@ void OpenQasmMLIRGenerator::visit(RegisterDecl &d) { 
    auto location =

        builder.getFileLineColLoc(builder.getIdentifier(fname), line, col);



    if (is_first_inst && !in_sub_kernel) {

      auto main_args = main_entry_block->getArguments();

      builder.create<mlir::quantum::QRTInitOp>(location, main_args[0],

                                               main_args[1]);

      is_first_inst = false;

    }

    auto integer_type = builder.getI64Type();

    auto integer_attr = mlir::IntegerAttr::get(integer_type, size);
@@ -205,6 +205,14 @@ void OpenQasmMLIRGenerator::visit(UGate &u) { 
  auto location =

      builder.getFileLineColLoc(builder.getIdentifier(fname), line, col);



  if (is_first_inst && !in_sub_kernel) {

    auto main_args = main_entry_block->getArguments();



    builder.create<mlir::quantum::QRTInitOp>(location, main_args[0],

                                             main_args[1]);

    is_first_inst = false;

  }



  auto str_attr = builder.getStringAttr("u3");

  // params

  auto dataType = mlir::VectorType::get({3}, builder.getF64Type());
@@ -252,6 +260,13 @@ void OpenQasmMLIRGenerator::visit(CNOTGate &g) { 
  auto location =

      builder.getFileLineColLoc(builder.getIdentifier(fname), line, col);



  if (is_first_inst && !in_sub_kernel) {

    auto main_args = main_entry_block->getArguments();



    builder.create<mlir::quantum::QRTInitOp>(location, main_args[0],

                                             main_args[1]);

    is_first_inst = false;

  }

  auto str_attr = builder.getStringAttr("cx");



  // params
@@ -324,6 +339,14 @@ void OpenQasmMLIRGenerator::visit(DeclaredGate &g) { 
  auto location =

      builder.getFileLineColLoc(builder.getIdentifier(fname), line, col);



  if (is_first_inst && !in_sub_kernel) {

    auto main_args = main_entry_block->getArguments();



    builder.create<mlir::quantum::QRTInitOp>(location, main_args[0],

                                             main_args[1]);

    is_first_inst = false;

  }



  auto str_attr = builder.getStringAttr(g.name());



  // params

mlir/parsers/openqasm/openqasm_mlir_generator.hpp

+2 −0
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#pragma GCC diagnostic ignored "-Wdeprecated-copy"

#pragma GCC diagnostic ignored "-Wunused-function"



#include "mlir/IR/Region.h"

#include "ast/ast.hpp"

#include "ast/traversal.hpp"

#include "mlir_generator.hpp"
@@ -25,6 +26,7 @@ class OpenQasmMLIRGenerator : public qcor::QuantumMLIRGenerator, 
  bool in_sub_kernel = false;

  std::map<std::string, mlir::Value> temporary_sub_kernel_args;

  std::vector<std::string> function_names;

  bool is_first_inst = true;



  mlir::Type qubit_type;

  mlir::Type array_type;

mlir/qir_qrt/qir-qrt.cpp

+24 −10
Original line number Diff line number Diff line
@@ -12,11 +12,24 @@ Result ResultOne = 1; 
unsigned long allocated_qbits = 0;

std::shared_ptr<xacc::AcceleratorBuffer> qbits;

std::shared_ptr<xacc::Accelerator> qpu;

std::string qpu_name = "qpp";



std::vector<std::unique_ptr<Array>> allocated_arrays;



bool initialized = false;

void __quantum__rt__initialize(int argc, char** argv);

void __quantum__rt__initialize(int argc, int8_t** argv) {

  

  char ** casted = reinterpret_cast<char**>(argv);

  std::vector<std::string> args(casted, casted+argc);



  for (auto [i, arg] : qcor::enumerate(args)) {

    if (arg == "-qpu") {

      qpu_name = args[i+1];

    }

  }



  initialize();

}



void initialize() {

  if (!initialized) {
@@ -24,7 +37,8 @@ void initialize() { 
    // qcor::set_verbose(true);

    xacc::internal_compiler::__qrt_env = "ftqc";

    xacc::Initialize();

    auto qpu = xacc::getAccelerator("aer");

    std::cout << "[qir-qrt] Running on " << qpu_name << " backend.\n";

    auto qpu = xacc::getAccelerator(qpu_name);

    xacc::internal_compiler::qpu = qpu;

    ::quantum::qrt_impl = xacc::getService<::quantum::QuantumRuntime>(

        xacc::internal_compiler::__qrt_env);
@@ -34,18 +48,14 @@ void initialize() { 
}



void __quantum__qis__cnot(Qubit* src, Qubit* tgt) {

  initialize();

  // printf("[qir-qrt] Applying CNOT %lu %lu \n", src->second,

  // tgt->second);

  std::size_t src_copy = *src;  // src->second;

  std::size_t tgt_copy = *tgt;  // tgt->second;

  std::size_t src_copy = reinterpret_cast<std::size_t>(src);

  std::size_t tgt_copy = reinterpret_cast<std::size_t>(tgt);

  printf("[qir-qrt] Applying CX %lu, %lu\n", src_copy, tgt_copy);

  ::quantum::cnot({"q", src_copy}, {"q", tgt_copy});

}



void __quantum__qis__h(Qubit* q) {

  initialize();

  std::size_t qcopy = reinterpret_cast<std::size_t>(q);  // q->second;



  std::size_t qcopy = reinterpret_cast<std::size_t>(q); 

  printf("[qir-qrt] Applying H %lu\n", qcopy);

  ::quantum::h({"q", qcopy});

}
@@ -139,3 +149,7 @@ void __quantum__rt__qubit_release_array(Array* q) { 
    }

  }

}



void __quantum__rt__finalize() {

  std::cout << "[qir-qrt] Running finalization routine.\n";

}
 
 No newline at end of file