protected IEnumerable <XElement> GetLinkSettings()
{
var expressionParser = new ExpressionParser();
List <XElement> result = new List <XElement> ();
foreach (var configPlatform in configurationPlatforms_.Enumerate())
{
var element = new XElement("PropertyGroup",
new XAttribute("Condition", $"'$(Configuration)|$(Platform)'=='{configPlatform}'"),
new XElement("LinkIncremental", false));
ExpressionEvaluationContext ctx = new ExpressionEvaluationContext
{
Configuration = configPlatform.Configuration,
Platform = configPlatform.Platform
};
var name = expressionParser.Parse(Target.OutputName).Evaluate(ctx);
var suffix = expressionParser.Parse(Target.OutputSuffix).Evaluate(ctx);
element.Add(new XElement("TargetName",
$"{name}{suffix}"));
result.Add(element);
}
return(result);
}
protected override ExpressionVariant EvaluateCore(TimeSpan now, ExpressionVariant currentValue)
{
var starting = ExpressionVariant.Create(_startingValue);
var ctx = new ExpressionEvaluationContext
{
Parameters = Parameters,
Target = TargetObject,
CurrentValue = currentValue,
FinalValue = _finalValue ?? starting,
StartingValue = starting,
ForeignFunctionInterface = BuiltInExpressionFfi.Instance
};
var elapsed = now - _startedAt;
var res = EvaluateImpl(elapsed, currentValue, ref ctx);
if (_iterationBehavior == AnimationIterationBehavior.Count &&
!_finished &&
elapsed > _totalDuration)
{
// Active check?
TargetObject.Compositor.RemoveFromClock(this);
_finished = true;
}
return(res);
}
public ObjectDecorationValueEvaluatorTest()
{
FunctionBinder binder = new FunctionBinder(new Type[] { typeof(BuiltInFunctions) });
ExpressionEvaluationContext <object> context = new ExpressionEvaluationContext <object>(
VariableMock.GetGlobalVariable, VariableMock.GetLocalVariable, binder, null);
_evaluator = new ObjectDecorationInterpreter <object>(context);
}
public override ExpressionVariant Evaluate(ref ExpressionEvaluationContext context)
{
var cond = Condition.Evaluate(ref context);
if (cond.Type == VariantType.Boolean && cond.Boolean)
{
return(TruePart.Evaluate(ref context));
}
return(FalsePart.Evaluate(ref context));
}
public void Record(ExpressionEvaluationStrategy strategy,
ExpressionEvaluationContext context, StepsRecorder stepsRecorder,
long startTimestampUs, long endTimestampUs, string natvisValueId)
{
var batchParams = new ExpressionEvaluationBatchParams(
strategy, context, stepsRecorder.GetStepsList(), startTimestampUs, endTimestampUs,
natvisValueId);
_batchEventAggregator.Add(batchParams);
}
T GetKeyFrame(ref ExpressionEvaluationContext ctx, ServerKeyFrame <T> f)
{
if (f.Expression != null)
{
return(f.Expression.Evaluate(ref ctx).CastOrDefault <T>());
}
else
{
return(f.Value);
}
}
public ExpressionEvaluationBatchParams(ExpressionEvaluationStrategy strategy,
ExpressionEvaluationContext context,
List <ExpressionEvaluationStepBatchParams> evaluationSteps,
long startTimestampUs, long endTimestampUs,
string natvisValueId)
{
StrategyParam = strategy;
ContextParam = context;
EvaluationSteps = evaluationSteps;
StartTimestampUs = startTimestampUs;
EndTimestampUs = endTimestampUs;
NatvisValueId = natvisValueId;
}
protected override ExpressionVariant EvaluateCore(TimeSpan now, ExpressionVariant currentValue)
{
var ctx = new ExpressionEvaluationContext
{
Parameters = Parameters,
Target = TargetObject,
ForeignFunctionInterface = BuiltInExpressionFfi.Instance,
StartingValue = _startingValue,
FinalValue = _finalValue ?? _startingValue,
CurrentValue = currentValue
};
return(_expression.Evaluate(ref ctx));
}
public void Record(ExpressionEvaluationStrategy expressionEvaluationStrategy,
ExpressionEvaluationContext expressionEvaluationContext,
StepsRecorder stepsRecorder, long startTimestampUs, long endTimestampUs)
{
// Expression evaluation with 'Value' context should use the method signature that
// includes the natvisValueId parameter. This method is only meant to be used by
// 'Frame' context expression evaluations.
if (expressionEvaluationContext == ExpressionEvaluationContext.VALUE)
{
throw new ArgumentException(
"Record method invocation with 'Value' context should include natvisValueId.");
}
Record(expressionEvaluationStrategy, expressionEvaluationContext, stepsRecorder,
startTimestampUs, endTimestampUs, null);
}
private static void EvaluateSpiceSharpBehavioral(string expression, int count)
{
Console.WriteLine("---------- Spice# Behavioral ----------");
var sw = new Stopwatch();
// Setup
var parser = new SpiceParser();
parser.RegisterDefaults();
var evctxt = new ExpressionEvaluationContext(); // We don't want to test this speed in the benchmark, so let's replicate it.
var dict = evctxt.ExpressionContext.Parameters;
double X() => dict["x"].CurrentValue;
parser.RegisterVariable("x", X);
evctxt.ExpressionContext.Parameters.Add("x", new ConstantExpression(2.0));
// Func<double> e = null;
System.Linq.Expressions.Expression e = null;
for (var i = 0; i < 5; i++)
{
sw.Restart();
e = parser.Parse(expression, null);
sw.Stop();
Console.WriteLine($"Parsing (run {i + 1}): {sw.ElapsedTicks} ({sw.ElapsedMilliseconds} ms)");
}
// Compile
sw.Restart();
var f = System.Linq.Expressions.Expression.Lambda <Func <double> >(e).Compile();
sw.Stop();
Console.WriteLine($"Compilation: {sw.ElapsedTicks} ({sw.ElapsedMilliseconds} ms)");
// Evaluate a first time
dict["x"] = new ConstantExpression(1.0);
Console.WriteLine($"Evaluation: {f()}");
sw.Restart();
for (var i = 0; i < count; i++)
{
f();
}
sw.Stop();
Console.WriteLine($"Execution: {sw.ElapsedTicks} ({sw.ElapsedMilliseconds} ms)");
Console.WriteLine();
}
public void ContextBatchTest(ExpressionEvaluationContext contextSource,
ExpressionEvaluation.Types.Context contextExpected)
{
_expressionEvaluationBatch.Add(new ExpressionEvaluationBatchParams(
ExpressionEvaluationStrategy.LLDB, contextSource,
new List <ExpressionEvaluationStepBatchParams>(), 500,
2000, null));
var batchSummary = _expressionEvaluationBatch.GetSummary();
Assert.NotNull(batchSummary.Proto.ExpressionEvaluations);
Assert.AreEqual(1, batchSummary.Proto.ExpressionEvaluations.Count);
var expressionEvaluation = batchSummary.Proto.ExpressionEvaluations[0];
Assert.AreEqual(contextExpected, expressionEvaluation.Context);
}
public TextDecorationExEvaluator(string objectDecoration,
Func <string, string> evaluateVariable,
Func <string, IEnvelope, object> evaluateRecordVariable,
ILogger logger
)
{
_tree = TextDecorationParserFacade.ParseTextDecoration(objectDecoration);
FunctionBinder binder = new FunctionBinder(new Type[] { typeof(BuiltInFunctions) });
ExpressionEvaluationContext <IEnvelope> evalContext = new ExpressionEvaluationContext <IEnvelope>(
evaluateVariable,
evaluateRecordVariable,
binder,
logger
);
var validator = new TextDecorationValidator <IEnvelope>(evalContext);
validator.Visit(_tree, null); //Should throw if cannot resolve function
_interpreter = new TextDecorationInterpreter <IEnvelope>(evalContext);
}
private static void EvaluateSpiceSharpParser(string expression, int count)
{
Console.WriteLine("---------- Spice# Parser ----------");
var sw = new Stopwatch();
// Setup
var parser = new SpiceSharpParser.Parsers.Expression.SpiceExpressionParser();
var ectxt = new SpiceExpressionContext(SpiceExpressionMode.LtSpice);
var pctxt = new ExpressionParserContext()
{
Functions = ectxt.Functions
};
var evctxt = new ExpressionEvaluationContext();
// Parse
ExpressionParseResult pr = null;
for (var i = 0; i < 5; i++)
{
sw.Restart();
pr = parser.Parse(expression, pctxt);
sw.Stop();
Console.WriteLine($"Parsing (run {i + 1}): {sw.ElapsedTicks} ({sw.ElapsedMilliseconds} ms)");
}
// Evaluate a first time
evctxt.ExpressionContext.Parameters["x"] = new ConstantExpression(1.0);
Console.WriteLine($"Evaluation: {pr.Value(evctxt)}");
// Test bulk runs
sw.Restart();
for (var i = 0; i < count; i++)
{
pr.Value(evctxt);
}
sw.Stop();
Console.WriteLine($"Execution: {sw.ElapsedTicks} ({sw.ElapsedMilliseconds} ms)");
Console.WriteLine();
}
public void RecordSingleEventWithTwoStepsTest()
{
const ExpressionEvaluationStrategy strategySource = ExpressionEvaluationStrategy.LLDB;
const ExpressionEvaluationContext contextSource = ExpressionEvaluationContext.FRAME;
var stepsRecorder = new ExpressionEvaluationRecorder.StepsRecorder(_timeSource);
using (Step step = stepsRecorder.NewStep(ExpressionEvaluationEngine.LLDB_VARIABLE_PATH))
{
step.Finalize(LLDBErrorCode.ERROR);
}
using (Step step = stepsRecorder.NewStep(ExpressionEvaluationEngine.LLDB))
{
step.Finalize(LLDBErrorCode.OK);
}
const long startTimestampUs = 750;
const long endTimestampUs = 21562;
_expressionEvaluationRecorder.Record(strategySource, contextSource, stepsRecorder,
startTimestampUs, endTimestampUs);
// Get a copy of the batch summary sent to batchEventAggregator so we can verify
// that it matches the one being sent to metrics.
ExpressionEvaluationBatchSummary batchSummary = null;
_batchEventAggregator.BatchSummaryReady += (_, newSummary) => batchSummary = newSummary;
_timer.Increment(_minimumBatchSeparationMilliseconds);
_eventScheduler.Increment(_minimumBatchSeparationMilliseconds);
const ExpressionEvaluation.Types.Strategy strategyExpected =
ExpressionEvaluation.Types.Strategy.Lldb;
const ExpressionEvaluation.Types.Context contextExpected = ExpressionEvaluation.Types
.Context.Frame;
Assert.AreEqual(1, batchSummary.Proto.ExpressionEvaluations.Count);
ExpressionEvaluation received = batchSummary.Proto.ExpressionEvaluations[0];
Assert.Multiple(() =>
{
Assert.AreEqual(strategyExpected, received.Strategy);
Assert.AreEqual(contextExpected, received.Context);
Assert.NotNull(received.EvaluationSteps);
Assert.AreEqual(2, received.EvaluationSteps.Count);
Assert.AreEqual(startTimestampUs, received.StartTimestampMicroseconds);
Assert.AreEqual(endTimestampUs, received.EndTimestampMicroseconds);
Assert.Null(received.NatvisValueId);
});
const ExpressionEvaluationStep.Types.Engine firstStepEngineExpected =
ExpressionEvaluationStep.Types.Engine.LldbVariablePath;
const ExpressionEvaluationStep.Types.EngineResult firstStepEngineResultExpected =
ExpressionEvaluationStep.Types.EngineResult.LldbError;
const ExpressionEvaluationStep.Types.Engine secondStepEngineExpected =
ExpressionEvaluationStep.Types.Engine.Lldb;
const ExpressionEvaluationStep.Types.EngineResult secondStepEngineResultExpected =
ExpressionEvaluationStep.Types.EngineResult.LldbOk;
ExpressionEvaluationStep firstStep = received.EvaluationSteps[0];
ExpressionEvaluationStep secondStep = received.EvaluationSteps[1];
Assert.Multiple(() =>
{
Assert.AreEqual(firstStepEngineExpected, firstStep.Engine);
Assert.AreEqual(firstStepEngineResultExpected, firstStep.Result);
Assert.AreEqual(1, firstStep.DurationMicroseconds);
Assert.AreEqual(secondStepEngineExpected, secondStep.Engine);
Assert.AreEqual(secondStepEngineResultExpected, secondStep.Result);
Assert.AreEqual(1, secondStep.DurationMicroseconds);
});
_metrics.Received(1)
.RecordEvent(DeveloperEventType.Types.Type.VsiDebugExpressionEvaluationBatch,
new DeveloperLogEvent
{
DebugExpressionEvaluationBatch = batchSummary.Proto,
StatusCode = DeveloperEventStatus.Types.Code.Success
});
}
public void RecordSingleEventWithValueContextTest()
{
const ExpressionEvaluationStrategy strategySource =
ExpressionEvaluationStrategy.LLDB_EVAL;
const ExpressionEvaluationContext contextSource = ExpressionEvaluationContext.VALUE;
var stepsRecorder = new ExpressionEvaluationRecorder.StepsRecorder(_timeSource);
using (Step step = stepsRecorder.NewStep(ExpressionEvaluationEngine.LLDB_EVAL))
{
step.Finalize(LldbEvalErrorCode.Ok);
}
const long startTimestampUs = 750;
const long endTimestampUs = 21562;
// Attempt to record expression evaluation with context Value, without natvisValueId
// should throw an exception.
Assert.Throws <ArgumentException>(() =>
{
_expressionEvaluationRecorder.Record(
strategySource, contextSource, stepsRecorder,
startTimestampUs, endTimestampUs);
});
const string natvisValueId = "TestId";
_expressionEvaluationRecorder.Record(strategySource, contextSource, stepsRecorder,
startTimestampUs, endTimestampUs, natvisValueId);
// Get a copy of the batch summary sent to batchEventAggregator so we can verify
// that it matches the one being sent to metrics.
ExpressionEvaluationBatchSummary batchSummary = null;
_batchEventAggregator.BatchSummaryReady += (_, newSummary) => batchSummary = newSummary;
_timer.Increment(_minimumBatchSeparationMilliseconds);
_eventScheduler.Increment(_minimumBatchSeparationMilliseconds);
const ExpressionEvaluation.Types.Strategy strategyExpected =
ExpressionEvaluation.Types.Strategy.LldbEval;
const ExpressionEvaluation.Types.Context contextExpected =
ExpressionEvaluation.Types.Context.Value;
Assert.AreEqual(1, batchSummary.Proto.ExpressionEvaluations.Count);
ExpressionEvaluation received = batchSummary.Proto.ExpressionEvaluations[0];
Assert.Multiple(() =>
{
Assert.AreEqual(strategyExpected, received.Strategy);
Assert.AreEqual(contextExpected, received.Context);
Assert.NotNull(received.EvaluationSteps);
Assert.AreEqual(1, received.EvaluationSteps.Count);
Assert.AreEqual(startTimestampUs, received.StartTimestampMicroseconds);
Assert.AreEqual(endTimestampUs, received.EndTimestampMicroseconds);
Assert.AreEqual(natvisValueId, received.NatvisValueId);
});
const ExpressionEvaluationStep.Types.Engine stepEngineExpected =
ExpressionEvaluationStep.Types.Engine.LldbEval;
const ExpressionEvaluationStep.Types.EngineResult stepEngineResultExpected =
ExpressionEvaluationStep.Types.EngineResult.LldbEvalOk;
ExpressionEvaluationStep receivedEvaluationStep = received.EvaluationSteps[0];
Assert.Multiple(() =>
{
Assert.AreEqual(stepEngineExpected, receivedEvaluationStep.Engine);
Assert.AreEqual(stepEngineResultExpected, receivedEvaluationStep.Result);
Assert.AreEqual(1, receivedEvaluationStep.DurationMicroseconds);
});
_metrics.Received(1)
.RecordEvent(DeveloperEventType.Types.Type.VsiDebugExpressionEvaluationBatch,
new DeveloperLogEvent
{
DebugExpressionEvaluationBatch = batchSummary.Proto,
StatusCode = DeveloperEventStatus.Types.Code.Success
});
}
private ExpressionVariant EvaluateImpl(TimeSpan elapsed, ExpressionVariant currentValue, ref ExpressionEvaluationContext ctx)
{
if (elapsed < _delayTime)
{
if (_delayBehavior == AnimationDelayBehavior.SetInitialValueBeforeDelay)
{
return(ExpressionVariant.Create(GetKeyFrame(ref ctx, _keyFrames[0])));
}
return(currentValue);
}
elapsed -= _delayTime;
var iterationNumber = elapsed.Ticks / _duration.Ticks;
if (_iterationBehavior == AnimationIterationBehavior.Count &&
iterationNumber >= _iterationCount)
{
return(ExpressionVariant.Create(GetKeyFrame(ref ctx, _keyFrames[_keyFrames.Length - 1])));
}
var evenIterationNumber = iterationNumber % 2 == 0;
elapsed = TimeSpan.FromTicks(elapsed.Ticks % _duration.Ticks);
var reverse =
_direction == PlaybackDirection.Alternate
? !evenIterationNumber
: _direction == PlaybackDirection.AlternateReverse
? evenIterationNumber
: _direction == PlaybackDirection.Reverse;
var iterationProgress = elapsed.TotalSeconds / _duration.TotalSeconds;
if (reverse)
{
iterationProgress = 1 - iterationProgress;
}
var left = new ServerKeyFrame <T>
{
Value = _startingValue
};
var right = _keyFrames[_keyFrames.Length - 1];
for (var c = 0; c < _keyFrames.Length; c++)
{
var kf = _keyFrames[c];
if (kf.Key < iterationProgress)
{
// this is the last frame
if (c == _keyFrames.Length - 1)
{
return(ExpressionVariant.Create(GetKeyFrame(ref ctx, kf)));
}
left = kf;
right = _keyFrames[c + 1];
break;
}
}
var keyProgress = Math.Max(0, Math.Min(1, (iterationProgress - left.Key) / (right.Key - left.Key)));
var easedKeyProgress = (float)right.EasingFunction.Ease(keyProgress);
if (float.IsNaN(easedKeyProgress) || float.IsInfinity(easedKeyProgress))
{
return(currentValue);
}
return(ExpressionVariant.Create(_interpolator.Interpolate(
GetKeyFrame(ref ctx, left),
GetKeyFrame(ref ctx, right),
easedKeyProgress
)));
}
