private void PerformMultithreadedTest(FilterHandleSetNode topNode,
int numberOfThreads,
int numberOfRunnables,
int numberOfSecondsSleep)
{
Log.Info(".performMultithreadedTest Loading thread pool work queue,numberOfRunnables=" + numberOfRunnables);
var pool = new DedicatedExecutorService("test", numberOfThreads, new ImperfectBlockingQueue <Runnable>());
for (var i = 0; i < numberOfRunnables; i++)
{
var runnable = new IndexTreeBuilderRunnable(_eventType, topNode, _testFilterSpecs, _matchedEvents, _unmatchedEvents);
pool.Submit(runnable.Run);
}
Log.Info(".performMultithreadedTest Starting thread pool, threads=" + numberOfThreads);
// Sleep X seconds
Sleep(numberOfSecondsSleep);
Log.Info(".performMultithreadedTest Completed, numberOfRunnables=" + numberOfRunnables +
" numberOfThreads=" + numberOfThreads +
" completed=" + pool.NumExecuted);
pool.Shutdown();
pool.AwaitTermination(TimeSpan.FromSeconds(1));
Assert.AreEqual(pool.NumExecuted, numberOfRunnables);
}
public void PerformTest(int numberOfThreads,
int numberOfTicksToSend,
int ratioPriceOutOfLimit,
int numberOfSecondsWaitForCompletion)
{
var totalNumTicks = numberOfTicksToSend + 2 * TestStockTickerGenerator.NUM_STOCK_NAMES;
Log.Info(
".performTest Generating data, numberOfTicksToSend=" +
numberOfTicksToSend +
" ratioPriceOutOfLimit=" +
ratioPriceOutOfLimit);
var generator = new StockTickerEventGenerator();
var stream = generator.MakeEventStream(
numberOfTicksToSend,
ratioPriceOutOfLimit,
TestStockTickerGenerator.NUM_STOCK_NAMES,
PRICE_LIMIT_PCT_LOWER_LIMIT,
PRICE_LIMIT_PCT_UPPER_LIMIT,
PRICE_LOWER_LIMIT,
PRICE_UPPER_LIMIT,
true);
var eventService = _runtime.EventService;
Log.Info(".performTest Send limit and initial tick events - singlethreaded");
for (var i = 0; i < TestStockTickerGenerator.NUM_STOCK_NAMES * 2; i++)
{
var @event = stream.First();
stream.RemoveAt(0);
eventService.SendEventBean(@event, @event.GetType().Name);
}
Log.Info(".performTest Loading thread pool work queue, numberOfRunnables=" + stream.Count);
var executorService = new DedicatedExecutorService(string.Empty, numberOfThreads, new LinkedBlockingQueue <Runnable>());
foreach (var @event in stream)
{
var innerEvent = @event;
executorService.Submit(() => eventService.SendEventBean(
innerEvent, innerEvent.GetType().Name));
}
Log.Info(".performTest Listening for completion");
EPRuntimeUtil.AwaitCompletion(_runtime, totalNumTicks, numberOfSecondsWaitForCompletion, 1, 10);
executorService.Shutdown();
// Check results : make sure the given ratio of out-of-limit stock prices was reported
var expectedNumEmitted = numberOfTicksToSend / ratioPriceOutOfLimit + 1;
Assert.IsTrue(_listener.Count == expectedNumEmitted);
Log.Info(".performTest Done test");
}
private void TryIterate(int numThreads, int numRepeats)
{
var callList = CompatExtensions.XRange(0, numThreads)
.Select(ii => new StmtNamedWindowQueryCallable(Convert.ToString(ii), _engine, numRepeats))
.ToList();
var threadPool = new DedicatedExecutorService("test", numThreads);
var threadFutures = callList
.Select(threadPool.Submit)
.ToList();
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 10));
Thread.Sleep(100);
threadFutures.ForEach(
future => Assert.IsTrue(future.GetValueOrDefault()));
}
private void TryStatementListenerAddRemove(int numThreads, EPStatement statement, bool isEPL, int numRepeats)
{
var threadPool = new DedicatedExecutorService("test", numThreads);
var future = new Future <bool> [numThreads];
for (int i = 0; i < numThreads; i++)
{
var callable = new StmtListenerAddRemoveCallable(_engine, statement, isEPL, numRepeats);
future[i] = threadPool.Submit(callable);
}
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 30));
for (int i = 0; i < numThreads; i++)
{
Assert.IsTrue(future[i].GetValueOrDefault(), "Failed stmt=" + statement.Text);
}
}
public void Run()
{
if (_isWaitKeypress)
{
Console.WriteLine("...press enter to start simulation...");
Console.ReadKey();
}
// Configure engine with event names to make the statements more readable.
// This could also be done in a configuration file.
Configuration configuration = new Configuration();
configuration.AddEventType("MarketDataEvent", typeof(MarketDataEvent).FullName);
// Get engine instance
EPServiceProvider epService = EPServiceProviderManager.GetProvider(_engineURI, configuration);
// Set up statements
var tickPerSecStmt = TicksPerSecondStatement.Create(epService.EPAdministrator);
tickPerSecStmt.Events += LogRate;
var falloffStmt = TicksFalloffStatement.Create(epService.EPAdministrator);
falloffStmt.Events += MonitorRate;
// Send events
var threadPool = new DedicatedExecutorService(string.Empty, _numberOfThreads);
MarketDataSendRunnable[] runnables = new MarketDataSendRunnable[_numberOfThreads];
for (int i = 0; i < _numberOfThreads; i++)
{
runnables[i] = new MarketDataSendRunnable(epService);
threadPool.Submit(runnables[i].Run);
}
int seconds = 0;
Random random = new Random();
while (seconds < _numSeconds)
{
seconds++;
Thread.Sleep(1000);
FeedEnum? feedToDropOff;
if (random.NextDouble() * 100 < _dropProbability)
{
feedToDropOff = FeedEnum.FEED_A;
if (random.Next(0, 2) == 1)
{
feedToDropOff = FeedEnum.FEED_B;
}
Log.Info("Setting drop-off for feed {0}", feedToDropOff);
}
else
{
feedToDropOff = null;
}
foreach (MarketDataSendRunnable t in runnables)
{
t.SetRateDropOffFeed(feedToDropOff);
}
}
Log.Info("Shutting down threadpool");
for (int i = 0; i < runnables.Length; i++)
{
runnables[i].SetShutdown();
}
threadPool.Shutdown();
threadPool.AwaitTermination(new TimeSpan(0, 0, 0, 10));
}
