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)); }