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);
}
