public EventBusSource( ILockManager lockManager, IThreadLocalManager threadLocalManager) { _iLock = lockManager.CreateLock(GetType()); _collectorDataTL = threadLocalManager.Create <EPDataFlowEventBeanCollectorContext>(() => null); }
public EmitterCollectorUpdateListener(EPDataFlowIRStreamCollector collector, LocalEmitter emitterForCollector, IThreadLocal <EPDataFlowIRStreamCollectorContext> collectorDataTL, bool submitEventBean) { _collector = collector; _emitterForCollector = emitterForCollector; _collectorDataTL = collectorDataTL; _submitEventBean = submitEventBean; }
public EPStatementSource( ILockManager lockManager, IThreadLocalManager threadLocalManager) { _iLock = lockManager.CreateLock(MethodBase.GetCurrentMethod().DeclaringType); _collectorDataTL = threadLocalManager.Create <EPDataFlowIRStreamCollectorContext>(() => null); _lifeCycleEventHandler = Observe; }
public ExpressionResultCacheService( int declareExprCacheSize, IThreadLocalManager threadLocalManager) { _declareExprCacheSize = declareExprCacheSize; _threadCache = threadLocalManager.Create( () => new ExpressionResultCacheServiceHolder(declareExprCacheSize)); }
public ExprConcatNodeEvalThreadLocal( ExprConcatNode parent, ExprEvaluator[] evaluators, IThreadLocalManager threadLocalManager) { _parent = parent; _evaluators = evaluators; _localBuffer = threadLocalManager.Create <StringBuilder>(() => new StringBuilder()); }
/// <summary> /// Ctor. /// </summary> /// <param name="statementResultService">handles result delivery</param> /// <param name="dispatchService">for performing the dispatch</param> /// <param name="threadLocalManager">The thread local manager.</param> protected UpdateDispatchViewBase( StatementResultService statementResultService, DispatchService dispatchService, IThreadLocalManager threadLocalManager) { _isDispatchWaiting = threadLocalManager.Create(() => new Mutable <bool>()); DispatchService = dispatchService; StatementResultService = statementResultService; }
public ThreadLocal(Func <T> valueFactory, bool trackAllValues) { if (valueFactory == null) { throw new ArgumentNullException(nameof(valueFactory)); } _wrapped = trackAllValues ? (IThreadLocal <T>) new TrackingThreadLocal <T>(valueFactory) : new NoTrackingThreadLocal <T>(valueFactory); }
/// <summary> /// Initializes a new instance of the <see cref="VariableVersionThreadLocal"/> class. /// </summary> /// <param name="threadLocalManager">The thread local manager.</param> public VariableVersionThreadLocal(IThreadLocalManager threadLocalManager) { if (threadLocalManager != null) { _vThreadLocal = threadLocalManager.Create(CreateEntry); } else { _vThreadLocal = null; } }
public StatementResultServiceImpl( StatementInformationalsRuntime statementInformationals, EPServicesContext epServicesContext) { StatementDispatchTl = new SlimThreadLocal<StatementDispatchTLEntry>(() => new StatementDispatchTLEntry()); _statementInformationals = statementInformationals; _epServicesContext = epServicesContext; _outboundThreading = epServicesContext.ThreadingService.IsOutboundThreading; IsMakeSynthetic = statementInformationals.IsAlwaysSynthesizeOutputEvents; }
public ExprConcatNodeEvalThreadLocal( ExprConcatNode parent, ExprEvaluator[] evaluators) { localBuffer = new SystemThreadLocal<StringBuilder>(() => new StringBuilder()); buffer = localBuffer.GetOrCreate(); this.parent = parent; this.evaluators = evaluators; buffer = localBuffer.GetOrCreate(); }
private void Dispose(bool disposeManagedResources) { if (disposeManagedResources) { if (Interlocked.CompareExchange(ref _disposing, 1, 0) == 0) { _wrapped.Dispose(); _wrapped = null; } } }
public ExprNodeAdapterMultiStream(int filterSpecId, int filterSpecParamPathNum, ExprNode exprNode, ExprEvaluatorContext evaluatorContext, VariableService variableService, EventBean[] prototype) : base(filterSpecId, filterSpecParamPathNum, exprNode, evaluatorContext, variableService) { _prototypeArray = prototype; _arrayPerThread = ThreadLocalManager.Create( () => { var eventsPerStream = new EventBean[_prototypeArray.Length]; Array.Copy(_prototypeArray, 0, eventsPerStream, 0, _prototypeArray.Length); return(eventsPerStream); }); }
/// <summary>Ctor. </summary> /// <param name="svc">isolated services</param> /// <param name="unisolatedSvc">engine services</param> public EPRuntimeIsolatedImpl(EPIsolationUnitServices svc, EPServicesContext unisolatedSvc) { _services = svc; _unisolatedServices = unisolatedSvc; _threadWorkQueue = new ThreadWorkQueue(); _isSubselectPreeval = unisolatedSvc.EngineSettingsService.EngineSettings.Expression.IsSelfSubselectPreeval; _isPrioritized = unisolatedSvc.EngineSettingsService.EngineSettings.Execution.IsPrioritized; _isLatchStatementInsertStream = unisolatedSvc.EngineSettingsService.EngineSettings.Threading.IsInsertIntoDispatchPreserveOrder; _threadLocalData = ThreadLocalManager.Create(CreateLocalData); }
/// <summary> /// Dispatches when the statement is stopped any remaining results. /// </summary> public void DispatchOnStop() { var dispatches = _lastResults.GetOrCreate(); if (dispatches.IsEmpty()) { return; } Execute(); _lastResults = ThreadLocalManager.Create( () => new LinkedList <UniformPair <EventBean[]> >()); }
public MethodPollingViewable( MethodStreamSpec methodStreamSpec, DataCache dataCache, EventType eventType, ExprEvaluatorContext exprEvaluatorContext, MethodPollingViewableMeta metadata, IThreadLocalManager threadLocalManager) { _methodStreamSpec = methodStreamSpec; _dataCacheThreadLocal = threadLocalManager.Create <DataCache>(() => null); _dataCache = dataCache; _eventType = eventType; _exprEvaluatorContext = exprEvaluatorContext; _metadata = metadata; }
private void Dispose(bool disposeManagedResources) { if (!disposeManagedResources) { return; } if (Interlocked.CompareExchange(ref _disposing, 1, 0) != 0) { return; } _wrapped?.Dispose(); _wrapped = null; }
/// <summary> /// Ctor. /// </summary> /// <param name="myStreamNumber">is the stream number of the view</param> /// <param name="inputParameters">are the event property names providing input parameter keys</param> /// <param name="pollExecStrategy">is the strategy to use for retrieving results</param> /// <param name="dataCache">is looked up before using the strategy</param> /// <param name="eventType">is the type of events generated by the view</param> /// <param name="threadLocalManager">The thread local manager.</param> public DatabasePollingViewable( int myStreamNumber, IList <String> inputParameters, PollExecStrategy pollExecStrategy, DataCache dataCache, EventType eventType, IThreadLocalManager threadLocalManager) { _dataCacheThreadLocal = threadLocalManager.Create <DataCache>(() => null); _myStreamNumber = myStreamNumber; _inputParameters = inputParameters; _pollExecStrategy = pollExecStrategy; _dataCache = dataCache; _eventType = eventType; }
public ThreadLocal(Func <T> valueFactory, bool trackAllValues) { if (valueFactory == null) { throw new ArgumentNullException("valueFactory"); } if (trackAllValues) { _wrapped = new TrackingThreadLocal <T>(valueFactory); } else { _wrapped = new NoTrackingThreadLocal <T>(valueFactory); } }
public ExprNodeAdapterMSPlain( FilterSpecParamExprNode factory, ExprEvaluatorContext evaluatorContext, EventBean[] prototype, VariableManagementService variableService) : base(factory, evaluatorContext, prototype) { _variableService = variableService; _arrayPerThread = new SlimThreadLocal<EventBean[]>( () => { var eventsPerStream = new EventBean[prototypeArray.Length]; Array.Copy(prototypeArray, 0, eventsPerStream, 0, prototypeArray.Length); return eventsPerStream; }); }
/// <summary> /// Ctor. /// </summary> /// <param name="exprNode">is the bool expression</param> /// <param name="prototype">is the row of events the we are matching on</param> /// <param name="variableService">for setting variable version for evaluating variables, if required</param> public ExprNodeAdapter(ExprNode exprNode, EventBean[] prototype, VariableService variableService) { _exprNode = exprNode; _exprNodeEval = exprNode.ExprEvaluator; _variableService = variableService; _arrayPerThread = ThreadLocalManager.Create <EventBean[]>(CreateLocalData); if (prototype == null) { _prototype = new EventBean[1]; } else { _prototype = prototype; } }
/// <summary> /// Ctor. /// </summary> /// <param name="statementName">Name of the statement.</param> /// <param name="statementLifecycleSvc">handles persistence for statements</param> /// <param name="metricReportingService">for metrics reporting</param> /// <param name="threadingService">for outbound threading</param> /// <param name="threadLocalManager">The thread local manager.</param> public StatementResultServiceImpl( String statementName, StatementLifecycleSvc statementLifecycleSvc, MetricReportingServiceSPI metricReportingService, ThreadingService threadingService, IThreadLocalManager threadLocalManager) { Log.Debug(".ctor"); _threadLocalManager = threadLocalManager; _lastResults = threadLocalManager.Create(() => new LinkedList <UniformPair <EventBean[]> >()); _isDebugEnabled = ExecutionPathDebugLog.IsEnabled && Log.IsDebugEnabled; _statementName = statementName; _statementLifecycleSvc = statementLifecycleSvc; _metricReportingService = metricReportingService; _statementOutputHooks = metricReportingService != null ? metricReportingService.StatementOutputHooks : new List <StatementResultListener>(); _threadingService = threadingService; }
/// <summary> /// Ctor. /// </summary> /// <param name="schedulingService">The scheduling service.</param> /// <param name="variableService">is for variable access</param> /// <param name="tableService">The table service.</param> /// <param name="isPrioritized">if the engine is running with prioritized execution</param> /// <param name="eventProcessingRWLock">The event processing rw lock.</param> /// <param name="exceptionHandlingService">The exception handling service.</param> /// <param name="metricReportingService">The metric reporting service.</param> /// <param name="threadLocalManager">The thread local manager.</param> public NamedWindowDispatchServiceImpl( SchedulingService schedulingService, VariableService variableService, TableService tableService, bool isPrioritized, IReaderWriterLock eventProcessingRWLock, ExceptionHandlingService exceptionHandlingService, MetricReportingService metricReportingService, IThreadLocalManager threadLocalManager) { _threadLocal = threadLocalManager.Create <DispatchesTL>(() => new DispatchesTL()); _schedulingService = schedulingService; _variableService = variableService; _tableService = tableService; _isPrioritized = isPrioritized; _eventProcessingRwLock = eventProcessingRWLock; _exceptionHandlingService = exceptionHandlingService; _metricReportingService = metricReportingService; }
public TableExprEvaluatorContext(IThreadLocalManager threadLocalManager) { _threadLocal = threadLocalManager.Create <IDictionary <ILockable, IDisposable> >( () => new Dictionary <ILockable, IDisposable>()); }
/// <summary> /// Dispose for destroying an engine instance: sets references to null and clears thread-locals /// </summary> public void Dispose() { _services = null; _threadLocalData = null; }
/// <summary> /// Initializes a new instance of the <see cref="ThreadWorkQueue"/> class. /// </summary> public ThreadWorkQueue(IThreadLocalManager threadLocalManager) { _threadQueue = threadLocalManager.Create( () => new DualWorkQueue <object>()); }
public EventBusSink(IThreadLocalManager threadLocalManager) { _collectorDataTL = threadLocalManager.Create <EPDataFlowEventCollectorContext>(() => null); }
/// <summary> /// Ctor. /// </summary> public VariableVersionThreadLocal() { _vThreadLocal = ThreadLocalManager.Create <VariableVersionThreadEntry>(CreateEntry); }
static MultiMatchHandlerNoSubqueryWDedup() { Dedups = (new FastThreadLocalFactory()) .CreateThreadLocal(() => new LinkedHashSet <FilterHandleCallback>()); }
public void Init() { _threadCache = ThreadLocalManager.Create( () => new ExpressionResultCacheServiceAgentInstance()); }
/// <summary> /// Initializes a new instance of the <see cref="DispatchServiceImpl"/> class. /// </summary> public DispatchServiceImpl() { _threadDispatchQueue = ThreadLocalManager.Create( () => new Queue <Dispatchable>()); }