DYN-4230 Callsite ExecWithRISlowPath optimizations to improve Cross Product replication performance (#11921)

saintentropy · web-flow · commit 4f4005837941 · 2022-04-13T14:47:02.000-04:00
* Remove homogeneous parameter check. Use FunctionEndPoint option count instead (cherry picked from commit 6cfc8b5) * Renam FunctionEndPoint list to plural for clarity (cherry picked from commit 9e6009f) * Define finalFunctionEndPoint if functionEndPoints list contains only one option (cherry picked from commit 220c357) * Move allocaiton of parameters list outside of final for loop. This saves memory and GC time. (cherry picked from commit 9319e64) * Use DSArray directly to access parameters vs copy to another array. Saves time, memory, and GC. (cherry picked from commit d66dde2) * Set list capacity directly vs resizing dynamically during initialization (cherry picked from commit de85122) Co-authored-by: Craig Long <craig.long@autodesk.com>
diff --git a/src/Engine/ProtoCore/Lang/CallSite.cs b/src/Engine/ProtoCore/Lang/CallSite.cs
@@ -1549,7 +1549,7 @@ internal StackValue DispatchDispose(StackValue stackValue, RuntimeCore runtimeCo
         }
 
         private StackValue Execute(
-            List<FunctionEndPoint> functionEndPoint,
+            List<FunctionEndPoint> functionEndPoints,
             Context c,
             List<StackValue> formalParameters,
             List<ReplicationInstruction> replicationInstructions,
@@ -1563,12 +1563,12 @@ private StackValue Execute(
             if (replicationInstructions.Count == 0)
             {
                 c.IsReplicating = false;
-                ret = ExecWithZeroRI(functionEndPoint, c, formalParameters, stackFrame, runtimeCore, singleRunTraceData, newTraceData);
+                ret = ExecWithZeroRI(functionEndPoints, c, formalParameters, stackFrame, runtimeCore, singleRunTraceData, newTraceData);
             }
             else //replicated call
             {
                 c.IsReplicating = true;
-                ret = ExecWithRISlowPath(functionEndPoint, c, formalParameters, replicationInstructions, stackFrame, runtimeCore, singleRunTraceData, newTraceData);
+                ret = ExecWithRISlowPath(functionEndPoints, c, formalParameters, replicationInstructions, stackFrame, runtimeCore, singleRunTraceData, newTraceData);
             }
 
             //Do a trace save here
@@ -1588,7 +1588,7 @@ private StackValue Execute(
         /// <summary>
         /// Execute an arbitrary depth replication using the full slow path algorithm
         /// </summary>
-        /// <param name="functionEndPoint"></param>
+        /// <param name="functionEndPoints"></param>
         /// <param name="c"></param>
         /// <param name="formalParameters"></param>
         /// <param name="replicationInstructions"></param>
@@ -1599,7 +1599,7 @@ private StackValue Execute(
         /// <param name="finalFunctionEndPoint"></param>
         /// <returns></returns>
         private StackValue ExecWithRISlowPath(
-            List<FunctionEndPoint> functionEndPoint,
+            List<FunctionEndPoint> functionEndPoints,
             Context c,
             List<StackValue> formalParameters,
             List<ReplicationInstruction> replicationInstructions,
@@ -1615,7 +1615,12 @@ private StackValue ExecWithRISlowPath(
             //Recursion base case
             if (replicationInstructions.Count == 0)
             {
-                return ExecWithZeroRI(functionEndPoint, c, formalParameters, stackFrame, runtimeCore, previousTraceData, newTraceData, finalFunctionEndPoint);
+                return ExecWithZeroRI(functionEndPoints, c, formalParameters, stackFrame, runtimeCore, previousTraceData, newTraceData, finalFunctionEndPoint);
+            }
+
+            if (finalFunctionEndPoint == null && functionEndPoints.Count == 1)
+            {
+                finalFunctionEndPoint = SelectFinalFep(c, functionEndPoints, formalParameters, stackFrame, runtimeCore);
             }
 
             //Get the replication instruction that this call will deal with
@@ -1648,15 +1653,6 @@ private StackValue ExecWithRISlowPath(
                         throw new ReplicationCaseNotCurrentlySupported(Resources.AlgorithmNotSupported);
                 }
 
-                //We determine if the input parameters are of homogeneous types to set the final function endpoint once
-                var homogeneousReturn = AreParametersHomogeneousTypes(formalParameters, runtimeCore);
-                var isHomogeneous = homogeneousReturn.Item1;
-                if (isHomogeneous)
-                {
-                    var finalFormalParameters = homogeneousReturn.Item2;
-                    finalFunctionEndPoint = SelectFinalFep(c, functionEndPoint, finalFormalParameters, stackFrame, runtimeCore);
-                }
-
                 bool hasEmptyArg = false;
                 foreach (int repIndex in repIndecies)
                 {
@@ -1749,7 +1745,7 @@ private StackValue ExecWithRISlowPath(
 
                     SingleRunTraceData cleanRetTrace = new SingleRunTraceData();
 
-                    retSVs[i] = ExecWithRISlowPath(functionEndPoint, c, newFormalParams, newRIs, stackFrame, runtimeCore, lastExecTrace, cleanRetTrace, finalFunctionEndPoint);
+                    retSVs[i] = ExecWithRISlowPath(functionEndPoints, c, newFormalParams, newRIs, stackFrame, runtimeCore, lastExecTrace, cleanRetTrace, finalFunctionEndPoint);
 
                     runtimeCore.AddCallSiteGCRoot(CallSiteID, retSVs[i]);
 
@@ -1775,28 +1771,15 @@ private StackValue ExecWithRISlowPath(
                 //We will call the subsequent reductions n times
                 int cartIndex = ri.CartesianIndex;
 
-                //We determine if the input parameters are of homogeneous types to set the final function endpoint once
-                if (cartIndex == 0)
-                {
-                    var homogeneousReturn = AreParametersHomogeneousTypes(formalParameters, runtimeCore);
-                    var isHomogeneous = homogeneousReturn.Item1;
-                    if (isHomogeneous)
-                    {
-                        var finalFormalParameters = homogeneousReturn.Item2;
-                        finalFunctionEndPoint = SelectFinalFep(c, functionEndPoint, finalFormalParameters, stackFrame, runtimeCore);
-                    }
-                }
-
                 //this will hold the heap elements for all the arrays that are going to be replicated over
                 bool supressArray = false;
                 int retSize;
-                StackValue[] parameters = null;
+                DSArray array = null;
 
                 if (formalParameters[cartIndex].IsArray)
                 {
-                    DSArray array = runtimeCore.Heap.ToHeapObject<DSArray>(formalParameters[cartIndex]);
-                    parameters = array.Values.ToArray();
-                    retSize = parameters.Length;
+                    array = runtimeCore.Heap.ToHeapObject<DSArray>(formalParameters[cartIndex]);
+                    retSize = array.Count;
                 }
                 else
                 {
@@ -1807,7 +1790,7 @@ private StackValue ExecWithRISlowPath(
                 StackValue[] retSVs = new StackValue[retSize];
 
                 SingleRunTraceData retTrace = newTraceData;
-                retTrace.NestedData = new List<SingleRunTraceData>(); //this will shadow the SVs as they are created
+                retTrace.NestedData = new List<SingleRunTraceData>(retSize); //this will shadow the SVs as they are created
 
                 //Populate out the size of the list with default values
                 //@TODO:Luke perf optimisation here
@@ -1816,26 +1799,21 @@ private StackValue ExecWithRISlowPath(
                     retTrace.NestedData.Add(new SingleRunTraceData());
                 }
 
+                //Build the call
+                List<StackValue> newFormalParams = formalParameters.ToList();
+
                 if (supressArray)
                 {
                     List<ReplicationInstruction> newRIs = replicationInstructions.GetRange(1, replicationInstructions.Count - 1);
 
-                    List<StackValue> newFormalParams = formalParameters.ToList();
-
-                    return ExecWithRISlowPath(functionEndPoint, c, newFormalParams, newRIs, stackFrame, runtimeCore, previousTraceData, newTraceData, finalFunctionEndPoint);
+                    return ExecWithRISlowPath(functionEndPoints, c, newFormalParams, newRIs, stackFrame, runtimeCore, previousTraceData, newTraceData, finalFunctionEndPoint);
                 }
 
                 //Now iterate over each of these options
                 for (int i = 0; i < retSize; i++)
                 {
-                    //Build the call
-                    List<StackValue> newFormalParams = formalParameters.ToList();
-
-                    if (parameters != null)
-                    {
-                        //It was an array pack the arg with the current value
-                        newFormalParams[cartIndex] = parameters[i];
-                    }
+                    //It was an array pack the arg with the current value
+                    newFormalParams[cartIndex] = array.GetValueFromIndex(i, runtimeCore);
 
                     List<ReplicationInstruction> newRIs = replicationInstructions.GetRange(1, replicationInstructions.Count - 1);
 
@@ -1863,7 +1841,7 @@ private StackValue ExecWithRISlowPath(
                     //previousTraceData = lastExecTrace;
                     SingleRunTraceData cleanRetTrace = new SingleRunTraceData();
 
-                    retSVs[i] = ExecWithRISlowPath(functionEndPoint, c, newFormalParams, newRIs, stackFrame, runtimeCore, lastExecTrace, cleanRetTrace, finalFunctionEndPoint);
+                    retSVs[i] = ExecWithRISlowPath(functionEndPoints, c, newFormalParams, newRIs, stackFrame, runtimeCore, lastExecTrace, cleanRetTrace, finalFunctionEndPoint);
 
                     runtimeCore.AddCallSiteGCRoot(CallSiteID, retSVs[i]);
 
@@ -1963,62 +1941,6 @@ private StackValue ExecWithZeroRI(List<FunctionEndPoint> functionEndPoint, Conte
             return ret;
         }
 
-        /// <summary>
-        /// Determine if the formalParameters are homogeneous types and initialize a flat list of final formalParameters
-        /// </summary>
-        /// <param name="formalParameters"></param>
-        /// <param name="runtimeCore"></param>
-        /// <returns>item1: true if the formalParameters are homogeneous, item2: finalformalParameters</returns>
-        private static Tuple<bool, List<StackValue>> AreParametersHomogeneousTypes(List<StackValue> formalParameters, RuntimeCore runtimeCore)
-        {
-            var finalFormalParameters = new List<StackValue>();
-
-            foreach (var formalParameter in formalParameters)
-            {
-                //expand array if required to compare inputs
-                if (formalParameter.IsArray)
-                {
-                    var array = runtimeCore.Heap.ToHeapObject<DSArray>(formalParameter);
-                    var flatParameters = array.Values.ToArray();
-
-                    switch (flatParameters.Length)
-                    {
-                        case 0:
-                            //set function result false and exit due to empty list
-                            return new Tuple<bool, List<StackValue>>(false, null);
-                        case 1:
-                            //Add single sample parameter to pass for evaluation in SelectFinalFep
-                            finalFormalParameters.Add(flatParameters[0]);
-                            break;
-                        default:
-                            for (int j = 0; j < flatParameters.Length - 1; j++)
-                            {
-                                //Compare the type data for subsequent items
-                                if (flatParameters[j].optype != flatParameters[j + 1].optype ||
-                                    flatParameters[j].metaData.type != flatParameters[j + 1].metaData.type)
-                                {
-                                    //set function result false and exit due to dissimilar function parameters
-                                    return new Tuple<bool, List<StackValue>>(false, null);
-                                }
-                            }
-
-                            //Add single sample parameter to pass for evaluation in SelectFinalFep
-                            finalFormalParameters.Add(flatParameters[0]);
-                            break;
-                    }
-                }
-                else
-                {
-                    //For single parameter add it to pass for evaluation in SelectFinalFep
-                    finalFormalParameters.Add(formalParameter);
-                }
-            }
-
-            //formalParameteres evaluated as homogeneous
-            return new Tuple<bool, List<StackValue>>(true, finalFormalParameters);
-        }
-
-
         /// <summary>
         /// If all the arguments that have rep guides are single values, then strip the rep guides
         /// </summary>
