Implement Reload

Implemented a default Reload. It will simply reload all the same values as Commit had saved.

This version conservatively reloads everything which is probably ok for garbage collected systems where objects may move.

We should consider some enhancements at some point.

- option to reload some or all of the elements via selective reload to ensure you don't refetch from memory if not needed.
- option to take into account stack size changes before reload. This is be useful in VMs where the virtual machine changes the stack with pops of arguments , and pushed results. In that case, you would adjust the stack for pops, and the reload the number of new elements pushed by the VM.

Test for VirtualMachineOperandStack reload which uses the operand stack, passes stack elements which are modfied in an external C call, then ensures those modified values are correct when returned and reloaded.

Signed-off-by: John Duimovich <jduimovich@gmail.com>

Author: jduimovich

compiler/ilgen/VirtualMachineOperandStack.cpp

@@ -87,8 +87,25 @@ VirtualMachineOperandStack::Commit(TR::IlBuilder *b)
       }
    }
 
-void
-VirtualMachineOperandStack::MergeInto(OMR::VirtualMachineOperandStack *other, TR::IlBuilder *b)
+   void
+   VirtualMachineOperandStack::Reload(TR::IlBuilder* b)
+   {
+       TR::IlType* Element = _elementType;
+       TR::IlType* pElement = _mb->typeDictionary()->PointerTo(Element);
+       // reload the elements back into the simulated operand stack
+       // If the # of stack element has changed, the user should adjust the # of elements 
+       // using Drop beforehand to add/delete stack elements.
+       TR::IlValue* stack = b->Load("OperandStack_base");
+       for (int32_t i = _stackTop; i >= 0; i--) {
+           _stack[i] = b->LoadAt(pElement,
+               b->IndexAt(pElement,
+                   stack,
+                   b->ConstInt32(i - _stackOffset)));
+       }
+   }
+
+   void
+   VirtualMachineOperandStack::MergeInto(OMR::VirtualMachineOperandStack* other, TR::IlBuilder* b)
    {
    TR_ASSERT(_stackTop == other->_stackTop, "stacks are not same size");
    for (int32_t i=_stackTop;i >= 0;i--)

compiler/ilgen/VirtualMachineOperandStack.hpp

@@ -106,6 +106,14 @@ class VirtualMachineOperandStack : public VirtualMachineState
     * @param b the builder where the operations will be placed to recreate the virtual machine operand stack
     */
    virtual void Commit(TR::IlBuilder *b);
+   
+   /**
+    * @brief read the virtual machine stack back into the simulated operand stack
+    * @param b the builder where the operations will be placed to recreate the simulated operand stack 
+    * Users can call Drop beforehand with the appropriate positive or negative count to ensure the simulated
+    * stack accounts for new or dropped virtual machine stack elements. 
+    */
+   virtual void Reload(TR::IlBuilder *b);
 
    /**
     * @brief create an identical copy of the current object.

jitbuilder/release/src/OperandStackTests.cpp

@@ -311,6 +311,30 @@ verifyResult12(STACKVALUETYPE top)
    OperandStackTestMethod::verifyStack("11", 3, 3, 5, 4, expectedResult12Top);
    }
 
+// used to compare expected values and report fail it not equal
+void
+verifyValuesEqual(STACKVALUETYPE v1, STACKVALUETYPE v2)
+   { 
+   REPORT2(v1 == v2, "verifyValuesEqual v1", v1, "verifyValuesEqual v2", v2); 
+   }
+
+// take the arguments from the stack and modify them
+void
+modifyTop3Elements(int32_t amountToAdd)
+   {
+   if (verbose) cout << "Push();Push();Push() - modify elements passed in real stack and return";
+   STACKVALUETYPE *realSP = *verifySP; 
+   REPORT1(realSP[0]== 3, "modifyTop3Elements realSP[0]", realSP[0]); 
+   REPORT1(realSP[-1]== 2, "modifyTop3Elements realSP[-1]", realSP[-1]); 
+   REPORT1(realSP[-2]== 1, "modifyTop3Elements realSP[-2]", realSP[-2]); 
+   realSP[0] += amountToAdd;
+   realSP[-1] += amountToAdd;
+   realSP[-2] += amountToAdd;  
+   }
+
+
+
+
 bool
 OperandStackTestMethod::verifyUntouched(int32_t maxTouched)
    {
@@ -372,12 +396,15 @@ OperandStackTestMethod::OperandStackTestMethod(TR::TypeDictionary *d)
    DefineFunction("verifyResult10", "0", "0", (void *)&verifyResult10, NoType, 1, _valueType);
    DefineFunction("verifyResult11", "0", "0", (void *)&verifyResult11, NoType, 0);
    DefineFunction("verifyResult12", "0", "0", (void *)&verifyResult12, NoType, 1, _valueType);
+   DefineFunction("verifyValuesEqual", "0", "0", (void *)&verifyValuesEqual, NoType, 2, _valueType, _valueType);
+   DefineFunction("modifyTop3Elements", "0", "0", (void *)&modifyTop3Elements, NoType, 1, _valueType);
    }
 
 // convenience macros
 #define STACK(b)	(((TestState *)(b)->vmState())->_stack)
 #define STACKTOP(b)	(((TestState *)(b)->vmState())->_stackTop)
 #define COMMIT(b)       ((b)->vmState()->Commit(b))
+#define RELOAD(b)       ((b)->vmState()->Reload(b))
 #define PUSH(b,v)	(STACK(b)->Push(b,v))
 #define POP(b)          (STACK(b)->Pop(b))
 #define TOP(b)          (STACK(b)->Top())
@@ -431,6 +458,9 @@ OperandStackTestMethod::testStack(TR::BytecodeBuilder *b, bool useEqual)
 
    COMMIT(b);
    b->Call("verifyResult11", 0);
+ 
+  
+
 
    TR::BytecodeBuilder *thenBB = OrphanBytecodeBuilder(0, (char*)"BCI_then");
    TR::BytecodeBuilder *elseBB = OrphanBytecodeBuilder(1, (char*)"BCI_else");
@@ -452,6 +482,25 @@ OperandStackTestMethod::testStack(TR::BytecodeBuilder *b, bool useEqual)
 
    COMMIT(mergeBB);
    mergeBB->Call("verifyResult12", 1, TOP(mergeBB));
+ 
+   int amountToAdd = 10;
+  // Reload test. Call a routine that modifies stack elements passed to it. 
+   // Test by reloading and test the popped values
+   PUSH(mergeBB, mergeBB->ConstInteger(_valueType, 1));
+   PUSH(mergeBB, mergeBB->ConstInteger(_valueType, 2));
+   PUSH(mergeBB, mergeBB->ConstInteger(_valueType, 3));  
+   COMMIT(mergeBB); 
+   mergeBB->Call("modifyTop3Elements",1, mergeBB->ConstInteger(_valueType, amountToAdd));  
+   RELOAD(mergeBB);
+   TR::IlValue *modifiedStackElement = POP(mergeBB);
+   TR::IlValue *expected =  mergeBB->ConstInteger(_valueType, 3+amountToAdd); 
+   mergeBB->Call("verifyValuesEqual", 2, modifiedStackElement, expected);  
+   modifiedStackElement = POP(mergeBB);
+   expected =  mergeBB->ConstInteger(_valueType, 2+amountToAdd);
+   mergeBB->Call("verifyValuesEqual",2,  modifiedStackElement, expected);  
+   modifiedStackElement = POP(mergeBB);
+   expected =  mergeBB->ConstInteger(_valueType, 1+amountToAdd);
+   mergeBB->Call("verifyValuesEqual",2,  modifiedStackElement, expected);  
 
    mergeBB->Return();