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