public BackgroundInventory(int parallelTasksCount, Dictionary <string, object> plugins)
{
if (plugins == null)
{
throw new ArgumentNullException(nameof(plugins));
}
this.scheduler = new QueuedTaskScheduler <SolarWinds.Orion.Core.BusinessLayer.BackgroundInventory.BackgroundInventory.InventoryTask>(new QueuedTaskScheduler <SolarWinds.Orion.Core.BusinessLayer.BackgroundInventory.BackgroundInventory.InventoryTask> .TaskProcessingRoutine(this.DoInventory), parallelTasksCount);
this.scheduler.TaskProcessingFinished += new EventHandler(this.scheduler_TaskProcessingFinished);
this.snmpGlobals = new SnmpGlobalSettings();
this.snmpGlobals.set_MaxReplies(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-SNMP MaxReps", 5));
this.snmpGlobals.set_RequestTimeout(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-SNMP Timeout", 2500));
this.snmpGlobals.set_RequestRetries(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-SNMP Retries", 2));
this.snmpGlobals.set_HsrpEnabled((bool)SettingsDAL.GetCurrent <bool>("SWNetPerfMon-Settings-SNMP HSRPEnabled", (M0)1));
this.wmiGlobals = new WmiGlobalSettings();
this.wmiGlobals.set_UserImpersonationLevel((ImpersonationLevel)SettingsDAL.GetCurrent <ImpersonationLevel>("SWNetPerfMon-Settings-Wmi UserImpersonationLevel", (M0)0));
this.wmiGlobals.set_ConnectionRationMode((WmiConnectionRationMode)SettingsDAL.GetCurrent <WmiConnectionRationMode>("SWNetPerfMon-Settings-Wmi ConnectionRationMode", (M0)1));
this.wmiGlobals.set_MaxRationedConnections(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-Wmi MaxRationedConnections", 0));
this.wmiGlobals.set_KillProcessExcessiveError((bool)SettingsDAL.GetCurrent <bool>("SWNetPerfMon-Settings-Wmi KillProcessExcessiveError", (M0)1));
this.wmiGlobals.set_ExcessiveErrorThreshhold(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-Wmi ExcessiveErrorThreshhold", 50));
this.wmiGlobals.set_WmiRetries(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-WMI Retries", 0));
this.wmiGlobals.set_WmiRetryInterval(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-WMI Retry Interval", 0));
this.wmiGlobals.set_WmiAutoCorrectRDNSInconsistency(Convert.ToBoolean(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-WMI Auto Correct Reverse DNS", 0)));
this.wmiGlobals.set_WmiDefaultRootNamespaceOverrideIndex(SettingsDAL.GetCurrentInt("SWNetPerfMon-Settings-WMI Default Root Namespace Override Index", 0));
this.inventories = plugins;
}
static void _mainTaskSheduler_QueueIsEmpty(object sender, EventArgs e)
{
QueuedTaskScheduler deprecatedScheduler = (QueuedTaskScheduler)sender;
deprecatedScheduler.QueueIsEmpty -= _mainTaskSheduler_QueueIsEmpty;
deprecatedScheduler.Dispose();
}
public RPCUserInfo(SocketAsyncEventArgs asyn) : base(asyn, 1024 * 64)
{
QueueScheduler = new QueuedTaskScheduler();
RPC_Call = new RPC();
RPC_Call.CallBufferOutSend += RPC_OBJ_CallBufferOutSend;
Stream = new ZYNetRingBufferPool(1024 * 64);//64K
}
public void Sched_Task_NewTask_ContinueWith_Wrapped()
{
TaskScheduler scheduler = new QueuedTaskScheduler();
Task wrapped = new Task(() =>
{
output.WriteLine("#0 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}",
SynchronizationContext.Current, TaskScheduler.Current);
Task t0 = new Task(() =>
{
output.WriteLine("#1 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}",
SynchronizationContext.Current, TaskScheduler.Current);
Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #1");
});
Task t1 = t0.ContinueWith(task =>
{
Assert.IsFalse(task.IsFaulted, "Task #1 Faulted=" + task.Exception);
output.WriteLine("#2 - new Task - SynchronizationContext.Current={0} TaskScheduler.Current={1}",
SynchronizationContext.Current, TaskScheduler.Current);
Assert.AreEqual(scheduler, TaskScheduler.Current, "TaskScheduler.Current #2");
});
t0.Start(scheduler);
bool ok = t1.Wait(TimeSpan.FromSeconds(15));
if (!ok) throw new TimeoutException();
});
wrapped.Start(scheduler);
bool finished = wrapped.Wait(TimeSpan.FromSeconds(30));
if (!finished) throw new TimeoutException();
}
protected void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (_cancel != null)
{
_cancel.Cancel();
_cancel.Token.WaitHandle.WaitOne();
_cancel.Dispose();
_cancel = null;
}
_factories.Clear();
_schedulers.Clear();
if (_scheduler != null)
{
_scheduler.Dispose();
_scheduler = null;
}
if (Background != null)
{
Background.Dispose();
Background = null;
}
if (Maintenance != null)
{
Maintenance.Dispose();
Maintenance = null;
}
}
protected void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if (_cancel != null)
{
_cancel.Cancel();
_cancel.Token.WaitHandle.WaitOne();
_cancel.Dispose();
_cancel = null;
}
_factories?.Clear();
_schedulers?.Clear();
_scheduler?.Dispose();
_scheduler = null;
_background?.Dispose();
_background = null;
_maintenance?.Dispose();
_maintenance = null;
}
public void Stop(CancellationToken cancellationToken = default, bool immediate = false)
{
_logger.Info(() => "Stopping background task host");
var options = new ParallelOptions
{
CancellationToken = cancellationToken, MaxDegreeOfParallelism = ResolveConcurrency()
};
var pendingTasks = _pending.Where(entry => entry.Value.OnHalt != null);
Parallel.ForEach(pendingTasks, options, async e =>
{
// FIXME: halt operation won't have user data in this context
using var context = ProvisionExecutionContext(cancellationToken, null);
// ReSharper disable once AccessToDisposedClosure (this is safe: immediately invoked and blocking)
await e.Value.OnHalt.HaltAsync(context, immediate);
});
_pending.Clear();
_scheduler?.Dispose();
_scheduler = null;
_background.Stop(immediate);
_maintenance.Stop(immediate);
}
public async Task Initialize()
{
await Manage().ConfigureAwait(false);
string threadName = $"QuartzScheduler_{jobStore.InstanceName}-{jobStore.InstanceId}_ClusterManager";
taskScheduler = new QueuedTaskScheduler(threadCount: 1, threadPriority: ThreadPriority.AboveNormal, threadName: threadName, useForegroundThreads: !jobStore.MakeThreadsDaemons);
task = Task.Factory.StartNew(() => Run(cancellationTokenSource.Token), cancellationTokenSource.Token, TaskCreationOptions.HideScheduler, taskScheduler).Unwrap();
}
public RPCUserInfo(SocketAsyncEventArgs asyn, int maxSize, bool isCallReturn)
{
Scheduler = new QueuedTaskScheduler(4);
RPC_Call = new RPC(isCallReturn);
RPC_Call.CallBufferOutSend += SendData;
Stream = new ZYNetRingBufferPool(maxSize);
this.Asyn = asyn;
}
/*
* public void CallAsyn<Mode>(Expression<Action<Mode>> action)
* {
* RPC_Call.CallAsyn<Mode>(action);
* }
* public void CallAsyn<Mode, Result>(Expression<Func<Mode, Result>> action, Action<AsynReturn> Callback)
* {
* RPC_Call.CallAsyn<Mode, Result>(action, Callback);
* }
*
* public void CallAsyn<Mode>(Expression<Action<Mode>> action, Action<AsynReturn> Callback)
* {
* RPC_Call.CallAsyn<Mode>(action, Callback);
* }
*
* public Result Call<Mode, Result>(Expression<Func<Mode, Result>> action)
* {
* return RPC_Call.Call<Mode, Result>(action);
* }
*
* public void Call<Mode>(Expression<Action<Mode>> action)
* {
* RPC_Call.Call<Mode>(action);
* }
*/
#endregion
public RPCUserInfo(SocketAsyncEventArgs asyn)
{
Scheduler = new QueuedTaskScheduler(4);
RPC_Call = new RPC();
RPC_Call.CallBufferOutSend += RPC_OBJ_CallBufferOutSend;
this.Asyn = asyn;
Stream = new ZYNetRingBufferPool(1024 * 1024 * 2);//2MB
}
public RPCClient()
{
OrderSchedulerSend = new QueuedTaskScheduler();
OrderSchedulerRead = new QueuedTaskScheduler();
RPC_Call = new RPC();
RPC_Call.CallBufferOutSend += RPC_Call_CallBufferOutSend;
RPC_Call.ErrMsgOut += RPC_Call_ErrMsgOut;
}
public ProcessingGroupWrapper(string transportId, string name, ProcessingGroupInfo processingGroupInfo)
{
TransportId = transportId;
Name = name;
var threadCount = Math.Max(processingGroupInfo.ConcurrencyLevel, 1);
m_TaskScheduler = new QueuedTaskScheduler(threadCount);
m_TaskFactories = new Dictionary <int, TaskFactory>();
}
internal MisfireHandler(JobStoreSupport jobStoreSupport)
{
this.jobStoreSupport = jobStoreSupport;
string threadName = $"QuartzScheduler_{jobStoreSupport.InstanceName}-{jobStoreSupport.InstanceId}_MisfireHandler";
taskScheduler = new QueuedTaskScheduler(threadCount: 1, threadName: threadName, useForegroundThreads: !jobStoreSupport.MakeThreadsDaemons);
cancellationTokenSource = new CancellationTokenSource();
}
public void Start()
{
if(_queue == null)
{
_queue = new QueuedTaskScheduler(_threads);
}
// This probaby uses a worker pool thread, so should be replaced eventually
_background = new Timer(state => SeedJobsFromQueue(), null, 0, Linger.SleepDelay * 1000);
}
public InMemoryTransport(Uri inputAddress, int concurrencyLimit)
{
_inputAddress = inputAddress;
_sendObservable = new SendObservable();
_receiveObservable = new ReceiveObservable();
_endpointObservable = new ReceiveEndpointObservable();
_scheduler = new QueuedTaskScheduler(TaskScheduler.Default, concurrencyLimit);
}
public void Start()
{
if (_queue == null)
{
_queue = new QueuedTaskScheduler(_threads);
}
// This probaby uses a worker pool thread, so should be replaced eventually
_background = new Timer(state => SeedJobsFromQueue(), null, 0, Linger.SleepDelay * 1000);
}
public QueuedTaskSchedulerFactory()
{
// TODO: hook up the number of threads to settings and figure out the optimal value.
// We expect node splitting to have a lot of blocking when the work is moved to the GPU
// so more than the number of cores is probably desired.
// TODO: we might be able to build our own prioritized task scheduler that takes more things
// into account than just the level of the node. For instance, we could prioritize
// currently-visible nodes over non-visible nodes. To do this we'd probably drop
// QueuedTaskScheduler in favor of a custom scheduler that uses Task.AsyncState to get
// information about each queued node and then sorts them accordingly.
_scheduler = new QueuedTaskScheduler(0, "", false, ThreadPriority.BelowNormal);
}
public void Stop()
{
if(_queue != null)
{
_queue.Dispose();
_queue = null;
}
if(_background != null)
{
_background.Dispose();
_background = null;
}
}
private void Dispose(bool disposing)
{
if (this.disposed)
{
return;
}
if (disposing && this.scheduler != null)
{
this.scheduler.Dispose();
this.scheduler = (QueuedTaskScheduler <SolarWinds.Orion.Core.BusinessLayer.BackgroundInventory.BackgroundInventory.InventoryTask>)null;
}
this.disposed = true;
}
public void Stop()
{
if (_queue != null)
{
_queue.Dispose();
_queue = null;
}
if (_background != null)
{
_background.Dispose();
_background = null;
}
}
public CommandDispatcher(string boundedContext, int threadCount = 1, long failedCommandRetryDelay = 60000)
{
m_FailedCommandRetryDelay = failedCommandRetryDelay;
m_QueuedTaskScheduler = new QueuedTaskScheduler(threadCount);
foreach (var value in Enum.GetValues(typeof(CommandPriority)))
{
m_TaskFactories[(CommandPriority)value] = new TaskFactory(
((CommandPriority)value) == CommandPriority.Normal
? new CurrentThreadTaskScheduler()
: m_QueuedTaskScheduler.ActivateNewQueue((int)value));
}
m_BoundedContext = boundedContext;
}
public QueuedTaskSchedulerFactory()
{
// TODO: hook up the number of threads to settings and figure out the optimal value.
// We expect node splitting to have a lot of blocking when the work is moved to the GPU
// so more than the number of cores is probably desired.
// TODO: we might be able to build our own prioritized task scheduler that takes more things
// into account than just the level of the node. For instance, we could prioritize
// currently-visible nodes over non-visible nodes. To do this we'd probably drop
// QueuedTaskScheduler in favor of a custom scheduler that uses Task.AsyncState to get
// information about each queued node and then sorts them accordingly.
_scheduler = new QueuedTaskScheduler(Environment.ProcessorCount, "QueuedTaskScheduler", false, ThreadPriority.BelowNormal);
}
public InMemoryTransport(Uri inputAddress, int concurrencyLimit)
{
_inputAddress = inputAddress;
_sendObservable = new SendObservable();
_receiveObservable = new ReceiveObservable();
_endpointObservable = new ReceiveEndpointObservable();
_supervisor = new TaskSupervisor();
_participant = _supervisor.CreateParticipant();
_scheduler = new QueuedTaskScheduler(TaskScheduler.Default, concurrencyLimit);
}
public void Start(bool immediate = false)
{
if (_scheduler == null)
{
_scheduler = new QueuedTaskScheduler(_threads);
}
Background.Produce(SeedTasksFromQueue, _settings.SleepInterval);
Background.Start(immediate);
Maintenance.Produce(HangingTasks, TimeSpan.FromMinutes(5));
Maintenance.Start(immediate);
}
public RabbitMqConnectionContext(IConnection connection, RabbitMqHostSettings hostSettings, CancellationToken cancellationToken)
{
_connection = connection;
_hostSettings = hostSettings;
_payloadCache = new PayloadCache();
_completed = new TaskCompletionSource <bool>();
_tokenSource = new CancellationTokenSource();
_registration = cancellationToken.Register(OnCancellationRequested);
_taskScheduler = new QueuedTaskScheduler(TaskScheduler.Default, 1);
connection.ConnectionShutdown += OnConnectionShutdown;
}
public void Start(bool immediate = false)
{
_logger.Info(() => "Starting background task host");
if (_scheduler == null)
{
_scheduler = new QueuedTaskScheduler(ResolveConcurrency());
}
_background.Produce(EnqueueTasks, TimeSpan.FromSeconds(_options.CurrentValue.SleepIntervalSeconds));
_background.Start(immediate);
_maintenance.Produce(HangingTasks, TimeSpan.FromMinutes(1));
_maintenance.Start(immediate);
}
public async Task TestRunWithTaskScheduler1() // Aligned with the coroutine test TestExecuteRepeated1
{
QueuedTaskScheduler scheduler = new QueuedTaskScheduler(TaskScheduler.Default, maxConcurrencyLevel: 1);
var cancel = new CancellationTokenSource();
// Create both tasks at the same time:
Task t1 = TaskV2.Run(SomeAsyncTask1, cancel, scheduler);
Task <string> t2 = TaskV2.Run(SomeAsyncTask2, cancel, scheduler);
Assert.Equal(1, scheduler.GetRemainingScheduledTaskCount()); // 1 task started and 1 waiting
Assert.Equal("Some string result", await t2);
Assert.Equal(0, scheduler.GetRemainingScheduledTaskCount());
// Since the scheduler allows only one task at a time, if t2 is done, t1 also must be completed:
Assert.True(t1.IsCompleted);
}
public void Task_GroupedMasterTaskScheduler()
{
const string testNameBase = "Task_GroupedMasterTaskScheduler";
int[] testPoints = new[]
{
100,
500,
1000,
2000,
3000,
4000,
5000,
10000,
20000,
30000,
40000,
50000,
100000,
500000
};
foreach (int numSchedulers in testPoints)
{
string testName = testNameBase + "-" + numSchedulers;
int numTasks = numSchedulers * 10;
Console.WriteLine(testName + " NumTasks=" + numTasks + " NumSchedulers=" + numSchedulers);
// Run baseline test with single, Default scheduler
var baseline = TimeRun(1, TimeSpan.Zero, testName + "-Baseline", () => RunTestLoop(numTasks, null));
// Run test with many schedulers...
// Pre-create schedulers
var masterScheduler = new QueuedTaskScheduler();
TaskScheduler[] schedulers = new TaskScheduler[numSchedulers];
for (int i = 0; i < numSchedulers; i++)
{
schedulers[i] = new TaskSchedulerWrapper(masterScheduler);
}
TimeRun(1, baseline, testName, () => RunTestLoop(numTasks, schedulers));
}
}
public void Task_GroupedMasterTaskScheduler()
{
const string testNameBase = "Task_GroupedMasterTaskScheduler";
int[] testPoints = new[]
{
100,
500,
1000,
2000,
3000,
4000,
5000,
10000,
20000,
30000,
40000,
50000,
100000,
500000
};
foreach (int numSchedulers in testPoints)
{
string testName = testNameBase + "-" + numSchedulers;
int numTasks = numSchedulers * 10;
output.WriteLine(testName + " NumTasks=" + numTasks + " NumSchedulers=" + numSchedulers);
// Run baseline test with single, Default scheduler
var baseline = TimeRun(1, TimeSpan.Zero, testName + "-Baseline", output, () => RunTestLoop(numTasks, null));
// Run test with many schedulers...
// Pre-create schedulers
var masterScheduler = new QueuedTaskScheduler();
TaskScheduler[] schedulers = new TaskScheduler[numSchedulers];
for (int i = 0; i < numSchedulers; i++)
{
schedulers[i] = new TaskSchedulerWrapper(masterScheduler);
}
TimeRun(1, baseline, testName, output, () => RunTestLoop(numTasks, schedulers));
}
}
public RabbitMqModelContext(ConnectionContext connectionContext, IModel model, CancellationToken cancellationToken)
{
_connectionContext = connectionContext;
_model = model;
_payloadCache = new PayloadCache();
_published = new ConcurrentDictionary <ulong, PendingPublish>();
_taskScheduler = new QueuedTaskScheduler(TaskScheduler.Default, 1);
_tokenSource = new CancellationTokenSource();
_registration = cancellationToken.Register(OnCancellationRequested);
_model.ModelShutdown += OnModelShutdown;
_model.BasicAcks += OnBasicAcks;
_model.BasicNacks += OnBasicNacks;
_model.BasicReturn += OnBasicReturn;
_model.ConfirmSelect();
}
public void Stop(bool immediate = false)
{
Parallel.ForEach(_pending.Where(entry => entry.Value.OnHalt != null), e =>
{
e.Value.OnHalt.Halt(immediate);
});
_pending.Clear();
if (_scheduler != null)
{
_scheduler.Dispose();
_scheduler = null;
}
Background.Stop(immediate);
Maintenance.Stop(immediate);
}
private static void CreateTaskScheduler()
{
if (_mainTaskSheduler != null)
{
_mainTaskSheduler.QueueIsEmpty += _mainTaskSheduler_QueueIsEmpty;
}
if (_monoConcurrencyTaskSheduler == null)
{
_monoConcurrencyTaskSheduler = new QueuedTaskScheduler(TaskScheduler.Default, 1);
}
//We will never start more thread than the number of Virutal processor on the computer !
int nbrThreads = ThreadsManager._isBoostMode ? _totThread + 4 : _totThread;
_mainTaskSheduler = new QueuedTaskScheduler(TaskScheduler.Default, nbrThreads);
//Create the Priority queues
_highPrioritySchedduler = _mainTaskSheduler.ActivateNewQueue(0);
_normalPrioritySchedduler = _mainTaskSheduler.ActivateNewQueue(1);
_lowPrioritySchedduler = _mainTaskSheduler.ActivateNewQueue(2);
}
private void CreateEmails()
{
int threadCount = 0;
bool isOperationCancelled = false;
try
{
TaskScheduler taskScheduler = TaskScheduler.Current;
List <Task> taskList = new List <Task>(dtRecords.Rows.Count);
string threadcnt = txtThreads.Text;
if (!int.TryParse(txtThreads.Text, out threadCount))
{
MessageBox.Show("Please enter valid thread count.");
}
cancellationTokenSource = new CancellationTokenSource();
QueuedTaskScheduler qts = new QueuedTaskScheduler(TaskScheduler.Default, threadCount);
TaskScheduler pri0 = qts.ActivateNewQueue(priority: 0);
int i = 0;
List <Task <ThreadResult> > lst = new List <Task <ThreadResult> >();
for (i = 0; i < dtRecords.Rows.Count; i = i + 9)
{
CreateParallelRequests(pri0, i);
}
}
catch (OperationCanceledException)
{
isOperationCancelled = true;
}
catch (Exception ex)
{
MessageBox.Show(string.Format("Exception occured: {0}\nPlease try again", ex.Message));
}
finally
{
if (isOperationCancelled)
{
//MessageBox.Show("Operation Cancelled.");
}
}
}
public async Task TestRunWithTaskScheduler2() // Aligned with the coroutine test TestExecuteRepeated1
{
var maxConcurrencyLevel = 2;
QueuedTaskScheduler scheduler = new QueuedTaskScheduler(TaskScheduler.Default, maxConcurrencyLevel);
var cancel = new CancellationTokenSource();
// Create both tasks at the same time:
Task t1 = TaskV2.Run(SomeAsyncTask1, cancel, scheduler);
Task <string> t2 = TaskV2.Run(SomeAsyncTask2, cancel, scheduler);
var t3 = TaskV2.Run(SomeAsyncTask1, cancel, scheduler); // Add a 3rd task (will not be started)
Assert.True(scheduler.GetRemainingScheduledTaskCount() >= 1);
Assert.Equal("Some string result", await t2);
// Check that now also task t3 was started:
Assert.Equal(0, scheduler.GetRemainingScheduledTaskCount());
// Since the scheduler allows 2 tasks at a time, t1 will not be complete when t2 is done:
Assert.False(t1.IsCompleted);
await t1;
}
public void Dispose(bool disposing)
{
if (!disposing)
{
return;
}
if(_cancel != null)
{
_cancel.Cancel();
_cancel.Token.WaitHandle.WaitOne();
_cancel.Dispose();
_cancel = null;
}
_factories.Clear();
_schedulers.Clear();
if (_queue == null)
{
return;
}
_queue.Dispose();
_queue = null;
}
protected void parseSources(ParserFactory factory, IEnumerable<ICharStream> sources)
{
Stopwatch startTime = Stopwatch.StartNew();
Thread.VolatileWrite(ref tokenCount, 0);
int sourceCount = 0;
int inputSize = 0;
#if NET_4_0
BlockingCollection<int> threadIdentifiers = new BlockingCollection<int>();
for (int i = 0; i < NUMBER_OF_THREADS; i++)
threadIdentifiers.Add(i);
ICollection<Task<int>> results = new List<Task<int>>();
QueuedTaskScheduler executorServiceHost = new QueuedTaskScheduler(NUMBER_OF_THREADS);
TaskScheduler executorService = executorServiceHost.ActivateNewQueue();
#else
ICollection<Func<int>> results = new List<Func<int>>();
#endif
foreach (ICharStream input in sources)
{
sourceCount++;
input.Seek(0);
inputSize += input.Size;
#if NET_4_0
Task<int> futureChecksum = Task.Factory.StartNew<int>(new Callable_1(input, factory, threadIdentifiers).call, CancellationToken.None, TaskCreationOptions.None, executorService);
#else
Func<int> futureChecksum = new Callable_1(input, factory).call;
#endif
results.Add(futureChecksum);
}
Checksum checksum = new CRC32();
foreach (var future in results)
{
#if NET_4_0
int value = future.Result;
#else
int value = future();
#endif
if (COMPUTE_CHECKSUM)
{
updateChecksum(checksum, value);
}
}
#if NET_4_0
executorServiceHost.Dispose();
#endif
Console.Out.WriteLine("Total parse time for {0} files ({1} KB, {2} tokens, checksum 0x{3:X8}): {4}ms",
sourceCount,
inputSize / 1024,
Thread.VolatileRead(ref tokenCount),
COMPUTE_CHECKSUM ? checksum.Value : 0,
startTime.ElapsedMilliseconds);
if (sharedLexers.Length > 0)
{
Lexer lexer = sharedLexers[0];
LexerATNSimulator lexerInterpreter = lexer.Interpreter;
DFA[] modeToDFA = lexerInterpreter.atn.modeToDFA;
if (SHOW_DFA_STATE_STATS)
{
int states = 0;
int configs = 0;
HashSet<ATNConfig> uniqueConfigs = new HashSet<ATNConfig>();
for (int i = 0; i < modeToDFA.Length; i++)
{
DFA dfa = modeToDFA[i];
if (dfa == null || dfa.states == null)
{
continue;
}
states += dfa.states.Count;
foreach (DFAState state in dfa.states.Values)
{
configs += state.configs.Count;
uniqueConfigs.UnionWith(state.configs);
}
}
Console.Out.WriteLine("There are {0} lexer DFAState instances, {1} configs ({2} unique), {3} prediction contexts.", states, configs, uniqueConfigs.Count, lexerInterpreter.atn.GetContextCacheSize());
}
}
if (RUN_PARSER && sharedParsers.Length > 0)
{
Parser parser = sharedParsers[0];
// make sure the individual DFAState objects actually have unique ATNConfig arrays
ParserATNSimulator interpreter = parser.Interpreter;
DFA[] decisionToDFA = interpreter.atn.decisionToDFA;
if (SHOW_DFA_STATE_STATS)
{
int states = 0;
int configs = 0;
HashSet<ATNConfig> uniqueConfigs = new HashSet<ATNConfig>();
for (int i = 0; i < decisionToDFA.Length; i++)
{
DFA dfa = decisionToDFA[i];
if (dfa == null || dfa.states == null)
{
continue;
}
states += dfa.states.Count;
foreach (DFAState state in dfa.states.Values)
{
configs += state.configs.Count;
uniqueConfigs.UnionWith(state.configs);
}
}
Console.Out.WriteLine("There are {0} parser DFAState instances, {1} configs ({2} unique), {3} prediction contexts.", states, configs, uniqueConfigs.Count, interpreter.atn.GetContextCacheSize());
}
int localDfaCount = 0;
int globalDfaCount = 0;
int localConfigCount = 0;
int globalConfigCount = 0;
int[] contextsInDFAState = new int[0];
for (int i = 0; i < decisionToDFA.Length; i++)
{
DFA dfa = decisionToDFA[i];
if (dfa == null || dfa.states == null)
{
continue;
}
if (SHOW_CONFIG_STATS)
{
foreach (DFAState state in dfa.states.Keys)
{
if (state.configs.Count >= contextsInDFAState.Length)
{
Array.Resize(ref contextsInDFAState, state.configs.Count + 1);
}
if (state.isAcceptState)
{
bool hasGlobal = false;
foreach (ATNConfig config in state.configs)
{
if (config.ReachesIntoOuterContext)
{
globalConfigCount++;
hasGlobal = true;
}
else
{
localConfigCount++;
}
}
if (hasGlobal)
{
globalDfaCount++;
}
else
{
localDfaCount++;
}
}
contextsInDFAState[state.configs.Count]++;
}
}
if (EXPORT_LARGEST_CONFIG_CONTEXTS)
{
foreach (DFAState state in dfa.states.Keys)
{
foreach (ATNConfig config in state.configs)
{
string configOutput = config.ToDotString();
if (configOutput.Length <= configOutputSize)
{
continue;
}
configOutputSize = configOutput.Length;
writeFile(tmpdir, "d" + dfa.decision + ".s" + state.stateNumber + ".a" + config.Alt + ".config.dot", configOutput);
}
}
}
}
if (SHOW_CONFIG_STATS && currentPass == 0)
{
Console.Out.WriteLine(" DFA accept states: {0} total, {1} with only local context, {2} with a global context", localDfaCount + globalDfaCount, localDfaCount, globalDfaCount);
Console.Out.WriteLine(" Config stats: {0} total, {1} local, {2} global", localConfigCount + globalConfigCount, localConfigCount, globalConfigCount);
if (SHOW_DFA_STATE_STATS)
{
for (int i = 0; i < contextsInDFAState.Length; i++)
{
if (contextsInDFAState[i] != 0)
{
Console.Out.WriteLine(" {0} configs = {1}", i, contextsInDFAState[i]);
}
}
}
}
}
}
