public static bool TakeMillis(double milliSecTarget)
{
PerformanceMetricsHelper.ExecCpuBound(
context => {
var currentMillis = (context.CurrentUserTime - context.InitialUserTime).TotalMilliseconds;
return milliSecTarget > currentMillis;
});
return true;
}
public static bool TakeNanos(long nanoSecTarget)
{
if (nanoSecTarget < 100) {
throw new EPException("CPU time wait nsec less then zero, was " + nanoSecTarget);
}
PerformanceMetricsHelper.ExecCpuBound(
context => {
var currentMillis = (context.CurrentUserTime - context.InitialUserTime).TotalMilliseconds;
var currentNanos = 1000000L * currentMillis;
return nanoSecTarget > currentNanos;
});
return true;
}
public void Run(RegressionEnvironment env)
{
var fields = Collections.Array("RuntimeURI", "Timestamp", "InputCount", "InputCountDelta", "ScheduleDepth");
SendTimer(env, 1000);
var text = "@Name('s0') select * from " + typeof(RuntimeMetric).FullName;
env.CompileDeploy(text).AddListener("s0");
env.SendEventBean(new SupportBean());
SendTimer(env, 10999);
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.CompileDeploy("select * from pattern[timer:interval(5 sec)]");
SendTimer(env, 11000);
var theEvent = env.Listener("s0").AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(
theEvent,
fields,
new object[] {"default", 11000L, 1L, 1L, 1L});
env.SendEventBean(new SupportBean());
env.SendEventBean(new SupportBean());
SendTimer(env, 20000);
SendTimer(env, 21000);
theEvent = env.Listener("s0").AssertOneGetNewAndReset();
EPAssertionUtil.AssertProps(
theEvent,
fields,
new object[] {"default", 21000L, 4L, 3L, 0L});
var cpuGoal = 10.0d; // milliseconds of execution time
#if !NETCORE
var before = PerformanceMetricsHelper.GetCurrentMetricResult();
MyMetricFunctions.TakeMillis(cpuGoal);
var after = PerformanceMetricsHelper.GetCurrentMetricResult();
Assert.IsTrue((after.UserTime - before.UserTime).TotalMilliseconds > cpuGoal);
#endif
env.UndeployAll();
}
private void ProcessDispatches(
ArrayDeque<NamedWindowConsumerLatch> dispatches,
IDictionary<EPStatementAgentInstanceHandle, object> dispatchesPerStmt)
{
try {
foreach (var latch in dispatches) {
foreach (var entry in latch.DispatchTo) {
var handle = entry.Key;
var perStmtObj = dispatchesPerStmt.Get(handle);
if (perStmtObj == null) {
dispatchesPerStmt.Put(handle, latch);
}
else if (perStmtObj is IList<NamedWindowConsumerLatch> windowConsumerLatches) {
windowConsumerLatches.Add(latch);
}
else {
// convert from object to list
var unitObj = (NamedWindowConsumerLatch) perStmtObj;
IList<NamedWindowConsumerLatch> list = new List<NamedWindowConsumerLatch>();
list.Add(unitObj);
list.Add(latch);
dispatchesPerStmt.Put(handle, list);
}
}
}
// Dispatch - with or without metrics reporting
if (metricReportingService.IsMetricsReportingEnabled) {
foreach (var entry in dispatchesPerStmt) {
var handle = entry.Key;
var perStmtObj = entry.Value;
// dispatch of a single result to the statement
if (perStmtObj is NamedWindowConsumerLatch) {
var unit = (NamedWindowConsumerLatch) perStmtObj;
var newData = unit.DeltaData.NewData;
var oldData = unit.DeltaData.OldData;
if (handle.StatementHandle.MetricsHandle.IsEnabled) {
var performanceMetric = PerformanceMetricsHelper.Call(
() => ProcessHandle(handle, unit.DispatchTo.Get(handle), newData, oldData));
metricReportingService.AccountTime(
handle.StatementHandle.MetricsHandle,
performanceMetric, performanceMetric.NumInput);
}
else {
var entries = unit.DispatchTo;
var items = entries.Get(handle);
if (items != null) {
ProcessHandle(handle, items, newData, oldData);
}
}
if (isPrioritized && handle.IsPreemptive) {
break;
}
continue;
}
// dispatch of multiple results to a the same statement, need to aggregate per consumer view
var deltaPerConsumer = GetDeltaPerConsumer(perStmtObj, handle);
if (handle.StatementHandle.MetricsHandle.IsEnabled) {
var performanceMetric = PerformanceMetricsHelper.Call(
() => ProcessHandleMultiple(handle, deltaPerConsumer));
metricReportingService.AccountTime(
handle.StatementHandle.MetricsHandle,
performanceMetric, performanceMetric.NumInput);
}
else {
ProcessHandleMultiple(handle, deltaPerConsumer);
}
if (isPrioritized && handle.IsPreemptive) {
break;
}
}
}
else {
foreach (var entry in dispatchesPerStmt) {
var handle = entry.Key;
var perStmtObj = entry.Value;
// dispatch of a single result to the statement
if (perStmtObj is NamedWindowConsumerLatch) {
var unit = (NamedWindowConsumerLatch) perStmtObj;
var newData = unit.DeltaData.NewData;
var oldData = unit.DeltaData.OldData;
ProcessHandle(handle, unit.DispatchTo.Get(handle), newData, oldData);
if (isPrioritized && handle.IsPreemptive) {
break;
}
continue;
}
// dispatch of multiple results to a the same statement, need to aggregate per consumer view
var deltaPerConsumer = GetDeltaPerConsumer(perStmtObj, handle);
ProcessHandleMultiple(handle, deltaPerConsumer);
if (isPrioritized && handle.IsPreemptive) {
break;
}
}
}
}
finally {
foreach (var latch in dispatches) {
latch.Done();
}
dispatchesPerStmt.Clear();
dispatches.Clear();
}
}
private void ProcessDispatches(
ArrayDeque<NamedWindowConsumerLatch> dispatches,
ArrayDeque<NamedWindowConsumerLatch> work,
IDictionary<EPStatementAgentInstanceHandle, object> dispatchesPerStmt)
{
if (dispatches.Count == 1) {
var latch = dispatches.First;
try {
latch.Await();
var newData = latch.DeltaData.NewData;
var oldData = latch.DeltaData.OldData;
if (metricReportingService.IsMetricsReportingEnabled) {
foreach (var entry in latch.DispatchTo) {
var handle = entry.Key;
if (handle.StatementHandle.MetricsHandle.IsEnabled) {
var performanceMetric = PerformanceMetricsHelper.Call(
() => ProcessHandle(handle, entry.Value, newData, oldData), 1);
metricReportingService.AccountTime(
handle.StatementHandle.MetricsHandle,
performanceMetric, performanceMetric.NumInput);
}
else {
ProcessHandle(handle, entry.Value, newData, oldData);
}
if (isPrioritized && handle.IsPreemptive) {
break;
}
}
}
else {
foreach (var entry in latch.DispatchTo) {
var handle = entry.Key;
ProcessHandle(handle, entry.Value, newData, oldData);
if (isPrioritized && handle.IsPreemptive) {
break;
}
}
}
}
finally {
latch.Done();
}
return;
}
// Multiple different-result dispatches to same or different statements are needed in two situations:
// a) an event comes in, triggers two insert-into statements inserting into the same named window and the window produces 2 results
// b) a time batch is grouped in the named window, and a timer fires for both groups at the same time producing more then one result
// c) two on-merge/update/delete statements fire for the same arriving event each updating the named window
// Most likely all dispatches go to different statements since most statements are not joins of
// named windows that produce results at the same time. Therefore sort by statement handle.
// We need to process in N-element chains to preserve dispatches that are next to each other for the same thread.
while (!dispatches.IsEmpty()) {
// the first latch always gets awaited
var first = dispatches.RemoveFirst();
first.Await();
work.Add(first);
// determine which further latches are in this chain and add these, skipping await for any latches in the chain
dispatches.RemoveWhere(
(next, continuation) => {
var result = next.Earlier == null || work.Contains(next.Earlier);
continuation.Value = !result;
return result;
},
work.Add);
#if false
var enumerator = dispatches.GetEnumerator();
while (enumerator.MoveNext()) {
var next = enumerator.Current;
var earlier = next.Earlier;
if (earlier == null || work.Contains(earlier)) {
work.Add(next);
enumerator.Remove();
}
else {
break;
}
}
#endif
ProcessDispatches(work, dispatchesPerStmt);
}
}
