예제 #1
0
        protected void ScheduleCallback()
        {
            long current = _agentInstanceContext.StatementContext.SchedulingService.Time;
            ExprTimePeriodEvalDeltaResult deltaWReference = _timeDeltaComputation.DeltaAddWReference(
                current, _currentReferencePoint.Value);
            long afterTime = deltaWReference.Delta;

            _currentReferencePoint = deltaWReference.LastReference;

            var callback = new ProxyScheduleHandleCallback()
            {
                ProcScheduledTrigger = (extensionServicesContext) =>
                {
                    if (InstrumentationHelper.ENABLED)
                    {
                        InstrumentationHelper.Get().QViewScheduledEval(this, _timeBatchViewFactory.ViewName);
                    }
                    SendBatch();
                    if (InstrumentationHelper.ENABLED)
                    {
                        InstrumentationHelper.Get().AViewScheduledEval();
                    }
                }
            };

            _handle = new EPStatementHandleCallback(_agentInstanceContext.EpStatementAgentInstanceHandle, callback);
            _agentInstanceContext.StatementContext.SchedulingService.Add(afterTime, _handle, _scheduleSlot);
        }
예제 #2
0
        public void TestComputeDelta()
        {
            ExprTimePeriod timePeriod = new ExprTimePeriodImpl(
                TimeZoneInfo.Local,
                false, true, false, false, false, false, false, false, false,
                TimeAbacusMilliseconds.INSTANCE,
                _container.LockManager());

            timePeriod.AddChildNode(new ExprConstantNodeImpl(1));
            timePeriod.Validate(null);

            ExprTimePeriodEvalDeltaConstGivenDtxAdd addMonth = (ExprTimePeriodEvalDeltaConstGivenDtxAdd)timePeriod.ConstEvaluator(null);

            Assert.AreEqual(28 * 24 * 60 * 60 * 1000L, addMonth.DeltaAdd(Parse("2002-02-15T09:00:00.000")));
            Assert.AreEqual(28 * 24 * 60 * 60 * 1000L, addMonth.DeltaSubtract(Parse("2002-03-15T09:00:00.000")));

            ExprTimePeriodEvalDeltaResult result = addMonth.DeltaAddWReference(
                Parse("2002-02-15T09:00:00.000"), Parse("2002-02-15T09:00:00.000"));

            Assert.AreEqual(Parse("2002-03-15T09:00:00.000") - Parse("2002-02-15T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-02-15T09:00:00.000"), result.LastReference);

            result = addMonth.DeltaAddWReference(
                Parse("2002-03-15T09:00:00.000"), Parse("2002-02-15T09:00:00.000"));
            Assert.AreEqual(Parse("2002-04-15T09:00:00.000") - Parse("2002-03-15T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-03-15T09:00:00.000"), result.LastReference);

            result = addMonth.DeltaAddWReference(
                Parse("2002-04-15T09:00:00.000"), Parse("2002-03-15T09:00:00.000"));
            Assert.AreEqual(Parse("2002-05-15T09:00:00.000") - Parse("2002-04-15T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-04-15T09:00:00.000"), result.LastReference);

            // try future reference
            result = addMonth.DeltaAddWReference(
                Parse("2002-02-15T09:00:00.000"), Parse("2900-03-15T09:00:00.000"));
            Assert.AreEqual(Parse("2002-03-15T09:00:00.000") - Parse("2002-02-15T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-02-15T09:00:00.000"), result.LastReference);

            // try old reference
            result = addMonth.DeltaAddWReference(
                Parse("2002-02-15T09:00:00.000"), Parse("1980-03-15T09:00:00.000"));
            Assert.AreEqual(Parse("2002-03-15T09:00:00.000") - Parse("2002-02-15T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-02-15T09:00:00.000"), result.LastReference);

            // try different-dates
            result = addMonth.DeltaAddWReference(
                Parse("2002-02-18T09:00:00.000"), Parse("1980-03-15T09:00:00.000"));
            Assert.AreEqual(Parse("2002-03-15T09:00:00.000") - Parse("2002-02-18T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-02-15T09:00:00.000"), result.LastReference);

            result = addMonth.DeltaAddWReference(
                Parse("2002-02-11T09:00:00.000"), Parse("2980-03-15T09:00:00.000"));
            Assert.AreEqual(Parse("2002-02-15T09:00:00.000") - Parse("2002-02-11T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-01-15T09:00:00.000"), result.LastReference);

            result = addMonth.DeltaAddWReference(
                Parse("2002-04-05T09:00:00.000"), Parse("2002-02-11T09:01:02.003"));
            Assert.AreEqual(Parse("2002-04-11T09:01:02.003") - Parse("2002-04-05T09:00:00.000"), result.Delta);
            Assert.AreEqual(Parse("2002-03-11T09:01:02.003"), result.LastReference);
        }
예제 #3
0
        protected void ScheduleCallback()
        {
            long current = _agentInstanceContext.StatementContext.SchedulingService.Time;
            ExprTimePeriodEvalDeltaResult deltaWReference = _timeDeltaComputation.DeltaMillisecondsAddWReference(
                current, _currentReferencePoint.Value);
            long afterMSec = deltaWReference.Delta;

            _currentReferencePoint = deltaWReference.LastReference;

            ScheduleHandleCallback callback = new ProxyScheduleHandleCallback
            {
                ProcScheduledTrigger = extensionServicesContext => Instrument.With(
                    i => i.QViewScheduledEval(this, _timeBatchViewFactory.ViewName),
                    i => i.AViewScheduledEval(),
                    SendBatch)
            };

            _handle = new EPStatementHandleCallback(_agentInstanceContext.EpStatementAgentInstanceHandle, callback);
            _agentInstanceContext.StatementContext.SchedulingService.Add(afterMSec, _handle, _scheduleSlot);
        }
예제 #4
0
        private void ScheduleCallback()
        {
            _isCallbackScheduled = true;
            long current = _context.StatementContext.SchedulingService.Time;
            ExprTimePeriodEvalDeltaResult delta = _parent.TimePeriod.NonconstEvaluator().DeltaMillisecondsAddWReference(
                current, _currentReferencePoint.Value, null, true, _context);
            long afterMSec = delta.Delta;

            _currentReferencePoint = delta.LastReference;
            _currentScheduledTime  = afterMSec;

            if ((ExecutionPathDebugLog.IsEnabled) && (Log.IsDebugEnabled))
            {
                Log.Debug(
                    ".scheduleCallback Scheduled new callback for " +
                    " afterMsec=" + afterMSec +
                    " now=" + current +
                    " currentReferencePoint=" + _currentReferencePoint);
            }

            ScheduleHandleCallback callback = new ProxyScheduleHandleCallback
            {
                ProcScheduledTrigger = extensionServicesContext => Instrument.With(
                    i => i.QOutputRateConditionScheduledEval(),
                    i => i.AOutputRateConditionScheduledEval(),
                    () =>
                {
                    _isCallbackScheduled = false;
                    OutputCallback.Invoke(DO_OUTPUT, FORCE_UPDATE);
                    ScheduleCallback();
                })
            };

            _handle = new EPStatementHandleCallback(_context.EpStatementAgentInstanceHandle, callback);
            _context.StatementContext.SchedulingService.Add(afterMSec, _handle, _scheduleSlot);
            _context.AddTerminationCallback(new ProxyStopCallback(Stop));
        }
예제 #5
0
        public void TestComputeDelta()
        {
            ExprTimePeriodEvalDeltaConstGivenDelta delta500 = new ExprTimePeriodEvalDeltaConstGivenDelta(500);

            Assert.AreEqual(500, delta500.DeltaAdd(0));
            Assert.AreEqual(500, delta500.DeltaSubtract(0));

            ExprTimePeriodEvalDeltaConstGivenDelta delta10k = new ExprTimePeriodEvalDeltaConstGivenDelta(10000);

            Assert.AreEqual(10000, delta10k.DeltaAdd(0));
            Assert.AreEqual(10000, delta10k.DeltaSubtract(0));

            // With current=2300, ref=1000, and interval=500, expect 2500 as next interval and 200 as solution
            // the reference will stay the same since the computation is cheap without updated reference
            ExprTimePeriodEvalDeltaResult result = delta500.DeltaAddWReference(2300, 1000);

            Assert.AreEqual(200, result.Delta);
            Assert.AreEqual(1000, result.LastReference);

            result = delta500.DeltaAddWReference(2300, 4200);
            Assert.AreEqual(400, result.Delta);
            Assert.AreEqual(4200, result.LastReference);

            result = delta500.DeltaAddWReference(2200, 4200);
            Assert.AreEqual(500, result.Delta);
            Assert.AreEqual(4200, result.LastReference);

            result = delta500.DeltaAddWReference(2200, 2200);
            Assert.AreEqual(500, result.Delta);
            Assert.AreEqual(2200, result.LastReference);

            result = delta500.DeltaAddWReference(2201, 2200);
            Assert.AreEqual(499, result.Delta);
            Assert.AreEqual(2200, result.LastReference);

            result = delta500.DeltaAddWReference(2600, 2200);
            Assert.AreEqual(100, result.Delta);
            Assert.AreEqual(2200, result.LastReference);

            result = delta500.DeltaAddWReference(2699, 2200);
            Assert.AreEqual(1, result.Delta);
            Assert.AreEqual(2200, result.LastReference);

            result = delta500.DeltaAddWReference(2699, 2700);
            Assert.AreEqual(1, result.Delta);
            Assert.AreEqual(2700, result.LastReference);

            result = delta10k.DeltaAddWReference(2699, 2700);
            Assert.AreEqual(1, result.Delta);
            Assert.AreEqual(2700, result.LastReference);

            result = delta10k.DeltaAddWReference(2700, 2700);
            Assert.AreEqual(10000, result.Delta);
            Assert.AreEqual(2700, result.LastReference);

            result = delta10k.DeltaAddWReference(2700, 6800);
            Assert.AreEqual(4100, result.Delta);
            Assert.AreEqual(6800, result.LastReference);

            result = delta10k.DeltaAddWReference(23050, 16800);
            Assert.AreEqual(3750, result.Delta);
            Assert.AreEqual(16800, result.LastReference);
        }