public void Run(Configuration configuration) { idCounter = new AtomicLong(0); executorService = Executors.NewCachedThreadPool(); noActionUpdateListener = new NoActionUpdateListener(); configuration.Runtime.Threading.IsInternalTimerEnabled = true; configuration.Common.AddEventType(typeof(SupportBean)); configuration.Runtime.Threading.InsertIntoDispatchLocking = Locking.SUSPEND; var runtime = EPRuntimeProvider.GetRuntime(GetType().Name, configuration); runtime.Initialize(); epRuntime = runtime.EventService; var path = new RegressionPath(); var epl = "insert into Stream1 select count(*) as cnt from SupportBean#time(7 sec)"; var compiled = SupportCompileDeployUtil.Compile(epl, configuration, path); path.Add(compiled); SupportCompileDeployUtil.Deploy(compiled, runtime); epl = epl + " output every 10 seconds"; compiled = SupportCompileDeployUtil.Compile(epl, configuration, path); SupportCompileDeployUtil.DeployAddListener(compiled, "insert", noActionUpdateListener, runtime); var sendTickEventRunnable = new SendEventRunnable(this, 10000); Start(sendTickEventRunnable, 4); // Adjust here for long-running test SupportCompileDeployUtil.ThreadSleep(3000); sendTickEventRunnable.Shutdown = true; executorService.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(executorService, 1, TimeUnit.SECONDS); runtime.Destroy(); }
private static void TrySend( RegressionEnvironment env, int numThreads, int numRepeats) { var compiled = env.Compile("@Name('upd') update istream SupportBean set TheString='a'"); var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadUpdate)).ThreadFactory); var future = new IFuture<object>[numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new StmtUpdateSendCallable(i, env.Runtime, numRepeats); future[i] = threadPool.Submit(callable); } for (var i = 0; i < 50; i++) { env.Deploy(compiled); SupportCompileDeployUtil.ThreadSleep(10); env.UndeployModuleContaining("upd"); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 5, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); }
public void Run(RegressionEnvironment env) { var statementTwo = "select * from pattern[( every event1=SupportTradeEvent(UserId in ('100','101')) ->\n" + " (SupportTradeEvent(UserId in ('100','101'), Direction = event1.Direction ) ->\n" + " SupportTradeEvent(UserId in ('100','101'), Direction = event1.Direction )\n" + " ) where timer:within(8 hours)\n" + " and not eventNC=SupportTradeEvent(UserId in ('100','101'), Direction!= event1.Direction )\n" + " ) -> eventFinal=SupportTradeEvent(UserId in ('100','101'), Direction != event1.Direction ) where timer:within(1 hour)]"; var compiledTwo = env.Compile(statementTwo); var runnable = new TwoPatternRunnable(env); var t = new Thread(runnable.Run); t.Name = typeof(MultithreadStmtTwoPatterns).Name; t.Start(); SupportCompileDeployUtil.ThreadSleep(100); // Create a second pattern, wait 500 msec, destroy second pattern in a loop var numRepeats = env.IsHA ? 1 : 10; for (var i = 0; i < numRepeats; i++) { try { var deployed = env.Deployment.Deploy(compiledTwo); SupportCompileDeployUtil.ThreadSleep(200); env.Undeploy(deployed.DeploymentId); } catch (Exception ex) { throw new EPException(ex); } } runnable.Shutdown = true; SupportCompileDeployUtil.ThreadSleep(1000); Assert.IsFalse(t.IsAlive); env.UndeployAll(); }
public void Run(RegressionEnvironment env) { var path = new RegressionPath(); var eplStatement = "create context MyContext start PayloadEvent end after 0.5 seconds"; env.CompileDeploy(eplStatement, path); var aggStatement = "@Name('select') context MyContext " + "select count(*) as theCount " + "from PayloadEvent " + "output snapshot when terminated"; env.CompileDeploy(aggStatement, path); var listener = new MyListener(); env.Statement("select").AddListener(listener); // start thread long numEvents = 10000000; var myRunnable = new MyRunnable(env.Runtime, numEvents); var thread = new Thread(myRunnable.Run); thread.Name = typeof(MultithreadContextStartedBySameEvent).Name; thread.Start(); SupportCompileDeployUtil.ThreadJoin(thread); SupportCompileDeployUtil.ThreadSleep(1000); // assert Assert.IsNull(myRunnable.exception); Assert.AreEqual(numEvents, listener.total); 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 void Run() { long time = 1000; long numAdvances = 0; try { while (latch.Get() && (maxNumAdvances == -1 || numAdvances < maxNumAdvances)) { env.AdvanceTime(time); numAdvances++; time += 1000; SupportCompileDeployUtil.ThreadSleep((int) threadSleepTime); } } catch (Exception ex) { log.Error("Error while processing", ex); } }
private void RunAssertion( FilterServiceProfile profile, Configuration configuration) { configuration.Runtime.Execution.FilterServiceProfile = profile; configuration.Common.AddEventType(typeof(MyEvent)); var runtimeURI = GetType().Name + "_" + profile; var runtime = EPRuntimeProvider.GetRuntime(runtimeURI, configuration); var path = new RegressionPath(); var eplContext = "create context MyContext start @now end after 100 milliseconds;\n"; var compiledContext = SupportCompileDeployUtil.Compile(eplContext, configuration, path); SupportCompileDeployUtil.Deploy(compiledContext, runtime); path.Add(compiledContext); var epl = "context MyContext select FieldOne, count(*) as cnt from MyEvent " + "group by FieldOne output last when terminated;\n"; var compiledStmt = SupportCompileDeployUtil.Compile(epl, configuration, path); var listeners = new SupportUpdateListener[100]; for (var i = 0; i < 100; i++) { listeners[i] = new SupportUpdateListener(); var stmtName = "s" + i; SupportCompileDeployUtil.DeployAddListener(compiledStmt, stmtName, listeners[i], runtime); } var eventCount = 100000; // keep this divisible by 1000 for (var i = 0; i < eventCount; i++) { var group = Convert.ToString(eventCount % 1000); runtime.EventService.SendEventBean(new MyEvent(Convert.ToString(i), group), "MyEvent"); } SupportCompileDeployUtil.ThreadSleep(2000); AssertReceived(eventCount, listeners); try { runtime.DeploymentService.UndeployAll(); } catch (EPUndeployException e) { throw new EPException(e); } runtime.Destroy(); }
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(); } }
private static void TryChainedCountSum( RegressionEnvironment env, int numThreads, int numEvents) { // setup statements var path = new RegressionPath(); env.CompileDeploy("insert into MyStreamOne select count(*) as cnt from SupportBean", path); env.CompileDeploy("@Name('s0') insert into MyStreamTwo select sum(cnt) as mysum from MyStreamOne", path); var listener = new SupportUpdateListener(); env.Statement("s0").AddListener(listener); // execute var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadDeterminismInsertInto)).ThreadFactory); var future = new IFuture<object>[numThreads]; IReaderWriterLock sharedStartLock = new SlimReaderWriterLock(); using (sharedStartLock.WriteLock.Acquire()) { for (var i = 0; i < numThreads; i++) { future[i] = threadPool.Submit( new SendEventRWLockCallable( i, sharedStartLock, env.Runtime, new GeneratorEnumerator(numEvents))); } SupportCompileDeployUtil.ThreadSleep(100); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); // assert result var newEvents = listener.NewDataListFlattened; for (var i = 0; i < numEvents - 1; i++) { var expected = Total(i + 1); Assert.AreEqual(expected, newEvents[i].Get("mysum")); } env.UndeployAll(); }
private static void TryIterate( RegressionEnvironment env, RegressionPath path, int numThreads, int numRepeats) { var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadStmtNamedWindowFAF)).ThreadFactory); var future = new IFuture<object>[numThreads]; for (var i = 0; i < numThreads; i++) { var callable = new StmtNamedWindowQueryCallable(env, path, numRepeats, Convert.ToString(i)); future[i] = threadPool.Submit(callable); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.ThreadSleep(100); SupportCompileDeployUtil.AssertFutures(future); }
public object Call() { var count = 0; while (true) { insertIntoTimer.SendEvent(); SupportCompileDeployUtil.ThreadSleep(1); count++; if (count % 1000 == 0) { log.Info("Thread " + Thread.CurrentThread.ManagedThreadId + " send " + count + " events"); } if (count > maxSent) { break; } if (shutdown) { break; } } return null; }
public void Run(RegressionEnvironment env) { var epl = "create window A#unique(Key) as MyEventA;\n" + "create window B#unique(Key) as MyEventB;\n" + "insert into A select * from MyEventA;\n" + "insert into B select * from MyEventB;\n" + "\n" + "@Name('stmt') select sum(A.Data) as aTotal,sum(B.Data) as bTotal " + "from A unidirectional, B where A.Key = B.Key;\n"; env.CompileDeploy(epl); var es = Executors.NewFixedThreadPool( 10, new SupportThreadFactory(typeof(MultithreadStmtNamedWindowJoinUniqueView)).ThreadFactory); IList<MyRunnable> runnables = new List<MyRunnable>(); for (var i = 0; i < 6; i++) { runnables.Add(new MyRunnable(env.EventService)); } foreach (var toRun in runnables) { es.Submit(toRun.Run); } SupportCompileDeployUtil.ThreadSleep(2000); foreach (var toRun in runnables) { toRun.Shutdown = true; } es.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(es, 20, TimeUnit.SECONDS); foreach (var runnable in runnables) { Assert.IsNull(runnable.Exception); } env.UndeployAll(); }
private static void TryMultiInsertGroup( RegressionEnvironment env, int numThreads, int numStatements, int numEvents) { // This should fail all test in this class // config.getEngineDefaults().getThreading().setInsertIntoDispatchPreserveOrder(false); // setup statements var path = new RegressionPath(); var insertIntoStmts = new EPStatement[numStatements]; for (var i = 0; i < numStatements; i++) { var epl = $"@Name('s{i}') insert into MyStream select {i} as ident,count(*) as cnt from SupportBean"; insertIntoStmts[i] = env.CompileDeploy(epl, path).Statement("s" + i); } env.CompileDeploy("@Name('final') select ident, sum(cnt) as mysum from MyStream group by ident", path); var listener = new SupportMTUpdateListener(); env.Statement("final").AddListener(listener); // execute var threadPool = Executors.NewFixedThreadPool( numThreads, new SupportThreadFactory(typeof(MultithreadDeterminismInsertInto)).ThreadFactory); var future = new IFuture<object>[numThreads]; var sharedStartLock = new SlimReaderWriterLock(); using (sharedStartLock.WriteLock.Acquire()) { for (var i = 0; i < numThreads; i++) { future[i] = threadPool.Submit( new SendEventRWLockCallable( i, sharedStartLock, env.Runtime, new GeneratorEnumerator(numEvents))); } SupportCompileDeployUtil.ThreadSleep(100); } threadPool.Shutdown(); SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS); SupportCompileDeployUtil.AssertFutures(future); // assert result var newEvents = listener.GetNewDataListFlattened(); IList<long>[] resultsPerIdent = new List<long>[numStatements]; foreach (var theEvent in newEvents) { var ident = theEvent.Get("ident").AsInt32(); if (resultsPerIdent[ident] == null) { resultsPerIdent[ident] = new List<long>(); } var mysum = theEvent.Get("mysum").AsInt64(); resultsPerIdent[ident].Add(mysum); } for (var statement = 0; statement < numStatements; statement++) { for (var i = 0; i < numEvents - 1; i++) { var expected = Total(i + 1); Assert.AreEqual( expected, resultsPerIdent[statement][i], "Failed for statement " + statement); } } env.UndeployAll(); }