public void dispatchExit(HiddenFunctionId hiddenFunctionId, ImmutableNodeReferer resultOfCall)
{
if (!privateEnabledTimingInstrumentation)
{
return;
}
sw.Stop();
double ticks = sw.ElapsedTicks;
long elapsedNs = (long)((ticks / Stopwatch.Frequency) * 1000000000);
Instrumentation instrumentation = countersDictionary[hiddenFunctionId];
if (instrumentation.toIgnoreCounter == 0)
{
instrumentation.statisticsCalltimeSumInNs += elapsedNs;
instrumentation.statisticsCalltimeMaxInNs = Math.Max(elapsedNs, instrumentation.statisticsCalltimeMaxInNs);
// needs special handling for the case when it's the first call
if (instrumentation.callcounter == 1)
{
instrumentation.statisticsCalltimeMinInNs = elapsedNs;
}
else
{
instrumentation.statisticsCalltimeMinInNs = Math.Min(elapsedNs, instrumentation.statisticsCalltimeMinInNs);
}
}
}
public void updateParameterNames(HiddenFunctionId functionId, IList <string> parameterNames)
{
if (!functiondescriptorByFunctionId.ContainsKey(functionId))
{
functiondescriptorByFunctionId[functionId] = new FunctionDescriptor();
}
functiondescriptorByFunctionId[functionId].parameterNames = parameterNames;
}
public void updateFunctionBody(HiddenFunctionId functionId, ImmutableNodeReferer body)
{
if (!functiondescriptorByFunctionId.ContainsKey(functionId))
{
functiondescriptorByFunctionId[functionId] = new FunctionDescriptor();
}
functiondescriptorByFunctionId[functionId].body = body;
}
public void invalidateByFunctionId(HiddenFunctionId functionId)
{
if (!functiondescriptorByFunctionId.ContainsKey(functionId))
{
return;
}
functiondescriptorByFunctionId.Remove(functionId);
}
public ImmutableNodeReferer dispatchCall(HiddenFunctionId functionId, IList <ImmutableNodeReferer> arguments)
{
Ensure.ensure(functiondescriptorByFunctionId.ContainsKey(functionId));
FunctionDescriptor fnDescriptor = functiondescriptorByFunctionId[functionId];
interpreter.interpret(interpretationContext, fnDescriptor.body, arguments, fnDescriptor.parameterNames);
return(fnDescriptor.body.interpretationResult);
}
public ImmutableNodeReferer dispatch(PublicFunctionId publicFunctionId, IList <ImmutableNodeReferer> arguments)
{
Ensure.ensure(functionsByPublicFunctionId.ContainsKey(publicFunctionId));
FunctionDescriptor fnDescriptor = functionsByPublicFunctionId[publicFunctionId];
HiddenFunctionId hiddenFunctionIdByArguments = fnDescriptor.getHiddenFunctionForArguments(extractValuesFromNodes(arguments));
return(hiddenDispatcher.dispatch(hiddenFunctionIdByArguments, arguments));
}
public void dispatchEnter(HiddenFunctionId hiddenFunctionId, IList <ImmutableNodeReferer> arguments)
{
incrementCallCounter(hiddenFunctionId);
if (!privateEnabledTimingInstrumentation)
{
return;
}
sw.Restart();
}
public void updateSurrogateByFunctionId(HiddenFunctionId functionId, ISurrogate surrogate)
{
// if there is already an surrogate we invalidate it
if (surrogateByFunctionId.ContainsKey(functionId))
{
surrogateByFunctionId[functionId].invalidateByFunctionId(functionId);
}
surrogateByFunctionId[functionId] = surrogate;
}
public InstrumentationDescriptor getInstrumentation(HiddenFunctionId hiddenFunctionId)
{
InstrumentationDescriptor descriptor = new InstrumentationDescriptor();
descriptor.callcounter = countersDictionary[hiddenFunctionId].callcounter;
descriptor.callcounterIgnored = countersDictionary[hiddenFunctionId].callcounterIgnored;
descriptor.functionId = countersDictionary[hiddenFunctionId].functionId;
if (privateEnabledTimingInstrumentation)
{
descriptor.calltimeMaxInNs = countersDictionary[hiddenFunctionId].statisticsCalltimeMaxInNs;
descriptor.calltimeMinInNs = countersDictionary[hiddenFunctionId].statisticsCalltimeMinInNs;
descriptor.calltimeSumInNs = countersDictionary[hiddenFunctionId].statisticsCalltimeSumInNs;
}
return(descriptor);
}
public ImmutableNodeReferer dispatch(HiddenFunctionId hiddenFunctionId, IList <ImmutableNodeReferer> arguments)
{
for (int i = dispatchObservers.Count - 1; i >= 0; i--)
{
dispatchObservers[i].dispatchEnter(hiddenFunctionId, arguments);
}
ImmutableNodeReferer result = chainDispatcher.dispatch(hiddenFunctionId, arguments);
for (int i = 0; i < dispatchObservers.Count; i++)
{
dispatchObservers[i].dispatchExit(hiddenFunctionId, result);
}
return(result);
}
void incrementCallCounter(HiddenFunctionId functionId)
{
if (!countersDictionary.ContainsKey(functionId))
{
countersDictionary[functionId] = new Instrumentation();
countersDictionary[functionId].callcounter = 0;
countersDictionary[functionId].functionId = functionId;
countersDictionary[functionId].toIgnoreCounter = ignoredFirstCalls;
}
Ensure.ensureHard(countersDictionary[functionId].toIgnoreCounter >= 0);
if (countersDictionary[functionId].toIgnoreCounter == 0)
{
countersDictionary[functionId].callcounter++;
}
else
{
countersDictionary[functionId].callcounterIgnored++;
}
countersDictionary[functionId].toIgnoreCounter = Math.Max(0, countersDictionary[functionId].toIgnoreCounter - 1);
}
public ImmutableNodeReferer dispatch(HiddenFunctionId hiddenFunctionId, IList <ImmutableNodeReferer> arguments)
{
ImmutableNodeReferer result;
foreach (IShadowableDispatcher iDispatcher in shadowableDispatchers)
{
bool wasShadowed;
result = iDispatcher.tryDispatch(hiddenFunctionId, arguments, out wasShadowed);
if (wasShadowed)
{
return(result);
}
}
result = proxy.dispatch(hiddenFunctionId, arguments);
// inform all shadowable dispatchers about the result
foreach (IShadowableDispatcher iDispatcher in shadowableDispatchers)
{
iDispatcher.informCompleteFallThroughWithResult(hiddenFunctionId, arguments, result);
}
return(result);
}
bool existsFunctionId(HiddenFunctionId functionId)
{
return(surrogateByFunctionId.ContainsKey(functionId));
}
public ImmutableNodeReferer dispatch(HiddenFunctionId functionId, IList <ImmutableNodeReferer> arguments)
{
Ensure.ensure(existsFunctionId(functionId));
return(surrogateByFunctionId[functionId].dispatchCall(functionId, arguments));
}
