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();
}
public void TryCount(
RegressionEnvironment env,
int numUsers,
int numOrders,
int numThreads)
{
var path = new RegressionPath();
for (var i = 0; i < numUsers; i++) {
env.CompileDeploy(
"@Name('create_" +
i +
"') create window MyWindow_" +
i +
"#unique(OrderId) as select * from OrderEvent",
path);
env.CompileDeploy(
"@Name('insert_" +
i +
"') insert into MyWindow_" +
i +
" select * from OrderEvent(UserId = 'user" +
i +
"')",
path);
env.CompileDeploy(
"on OrderCancelEvent as d delete from MyWindow_" + i + " w where w.OrderId = d.OrderId",
path);
env.CompileDeploy(
"@Name('select_" +
i +
"') on OrderEvent as s select sum(w.Price) from MyWindow_" +
i +
" w where w.Side = s.Side group by w.Side",
path);
}
var runnables = new RunnableOrderSim[numThreads];
var threads = new Thread[numThreads];
for (var i = 0; i < numThreads; i++) {
runnables[i] = new RunnableOrderSim(env.Runtime, i, numUsers, numOrders);
threads[i] = new Thread(runnables[i].Run) {
Name = typeof(MultithreadStmtNamedWindowMultiple).Name
};
}
for (var i = 0; i < threads.Length; i++) {
threads[i].Start();
}
for (var i = 0; i < threads.Length; i++) {
SupportCompileDeployUtil.ThreadJoin(threads[i]);
Assert.IsTrue(runnables[i].Status);
}
env.UndeployAll();
}
public void Run(RegressionEnvironment env)
{
env.AdvanceTime(0);
var path = new RegressionPath();
env.CompileDeploy(
"create context MyCtx partition by TheString from SupportBean terminated after 1 second",
path);
env.CompileDeploy(
"@Name('s0') context MyCtx select count(*) as cnt from SupportBean output last when terminated",
path);
var listener = new SupportUpdateListener();
env.Statement("s0").AddListener(listener);
var latch = new AtomicBoolean(true);
// With 0-sleep or 1-sleep the counts start to drop because the event is chasing the context partition.
var t = new Thread(
new MyTimeAdvancingRunnable(env, latch, 10, -1).Run);
t.Name = typeof(MultithreadContextPartitionedWTerm).Name;
t.Start();
var numEvents = 10000;
for (var i = 0; i < numEvents; i++) {
env.SendEventBean(new SupportBean());
}
latch.Set(false);
SupportCompileDeployUtil.ThreadJoin(t);
env.AdvanceTime(int.MaxValue);
long total = 0;
var deliveries = listener.NewDataListFlattened;
foreach (var @event in deliveries) {
var count = @event.Get("cnt").AsInt64();
total += count;
}
Assert.AreEqual(numEvents, total);
env.UndeployAll();
}
private static void TrySend(
RegressionEnvironment env,
int numThreads,
int numEvents,
string[] choices)
{
if (numEvents < choices.Length) {
throw new ArgumentException("Number of events must at least match number of choices");
}
env.AdvanceTime(0);
var path = new RegressionPath();
env.CompileDeploy("@Name('var') create variable boolean myvar = false", path);
env.CompileDeploy("create context SegmentedByString as partition by TheString from SupportBean", path);
env.CompileDeploy(
"@Name('s0') context SegmentedByString select TheString, count(*) - 1 as cnt from SupportBean output snapshot when myvar = true",
path);
var listener = new SupportUpdateListener();
env.Statement("s0").AddListener(listener);
// preload - since concurrently sending same-category events an event can be dropped
for (var i = 0; i < choices.Length; i++) {
env.SendEventBean(new SupportBean(choices[i], 0));
}
var runnables = new EventRunnable[numThreads];
for (var i = 0; i < runnables.Length; i++) {
runnables[i] = new EventRunnable(env, numEvents, choices);
}
// start
var threads = new Thread[runnables.Length];
for (var i = 0; i < runnables.Length; i++) {
threads[i] = new Thread(runnables[i].Run);
threads[i].Name = typeof(MultithreadContextPartitionedWCount).Name;
threads[i].Start();
}
// join
log.Info("Waiting for completion");
for (var i = 0; i < runnables.Length; i++) {
SupportCompileDeployUtil.ThreadJoin(threads[i]);
}
IDictionary<string, long> totals = new Dictionary<string, long>();
foreach (var choice in choices) {
totals.Put(choice, 0L);
}
// verify
var sum = 0;
for (var i = 0; i < runnables.Length; i++) {
Assert.IsNull(runnables[i].Exception);
foreach (var entry in runnables[i].GetTotals()) {
var current = totals.Get(entry.Key);
current += entry.Value;
sum += entry.Value;
totals.Put(entry.Key, current);
//System.out.println("Thread " + i + " key " + entry.getKey() + " count " + entry.getValue());
}
}
Assert.AreEqual(numThreads * numEvents, sum);
env.Runtime.VariableService.SetVariableValue(env.DeploymentId("var"), "myvar", true);
env.AdvanceTime(10000);
var result = listener.LastNewData;
Assert.AreEqual(choices.Length, result.Length);
foreach (var item in result) {
var theString = (string) item.Get("TheString");
var count = item.Get("cnt").AsInt64();
//System.out.println("String " + string + " count " + count);
Assert.AreEqual(count, totals.Get(theString));
}
env.UndeployAll();
}
