public override void Update(EventBean[] newData, EventBean[] oldData) { Instrument.With( i => i.QViewProcessIRStream(this, _timeWindowViewFactory.ViewName, newData, oldData), i => i.AViewProcessIRStream(), () => { long timestamp = _agentInstanceContext.StatementContext.SchedulingService.Time; if (oldData != null) { for (int i = 0; i < oldData.Length; i++) { _timeWindow.Remove(oldData[i]); } } // we don't care about removed data from a prior view if ((newData != null) && (newData.Length > 0)) { // If we have an empty window about to be filled for the first time, schedule a callback // for now plus timeDeltaComputation if (_timeWindow.IsEmpty()) { long current = _agentInstanceContext.StatementContext.SchedulingService.Time; ScheduleCallback(_timeDeltaComputation.DeltaMillisecondsAdd(current)); } // add data points to the timeWindow for (int i = 0; i < newData.Length; i++) { _timeWindow.Add(timestamp, newData[i]); } if (_viewUpdatedCollection != null) { _viewUpdatedCollection.Update(newData, null); } } // Update child views if (HasViews) { Instrument.With( i => i.QViewIndicate(this, _timeWindowViewFactory.ViewName, newData, oldData), i => i.AViewIndicate(), () => UpdateChildren(newData, oldData)); } }); }
protected void ScheduleCallback(long delta) { ScheduleHandleCallback callback = new ProxyScheduleHandleCallback { ProcScheduledTrigger = extensionServicesContext => Instrument.With( i => i.QViewScheduledEval(this, _timeLengthBatchViewFactory.ViewName), i => i.AViewScheduledEval(), () => SendBatch(true)) }; _handle = new EPStatementHandleCallback(_agentInstanceContext.EpStatementAgentInstanceHandle, callback); var currentTime = _agentInstanceContext.StatementContext.SchedulingService.Time; var scheduled = _timeDeltaComputation.DeltaMillisecondsAdd(currentTime) - delta; _agentInstanceContext.StatementContext.SchedulingService.Add(scheduled, _handle, _scheduleSlot); _callbackScheduledTime = _agentInstanceContext.StatementContext.SchedulingService.Time + scheduled; }
/// <summary> /// Returns the number of milliseconds. /// </summary> public long GetScheduleForwardDelta(long fromTime, AgentInstanceContext agentInstanceContext) { if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().QRegIntervalValue(TimePeriodExpr); } if (_timeDeltaComputation == null) { _timeDeltaComputation = TimePeriodExpr.ConstEvaluator(new ExprEvaluatorContextStatement(agentInstanceContext.StatementContext, false)); } long result = _timeDeltaComputation.DeltaMillisecondsAdd(fromTime); if (InstrumentationHelper.ENABLED) { InstrumentationHelper.Get().ARegIntervalValue(result); } return(result); }
private void ScheduleCallback() { long afterMSec = _timeDeltaComputation.DeltaMillisecondsAdd( AgentInstanceContext.StatementContext.SchedulingService.Time); ScheduleHandleCallback callback = new ProxyScheduleHandleCallback { ProcScheduledTrigger = extensionServicesContext => Instrument.With( i => i.QViewScheduledEval(this, _timeFirstViewFactory.ViewName), i => i.AViewScheduledEval(), () => { _isClosed = true; InternalHandleClosed(); }) }; _handle = new EPStatementHandleCallback(AgentInstanceContext.EpStatementAgentInstanceHandle, callback); AgentInstanceContext.StatementContext.SchedulingService.Add(afterMSec, _handle, _scheduleSlot); }
public override void Update(EventBean[] newData, EventBean[] oldData) { using (Instrument.With( i => i.QViewProcessIRStream(this, _factory.ViewName, newData, oldData), i => i.AViewProcessIRStream())) { if ((newData != null) && (newData.Length > 0)) { // If we have an empty window about to be filled for the first time, add a callback bool removeSchedule = false; bool addSchedule = false; long timestamp = _agentInstanceContext.StatementContext.SchedulingService.Time; // if the window is already filled, then we may need to reschedule if (_currentBatch.IsNotEmpty()) { // check if we need to reschedule long callbackTime = timestamp + _timeDeltaComputation.DeltaMillisecondsAdd(timestamp); if (callbackTime != _callbackScheduledTime) { removeSchedule = true; addSchedule = true; } } else { addSchedule = true; } if (removeSchedule) { _agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot); _callbackScheduledTime = -1; } if (addSchedule) { long msecIntervalSize = _timeDeltaComputation.DeltaMillisecondsAdd(timestamp); _agentInstanceContext.StatementContext.SchedulingService.Add( msecIntervalSize, _handle, _scheduleSlot); _callbackScheduledTime = msecIntervalSize + timestamp; } // add data points to the window for (int i = 0; i < newData.Length; i++) { _currentBatch.Put(newData[i], timestamp); InternalHandleAdded(newData[i], timestamp); _lastEvent = newData[i]; } } if ((oldData != null) && (oldData.Length > 0)) { bool removedLastEvent = false; foreach (EventBean anOldData in oldData) { _currentBatch.Remove(anOldData); InternalHandleRemoved(anOldData); if (anOldData == _lastEvent) { removedLastEvent = true; } } // we may need to reschedule as the newest event may have been deleted if (_currentBatch.Count == 0) { _agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot); _callbackScheduledTime = -1; _lastEvent = null; } else { // reschedule if the last event was removed if (removedLastEvent) { ICollection <EventBean> keyset = _currentBatch.Keys; EventBean[] events = keyset.ToArray(); _lastEvent = events[events.Length - 1]; long lastTimestamp = _currentBatch.Get(_lastEvent); // reschedule, newest event deleted long timestamp = _agentInstanceContext.StatementContext.SchedulingService.Time; long callbackTime = lastTimestamp + _timeDeltaComputation.DeltaMillisecondsAdd(lastTimestamp); long deltaFromNow = callbackTime - timestamp; if (callbackTime != _callbackScheduledTime) { _agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot); _agentInstanceContext.StatementContext.SchedulingService.Add( deltaFromNow, _handle, _scheduleSlot); _callbackScheduledTime = callbackTime; } } } } // Update child views if (HasViews) { using (Instrument.With( i => i.QViewIndicate(this, _factory.ViewName, newData, oldData), i => i.AViewIndicate())) { UpdateChildren(newData, oldData); } } } }
private static ExprOptionalConstant GetExprOrConstant(ExprNode exprNode) { if (exprNode is ExprTimePeriod) { var timePeriod = (ExprTimePeriod)exprNode; if (!timePeriod.HasMonth && !timePeriod.HasYear) { // no-month and constant if (exprNode.IsConstantResult) { double sec = timePeriod.EvaluateAsSeconds(null, true, null); var l = (long)(sec * 1000L); IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator { ProcEvaluate = (reference, eventsPerStream, isNewData, context) => l, }; return(new ExprOptionalConstant(eval, l)); } // no-month and not constant else { IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator { ProcEvaluate = (reference, eventsPerStream, isNewData, context) => { double sec = timePeriod.EvaluateAsSeconds(eventsPerStream, isNewData, context); return((long)Math.Round(sec * 1000d)); }, }; return(new ExprOptionalConstant(eval, null)); } } // has-month else { // has-month and constant if (exprNode.IsConstantResult) { ExprTimePeriodEvalDeltaConst timerPeriodConst = timePeriod.ConstEvaluator(null); IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator { ProcEvaluate = (reference, eventsPerStream, isNewData, context) => { return (timerPeriodConst .DeltaMillisecondsAdd (reference)); }, }; return(new ExprOptionalConstant(eval, null)); } // has-month and not constant else { ExprTimePeriodEvalDeltaNonConst timerPeriodNonConst = timePeriod.NonconstEvaluator(); IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator { ProcEvaluate = (reference, eventsPerStream, isNewData, context) => timerPeriodNonConst.DeltaMillisecondsAdd( reference, eventsPerStream, isNewData, context), }; return(new ExprOptionalConstant(eval, null)); } } } else if (ExprNodeUtility.IsConstantValueExpr(exprNode)) { var constantNode = (ExprConstantNode)exprNode; long l = constantNode.GetConstantValue(null).AsLong(); IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator { ProcEvaluate = (reference, eventsPerStream, isNewData, context) => l, }; return(new ExprOptionalConstant(eval, l)); } else { var evaluator = exprNode.ExprEvaluator; IntervalDeltaExprEvaluator eval = new ProxyIntervalDeltaExprEvaluator { ProcEvaluate = (reference, eventsPerStream, isNewData, context) => evaluator.Evaluate( new EvaluateParams(eventsPerStream, isNewData, context)).AsLong(), }; return(new ExprOptionalConstant(eval, null)); } }
public override void Update(EventBean[] newData, EventBean[] oldData) { using (Instrument.With( i => i.QViewProcessIRStream(this, _factory.ViewName, newData, oldData), i => i.AViewProcessIRStream())) { // we don't care about removed data from a prior view if ((newData == null) || (newData.Length == 0)) { return; } // If we have an empty window about to be filled for the first time, addSchedule a callback bool removeSchedule = false; bool addSchedule = false; long timestamp = AgentInstanceContext.StatementContext.SchedulingService.Time; if (CurrentBatch.IsNotEmpty()) { // check if we need to reschedule long callbackTime = timestamp + _timeDeltaComputation.DeltaMillisecondsAdd(timestamp);; if (callbackTime != CallbackScheduledTime) { removeSchedule = true; addSchedule = true; } } else { addSchedule = true; } if (removeSchedule) { AgentInstanceContext.StatementContext.SchedulingService.Remove(Handle, ScheduleSlot); } if (addSchedule) { var msecIntervalSize = _timeDeltaComputation.DeltaMillisecondsAdd(timestamp); AgentInstanceContext.StatementContext.SchedulingService.Add(msecIntervalSize, Handle, ScheduleSlot); CallbackScheduledTime = msecIntervalSize + timestamp; } // add data points to the window foreach (EventBean newEvent in newData) { CurrentBatch.Add(newEvent); } // forward insert stream to child views if (ViewUpdatedCollection != null) { ViewUpdatedCollection.Update(newData, null); } // Update child views if (HasViews) { Instrument.With( i => i.QViewIndicate(this, _factory.ViewName, newData, null), i => i.AViewIndicate(), () => UpdateChildren(newData, null)); } } }
public override void Update(EventBean[] newData, EventBean[] oldData) { using (Instrument.With( i => i.QViewProcessIRStream(this, _timeOrderViewFactory.ViewName, newData, oldData), i => i.AViewProcessIRStream())) { EventBean[] postOldEventsArray = null; // Remove old data if (oldData != null) { for (int i = 0; i < oldData.Length; i++) { var oldDataItem = oldData[i]; var sortValues = GetTimestamp(oldDataItem); var result = CollectionUtil.RemoveEventByKeyLazyListMap(sortValues, oldDataItem, _sortedEvents); if (result) { _eventCount--; if (postOldEventsArray == null) { postOldEventsArray = oldData; } else { postOldEventsArray = CollectionUtil.AddArrayWithSetSemantics( postOldEventsArray, oldData); } InternalHandleRemoved(sortValues, oldDataItem); } } } if ((newData != null) && (newData.Length > 0)) { // figure out the current tail time long engineTime = _agentInstanceContext.StatementContext.SchedulingService.Time; long windowTailTime = engineTime - _timeDeltaComputation.DeltaMillisecondsAdd(engineTime) + 1; long oldestEvent = long.MaxValue; if (_sortedEvents.IsNotEmpty()) { oldestEvent = (long)_sortedEvents.Keys.First(); } bool addedOlderEvent = false; // add events or post events as remove stream if already older then tail time List <EventBean> postOldEvents = null; for (int i = 0; i < newData.Length; i++) { // get timestamp of event var newEvent = newData[i]; var timestamp = GetTimestamp(newEvent); // if the event timestamp indicates its older then the tail of the window, release it if (timestamp < windowTailTime) { if (postOldEvents == null) { postOldEvents = new List <EventBean>(2); } postOldEvents.Add(newEvent); } else { if (timestamp < oldestEvent) { addedOlderEvent = true; oldestEvent = timestamp.Value; } // add to list CollectionUtil.AddEventByKeyLazyListMapBack(timestamp, newEvent, _sortedEvents); _eventCount++; InternalHandleAdd(timestamp, newEvent); } } // If we do have data, check the callback if (_sortedEvents.IsNotEmpty()) { // If we haven't scheduled a callback yet, schedule it now if (!_isCallbackScheduled) { long callbackWait = oldestEvent - windowTailTime + 1; _agentInstanceContext.StatementContext.SchedulingService.Add( callbackWait, _handle, _scheduleSlot); _isCallbackScheduled = true; } else { // We may need to reschedule, and older event may have been added if (addedOlderEvent) { oldestEvent = (long)_sortedEvents.Keys.First(); long callbackWait = oldestEvent - windowTailTime + 1; _agentInstanceContext.StatementContext.SchedulingService.Remove(_handle, _scheduleSlot); _agentInstanceContext.StatementContext.SchedulingService.Add( callbackWait, _handle, _scheduleSlot); _isCallbackScheduled = true; } } } if (postOldEvents != null) { postOldEventsArray = postOldEvents.ToArray(); } if (_optionalSortedRandomAccess != null) { _optionalSortedRandomAccess.Refresh(_sortedEvents, _eventCount, _eventCount); } } // Update child views if (HasViews) { Instrument.With( i => i.QViewIndicate(this, _timeOrderViewFactory.ViewName, newData, postOldEventsArray), i => i.AViewIndicate(), () => UpdateChildren(newData, postOldEventsArray)); } } }