private static void TryThreadSafetyHistoricalJoin(
RegressionEnvironment env,
int numThreads,
int numRepeats)
{
var listener = new MyListener();
env.Statement("select").AddListener(listener);
var events = new IList<object>[numThreads];
for (var threadNum = 0; threadNum < numThreads; threadNum++) {
events[threadNum] = new List<object>();
for (var eventNum = 0; eventNum < numRepeats; eventNum++) {
// range: 1 to 1000
var partition = eventNum + 1;
events[threadNum].Add(new SupportBean(new int?(partition).ToString(), 0));
}
}
var threadPool = Executors.NewFixedThreadPool(
numThreads,
new SupportThreadFactory(typeof(MultithreadContextDBAccess)).ThreadFactory);
var futures = new IFuture<bool>[numThreads];
for (var i = 0; i < numThreads; i++) {
var callable = new SendEventCallable(i, env.Runtime, events[i].GetEnumerator());
futures[i] = threadPool.Submit(callable);
}
SupportCompileDeployUtil.AssertFutures(futures);
threadPool.Shutdown();
SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS);
Assert.AreEqual(numRepeats * numThreads, listener.Count);
}
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();
}
private static void TryPerformanceDispatch(
RegressionEnvironment env,
int numThreads,
int numRepeats)
{
var listener = new MyListener();
env.Statement("select").AddListener(listener);
var random = new Random();
var events = new IList<object>[numThreads];
var eventId = 0;
for (var threadNum = 0; threadNum < numThreads; threadNum++) {
events[threadNum] = new List<object>();
for (var eventNum = 0; eventNum < numRepeats; eventNum++) {
// range: 1 to 1000
var partition = random.Next(0, 50);
eventId++;
events[threadNum].Add(new SupportBean(new int?(partition).ToString(), eventId));
}
}
var threadPool = Executors.NewFixedThreadPool(
numThreads,
new SupportThreadFactory(typeof(MultithreadContextPartitioned)).ThreadFactory);
var futures = new IFuture<bool>[numThreads];
var startTime = PerformanceObserver.MilliTime;
for (var i = 0; i < numThreads; i++) {
var callable = new SendEventCallable(i, env.Runtime, events[i].GetEnumerator());
futures[i] = threadPool.Submit(callable);
}
SupportCompileDeployUtil.AssertFutures(futures);
var delta = PerformanceObserver.MilliTime - startTime;
threadPool.Shutdown();
SupportCompileDeployUtil.ExecutorAwait(threadPool, 10, TimeUnit.SECONDS);
// print those events not received
foreach (var eventList in events) {
foreach (var @event in eventList) {
if (!listener.Beans.Contains(@event)) {
log.Info("Expected event was not received, event " + @event);
}
}
}
Assert.AreEqual(numRepeats * numThreads, listener.Beans.Count);
Assert.That(delta, Is.LessThan(500));
}
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 void TrySend(
RegressionEnvironment env,
int numThreads,
int numRepeats,
int numStmts,
SupportCountListener[] listeners)
{
var executor = Executors.NewFixedThreadPool(
numThreads,
new SupportThreadFactory(typeof(MultithreadViewTimeWindow)).ThreadFactory);
var future = new IFuture<bool>[numThreads];
for (var i = 0; i < numThreads; i++) {
var callable = new SendEventCallable(i, env.Runtime, new GeneratorEnumerator(numRepeats));
future[i] = executor.Submit(callable);
}
log.Info("Waiting for threadpool shutdown");
executor.Shutdown();
executor.AwaitTermination(TimeSpan.FromSeconds(30));
for (var i = 0; i < numThreads; i++) {
Assert.IsTrue(future[i].GetValue(TimeSpan.FromSeconds(5)));
}
// set time to a large value
log.Info("Waiting for calm down");
Thread.Sleep(5000);
// Assert results
var totalExpected = numThreads * numRepeats;
// assert new data
for (var i = 0; i < numStmts; i++) {
var count = listeners[i].CountNew;
Assert.AreEqual(count, totalExpected);
var countOld = listeners[i].CountNew;
Assert.AreEqual(countOld, totalExpected);
}
}
