public object Recall(ObjectHashtable hash)
{
//hash is an (object -> int) mapping, the same that was used while memoizing
object[] objs = new object[memo.Length];
foreach(object obj in hash.Keys)
objs[(int)hash[obj]] = obj;
for(int i=0; i<memo.Length; i++)
{
object obj = objs[i];
if(obj == null)
continue;
Type type = memo[i].type;
if(!Equals(type, obj.GetType()))
throw new MemoException();
if(Equals(type,typeof(string)))
continue;//strings are immutable...
if(type.IsPrimitive)
{
//DmUtils call?...
}
else if(type.IsArray)
RecallArray(obj as Array, i, objs);
else
RecallObject(obj, i, objs);
}
return objs[1];
}
private void Ctor(object obj, ObjectHashtable hash)
{
if (hash.Count != 0)
{
throw new MemoException(); //XZ??
}
ArrayList heap = new ArrayList();
heap.Add(new MemoObject(null, null));
hash[null] = 0;
Memo(obj, heap, hash, true);
memo = new MemoObject[heap.Count];
heap.CopyTo(memo);
CalculateHashCode();
}
public void Recall(MemoState memo, ObjectHashtable hash)
{
StateDecomposition dec = memo.Recall(hash) as StateDecomposition;
this.stack.Clear();
for (int i = dec.Stack.Length - 1; i >= 0; i--)
{
this.stack.Push(dec.Stack[i]);
}
int j = 0;
foreach (Variable v in this.pool.GetVariables())
{
this.pool[v].Val = dec.Pool[j++].Val;
}
}
public MemoState Memorize(out ObjectHashtable hash)
{
hash = new ObjectHashtable();
Value[] stack = new Value[this.stack.Count];
for (int i = 0; i < this.stack.Count; i++)
{
stack[i] = this.stack[i];
}
int j = 0;
Location[] pool = new Location[this.pool.GetVariables().Count];
foreach (Variable v in this.pool.GetVariables())
{
pool[j++] = this.pool[v];
}
return(new MemoState(new StateDecomposition(stack, pool), hash));
}
public object Recall(ObjectHashtable hash)
{
//hash is an (object -> int) mapping, the same that was used while memoizing
object[] objs = new object[memo.Length];
foreach (object obj in hash.Keys)
{
objs[(int)hash[obj]] = obj;
}
for (int i = 0; i < memo.Length; i++)
{
object obj = objs[i];
if (obj == null)
{
continue;
}
Type type = memo[i].type;
if (!Equals(type, obj.GetType()))
{
throw new MemoException();
}
if (Equals(type, typeof(string)))
{
continue; //strings are immutable...
}
if (type.IsPrimitive)
{
//DmUtils call?...
}
else if (type.IsArray)
{
RecallArray(obj as Array, i, objs);
}
else
{
RecallObject(obj, i, objs);
}
}
return(objs[1]);
}
internal Data(MemoSpecState memo, ObjectHashtable objHash, PointerToNode ptrUpNode)
{
this.MemoSpecState = memo;
this.ObjectHashtable = objHash;
this.PointerToNode = ptrUpNode;
}
private BTType checkAnnotatedMethodForInvoke(AnnotatedMethod aMethod)
{
MethodBase sMethod = aMethod.SourceMethod;
if (sMethod.DeclaringType.ToString() == "System.Object" &&
sMethod.Name == ".ctor" &&
sMethod.GetParameters().Length == 0)
{
BTValue obj = aMethod.ParamVals[0].Val as BTValue;
return obj.BTType;
}
else if (this.holder.WhiteList.Contains(sMethod))
{
ObjectHashtable hash = new ObjectHashtable();
for (int i = 0; i < aMethod.ParamVals.Count; i++)
getAllFieldBTValue(aMethod.ParamVals[i].Val as ReferenceBTValue, 5, hash);
if (aMethod.ReturnValue != null)
getAllFieldBTValue(aMethod.ReturnValue, 5, hash);
foreach (ReferenceBTValue val in hash.Keys)
if (val.BTType == BTType.Dynamic)
goto P;
return BTType.Static;
}
P:
Creators crtrs = new Creators();
for (int i = 0; i < aMethod.ParamVals.Count; i++)
crtrs.AddCreators((aMethod.ParamVals[i].Val as ReferenceBTValue).Lift());
ReferenceBTValue ret = aMethod.ReturnValue;
if (ret != null)
crtrs.AddCreators(ret.Lift());
if (! crtrs.IsEmpty)
throw new LiftException(crtrs);
return BTType.Dynamic;
}
public MemoState(object obj, ObjectHashtable hash)
{
Ctor(obj, hash);
}
internal PtrComparer(ObjectHashtable objHash)
{
this.objHash = objHash;
}
private static int Memo(object obj, ArrayList heap, ObjectHashtable hash, bool addToHash)
{
int myIndex = heap.Count;
heap.Add(null); //Reserve some space for this object
if (addToHash) //addToHash == false, when obj is a boxed representation of some non-boxed value
{
hash[obj] = myIndex;
}
Type type = obj.GetType();
if (typeof(Pointer).IsAssignableFrom(type))
{
throw new MemoException(); //some mannaged wrapper for unmannaged data...
}
if (type.IsPrimitive)
{
switch (Type.GetTypeCode(type))
{
case TypeCode.Boolean:
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Char:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
SetElement(heap, myIndex, new MemoObject(type, (obj as IConvertible).ToInt64(null)));
return(myIndex);
case TypeCode.Single:
case TypeCode.Double:
SetElement(heap, myIndex, new MemoObject(type, (obj as IConvertible).ToDouble(null)));
return(myIndex);
default: //IntPtr? UIntPtr?
if (type.Equals(typeof(IntPtr)))
{
SetElement(heap, myIndex, new MemoObject(type, ((IntPtr)obj).ToInt64()));
return(myIndex);
}
else if (type.Equals(typeof(UIntPtr)))
{
SetElement(heap, myIndex, new MemoObject(type, (long)((UIntPtr)obj).ToUInt64()));
return(myIndex);
}
else
{
throw new MemoException();
}
} //switch
} //if(IsPrimitive)
int[] fieldIndices;
if (Equals(type, typeof(string)))
{
string str = obj as string;
fieldIndices = new int[str.Length];
for (int i = 0; i < str.Length; i++)
{
char fieldValue = str[i];
fieldIndices[i] = Memo(fieldValue, heap, hash, false);
}
}
else if (type.IsArray)
{
Array array = obj as Array;
if (array.Rank > 1 || array.GetLowerBound(0) != 0)
{
throw new MemoException(); //not supported yet...
}
fieldIndices = new int[array.Length];
bool doAddToHash = !type.GetElementType().IsValueType;
for (int i = 0; i < array.Length; i++)
{
object fieldValue = array.GetValue(i);
if (doAddToHash)
{
object fieldIndexBoxed = hash[fieldValue];
if (fieldIndexBoxed != null)
{
fieldIndices[i] = (int)fieldIndexBoxed;
continue;
}
}
fieldIndices[i] = Memo(fieldValue, heap, hash, doAddToHash);
}
}
else
{
//Custom object
FieldInfo[] fieldInfos = ReflectionUtils.GetAllFields(type);
fieldIndices = new int[fieldInfos.Length];
for (int i = 0; i < fieldInfos.Length; i++)
{
bool doAddToHash = !fieldInfos[i].FieldType.IsValueType;
object fieldValue = fieldInfos[i].GetValue(obj);
if (doAddToHash)
{
object fieldIndexBoxed = hash[fieldValue];
if (fieldIndexBoxed != null)
{
fieldIndices[i] = (int)fieldIndexBoxed;
continue;
}
}
fieldIndices[i] = Memo(fieldValue, heap, hash, doAddToHash);
}
}
SetElement(heap, myIndex, new MemoObject(type, fieldIndices));
return(myIndex);
}
internal void Recall(MemoSpecState memo, ObjectHashtable objHash)
{
this.state.Recall(memo.MemoState, objHash);
}
internal PointerValue[] GetPointers(ObjectHashtable objHash)
{
ArrayList ptrs = new ArrayList();
foreach (PointerValue ptr in this.hash.Keys)
if (objHash.ContainsKey(ptr.GetHeapObject()))
ptrs.Add(ptr);
ptrs.Sort(new PtrComparer(objHash));
return ptrs.ToArray(typeof(PointerValue)) as PointerValue[];
}
private void addCreator(BTValue val, ReferenceCreator crtr)
{
ObjectHashtable hash = new ObjectHashtable();
AnnotatingVisitor.getAllBTValue(val, hash);
foreach (BTValue v in hash.Keys)
v.Creators[this].AddCreator(crtr);
}
private void Ctor(object obj, ObjectHashtable hash)
{
if(hash.Count != 0)
throw new MemoException(); //XZ??
ArrayList heap = new ArrayList();
heap.Add(new MemoObject(null,null));
hash[null] = 0;
Memo(obj, heap, hash, true);
memo = new MemoObject[heap.Count];
heap.CopyTo(memo);
CalculateHashCode();
}
private void callMethod(Node downNode, AnnotatedMethod method, PointerToNode ptrUpNode, Node upNode, Value[] args)
{
if (method.SourceMethod.IsDefined(typeof(InlineAttribute), false) && ! (upNode is NewObject))
{
MethodBodyBlock mbbDown = this.holder.AnnotatedHolder[method];
SpecState state = new SpecState(mbbDown.Variables.Count);
int varCount = 0;
int argCount = 0;
foreach (Variable varDown in mbbDown.Variables.ParameterMapper)
{
state.Pool[varDown] = new Location(varDown.Type);
Variable varUp = this.mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Local);
this.varsHash[new PointerToLocationValue(state.Pool[varDown])] = varUp;
if (Annotation.GetValueBTType(method.ParamVals[varCount++].Val) == BTType.Static)
{
state.Pool[varDown].Val = args[argCount];
state.Stack.Push(args[argCount++]);
}
else
{
Node upNext = new StoreVar(varUp);
Node upPrevNext = ptrUpNode.Node;
ptrUpNode.Node = upNext;
upNext.Next = upPrevNext;
}
}
while (ptrUpNode.Node != null)
ptrUpNode = new PointerToNode(ptrUpNode.Node);
foreach (Variable varDown in mbbDown.Variables)
if (! state.Pool.ContainsVar(varDown))
{
state.Pool[varDown] = new Location(varDown.Type);
Variable varUp = this.mbbUp.Variables.CreateVar(varDown.Type, VariableKind.Local);
this.varsHash[new PointerToLocationValue(state.Pool[varDown])] = varUp;
ptrUpNode = SpecializingVisitor.initVariable(varUp, ptrUpNode);
}
int depth = state.Stack.Count + 1;
GraphProcessor graphProc = new GraphProcessor();
SpecializingVisitor visitor = new SpecializingVisitor(graphProc, this.holder, this.mbbUp, state, this.varsHash);
visitor.AddTask(mbbDown.Next, ptrUpNode);
graphProc.Process();
foreach (Data newData in visitor.exitData)
{
state.Recall(newData.MemoSpecState, newData.ObjectHashtable);
if (state.Stack.Count == depth)
this.state.Stack.Push(state.Stack.Pop());
this.AddTask(downNode.Next, newData.PointerToNode);
}
}
else
{
ObjectHashtable objHash = new ObjectHashtable();
MemoState memoArgs = new MemoState(args, objHash);
PointerValue[] ptrs = this.varsHash.GetPointers(objHash);
for (int i = 0; i < ptrs.Length; i++)
ptrUpNode = new PointerToNode(ptrUpNode.Node = new LoadVarAddr(this.varsHash[ptrs[i]]));
ptrUpNode = new PointerToNode(ptrUpNode.Node = upNode);
ResidualMethod callMethod = new ResidualMethod(method, memoArgs, args, ptrs);
Specialization.SetResidualMethod(upNode, callMethod);
this.holder.SpecializeMethod(callMethod);
this.AddTask(downNode.Next, ptrUpNode);
}
}
private static int Memo(object obj, ArrayList heap, ObjectHashtable hash, bool addToHash)
{
int myIndex = heap.Count;
heap.Add(null); //Reserve some space for this object
if(addToHash) //addToHash == false, when obj is a boxed representation of some non-boxed value
hash[obj] = myIndex;
Type type = obj.GetType();
if(typeof(Pointer).IsAssignableFrom(type))
throw new MemoException(); //some mannaged wrapper for unmannaged data...
if(type.IsPrimitive)
{
switch(Type.GetTypeCode(type))
{
case TypeCode.Boolean:
case TypeCode.Byte:
case TypeCode.SByte:
case TypeCode.Char:
case TypeCode.Int16:
case TypeCode.UInt16:
case TypeCode.Int32:
case TypeCode.UInt32:
case TypeCode.Int64:
case TypeCode.UInt64:
SetElement(heap , myIndex , new MemoObject(type, (obj as IConvertible).ToInt64(null)));
return(myIndex);
case TypeCode.Single:
case TypeCode.Double:
SetElement(heap , myIndex , new MemoObject(type, (obj as IConvertible).ToDouble(null)));
return(myIndex);
default: //IntPtr? UIntPtr?
if(type.Equals(typeof(IntPtr)))
{
SetElement(heap , myIndex , new MemoObject(type, ((IntPtr)obj).ToInt64()));
return(myIndex);
}
else if(type.Equals(typeof(UIntPtr)))
{
SetElement(heap , myIndex , new MemoObject(type, (long)((UIntPtr)obj).ToUInt64()));
return(myIndex);
}
else
throw new MemoException();
}//switch
}//if(IsPrimitive)
int[] fieldIndices;
if(Equals(type,typeof(string)))
{
string str = obj as string;
fieldIndices = new int[str.Length];
for(int i=0; i<str.Length; i++)
{
char fieldValue = str[i];
fieldIndices[i] = Memo(fieldValue, heap, hash, false);
}
}
else if(type.IsArray)
{
Array array = obj as Array;
if(array.Rank > 1 || array.GetLowerBound(0) != 0)
throw new MemoException(); //not supported yet...
fieldIndices = new int[array.Length];
bool doAddToHash = ! type.GetElementType().IsValueType;
for(int i=0; i<array.Length; i++)
{
object fieldValue = array.GetValue(i);
if(doAddToHash)
{
object fieldIndexBoxed = hash[fieldValue];
if(fieldIndexBoxed != null)
{
fieldIndices[i] = (int)fieldIndexBoxed;
continue;
}
}
fieldIndices[i] = Memo(fieldValue, heap, hash, doAddToHash);
}
}
else
{
//Custom object
FieldInfo[] fieldInfos = ReflectionUtils.GetAllFields(type);
fieldIndices = new int[fieldInfos.Length];
for(int i=0; i<fieldInfos.Length; i++)
{
bool doAddToHash = ! fieldInfos[i].FieldType.IsValueType;
object fieldValue = fieldInfos[i].GetValue(obj);
if(doAddToHash)
{
object fieldIndexBoxed = hash[fieldValue];
if(fieldIndexBoxed != null)
{
fieldIndices[i] = (int)fieldIndexBoxed;
continue;
}
}
fieldIndices[i] = Memo(fieldValue, heap, hash, doAddToHash);
}
}
SetElement(heap , myIndex , new MemoObject(type, fieldIndices));
return(myIndex);
}
public MemoState(object obj, ObjectHashtable hash)
{
Ctor(obj, hash);
}
internal MemoSpecState Memorize(VariablesHashtable varsHash, out ObjectHashtable objHash)
{
MemoState memo = this.state.Memorize(out objHash);
PointerValue[] ptrs = varsHash.GetPointers(objHash);
Variable[] vars = new Variable[ptrs.Length];
for (int i=0; i < vars.Length; i++)
vars[i] = varsHash[ptrs[i] as PointerValue] as Variable;
return new MemoSpecState(memo, vars);
}
private static void getAllFieldBTValue(BTValue val, int depth, ObjectHashtable hash)
{
if (! hash.Contains(val) && depth > 0)
{
hash[val] = true;
if (val is ReferenceBTValue)
foreach (BTValue v in (val as ReferenceBTValue).GetAllFieldBTValues())
AnnotatingVisitor.getAllFieldBTValue(v, depth-1, hash);
}
}