public void Update(object sender, UpdateEventArgs e) { _isCalled = true; // create statement for thread - this can be called multiple times as other threads send SupportBean var stmt = _engine.EPAdministrator.CreateEPL( "select * from " + typeof(SupportMarketDataBean).FullName + " where volume=" + _numThread); var listener = new SupportMTUpdateListener(); stmt.Events += listener.Update; var theEvent = new SupportMarketDataBean("", 0, (long)_numThread, null); _engine.EPRuntime.SendEvent(theEvent); stmt.Stop(); var eventsReceived = listener.GetNewDataListFlattened(); var found = false; for (var i = 0; i < eventsReceived.Length; i++) { if (eventsReceived[i].Underlying == theEvent) { found = true; } } Assert.IsTrue(found); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeploy( "@Name('create') create window MyWindow#keepall() as select TheString, LongPrimitive from SupportBean", path); var listenerWindow = new SupportMTUpdateListener(); env.Statement("create").AddListener(listenerWindow); env.CompileDeploy( "insert into MyWindow(TheString, LongPrimitive) select Symbol, Volume from SupportMarketDataBean", path); var stmtTextDelete = "on SupportBean_A as S0 delete from MyWindow as win where win.TheString = S0.Id"; env.CompileDeploy(stmtTextDelete, path); env.CompileDeploy("@Name('s0') select irstream TheString, LongPrimitive from MyWindow", path); var listenerConsumer = new SupportMTUpdateListener(); env.Statement("s0").AddListener(listenerConsumer); try { TrySend(4, 25000, listenerConsumer, listenerWindow, env); } catch (Exception ex) { throw new EPException("Failed: " + ex.Message, ex); } env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); env.CompileDeploy( "insert into XStream " + " select TheString as key, count(*) as mycount\n" + " from SupportBean#time(5 min)" + " group by TheString", path); env.CompileDeploy( "insert into XStream " + " select Symbol as key, count(*) as mycount\n" + " from SupportMarketDataBean#time(5 min)" + " group by Symbol", path); env.CompileDeploy("@Name('s0') select key, mycount from XStream", path); var listener = new SupportMTUpdateListener(); env.Statement("s0").AddListener(listener); TrySend(env, listener, 10, 5000); TrySend(env, listener, 4, 10000); env.UndeployAll(); }
private void TrySendContextCountSimple(int numThreads, int numRepeats) { var listener = new SupportMTUpdateListener(); _engine.EPAdministrator.GetStatement("select").Events += listener.Update; var events = new List <Object>(); for (int i = 0; i < numRepeats; i++) { events.Add(new SupportBean("E" + i, i)); } var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <object> [numThreads]; for (int i = 0; i < numThreads; i++) { var callable = new SendEventCallable(i, _engine, events.GetEnumerator()); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); threadPool.AwaitTermination(TimeSpan.FromSeconds(10)); EventBean[] result = listener.GetNewDataListFlattened(); Assert.AreEqual(numRepeats * numThreads, result.Length); }
public void Update( object sender, UpdateEventArgs eventArgs) { isCalled = true; // create statement for thread - this can be called multiple times as other threads send SupportBean env.Deploy(compiled); var listener = new SupportMTUpdateListener(); env.Statement("t" + numThread).AddListener(listener); object theEvent = new SupportMarketDataBean("", 0, numThread, null); env.SendEventBean(theEvent, theEvent.GetType().Name); env.UndeployModuleContaining("t" + numThread); var eventsReceived = listener.GetNewDataListFlattened(); var found = false; for (var i = 0; i < eventsReceived.Length; i++) { if (eventsReceived[i].Underlying == theEvent) { found = true; } } Assert.IsTrue(found); }
private static void TryCount( RegressionEnvironment env, int numThreads, int numMessages, string epl, GeneratorEnumeratorCallback generatorEnumeratorCallback) { var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtStatelessEnummethod)).ThreadFactory); env.CompileDeploy(epl); var listener = new SupportMTUpdateListener(); env.Statement("s0").AddListener(listener); var future = new IFuture <bool> [numThreads]; for (var i = 0; i < numThreads; i++) { future[i] = threadPool.Submit( new SendEventCallable( i, env.Runtime, new GeneratorEnumerator(numMessages, generatorEnumeratorCallback))); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); Assert.AreEqual(numMessages * numThreads, listener.GetNewDataListFlattened().Length); }
public bool Call() { try { var listener = new SupportMTUpdateListener(); _targetStatement.Events += listener.Update; for (var loop = 0; loop < _numRepeats; loop++) { var generalKey = "Key"; var valueExpected = _threadNum * 1000000000 + loop + 1; // send insert event with string-value NOT specific to thread SendEvent(generalKey, valueExpected); // send subquery trigger event _engine.EPRuntime.SendEvent(new SupportBean(generalKey, -1)); // assert trigger event received var events = listener.NewDataListCopy; var found = false; foreach (var arr in events) { foreach (var item in arr) { var value = item.Get("val").Unwrap <int?>(); foreach (var valueReceived in value) { if (valueReceived == valueExpected) { found = true; break; } } if (found) { break; } } if (found) { break; } } listener.Reset(); if (!found) { return(false); } // send delete event with string-value specific to thread SendEvent(generalKey, valueExpected); } } catch (Exception ex) { Log.Error("Error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return(false); } return(true); }
private void TrySend(EPServiceProvider epService, int numThreads, int numRepeats, int numStatements) { // Create same statement X times var stmt = new EPStatement[numStatements]; var listeners = new SupportMTUpdateListener[stmt.Length]; for (int i = 0; i < stmt.Length; i++) { stmt[i] = epService.EPAdministrator.CreateEPL( " select * " + " from " + typeof(SupportMarketDataBean).FullName + "#groupwin(symbol)#uni(price)"); listeners[i] = new SupportMTUpdateListener(); stmt[i].Events += listeners[i].Update; } var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <bool> [numThreads]; // Start send threads // Each threads sends each symbol with price = 0 to numRepeats long delta = PerformanceObserver.TimeMillis( () => { for (int i = 0; i < numThreads; i++) { var callable = new StmtSharedViewCallable(numRepeats, epService, SYMBOLS); future[i] = threadPool.Submit(callable); } // Shut down threadPool.Shutdown(); threadPool.AwaitTermination(10, TimeUnit.SECONDS); }); for (int i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault()); } Assert.That(delta, Is.LessThan(5000)); // should take less then 5 seconds even for 100 statements as they need to share resources thread-safely // Assert results foreach (SupportMTUpdateListener listener in listeners) { Assert.AreEqual(numRepeats * numThreads * SYMBOLS.Length, listener.NewDataList.Count); EventBean[] newDataLast = listener.NewDataList[listener.NewDataList.Count - 1]; Assert.AreEqual(1, newDataLast.Length); var result = newDataLast[0]; Assert.AreEqual(numRepeats * numThreads, result.Get("datapoints").AsLong()); Assert.IsTrue(Collections.List(SYMBOLS).Contains(result.Get("symbol"))); Assert.AreEqual(SumToN(numRepeats) * numThreads, result.Get("total")); listener.Reset(); } for (int i = 0; i < stmt.Length; i++) { stmt[i].Stop(); } }
private void TrySend(int numThreads, int numRepeats, int numStatements) { // Create same statement X times var stmts = new EPStatement[numStatements]; var listeners = new SupportMTUpdateListener[stmts.Length]; for (int i = 0; i < stmts.Length; i++) { stmts[i] = _engine.EPAdministrator.CreateEPL( " select * " + " from " + typeof(SupportMarketDataBean).FullName + ".std:groupwin(Symbol).stat:uni(Price)"); listeners[i] = new SupportMTUpdateListener(); stmts[i].Events += listeners[i].Update; } // Start send threads // Each threads sends each symbol with price = 0 to numRepeats var startTime = PerformanceObserver.MilliTime; var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <bool> [numThreads]; for (int i = 0; i < numThreads; i++) { var callable = new StmtSharedViewCallable(numRepeats, _engine, SYMBOLS); future[i] = threadPool.Submit(callable); } // Shut down threadPool.Shutdown(); threadPool.AwaitTermination(TimeSpan.FromSeconds(10)); for (int i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault()); } var endTime = PerformanceObserver.MilliTime; var delta = endTime - startTime; Assert.IsTrue(delta < 5000, "delta=" + delta + " not less then 5 sec"); // should take less then 5 seconds even for 100 statements as they need to share resources thread-safely // Assert results foreach (SupportMTUpdateListener listener in listeners) { Assert.AreEqual(numRepeats * numThreads * SYMBOLS.Count, listener.GetNewDataList().Count); EventBean[] newDataLast = listener.GetNewDataList()[listener.GetNewDataList().Count - 1]; Assert.AreEqual(1, newDataLast.Length); EventBean result = newDataLast[0]; Assert.AreEqual(numRepeats * numThreads, result.Get("datapoints").AsLong()); Assert.IsTrue(SYMBOLS.Contains((string)result.Get("Symbol"))); Assert.AreEqual(SumToN(numRepeats) * numThreads, result.Get("total")); listener.Reset(); } foreach (var stmt in stmts) { stmt.Stop(); } }
public bool Call() { try { // Add assertListener var assertListener = new SupportMTUpdateListener(); ThreadLogUtil.Trace("adding listeners ", assertListener); _stmt.Events += assertListener.Update; for (var loop = 0; loop < _numRepeats; loop++) { long id = _threadNum * 100000000 + loop; object eventS0 = MakeEvent("s0", id); object eventS1 = MakeEvent("s1", id); ThreadLogUtil.Trace("SENDING s0 event ", id, eventS0); _engine.EPRuntime.SendEvent(eventS0); ThreadLogUtil.Trace("SENDING s1 event ", id, eventS1); _engine.EPRuntime.SendEvent(eventS1); //ThreadLogUtil.Info("sent", eventS0, eventS1); // Should have received one that's mine, possible multiple since the statement is used by other threads var found = false; var events = assertListener.GetNewDataListFlattened(); foreach (var theEvent in events) { var s0Received = theEvent.Get("s0"); var s1Received = theEvent.Get("s1"); //ThreadLogUtil.Info("received", @event.Get("s0"), @event.Get("s1")); if (s0Received == eventS0 && s1Received == eventS1) { found = true; } } if (!found) { } Assert.IsTrue(found); assertListener.Reset(); } } catch (AssertionException ex) { Log.Error("Assertion error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return false; } catch (Exception ex) { Log.Error("Error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return false; } return true; }
public bool Call() { try { SupportMTUpdateListener listener = new SupportMTUpdateListener(); _targetStatement.Events += listener.Update; for (int loop = 0; loop < _numRepeats; loop++) { String threadKey = "K" + loop + "_" + _threadNum; int valueExpected = _threadNum * 1000000000 + loop + 1; // send insert event with string-value specific to thread SendEvent(threadKey, valueExpected); // send subquery trigger event with string-value specific to thread _engine.EPRuntime.SendEvent(new SupportBean(threadKey, -1)); // assert trigger event received IList <EventBean[]> events = listener.GetNewDataListCopy(); bool found = false; foreach (EventBean[] arr in events) { foreach (EventBean item in arr) { var value = (int?)item.Get("val"); if (value == valueExpected) { found = true; break; } } if (found) { break; } } listener.Reset(); if (!found) { return(false); } // send delete event with string-value specific to thread SendEvent(threadKey, 0); } } catch (Exception ex) { Log.Fatal("Error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return(false); } return(true); }
private void TrySend(EPServiceProvider epService, SupportMTUpdateListener listener, int numThreads, int numRepeats) { var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <bool> [numThreads]; for (int i = 0; i < numThreads; i++) { var callable = new StmtInsertIntoCallable(Convert.ToString(i), epService, numRepeats); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); threadPool.AwaitTermination(10, TimeUnit.SECONDS); for (int i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault()); } // Assert results int totalExpected = numThreads * numRepeats * 2; EventBean[] result = listener.GetNewDataListFlattened(); Assert.AreEqual(totalExpected, result.Length); var results = new LinkedHashMap <long, ISet <string> >(); foreach (EventBean theEvent in result) { long count = (long)theEvent.Get("mycount"); string key = (string)theEvent.Get("key"); ISet <string> entries = results.Get(count); if (entries == null) { entries = new HashSet <string>(); results.Put(count, entries); } entries.Add(key); } Assert.AreEqual(numRepeats, results.Count); foreach (ISet <string> value in results.Values) { Assert.AreEqual(2 * numThreads, value.Count); for (int i = 0; i < numThreads; i++) { Assert.IsTrue(value.Contains("E1_" + i)); Assert.IsTrue(value.Contains("E2_" + i)); } } listener.Reset(); }
private void TrySend(int numThreads, int numEvents, bool isPreserveOrder, ConfigurationEngineDefaults.ThreadingConfig.Locking?locking) { Configuration config = SupportConfigFactory.GetConfiguration(); config.EngineDefaults.Threading.IsListenerDispatchPreserveOrder = isPreserveOrder; config.EngineDefaults.Threading.ListenerDispatchLocking = locking.GetValueOrDefault(); EPServiceProvider engine = EPServiceProviderManager.GetProvider( SupportContainer.Instance, this.GetType().Name, config); engine.Initialize(); // setup statements EPStatement stmtInsert = engine.EPAdministrator.CreateEPL("select count(*) as cnt from " + typeof(SupportBean).FullName); var listener = new SupportMTUpdateListener(); stmtInsert.Events += listener.Update; // execute var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <bool> [numThreads]; for (int i = 0; i < numThreads; i++) { future[i] = threadPool.Submit(new SendEventCallable(i, engine, new GeneratorIterator(numEvents))); } threadPool.Shutdown(); threadPool.AwaitTermination(10, TimeUnit.SECONDS); for (int i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault()); } EventBean[] events = listener.GetNewDataListFlattened(); var result = new long[events.Length]; for (int i = 0; i < events.Length; i++) { result[i] = (long)events[i].Get("cnt"); } //Log.Info(".trySend result=" + CompatExtensions.Render(result)); // assert result Assert.AreEqual(numEvents * numThreads, events.Length); for (int i = 0; i < numEvents * numThreads; i++) { Assert.AreEqual(result[i], (long)i + 1); } engine.Dispose(); }
private void TrySend(EPServiceProvider epService, SupportMTUpdateListener listener, int numThreads, int numRepeats) { // set time to 0 epService.EPRuntime.SendEvent(new CurrentTimeEvent(0)); var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <bool> [numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new SendEventCallable(i, epService, new GeneratorIterator(numRepeats)); future[i] = threadPool.Submit(callable); } // Advance time window every 100 milliseconds for 1 second for (var i = 0; i < 10; i++) { epService.EPRuntime.SendEvent(new CurrentTimeEvent(i * 1000)); Thread.Sleep(100); } threadPool.Shutdown(); threadPool.AwaitTermination(10, TimeUnit.SECONDS); for (var i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault()); } // set time to a large value epService.EPRuntime.SendEvent(new CurrentTimeEvent(10000000000L)); // Assert results var totalExpected = numThreads * numRepeats; // assert new data var resultNewData = listener.GetNewDataListFlattened(); Assert.AreEqual(totalExpected, resultNewData.Length); var resultsNewData = SortPerIntKey(resultNewData); AssertResult(numRepeats, numThreads, resultsNewData); // assert old data var resultOldData = listener.GetOldDataListFlattened(); Assert.AreEqual(totalExpected, resultOldData.Length); var resultsOldData = SortPerIntKey(resultOldData); AssertResult(numRepeats, numThreads, resultsOldData); listener.Reset(); }
private void RunAssertionPatternFollowedBy(ConfigurationEngineDefaults.FilterServiceProfile profile) { Configuration config = SupportConfigFactory.GetConfiguration(); config.AddEventType("S0", typeof(SupportBean_S0)); String engineURI = GetType().Name + "_" + profile; EPServiceProvider epService = EPServiceProviderManager.GetProvider(engineURI, config); epService.Initialize(); String[] epls = { "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=0)->sb=S0(Id=1)) or (sc=S0(Id=1)->sd=S0(Id=0))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=1)->sb=S0(Id=2)) or (sc=S0(Id=2)->sd=S0(Id=1))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=2)->sb=S0(Id=3)) or (sc=S0(Id=3)->sd=S0(Id=2))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=3)->sb=S0(Id=4)) or (sc=S0(Id=4)->sd=S0(Id=3))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=4)->sb=S0(Id=5)) or (sc=S0(Id=5)->sd=S0(Id=4))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=5)->sb=S0(Id=6)) or (sc=S0(Id=6)->sd=S0(Id=5))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=6)->sb=S0(Id=7)) or (sc=S0(Id=7)->sd=S0(Id=6))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=7)->sb=S0(Id=8)) or (sc=S0(Id=8)->sd=S0(Id=7))]", "select sa.Id,sb.Id,sc.Id,sd.Id from pattern [(sa=S0(Id=8)->sb=S0(Id=9)) or (sc=S0(Id=9)->sd=S0(Id=8))]" }; for (int i = 0; i < 100; i++) { var listener = new SupportMTUpdateListener(); var stmts = new EPStatement[epls.Length]; for (int j = 0; j < epls.Length; j++) { stmts[j] = epService.EPAdministrator.CreateEPL(epls[j]); stmts[j].Events += listener.Update; } var threadOneValues = new int[] { 0, 2, 4, 6, 8 }; var threadTwoValues = new int[] { 1, 3, 5, 7, 9 }; var threadArray = new[] { threadOneValues, threadTwoValues }; Parallel.ForEach( threadArray, threadValues => ExecuteSender(epService.EPRuntime, threadValues)); EventBean[] events = listener.GetNewDataListFlattened(); Assert.AreEqual(9, events.Length); for (int j = 0; j < epls.Length; j++) { stmts[j].Dispose(); } } epService.Dispose(); }
private static void TryPattern( RegressionEnvironment env, string pattern, int numThreads, int numEvents) { var sendLock = new object(); var executor = Executors.NewMultiThreadedExecutor(numThreads); // new SupportThreadFactory(typeof(MultithreadStmtPattern)).ThreadFactory); var futures = new List<IFuture<object>>(); var callables = new SendEventWaitCallable[numThreads]; for (var i = 0; i < numThreads; i++) { callables[i] = new SendEventWaitCallable(i, env.Runtime, sendLock, new GeneratorEnumerator(numEvents)); futures.Add(executor.Submit(callables[i])); } var listener = new SupportMTUpdateListener[numEvents]; var epl = "select * from pattern[" + pattern + "]"; var compiled = env.Compile(epl); for (var i = 0; i < numEvents; i++) { var stmtName = "p" + i; env.Deploy(compiled, new DeploymentOptions().WithStatementNameRuntime(ctx => stmtName)); var stmt = env.Statement(stmtName); listener[i] = new SupportMTUpdateListener(); stmt.AddListener(listener[i]); lock (sendLock) { Monitor.PulseAll(sendLock); } } foreach (var callable in callables) { callable.Shutdown(); } lock (sendLock) { Monitor.PulseAll(sendLock); } executor.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(executor, TimeSpan.FromSeconds(10)); for (var i = 0; i < numEvents; i++) { var theEventReceived = listener[i].AssertOneGetNewAndReset(); Assert.NotNull(theEventReceived); var theEventValue = theEventReceived.Get("a"); Assert.NotNull(theEventValue); Assert.IsInstanceOf<SupportBean>(theEventValue); } env.UndeployAll(); }
private static void TrySend( RegressionEnvironment env, int numThreads, int numRepeats) { // set time to 0 env.AdvanceTime(0); var listener = new SupportMTUpdateListener(); env.CompileDeploy( "@Name('s0') select irstream IntPrimitive, TheString as key from SupportBean#time(1 sec)"); env.Statement("s0").AddListener(listener); var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtTimeWindow)).ThreadFactory); var futures = new List<IFuture<bool>>(); for (var i = 0; i < numThreads; i++) { var callable = new SendEventCallable(i, env.Runtime, new GeneratorEnumerator(numRepeats)); futures.Add(threadPool.Submit(callable)); } // Advance time window every 100 milliseconds for 1 second for (var i = 0; i < 10; i++) { env.AdvanceTime(i * 1000); SupportCompileDeployUtil.ThreadSleep(100); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(futures); // set time to a large value env.AdvanceTime(10000000000L); // Assert results var totalExpected = numThreads * numRepeats; // assert new data var resultNewData = listener.GetNewDataListFlattened(); Assert.AreEqual(totalExpected, resultNewData.Length); var resultsNewData = SortPerIntKey(resultNewData); AssertResult(numRepeats, numThreads, resultsNewData); // assert old data var resultOldData = listener.GetOldDataListFlattened(); Assert.AreEqual(totalExpected, resultOldData.Length); var resultsOldData = SortPerIntKey(resultOldData); AssertResult(numRepeats, numThreads, resultsOldData); env.UndeployAll(); }
public bool Call() { try { // Add assertListener var assertListener = new SupportMTUpdateListener(); ThreadLogUtil.Trace("adding listeners ", assertListener); _stmt.Events += assertListener.Update; for (var loop = 0; loop < _numRepeats; loop++) { var intPrimitive = loop % 10 + 1; object eventS0 = MakeEvent(intPrimitive); _engine.EPRuntime.SendEvent(eventS0); // Should have received one that's mine, possible multiple since the statement is used by other threads var found = false; var events = assertListener.GetNewDataListFlattened(); foreach (var theEvent in events) { var s0Received = theEvent.Get("s0"); var s1Received = (IDictionary<string, object>) theEvent.Get("s1"); if (s0Received == eventS0 || s1Received.Get("myvarchar").Equals(_myvarcharValues[intPrimitive - 1])) { found = true; } } if (!found) { } Assert.IsTrue(found); assertListener.Reset(); } } catch (AssertionException ex) { Log.Error("Assertion error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return false; } catch (Exception ex) { Log.Error("Error in thread " + Thread.CurrentThread.ManagedThreadId, ex); return false; } return true; }
private void TrySend(EPServiceProvider epService, SupportMTUpdateListener listenerWindow, int numThreads, int numRepeats, int numConsumers) { var listenerConsumers = new SupportMTUpdateListener[numConsumers]; for (int i = 0; i < listenerConsumers.Length; i++) { EPStatement stmtConsumer = epService.EPAdministrator.CreateEPL("select TheString, LongPrimitive from MyWindow"); listenerConsumers[i] = new SupportMTUpdateListener(); stmtConsumer.Events += listenerConsumers[i].Update; } var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <IList <string> > [numThreads]; for (int i = 0; i < numThreads; i++) { var callable = new StmtNamedWindowConsumeCallable(Convert.ToString(i), epService, numRepeats); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); threadPool.AwaitTermination(10, TimeUnit.SECONDS); // compute list of expected var expectedIdsList = new List <string>(); for (int i = 0; i < numThreads; i++) { expectedIdsList.AddAll(future[i].GetValueOrDefault()); } string[] expectedIds = expectedIdsList.ToArray(); Assert.AreEqual(numThreads * numRepeats, listenerWindow.NewDataList.Count); // old and new each // compute list of received for (int i = 0; i < listenerConsumers.Length; i++) { EventBean[] newEvents = listenerConsumers[i].GetNewDataListFlattened(); var receivedIds = new string[newEvents.Length]; for (int j = 0; j < newEvents.Length; j++) { receivedIds[j] = (string)newEvents[j].Get("TheString"); } Assert.AreEqual(receivedIds.Length, expectedIds.Length); Array.Sort(receivedIds); Array.Sort(expectedIds); CompatExtensions.DeepEquals(expectedIds, receivedIds); } }
private static void TrySend( int numThreads, int numEvents, bool isPreserveOrder, Locking locking, Configuration configuration) { configuration.Runtime.Threading.IsListenerDispatchPreserveOrder = isPreserveOrder; configuration.Runtime.Threading.ListenerDispatchLocking = locking; configuration.Common.AddEventType(typeof(SupportBean)); var runtime = EPRuntimeProvider.GetRuntime(typeof(MultithreadDeterminismListener).Name, configuration); runtime.Initialize(); // setup statements var deployed = SupportCompileDeployUtil.CompileDeploy( "@Name('s0') select count(*) as cnt from SupportBean", runtime, configuration); var listener = new SupportMTUpdateListener(); deployed.Statements[0].AddListener(listener); // execute var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadDeterminismListener)).ThreadFactory); var future = new IFuture<bool>[numThreads]; for (var i = 0; i < numThreads; i++) { future[i] = threadPool.Submit(new SendEventCallable(i, runtime, new GeneratorEnumerator(numEvents))); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); var events = listener.GetNewDataListFlattened(); var result = new long[events.Length]; for (var i = 0; i < events.Length; i++) { result[i] = events[i].Get("cnt").AsInt64(); } //log.info(".trySend result=" + Arrays.toString(result)); // assert result Assert.AreEqual(numEvents * numThreads, events.Length); for (var i = 0; i < numEvents * numThreads; i++) { Assert.AreEqual(result[i], (long) i + 1); } runtime.Destroy(); }
private void TrySend(int numThreads, int numEvents, bool isPreserveOrder, ConfigurationEngineDefaults.Threading.Locking?locking) { var config = SupportConfigFactory.GetConfiguration(); config.EngineDefaults.ThreadingConfig.IsListenerDispatchPreserveOrder = isPreserveOrder; config.EngineDefaults.ThreadingConfig.ListenerDispatchLocking = locking.GetValueOrDefault(); _engine = EPServiceProviderManager.GetDefaultProvider(config); _engine.Initialize(); // setup statements var stmtInsert = _engine.EPAdministrator.CreateEPL("select count(*) as cnt from " + typeof(SupportBean).FullName); var listener = new SupportMTUpdateListener(); stmtInsert.Events += listener.Update; // execute var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <object> [numThreads]; for (var i = 0; i < numThreads; i++) { future[i] = threadPool.Submit(new SendEventCallable(i, _engine, EnumerationGenerator.Create(numEvents))); } threadPool.Shutdown(); threadPool.AwaitTermination(new TimeSpan(0, 0, 10)); for (var i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault().AsBoolean()); } var events = listener.GetNewDataListFlattened(); var result = new long[events.Length]; for (var i = 0; i < events.Length; i++) { result[i] = (long)events[i].Get("cnt"); } //Log.Info(".trySend result=" + CompatExtensions.Render(result)); // assert result Assert.AreEqual(numEvents * numThreads, events.Length); for (var i = 0; i < numEvents * numThreads; i++) { Assert.AreEqual(result[i], (long)i + 1); } }
public void Run(RegressionEnvironment env) { var listenerSetOne = new SupportMTUpdateListener(); var listenerSetTwo = new SupportMTUpdateListener(); var stmtSetOneText = "@Name('setOne') on SupportBean set var1=LongPrimitive, var2=LongPrimitive, var3=var3+1"; var stmtSetTwoText = "@Name('setTwo')on SupportMarketDataBean set var1=Volume, var2=Volume, var3=var3+1"; env.CompileDeploy(stmtSetOneText).Statement("setOne").AddListener(listenerSetOne); env.CompileDeploy(stmtSetTwoText).Statement("setTwo").AddListener(listenerSetTwo); TrySetAndReadAtomic(env, listenerSetOne, listenerSetTwo, 2, 10000); env.UndeployAll(); }
public void TestTimeWin() { EPStatement stmt = _engine.EPAdministrator.CreateEPL( " select irstream IntPrimitive, TheString as key " + " from " + typeof(SupportBean).FullName + ".win:time(1 sec)"); _listener = new SupportMTUpdateListener(); stmt.Events += _listener.Update; TrySend(10, 5000); TrySend(6, 2000); TrySend(2, 10000); TrySend(3, 5000); TrySend(5, 2500); }
private static void TrySend( RegressionEnvironment env, SupportMTUpdateListener listenerWindow, SupportMTUpdateListener listenerConsumer, int numThreads, int numRepeats) { var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtNamedWindowDelete)).ThreadFactory); var future = new IFuture<object>[numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new StmtNamedWindowDeleteCallable(Convert.ToString(i), env.Runtime, numRepeats); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); // compute list of expected IList<string> expectedIdsList = new List<string>(); for (var i = 0; i < numThreads; i++) { try { expectedIdsList.AddAll((IList<string>) future[i].Get()); } catch (Exception t) { throw new EPException(t); } } var expectedIds = expectedIdsList.ToArray(); Assert.AreEqual(2 * numThreads * numRepeats, listenerWindow.NewDataList.Count); // old and new each Assert.AreEqual(2 * numThreads * numRepeats, listenerConsumer.NewDataList.Count); // old and new each // compute list of received var newEvents = listenerWindow.GetNewDataListFlattened(); var receivedIds = new string[newEvents.Length]; for (var i = 0; i < newEvents.Length; i++) { receivedIds[i] = (string) newEvents[i].Get("TheString"); } Assert.AreEqual(receivedIds.Length, expectedIds.Length); Array.Sort(receivedIds); Array.Sort(expectedIds); CompatExtensions.DeepEqualsWithType(expectedIds, receivedIds); }
private static void TrySend( RegressionEnvironment env, SupportMTUpdateListener listener, int numThreads, int numRepeats) { var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtInsertInto)).ThreadFactory); var future = new IFuture<object>[numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new StmtInsertIntoCallable(Convert.ToString(i), env.Runtime, numRepeats); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); // Assert results var totalExpected = numThreads * numRepeats * 2; var result = listener.GetNewDataListFlattened(); Assert.AreEqual(totalExpected, result.Length); IDictionary<long, ICollection<string>> results = new Dictionary<long, ICollection<string>>(); foreach (var theEvent in result) { var count = theEvent.Get("mycount").AsInt64(); var key = (string) theEvent.Get("key"); var entries = results.Get(count); if (entries == null) { entries = new HashSet<string>(); results.Put(count, entries); } entries.Add(key); } Assert.AreEqual(numRepeats, results.Count); foreach (var value in results.Values) { Assert.AreEqual(2 * numThreads, value.Count); for (var i = 0; i < numThreads; i++) { Assert.IsTrue(value.Contains("E1_" + i)); Assert.IsTrue(value.Contains("E2_" + i)); } } listener.Reset(); }
private static void TryListener( RegressionEnvironment env, int numThreads, int numRoutes) { env.CompileDeploy("@Name('trigger') select * from SupportBean"); env.CompileDeploy("@Name('s0') select * from SupportMarketDataBean"); var listener = new SupportMTUpdateListener(); env.Statement("s0").AddListener(listener); // Set of events routed by each listener ISet<SupportMarketDataBean> routed = new HashSet<SupportMarketDataBean>().AsSyncSet(); var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtListenerRoute)).ThreadFactory); var future = new IFuture<object>[numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new StmtListenerCreateStmtCallable( i, env.Runtime, env.Statement("trigger"), numRoutes, routed); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); // assert var results = listener.GetNewDataListFlattened(); Assert.IsTrue(results.Length >= numThreads * numRoutes); foreach (var routedEvent in routed) { var found = false; for (var i = 0; i < results.Length; i++) { if (results[i].Underlying == routedEvent) { found = true; } } Assert.IsTrue(found); } env.UndeployAll(); }
private void TryListener(EPServiceProvider epService, int numThreads, int numRoutes) { EPStatement stmtTrigger = epService.EPAdministrator.CreateEPL( " select * from " + typeof(SupportBean).FullName); EPStatement stmtListen = epService.EPAdministrator.CreateEPL( " select * from " + typeof(SupportMarketDataBean).FullName); var listener = new SupportMTUpdateListener(); stmtListen.Events += listener.Update; // Set of events routed by each listener var routed = CompatExtensions.AsSyncSet(new HashSet <SupportMarketDataBean>()); var threadPool = Executors.NewFixedThreadPool(numThreads); var future = new Future <bool> [numThreads]; for (int i = 0; i < numThreads; i++) { var callable = new StmtListenerCreateStmtCallable(i, epService, stmtTrigger, numRoutes, routed); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); threadPool.AwaitTermination(10, TimeUnit.SECONDS); for (int i = 0; i < numThreads; i++) { Assert.IsTrue(future[i].GetValueOrDefault()); } // assert EventBean[] results = listener.GetNewDataListFlattened(); Assert.IsTrue(results.Length >= numThreads * numRoutes); foreach (SupportMarketDataBean routedEvent in routed) { bool found = false; for (int i = 0; i < results.Length; i++) { if (results[i].Underlying == routedEvent) { found = true; } } Assert.IsTrue(found); } }
public override void Run(EPServiceProvider epService) { var stmt = epService.EPAdministrator.CreateEPL( " select irstream IntPrimitive, TheString as key " + " from " + typeof(SupportBean).FullName + "#time(1 sec)"); var listener = new SupportMTUpdateListener(); stmt.Events += listener.Update; TrySend(epService, listener, 10, 5000); TrySend(epService, listener, 6, 2000); TrySend(epService, listener, 2, 10000); TrySend(epService, listener, 3, 5000); TrySend(epService, listener, 5, 2500); }
private static void TrySendContextCountSimple( RegressionEnvironment env, int numThreads, int numRepeats) { var listener = new SupportMTUpdateListener(); env.Statement("select").AddListener(listener); IList<object>[] eventsPerThread = new List<object>[numThreads]; for (var t = 0; t < numThreads; t++) { eventsPerThread[t] = new List<object>(); for (var i = 0; i < numRepeats; i++) { eventsPerThread[t].Add(new SupportBean_S0(-1, "E" + i, i + "_" + t)); } } var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadContextCountSimple)).ThreadFactory); var future = new IFuture<bool>[numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new SendEventCallable(i, env.Runtime, eventsPerThread[i].GetEnumerator()); future[i] = threadPool.Submit(callable); } SupportCompileDeployUtil.ThreadSleep(2000); threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); var result = listener.GetNewDataListFlattened(); ISet<string> received = new HashSet<string>(); foreach (var @event in result) { var key = (string) @event.Get("P01"); if (received.Contains(key)) { Assert.Fail("key " + key + " received multiple times"); } received.Add(key); } if (received.Count != numRepeats * numThreads) { log.Info("Received are " + received.Count + " entries"); Assert.Fail(); } }
public override void Run(EPServiceProvider epService) { epService.EPAdministrator.Configuration.AddVariable("var1", typeof(long), 0); epService.EPAdministrator.Configuration.AddVariable("var2", typeof(long), 0); epService.EPAdministrator.Configuration.AddVariable("var3", typeof(long), 0); var listenerSetOne = new SupportMTUpdateListener(); var listenerSetTwo = new SupportMTUpdateListener(); string stmtSetOneText = "on " + typeof(SupportBean).FullName + " set var1=LongPrimitive, var2=LongPrimitive, var3=var3+1"; string stmtSetTwoText = "on " + typeof(SupportMarketDataBean).FullName + " set var1=volume, var2=volume, var3=var3+1"; epService.EPAdministrator.CreateEPL(stmtSetOneText).Events += listenerSetOne.Update; epService.EPAdministrator.CreateEPL(stmtSetTwoText).Events += listenerSetTwo.Update; TrySetAndReadAtomic(epService, listenerSetOne, listenerSetTwo, 2, 10000); }