enable --buffer-deallocation-pipeline;

Add (proper) memory effects for quantum ops.
Add TODO for mqbc measurement op's memory effects.

Author: paul0403

frontend/catalyst/pipelines.py

@@ -240,7 +240,7 @@ def get_bufferization_stage(options: CompileOptions) -> List[str]:
         "func.func(buffer-hoisting)",
         "func.func(buffer-loop-hoisting)",
         "func.func(promote-buffers-to-stack)",
-        # "buffer-deallocation-pipeline",
+        "buffer-deallocation-pipeline",
         "convert-arraylist-to-memref",
         "convert-bufferization-to-memref",
         "canonicalize",  # Must be after convert-bufferization-to-memref

mlir/include/MBQC/IR/MBQCOps.td

@@ -19,6 +19,7 @@ include "mlir/IR/AttrTypeBase.td"
 include "mlir/IR/EnumAttr.td"
 
 include "Quantum/IR/QuantumDialect.td"
+//include "Quantum/IR/QuantumOps.td"
 
 include "MBQC/IR/MBQCDialect.td"
 
@@ -54,7 +55,12 @@ def MeasurementPlaneAttr : EnumAttr<MBQC_Dialect, MeasurementPlane, "measurement
 // MBQC dialect operations.
 //===----------------------------------------------------------------------===//
 
-def MeasureInBasisOp : MBQC_Op<"measure_in_basis"> {
+def MeasureInBasisOp : MBQC_Op<"measure_in_basis"
+    // Measurement both read and write since it collapses states
+    // In fact, MBQC's entire point is to alter the state via measurement.
+    // TODO: restructure mbqc dialect to see the QuantumMemory Resource in Quantum dialect.
+    // ,[MemoryEffects<[MemRead<QuantumMemory>, MemWrite<QuantumMemory>]>]
+    > {
     let summary = "A parametric single-qubit projective measurement in an arbitrary basis.";
     let description = [{
         A parametric single-qubit projective measurement is equivalent to the `quantum.measure`

mlir/include/Quantum/IR/QuantumOps.td

@@ -63,23 +63,23 @@ def NamedObservableAttr : EnumAttr<QuantumDialect, NamedObservable, "named_obser
 
 class Quantum_Op<string mnemonic, list<Trait> traits = []> : Op<QuantumDialect, mnemonic, traits>;
 
-def InitializeOp : Quantum_Op<"init"> {
+def InitializeOp : Quantum_Op<"init", [MemoryEffects<[MemAlloc<QuantumMemory>]>]> {
     let summary = "Initialize the quantum runtime.";
 
     let assemblyFormat = [{
         attr-dict
     }];
 }
 
-def FinalizeOp : Quantum_Op<"finalize"> {
+def FinalizeOp : Quantum_Op<"finalize", [MemoryEffects<[MemFree<QuantumMemory>]>]> {
     let summary = "Teardown the quantum runtime.";
 
     let assemblyFormat = [{
         attr-dict
     }];
 }
 
-def DeviceInitOp : Quantum_Op<"device"> {
+def DeviceInitOp : Quantum_Op<"device", [MemoryEffects<[MemAlloc<QuantumMemory>]>]> {
     let summary = "Initialize a quantum device.";
 
     let arguments = (ins
@@ -95,7 +95,7 @@ def DeviceInitOp : Quantum_Op<"device"> {
 
 }
 
-def DeviceReleaseOp : Quantum_Op<"device_release"> {
+def DeviceReleaseOp : Quantum_Op<"device_release", [MemoryEffects<[MemFree<QuantumMemory>]>]> {
     let summary = "Release the active quantum device.";
 
     let assemblyFormat = [{
@@ -172,7 +172,7 @@ def DeallocQubitOp : Memory_Op<"dealloc_qb"> {
     }];
 }
 
-def DeallocOp : Memory_Op<"dealloc"> {
+def DeallocOp : Memory_Op<"dealloc", [MemoryEffects<[MemFree<QuantumMemory>]>]> {
     let summary = "Deallocate a quantum register.";
     let description = [{
     }];
@@ -856,7 +856,12 @@ def HamiltonianOp : Observable_Op<"hamiltonian"> {
 class Measurement_Op<string mnemonic, list<Trait> traits = []> :
         Quantum_Op<mnemonic, traits # [MeasurementProcess]>;
 
-def MeasureOp : Quantum_Op<"measure"> {
+def MeasureOp : Quantum_Op<"measure",
+    // Measurement both read and write since it collapses states
+    // This is even more true for the mbqc variant, since that one's entire point
+    // is to alter the state via measurement.
+    [MemoryEffects<[MemRead<QuantumMemory>, MemWrite<QuantumMemory>]>]
+    > {
     let summary = "A single-qubit projective measurement in the computational basis.";
     let description = [{
     }];
@@ -876,7 +881,7 @@ def MeasureOp : Quantum_Op<"measure"> {
     }];
 }
 
-def SampleOp : Measurement_Op<"sample", [AttrSizedOperandSegments]> {
+def SampleOp : Measurement_Op<"sample", [AttrSizedOperandSegments, MemoryEffects<[MemAlloc]>]> {
     let summary = "Sample eigenvalues from the given observable for the current state";
     let description = [{
         The `quantum.sample` operation represents the measurement process of sampling eigenvalues
@@ -942,7 +947,8 @@ def SampleOp : Measurement_Op<"sample", [AttrSizedOperandSegments]> {
     let hasVerifier = 1;
 }
 
-def CountsOp : Measurement_Op<"counts", [AttrSizedOperandSegments, SameVariadicResultSize]> {
+def CountsOp : Measurement_Op<"counts", [AttrSizedOperandSegments, SameVariadicResultSize,
+                                            MemoryEffects<[MemAlloc]>]> {
     let summary = "Compute sample counts for the given observable for the current state";
     let description = [{
         The `quantum.counts` operation represents the measurement process of sampling eigenvalues
@@ -1001,7 +1007,7 @@ def CountsOp : Measurement_Op<"counts", [AttrSizedOperandSegments, SameVariadicR
     let hasVerifier = 1;
 }
 
-def ExpvalOp : Measurement_Op<"expval"> {
+def ExpvalOp : Measurement_Op<"expval", [NoMemoryEffect]> {
     let summary = "Compute the expectation value of the given observable for the current state";
     let description = [{
         The `quantum.expval` operation represents the measurement process of computing the
@@ -1038,7 +1044,7 @@ def ExpvalOp : Measurement_Op<"expval"> {
     }];
 }
 
-def VarianceOp : Measurement_Op<"var"> {
+def VarianceOp : Measurement_Op<"var", [NoMemoryEffect]> {
     let summary = "Compute the variance of the given observable for the current state";
     let description = [{
         The `quantum.var` operation represents the measurement process of computing the variance of
@@ -1074,7 +1080,7 @@ def VarianceOp : Measurement_Op<"var"> {
     }];
 }
 
-def ProbsOp : Measurement_Op<"probs", [AttrSizedOperandSegments]> {
+def ProbsOp : Measurement_Op<"probs", [AttrSizedOperandSegments, MemoryEffects<[MemAlloc]>]> {
     let summary = "Compute computational basis probabilities for the current state";
     let description = [{
         The `quantum.probs` operation represents the measurement process of computing probabilities
@@ -1120,7 +1126,7 @@ def ProbsOp : Measurement_Op<"probs", [AttrSizedOperandSegments]> {
     let hasVerifier = 1;
 }
 
-def StateOp : Measurement_Op<"state", [AttrSizedOperandSegments]> {
+def StateOp : Measurement_Op<"state", [AttrSizedOperandSegments, MemoryEffects<[MemAlloc]>]> {
     let summary = "Return the current statevector";
     let description = [{
         The `quantum.state` operation represents the measurement process of returning the current

mlir/lib/Driver/Pipelines.cpp

@@ -86,6 +86,7 @@ void createBufferizationPipeline(OpPassManager &pm)
     pm.addNestedPass<mlir::func::FuncOp>(mlir::bufferization::createBufferHoistingPass());
     pm.addNestedPass<mlir::func::FuncOp>(mlir::bufferization::createBufferLoopHoistingPass());
     pm.addNestedPass<mlir::func::FuncOp>(mlir::bufferization::createPromoteBuffersToStackPass());
+    // TODO: what's the cpp for buffer-deallocation-pipeline???
     // pm.addPass(mlir::bufferization::createOwnershipBasedBufferDeallocationPass());
     pm.addPass(catalyst::createArrayListToMemRefPass());
     pm.addPass(mlir::createConvertBufferizationToMemRefPass());