public EPDataFlowEmitterNoTarget( int operatorNum, DataFlowSignalManager dataFlowSignalManager) { this.operatorNum = operatorNum; this.dataFlowSignalManager = dataFlowSignalManager; }
private static EPDataFlowEmitter GenerateRuntimeContext( string engineURI, string statementName, bool audit, string dataflowName, int producerOpNum, string operatorPrettyPrint, DataFlowSignalManager dataFlowSignalManager, IList <ObjectBindingPair>[] targetsPerStream, EPDataFlowInstantiationOptions options, EngineImportService engineImportService) { // handle no targets if (targetsPerStream == null) { return(new EPDataFlowEmitterNoTarget(producerOpNum, dataFlowSignalManager)); } // handle single-stream case if (targetsPerStream.Length == 1) { var targets = targetsPerStream[0]; // handle single-stream single target case if (targets.Count == 1) { var target = targets[0]; return(GetSubmitHandler( engineURI, statementName, audit, dataflowName, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, target, options.GetExceptionHandler(), engineImportService)); } var handlers = new SubmitHandler[targets.Count]; for (var i = 0; i < handlers.Length; i++) { handlers[i] = GetSubmitHandler( engineURI, statementName, audit, dataflowName, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, targets[i], options.GetExceptionHandler(), engineImportService); } return(new EPDataFlowEmitter1StreamNTarget(producerOpNum, dataFlowSignalManager, handlers)); } else { // handle multi-stream case var handlersPerStream = new SubmitHandler[targetsPerStream.Length][]; for (var streamNum = 0; streamNum < targetsPerStream.Length; streamNum++) { var handlers = new SubmitHandler[targetsPerStream[streamNum].Count]; handlersPerStream[streamNum] = handlers; for (var i = 0; i < handlers.Length; i++) { handlers[i] = GetSubmitHandler( engineURI, statementName, audit, dataflowName, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, targetsPerStream[streamNum][i], options.GetExceptionHandler(), engineImportService); } } return(new EPDataFlowEmitterNStreamNTarget(producerOpNum, dataFlowSignalManager, handlersPerStream)); } }
public EPDataFlowEmitterNStreamNTarget( int operatorNum, DataFlowSignalManager signalManager, SubmitHandler[][] handlersPerStream) { this.operatorNum = operatorNum; this.signalManager = signalManager; this.handlersPerStream = handlersPerStream; }
public EPDataFlowEmitter1StreamNTarget( int operatorNum, DataFlowSignalManager signalManager, SubmitHandler[] targets) { this.operatorNum = operatorNum; this.signalManager = signalManager; this.targets = targets; }
public EPDataFlowEmitter1Stream1TargetUnwind( int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target, EngineImportService engineImportService) : base(operatorNum, signalManager, signalHandler, exceptionHandler, target, engineImportService) { }
protected EPDataFlowEmitter1Stream1TargetBase(int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target) { OperatorNum = operatorNum; SignalManager = signalManager; SignalHandler = signalHandler; ExceptionHandler = exceptionHandler; var fastClass = FastClass.Create(target.Target.GetType()); _fastMethod = fastClass.GetMethod(target.Binding.ConsumingBindingDesc.Method); TargetObject = target.Target; }
public EPDataFlowEmitter1Stream1TargetPassAlongWStream( int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target, int streamNum, EngineImportService engineImportService) : base(operatorNum, signalManager, signalHandler, exceptionHandler, target, engineImportService) { _streamNum = streamNum; }
public EPDataFlowEmitter1Stream1TargetBase( int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target, ImportService importService) { this.operatorNum = operatorNum; this.signalManager = signalManager; this.signalHandler = signalHandler; this.exceptionHandler = exceptionHandler; fastMethod = target.Binding.ConsumingBindingDesc.Method; targetObject = target.Target; }
public EPDataFlowEmitter1Stream1TargetPassAlong( int operatorNum, DataFlowSignalManager signalManager, SignalHandler signalHandler, EPDataFlowEmitterExceptionHandler exceptionHandler, ObjectBindingPair target, ImportService importService) : base( operatorNum, signalManager, signalHandler, exceptionHandler, target, importService) { }
private static SubmitHandler GetSubmitHandler( string engineURI, string statementName, bool audit, string dataflowName, int producerOpNum, string operatorPrettyPrint, DataFlowSignalManager dataFlowSignalManager, ObjectBindingPair target, EPDataFlowExceptionHandler optionalExceptionHandler, EngineImportService engineImportService) { var signalHandler = GetSignalHandler( producerOpNum, target.Target, target.Binding.ConsumingSignalBindingDesc, engineImportService); var receivingOpNum = target.Binding.LogicalChannel.ConsumingOpNum; var receivingOpPretty = target.Binding.LogicalChannel.ConsumingOpPrettyPrint; var receivingOpName = target.Binding.LogicalChannel.ConsumingOpName; var exceptionHandler = new EPDataFlowEmitterExceptionHandler( engineURI, statementName, audit, dataflowName, receivingOpName, receivingOpNum, receivingOpPretty, optionalExceptionHandler); var bindingType = target.Binding.ConsumingBindingDesc.BindingType; if (bindingType is LogicalChannelBindingTypePassAlong) { return(new EPDataFlowEmitter1Stream1TargetPassAlong( producerOpNum, dataFlowSignalManager, signalHandler, exceptionHandler, target, engineImportService)); } else if (bindingType is LogicalChannelBindingTypePassAlongWStream) { var type = (LogicalChannelBindingTypePassAlongWStream)bindingType; return(new EPDataFlowEmitter1Stream1TargetPassAlongWStream( producerOpNum, dataFlowSignalManager, signalHandler, exceptionHandler, target, type.StreamNum, engineImportService)); } else if (bindingType is LogicalChannelBindingTypeUnwind) { return(new EPDataFlowEmitter1Stream1TargetUnwind( producerOpNum, dataFlowSignalManager, signalHandler, exceptionHandler, target, engineImportService)); } else { throw new UnsupportedOperationException("Unsupported binding type '" + bindingType + "'"); } }
public static DataflowStartDesc Realize(String dataFlowName, IDictionary <int, Object> operators, IDictionary <int, OperatorMetadataDescriptor> operatorMetadata, ICollection <int> operatorBuildOrder, IList <LogicalChannelBinding> bindings, DataFlowSignalManager dataFlowSignalManager, EPDataFlowInstantiationOptions options, EPServicesContext services, StatementContext statementContext) { // First pass: inject runtime context IDictionary <int, EPDataFlowEmitter> runtimeContexts = new Dictionary <int, EPDataFlowEmitter>(); OperatorStatisticsProvider statisticsProvider = null; if (options.IsOperatorStatistics()) { statisticsProvider = new OperatorStatisticsProvider(operatorMetadata); } bool audit = AuditEnum.DATAFLOW_OP.GetAudit(statementContext.Annotations) != null; foreach (int producerOpNum in operatorBuildOrder) { String operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint; if (Log.IsDebugEnabled) { Log.Debug("Generating runtime context for " + operatorPrettyPrint); } // determine the number of output streams Object producingOp = operators.Get(producerOpNum); int numOutputStreams = operatorMetadata.Get(producerOpNum).OperatorSpec.Output.Items.Count; IList <ObjectBindingPair>[] targets = GetOperatorConsumersPerStream( numOutputStreams, producerOpNum, operators, operatorMetadata, bindings); EPDataFlowEmitter runtimeContext = GenerateRuntimeContext( statementContext.EngineURI, statementContext.StatementName, audit, dataFlowName, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, targets, options); if (options.IsOperatorStatistics()) { runtimeContext = new EPDataFlowEmitterWrapperWStatistics( runtimeContext, producerOpNum, statisticsProvider, options.IsCpuStatistics()); } TypeHelper.SetFieldForAnnotation(producingOp, typeof(DataFlowContextAttribute), runtimeContext); runtimeContexts.Put(producerOpNum, runtimeContext); } // Second pass: hook punctuation such that it gets forwarded foreach (int producerOpNum in operatorBuildOrder) { String operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint; if (Log.IsDebugEnabled) { Log.Debug("Handling signals for " + operatorPrettyPrint); } // determine consumers that receive punctuation ICollection <int> consumingOperatorsWithPunctuation = new HashSet <int>(); foreach (LogicalChannelBinding binding in bindings) { if (!binding.LogicalChannel.OutputPort.HasPunctuation || binding.LogicalChannel.OutputPort.ProducingOpNum != producerOpNum) { continue; } consumingOperatorsWithPunctuation.Add(binding.LogicalChannel.ConsumingOpNum); } // hook up a listener for each foreach (int consumerPunc in consumingOperatorsWithPunctuation) { EPDataFlowEmitter context = runtimeContexts.Get(consumerPunc); if (context == null) { continue; } dataFlowSignalManager.AddSignalListener( producerOpNum, new ProxyDataFlowSignalListener { ProcSignal = context.SubmitSignal }); } } return(new DataflowStartDesc(statisticsProvider)); }
public static OperatorStatisticsProvider Realize( DataflowDesc dataflow, IDictionary<int, object> operators, IList<LogicalChannelBinding> bindings, DataFlowSignalManager dataFlowSignalManager, EPDataFlowInstantiationOptions options, AgentInstanceContext agentInstanceContext) { IDictionary<int, OperatorMetadataDescriptor> operatorMetadata = dataflow.OperatorMetadata; // First pass: inject runtime context IDictionary<int, EPDataFlowEmitter> runtimeContexts = new Dictionary<int, EPDataFlowEmitter>(); OperatorStatisticsProvider statisticsProvider = null; if (options.IsOperatorStatistics) { statisticsProvider = new OperatorStatisticsProvider(operatorMetadata); } foreach (int producerOpNum in dataflow.OperatorBuildOrder) { var operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint; if (Log.IsDebugEnabled) { Log.Debug("Generating runtime context for " + operatorPrettyPrint); } // determine the number of output streams var producingOp = operators.Get(producerOpNum); var numOutputStreams = operatorMetadata.Get(producerOpNum).NumOutputPorts; var targets = GetOperatorConsumersPerStream( numOutputStreams, producerOpNum, operators, operatorMetadata, bindings); var runtimeContext = GenerateRuntimeContext( agentInstanceContext, dataflow, options.DataFlowInstanceId, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, targets, options); if (options.IsOperatorStatistics) { runtimeContext = new EPDataFlowEmitterWrapperWStatistics( runtimeContext, producerOpNum, statisticsProvider, options.IsCpuStatistics); } TypeHelper.SetFieldForAnnotation(producingOp, typeof(DataFlowContextAttribute), runtimeContext); runtimeContexts.Put(producerOpNum, runtimeContext); } // Second pass: hook punctuation such that it gets forwarded foreach (int producerOpNum in dataflow.OperatorBuildOrder) { var operatorPrettyPrint = operatorMetadata.Get(producerOpNum).OperatorPrettyPrint; if (Log.IsDebugEnabled) { Log.Debug("Handling signals for " + operatorPrettyPrint); } // determine consumers that receive punctuation ISet<int> consumingOperatorsWithPunctuation = new HashSet<int>(); foreach (var binding in bindings) { if (!binding.LogicalChannel.OutputPort.HasPunctuation || binding.LogicalChannel.OutputPort.ProducingOpNum != producerOpNum) { continue; } consumingOperatorsWithPunctuation.Add(binding.LogicalChannel.ConsumingOpNum); } // hook up a listener for each foreach (var consumerPunc in consumingOperatorsWithPunctuation) { var context = runtimeContexts.Get(consumerPunc); if (context == null) { continue; } dataFlowSignalManager.AddSignalListener( producerOpNum, new ProxyDataFlowSignalListener { ProcProcessSignal = signal => context.SubmitSignal(signal) }); } } return statisticsProvider; }
private static EPDataFlowEmitter GenerateRuntimeContext( AgentInstanceContext agentInstanceContext, DataflowDesc dataflow, string instanceId, int producerOpNum, string operatorPrettyPrint, DataFlowSignalManager dataFlowSignalManager, IList<ObjectBindingPair>[] targetsPerStream, EPDataFlowInstantiationOptions options) { // handle no targets if (targetsPerStream == null) { return new EPDataFlowEmitterNoTarget(producerOpNum, dataFlowSignalManager); } var dataflowName = dataflow.DataflowName; var classpathImportService = agentInstanceContext.ImportServiceRuntime; // handle single-stream case if (targetsPerStream.Length == 1) { var targets = targetsPerStream[0]; // handle single-stream single target case if (targets.Count == 1) { var target = targets[0]; return GetSubmitHandler( agentInstanceContext, dataflow.DataflowName, instanceId, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, target, options.ExceptionHandler, classpathImportService); } var handlers = new SubmitHandler[targets.Count]; for (var i = 0; i < handlers.Length; i++) { handlers[i] = GetSubmitHandler( agentInstanceContext, dataflowName, instanceId, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, targets[i], options.ExceptionHandler, classpathImportService); } return new EPDataFlowEmitter1StreamNTarget(producerOpNum, dataFlowSignalManager, handlers); } // handle multi-stream case var handlersPerStream = new SubmitHandler[targetsPerStream.Length][]; for (var streamNum = 0; streamNum < targetsPerStream.Length; streamNum++) { var handlers = new SubmitHandler[targetsPerStream[streamNum].Count]; handlersPerStream[streamNum] = handlers; for (var i = 0; i < handlers.Length; i++) { handlers[i] = GetSubmitHandler( agentInstanceContext, dataflowName, instanceId, producerOpNum, operatorPrettyPrint, dataFlowSignalManager, targetsPerStream[streamNum][i], options.ExceptionHandler, classpathImportService); } } return new EPDataFlowEmitterNStreamNTarget(producerOpNum, dataFlowSignalManager, handlersPerStream); }
public static EPDataFlowInstance Instantiate( IContainer container, int agentInstanceId, DataflowDesc dataflow, EPDataFlowInstantiationOptions options) { var statementContext = dataflow.StatementContext; // allocate agent instance context var @lock = statementContext.StatementAgentInstanceLockFactory.GetStatementLock( statementContext.StatementName, statementContext.Annotations, statementContext.IsStatelessSelect, statementContext.StatementType); var handle = new EPStatementAgentInstanceHandle(statementContext.EpStatementHandle, agentInstanceId, @lock); var auditProvider = statementContext.StatementInformationals.AuditProvider; var instrumentationProvider = statementContext.StatementInformationals.InstrumentationProvider; var agentInstanceContext = new AgentInstanceContext(statementContext, handle, null, null, auditProvider, instrumentationProvider); // assure variables statementContext.VariableManagementService.SetLocalVersion(); // instantiate operators var operators = InstantiateOperators(container, agentInstanceContext, options, dataflow); // determine binding of each channel to input methods (ports) IList<LogicalChannelBinding> operatorChannelBindings = new List<LogicalChannelBinding>(); foreach (var channel in dataflow.LogicalChannels) { var targetClass = operators.Get(channel.ConsumingOpNum).GetType(); var consumingMethod = FindMatchingMethod(channel.ConsumingOpPrettyPrint, targetClass, channel, false); LogicalChannelBindingMethodDesc onSignalMethod = null; if (channel.OutputPort.HasPunctuation) { onSignalMethod = FindMatchingMethod(channel.ConsumingOpPrettyPrint, targetClass, channel, true); } operatorChannelBindings.Add(new LogicalChannelBinding(channel, consumingMethod, onSignalMethod)); } // obtain realization var dataFlowSignalManager = new DataFlowSignalManager(); var statistics = DataflowInstantiatorHelper.Realize( dataflow, operators, operatorChannelBindings, dataFlowSignalManager, options, agentInstanceContext); // For each GraphSource add runnable IList<GraphSourceRunnable> sourceRunnables = new List<GraphSourceRunnable>(); var audit = AuditEnum.DATAFLOW_SOURCE.GetAudit(statementContext.Annotations) != null; foreach (var operatorEntry in operators) { if (!(operatorEntry.Value is DataFlowSourceOperator)) { continue; } var meta = dataflow.OperatorMetadata.Get(operatorEntry.Key); var graphSource = (DataFlowSourceOperator) operatorEntry.Value; var runnable = new GraphSourceRunnable( agentInstanceContext, graphSource, dataflow.DataflowName, options.DataFlowInstanceId, meta.OperatorName, operatorEntry.Key, meta.OperatorPrettyPrint, options.ExceptionHandler, audit); sourceRunnables.Add(runnable); dataFlowSignalManager.AddSignalListener(operatorEntry.Key, runnable); } return new EPDataFlowInstanceImpl( options.DataFlowInstanceUserObject, options.DataFlowInstanceId, statistics, operators, sourceRunnables, dataflow, agentInstanceContext, statistics, options.ParametersURIs); }