Commit f65ea6a5 authored by Nguyen, Thien Minh's avatar Nguyen, Thien Minh
Browse files

Update Tuple header type implementation and add QIR API for result One and Zero getter 



(compiling latest Q# compiler)

Signed-off-by: default avatarThien Nguyen <nguyentm@ornl.gov>
parent 8e502cf3

mlir/qir_qrt/qir-qrt.cpp

+3 −0
Original line number Diff line number Diff line
@@ -240,6 +240,9 @@ bool __quantum__rt__result_equal(Result *res, Result *comp) { 
  return false;

}



Result* __quantum__rt__result_get_one() { return ResultOne; }

Result* __quantum__rt__result_get_zero() { return ResultZero;}



void __quantum__rt__string_update_reference_count(void *str, int64_t count) {

  // TODO

  if (verbose) std::cout << "CALL: " << __PRETTY_FUNCTION__ << "\n";

mlir/qir_qrt/qir-qrt.hpp

+3 −0
Original line number Diff line number Diff line
@@ -51,6 +51,9 @@ Result* __quantum__qis__mz(Qubit* q); 
// Compare results.

bool __quantum__rt__result_equal(Result *res, Result *comp);

void __quantum__rt__result_update_reference_count(Result *, int64_t count);

// Get reference Result.

Result* __quantum__rt__result_get_one();

Result* __quantum__rt__result_get_zero();



// Qubit Alloc/Dealloc API

Array* __quantum__rt__qubit_allocate_array(uint64_t idx);

mlir/qir_qrt/qir-types.hpp

+13 −11
Original line number Diff line number Diff line
@@ -87,19 +87,21 @@ struct Range { 


using TuplePtr = int8_t *;

struct TupleHeader {

  // Opaque/generic storage

  using Storage = std::vector<int8_t>;

  TuplePtr getTuple() { return &m_storage.front(); }

  static TupleHeader *create(int size) { return new TupleHeader(size); }

  // Tuple data

  int32_t m_tupleSize; 

  int8_t m_data[];

  

  TuplePtr getTuple() { return m_data; }

  size_t tupleSize() const { return m_tupleSize; }

  static TupleHeader *create(int size) {

    int8_t *buffer = new int8_t[sizeof(TupleHeader) + size];

    TupleHeader *th = reinterpret_cast<TupleHeader *>(buffer);

    th->m_tupleSize = size;

    return th;

  }

  static TupleHeader *getHeader(TuplePtr tuple) {

    // Get the TupleHeader wrapper

    return reinterpret_cast<TupleHeader *>(tuple -

                                        offsetof(TupleHeader, m_storage));

    return reinterpret_cast<TupleHeader *>(tuple - offsetof(TupleHeader, m_data));

  }



private:

  TupleHeader(int size) : m_storage(size, 0){};

  Storage m_storage;

};



// Callable: