Temporarily reverting ref count changes for release (#989)

* Revert "Fixing an issue where reference count increases were not applied in certain cases (#987)"

This reverts commit ed60c81.

* Revert "Splitting out general purpose helpers for branches and loops that yield values (#985)"

This reverts commit 34bd1fe.

* Revert "Ref count optimizations and some bug fixes (#982)"

This reverts commit 9689a96.

Co-authored-by: Bettina Heim <[email protected]>

Author: bettinaheim

src/QsCompiler/QirGeneration/Context.cs

@@ -152,18 +152,18 @@ private Value[] ProcessArguments(ArgumentTuple arg, IReadOnlyList<Argument> para
                 return (length, dataArr);
             }
 
-            IValue[] GetStructItems(Value value, IEnumerable<ResolvedType> itemTypes, bool registerWithScopeManager)
+            IValue[] GetStructItems(Value value, IEnumerable<ResolvedType> itemTypes)
             {
                 var itemIndex = 0;
                 Value NextTupleItem()
                 {
                     var itemPtr = this.sharedState.CurrentBuilder.GetElementPtr(Types.PointerElementType(value), value, this.PointerIndex(itemIndex++));
                     return this.sharedState.CurrentBuilder.Load(Types.PointerElementType(itemPtr), itemPtr);
                 }
-                return itemTypes.Select(arg => ProcessGivenValue(arg, registerWithScopeManager, NextTupleItem)).ToArray();
+                return itemTypes.Select(arg => ProcessGivenValue(arg, NextTupleItem)).ToArray();
             }
 
-            IValue ProcessGivenValue(ResolvedType type, bool registerWithScopeManager, Func<Value> next)
+            IValue ProcessGivenValue(ResolvedType type, Func<Value> next)
             {
                 if (type.Resolution.IsUnitType)
                 {
@@ -174,19 +174,15 @@ IValue ProcessGivenValue(ResolvedType type, bool registerWithScopeManager, Func<
                 if (type.Resolution is ResolvedTypeKind.ArrayType arrItemType)
                 {
                     var (length, dataArr) = LoadSizedArray(givenValue);
-                    ArrayValue array = this.sharedState.Values.CreateArray(length, arrItemType.Item, registerWithScopeManager: false);
-                    if (registerWithScopeManager)
-                    {
-                        this.sharedState.ScopeMgr.RegisterValue(array);
-                    }
+                    ArrayValue array = this.sharedState.Values.CreateArray(length, arrItemType.Item);
 
                     var dataArrStart = this.sharedState.CurrentBuilder.PointerToInt(dataArr, this.sharedState.Context.Int64Type);
                     var givenArrElementType = this.MapToInteropType(array.LlvmElementType) ?? this.sharedState.Values.Unit.LlvmType;
                     var givenArrElementSize = this.sharedState.ComputeSizeForType(givenArrElementType);
 
                     void PopulateItem(Value index)
                     {
-                        var element = ProcessGivenValue(array.QSharpElementType, false, () =>
+                        var element = ProcessGivenValue(array.QSharpElementType, () =>
                         {
                             var offset = this.sharedState.CurrentBuilder.Mul(index, givenArrElementSize);
                             var elementPointer = this.sharedState.CurrentBuilder.IntToPointer(
@@ -204,30 +200,24 @@ void PopulateItem(Value index)
                 }
                 else if (type.Resolution is ResolvedTypeKind.TupleType items)
                 {
-                    var tupleItems = GetStructItems(givenValue, items.Item, registerWithScopeManager);
-                    return this.sharedState.Values.CreateTuple(registerWithScopeManager, tupleItems);
+                    var tupleItems = GetStructItems(givenValue, items.Item);
+                    return this.sharedState.Values.CreateTuple(tupleItems);
                 }
                 else if (type.Resolution.IsBigInt)
                 {
                     var createBigInt = this.sharedState.GetOrCreateRuntimeFunction(RuntimeLibrary.BigIntCreateArray);
                     var (length, dataArr) = LoadSizedArray(givenValue);
                     var argValue = this.sharedState.CurrentBuilder.Call(createBigInt, length, dataArr);
                     var value = this.sharedState.Values.From(argValue, type);
-                    if (registerWithScopeManager)
-                    {
-                        this.sharedState.ScopeMgr.RegisterValue(value);
-                    }
+                    this.sharedState.ScopeMgr.RegisterValue(value);
                     return value;
                 }
                 else if (type.Resolution.IsString)
                 {
                     var createString = this.sharedState.GetOrCreateRuntimeFunction(RuntimeLibrary.StringCreate);
                     var argValue = this.sharedState.CurrentBuilder.Call(createString, givenValue);
                     var value = this.sharedState.Values.From(argValue, type);
-                    if (registerWithScopeManager)
-                    {
-                        this.sharedState.ScopeMgr.RegisterValue(value);
-                    }
+                    this.sharedState.ScopeMgr.RegisterValue(value);
                     return value;
                 }
                 else if (type.Resolution.IsResult)
@@ -247,7 +237,7 @@ void PopulateItem(Value index)
                 else if (type.Resolution.IsRange)
                 {
                     var itemTypes = Enumerable.Repeat(ResolvedType.New(ResolvedTypeKind.Int), 3);
-                    var rangeItems = GetStructItems(givenValue, itemTypes, registerWithScopeManager);
+                    var rangeItems = GetStructItems(givenValue, itemTypes);
                     return this.sharedState.CreateRange(rangeItems[0].Value, rangeItems[1].Value, rangeItems[2].Value);
                 }
                 else if (givenValue.NativeType.IsInteger)
@@ -279,7 +269,7 @@ IValue ProcessArgumentTupleItem(ArgumentTuple item, Func<Value> nextArgument)
                 else
                 {
                     return item is ArgumentTuple.QsTupleItem innerItem
-                        ? ProcessGivenValue(innerItem.Item.Type, true, nextArgument)
+                        ? ProcessGivenValue(innerItem.Item.Type, nextArgument)
                         : throw new NotSupportedException("unknown item in argument tuple");
                 }
             }
@@ -362,7 +352,7 @@ void PopulateItem(Value index)
                 var end = this.sharedState.CurrentBuilder.Sub(array.Length, this.sharedState.Context.CreateConstant(1L));
                 this.sharedState.IterateThroughRange(start, null, end, PopulateItem);
 
-                var tupleItems = new[] { array.Length, dataArr };
+                var tupleItems = new[] { array.Length, dataArr }; // FIXME: CAST DATA ARR TO THE RIGHT TYPE IF NEEDED
                 var mappedType = this.MapToInteropType(array.QSharpType)!;
                 return PopulateStruct((IPointerType)mappedType, tupleItems);
             }

src/QsCompiler/QirGeneration/Interop.cs

@@ -345,7 +345,7 @@ private Value AllocateTuple(bool registerWithScopeManager)
             var tuple = this.sharedState.CurrentBuilder.Call(constructor, size);
             if (registerWithScopeManager)
             {
-                this.sharedState.ScopeMgr.RegisterValue(this, shallow: true);
+                this.sharedState.ScopeMgr.RegisterValue(this);
             }
             return tuple;
         }
@@ -469,7 +469,7 @@ private Value AllocateArray(bool registerWithScopeManager)
             var pointer = this.sharedState.CurrentBuilder.Call(constructor, elementSize, this.Length);
             if (registerWithScopeManager)
             {
-                this.sharedState.ScopeMgr.RegisterValue(this, shallow: true);
+                this.sharedState.ScopeMgr.RegisterValue(this);
             }
             return pointer;
         }
@@ -536,34 +536,6 @@ internal class CallableValue : IValue
 
         public ResolvedType QSharpType { get; }
 
-        /// <summary>
-        /// Creates a callable value of the given type and registers it with the scope manager.
-        /// The necessary functions to invoke the callable are defined by the callable table;
-        /// i.e. the globally defined array of function pointers accessible via the given global variable.
-        /// </summary>
-        /// <param name="callableType">The Q# type of the callable value.</param>
-        /// <param name="table">The global variable that contains the array of function pointers defining the callable.</param>
-        /// <param name="context">Generation context where constants are defined and generated if needed.</param>
-        /// <param name="captured">All captured values.</param>
-        internal CallableValue(ResolvedType callableType, GlobalVariable table, GenerationContext context, ImmutableArray<TypedExpression>? captured = null)
-        {
-            this.LlvmType = context.Types.Callable;
-            this.QSharpType = callableType;
-
-            // The runtime function CallableCreate creates a new value with reference count 1.
-            var createCallable = context.GetOrCreateRuntimeFunction(RuntimeLibrary.CallableCreate);
-            var capture = captured == null || captured.Value.Length == 0 ? null : context.Values.CreateTuple(captured.Value);
-            var memoryManagementTable = context.GetOrCreateCallableMemoryManagementTable(capture);
-            this.Value = context.CurrentBuilder.Call(createCallable, table, memoryManagementTable, capture?.OpaquePointer ?? context.Constants.UnitValue);
-            context.ScopeMgr.RegisterValue(this, shallow: true);
-        }
-
-        /// <summary>
-        /// Creates a new callable value of the given type.
-        /// </summary>
-        /// <param name="value">The pointer to a QIR callable value.</param>
-        /// <param name="type">Q# type of the callable.</param>
-        /// <param name="context">Generation context where constants are defined and generated if needed.</param>
         internal CallableValue(Value value, ResolvedType type, GenerationContext context)
         {
             this.Value = value;

src/QsCompiler/QirGeneration/QIR/DataStructures.cs

@@ -113,15 +113,24 @@ internal TupleValue CreateTuple(ImmutableArray<ResolvedType> elementTypes, bool
         /// <param name="tupleElements">The tuple elements</param>
         internal TupleValue CreateTuple(ImmutableArray<TypedExpression> tupleElements, bool registerWithScopeManager = true)
         {
-            var elements = tupleElements.Select(this.sharedState.EvaluateSubexpression).ToArray();
-            return this.CreateTuple(null, registerWithScopeManager, elements);
+            var elementTypes = tupleElements.Select(v => v.ResolvedType).ToImmutableArray();
+            TupleValue tuple = new TupleValue(elementTypes, this.sharedState, registerWithScopeManager);
+            PointerValue[] itemPointers = tuple.GetTupleElementPointers();
+
+            var elements = tupleElements.Select(this.sharedState.BuildSubitem).ToArray();
+            for (var i = 0; i < itemPointers.Length; ++i)
+            {
+                itemPointers[i].StoreValue(elements[i]);
+            }
+
+            return tuple;
         }
 
         /// <summary>
         /// Builds a tuple with the items set to the given tuple elements.
         /// The tuple represents a value of user defined type if a name is specified.
         /// Registers the value with the scope manager, unless registerWithScopeManager is set to false.
-        /// Does *not* increase the reference count for the tuple elements.
+        /// Increases the reference count for the tuple elements.
         /// </summary>
         /// <param name="typeName">The name of the user defined typed that the tuple represents</param>
         /// <param name="registerWithScopeManager">Whether or not to register the built tuple with the scope manager</param>
@@ -135,6 +144,7 @@ private TupleValue CreateTuple(UserDefinedType? typeName, bool registerWithScope
             for (var i = 0; i < itemPointers.Length; ++i)
             {
                 itemPointers[i].StoreValue(tupleElements[i]);
+                this.sharedState.ScopeMgr.IncreaseReferenceCount(tupleElements[i]);
             }
 
             return tuple;
@@ -143,7 +153,7 @@ private TupleValue CreateTuple(UserDefinedType? typeName, bool registerWithScope
         /// <summary>
         /// Builds a tuple with the items set to the given tuple elements.
         /// Registers the value with the scope manager, unless registerWithScopeManager is set to false.
-        /// Does *not* increase the reference count for the tuple elements.
+        /// Increases the reference count for the tuple elements.
         /// </summary>
         /// <param name="registerWithScopeManager">Whether or not to register the built tuple with the scope manager</param>
         /// <param name="tupleElements">The tuple elements</param>
@@ -153,16 +163,16 @@ internal TupleValue CreateTuple(bool registerWithScopeManager, params IValue[] t
         /// <summary>
         /// Builds a tuple with the items set to the given tuple elements.
         /// Registers the value with the scope manager.
-        /// Does *not* increase the reference count for the tuple elements.
+        /// Increases the reference count for the tuple elements.
         /// </summary>
         /// <param name="tupleElements">The tuple elements</param>
         internal TupleValue CreateTuple(params IValue[] tupleElements) =>
-            this.CreateTuple(null, true, tupleElements);
+            this.CreateTuple(true, tupleElements);
 
         /// <summary>
         /// Builds a tuple representing a Q# value of user defined type with the items set to the given elements.
         /// Registers the value with the scope manager, unless registerWithScopeManager is set to false.
-        /// Does *not* increase the reference count for the tuple elements.
+        /// Increases the reference count for the tuple elements.
         /// </summary>
         /// <param name="typeName">The name of the user defined type</param>
         /// <param name="registerWithScopeManager">Whether or not to register the built tuple with the scope manager</param>
@@ -173,7 +183,7 @@ internal TupleValue CreateCustomType(UserDefinedType typeName, bool registerWith
         /// <summary>
         /// Builds a tuple representing a Q# value of user defined type with the items set to the given elements.
         /// Registers the value with the scope manager.
-        /// Does *not* increase the reference count for the tuple elements.
+        /// Increases the reference count for the tuple elements.
         /// </summary>
         /// <param name="typeName">The name of the user defined type</param>
         /// <param name="tupleElements">The tuple elements</param>
@@ -196,14 +206,22 @@ internal ArrayValue CreateArray(Value length, ResolvedType elementType, bool reg
         /// <param name="arrayElements">The elements in the array</param>
         internal ArrayValue CreateArray(ResolvedType elementType, ImmutableArray<TypedExpression> arrayElements, bool registerWithScopeManager = true)
         {
-            var elements = arrayElements.Select(this.sharedState.EvaluateSubexpression).ToArray();
-            return this.CreateArray(elementType, registerWithScopeManager, elements);
+            var array = new ArrayValue((uint)arrayElements.Length, elementType, this.sharedState, registerWithScopeManager);
+            var itemPointers = array.GetArrayElementPointers();
+
+            var elements = arrayElements.Select(this.sharedState.BuildSubitem).ToArray();
+            for (var i = 0; i < itemPointers.Length; ++i)
+            {
+                itemPointers[i].StoreValue(elements[i]);
+            }
+
+            return array;
         }
 
         /// <summary>
         /// Builds an array that containsthe given array elements.
         /// Registers the value with the scope manager, unless registerWithScopeManager is set to false.
-        /// Does *not* increase the reference count for the array elements.
+        /// Increases the reference count for the array elements.
         /// </summary>
         /// <param name="elementType">The Q# type of the array elements</param>
         /// <param name="registerWithScopeManager">Whether or not to register the built tuple with the scope manager</param>
@@ -216,6 +234,7 @@ internal ArrayValue CreateArray(ResolvedType elementType, bool registerWithScope
             for (var i = 0; i < itemPointers.Length; ++i)
             {
                 itemPointers[i].StoreValue(arrayElements[i]);
+                this.sharedState.ScopeMgr.IncreaseReferenceCount(arrayElements[i]);
             }
 
             return array;
@@ -224,21 +243,10 @@ internal ArrayValue CreateArray(ResolvedType elementType, bool registerWithScope
         /// <summary>
         /// Builds an array that containsthe given array elements.
         /// Registers the value with the scope manager.
-        /// Does *not* increase the reference count for the array elements.
+        /// Increases the reference count for the array elements.
         /// </summary>
         /// <param name="arrayElements">The elements in the array</param>
         internal ArrayValue CreateArray(ResolvedType elementType, params IValue[] arrayElements) =>
             this.CreateArray(elementType, true, arrayElements);
-
-        /// <summary>
-        /// Creates a callable value of the given type and registers it with the scope manager.
-        /// The necessary functions to invoke the callable are defined by the callable table;
-        /// i.e. the globally defined array of function pointers accessible via the given global variable.
-        /// </summary>
-        /// <param name="callableType">The Q# type of the callable value.</param>
-        /// <param name="table">The global variable that contains the array of function pointers defining the callable.</param>
-        /// <param name="captured">All captured values.</param>
-        internal CallableValue CreateCallable(ResolvedType callableType, GlobalVariable table, ImmutableArray<TypedExpression>? captured = null) =>
-            new CallableValue(callableType, table, this.sharedState, captured);
     }
 }