public WorkerPool(int workerMinimum, int workerMaximum, IWorkerFactory <T> workerFactory)
{
if (workerMinimum < 1)
{
throw new ArgumentException(nameof(workerMinimum));
}
if (workerMaximum < 1)
{
throw new ArgumentException(nameof(workerMaximum));
}
if (workerMinimum > workerMaximum)
{
throw new ArgumentException(nameof(workerMinimum), $"{nameof(workerMinimum)} should not be greater thant {nameof(workerMaximum)}");
}
WorkerMinimum = workerMinimum;
WorkerMaximum = workerMaximum;
_workerFactory = workerFactory;
_exclusiveBlock = new ExclusiveBlock(_workerIdentifier.ToString());
InitializeWorkers(workerMinimum, workerFactory);
}
static void Main(string[] args)
{
var container = new Container();
StructureMapConfig.RegisterComponents(container);
IWorkerFactory _workerFactory = container.GetInstance <IWorkerFactory>();
IList <string> _workerNames;
IList <IWorker> _workers;
int _numWorkers = 0;
_workerNames = _workerFactory.GetNames <IWorker>();
_workers = new List <IWorker>();
foreach (var name in _workerNames)
{
_workers.Add(_workerFactory.GetNamedWorker(name));
_numWorkers++;
}
EventLog.WriteEntry("OddsFetchingTriggerer", "Started OddsFetchingTriggerer...");
for (var i = 0; i < _numWorkers; i++)
{
_workers[i].DoWork();
}
}
public Application(Config config, IWorkerFactory factory, IPrinter printer)
{
_config = config ?? throw new ArgumentNullException(nameof(config));
_factory = factory ?? throw new ArgumentNullException(nameof(factory));
_printer = printer ?? throw new ArgumentNullException(nameof(printer));
_workers = MakeWorkers().ToArray();
}
public WorkerService(IWorkerQuery workerQuery, IWorkerRepository workerRepository, IWorkerValidator workerValidator, IHmacHelper hmacHelper, IWorkerFactory workerFactory)
{
_workerQuery = workerQuery;
_workerRepository = workerRepository;
_workerValidator = workerValidator;
_hmacHelper = hmacHelper;
_workerFactory = workerFactory;
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
}
public FlowControl(IOptions <AnymateConfig> anymateConfigOptions, ILogger <FlowControl> logger, IWorkerFactory workerFactory)
{
var anymateConfig = anymateConfigOptions.Value;
_anymateService = new AnymateService(anymateConfig.ClientId, anymateConfig.Secret, anymateConfig.Username, anymateConfig.Password);
_logger = logger;
_processKey = anymateConfig.ProcessKey;
_workerFactory = workerFactory;
}
public Scheduler(IWorkerFactory <T> workerFactory)
{
this.workerFactory = workerFactory;
currentWorkers = new List <IWorker>();
eventLock = new ManualResetEvent(true);
objectLock = new object();
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
}
public SyncHoleService(
IWorkerFactory workerFactory,
ILogger <SyncHoleService> logger,
SyncManifest syncManifest)
{
_logger = logger;
_syncManifest = syncManifest;
_workerFactory = workerFactory;
_cts = new CancellationTokenSource();
_expBackoff = new ExponentialBackoff(100, 60000);
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipeline pipeline, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipeline = pipeline;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
_options = options;
_log = rebusLoggerFactory.GetCurrentClassLogger();
}
public OddsFetchingTriggerer(IWorkerFactory workerFactory)
{
_workerFactory = workerFactory;
_workerNames = _workerFactory.GetNames <IWorker>();
_workers = new List <IWorker>();
foreach (var name in _workerNames)
{
_workers.Add(_workerFactory.GetNamedWorker(name));
}
InitializeComponent();
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, IDataBus dataBus)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
_options = options;
_busLifetimeEvents = busLifetimeEvents;
_dataBus = dataBus;
_log = rebusLoggerFactory.GetLogger <RebusBus>();
}
public CSharpThreadedOptimizer(IBlazorClientConfiguration blazorClientConfiguration, IServiceProvider serviceProvider,
IWorkerFactory workerFactory)
{
if (blazorClientConfiguration.CompileLocally)
{
_cSharpCompiler = (CSharpCompiler)serviceProvider.GetService(typeof(ICSharpCompiler));
}
else
{
_cSharpCompiler = (CSharpRemoteCompiler)serviceProvider.GetService(typeof(CSharpRemoteCompiler));
}
_workerFactory = workerFactory;
}
/// <summary>
/// Constructs the bus.
/// </summary>
public RebusBus(IWorkerFactory workerFactory, IRouter router, ITransport transport, IPipelineInvoker pipelineInvoker, ISubscriptionStorage subscriptionStorage, Options options, IRebusLoggerFactory rebusLoggerFactory, BusLifetimeEvents busLifetimeEvents, IDataBus dataBus)
{
_workerFactory = workerFactory;
_router = router;
_transport = transport;
_pipelineInvoker = pipelineInvoker;
_subscriptionStorage = subscriptionStorage;
_options = options;
_busLifetimeEvents = busLifetimeEvents;
_dataBus = dataBus;
_log = rebusLoggerFactory.GetLogger <RebusBus>();
var defaultBusName = $"Rebus {Interlocked.Increment(ref _busIdCounter)}";
_busName = options.OptionalBusName ?? defaultBusName;
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerCollection"/> class.
/// </summary>
/// <param name="workerConfiguration">The worker configuration.</param>
/// <param name="workerFactory">The worker factory.</param>
/// <param name="stopWorker">The stop worker.</param>
/// <param name="log">The log.</param>
/// <param name="workerPause">The worker pause.</param>
public WorkerCollection(IWorkerConfiguration workerConfiguration,
IWorkerFactory workerFactory,
StopWorker stopWorker,
ILogFactory log,
IWorkerWaitForEventOrCancel workerPause)
{
Guard.NotNull(() => workerConfiguration, workerConfiguration);
Guard.NotNull(() => workerFactory, workerFactory);
Guard.NotNull(() => stopWorker, stopWorker);
Guard.NotNull(() => log, log);
Guard.NotNull(() => workerPause, workerPause);
_workerConfiguration = workerConfiguration;
_workerFactory = workerFactory;
_stopWorker = stopWorker;
_log = log.Create();
_workerPause = workerPause;
}
/// <summary>
/// Initializes a new instance of the <see cref="WorkerCollection"/> class.
/// </summary>
/// <param name="workerConfiguration">The worker configuration.</param>
/// <param name="workerFactory">The worker factory.</param>
/// <param name="stopWorker">The stop worker.</param>
/// <param name="log">The log.</param>
/// <param name="workerPause">The worker pause.</param>
public WorkerCollection(IWorkerConfiguration workerConfiguration,
IWorkerFactory workerFactory,
StopWorker stopWorker,
ILogFactory log,
IWorkerWaitForEventOrCancel workerPause)
{
Guard.NotNull(() => workerConfiguration, workerConfiguration);
Guard.NotNull(() => workerFactory, workerFactory);
Guard.NotNull(() => stopWorker, stopWorker);
Guard.NotNull(() => log, log);
Guard.NotNull(() => workerPause, workerPause);
_workerConfiguration = workerConfiguration;
_workerFactory = workerFactory;
_stopWorker = stopWorker;
_log = log.Create();
_workerPause = workerPause;
}
public Worker CreateWorker(IWorkerFactory workerFactory)
{
Contract.Requires(workerFactory != null);
var workerId = new WorkerId { Name = String.Format("{0}.{1}", this.name, this.idgen++) };
var worker = workerFactory.NewWorker(workerId);
worker.Start();
lock (this.waitHandlesLock)
{
this.waitHandles = null;
this.workers.Add(workerId, worker);
}
return worker;
}
public WorkingLine(EventLoop eventLoop, string queueTag, IWorkerFactory factory, int worker = 1, ThreadPriority threadPriority = ThreadPriority.Normal)
{
QueueTag = queueTag ?? throw new ArgumentNullException(nameof(queueTag));
WorkerFactory = factory ?? throw new ArgumentNullException(nameof(factory));
Worker = Math.Max(1, Math.Min(MAX_WORKER, worker));
ThreadPriority = threadPriority;
_eventLoop = eventLoop;
for (int i = 0; i < worker; i++)
{
var thread = new WorkerThread(_queue, factory.Create(), $"{queueTag}_{i:0000}");
_threadBusy[thread] = false;
_threads.Add(thread);
thread.BusyChanged += WorkerThreadBusyChangedHandler;
thread.TaskRejected += WorkerThreadTaskRejectedHandler;
thread.WorkerError += WorkerThreadErrorHandler;
thread.TaskBegin += WorkerThreadTaskBeginHandler;
thread.TaskEnd += WorkerThreadTaskEndHandler;
}
}
public Worker CreateWorker(IWorkerFactory workerFactory)
{
Contract.Requires(workerFactory != null);
var workerId = new WorkerId {
Name = String.Format("{0}.{1}", this.name, this.idgen++)
};
var worker = workerFactory.NewWorker(workerId);
worker.Start();
lock (this.waitHandlesLock)
{
this.waitHandles = null;
this.workers.Add(workerId, worker);
}
return(worker);
}
public Task <ThreadLog <TOut> >[] BuildTasksTab <TOut>(int nbTasks, IWorkerFactory <TOut> factory)
{
var tasks = new Task <ThreadLog <TOut> > [nbTasks];
ThreadLog <TOut> DoWork(int TaskId)
{
var log = new ThreadLog <TOut>();
log.SetThreadId();
log.TaskId = TaskId;
// double parenthesis due to that the factory ouput a functor that can be called.
log.Result = factory.CreateWorker()();
return(log);
}
for (int taskId = 0; taskId < nbTasks; taskId++)
{
// you realy should pay attention here ;)
tasks[taskId] = Task <ThreadLog <TOut> > .Factory.StartNew(() => DoWork(taskId));
}
return(tasks);
}
private void InitializeWorkers(int workerMinimum, IWorkerFactory <T> workerFactory)
{
var spinLock = new SpinLock();
Parallel.For(0, workerMinimum, i =>
{
bool lockHasBeenTaken = false;
try
{
var workerItem = new WorkerItem <T>(workerFactory.CreateInstance(_workerIdentifier.ToString()), true);
spinLock.Enter(ref lockHasBeenTaken);
_currentWorkers.Add(workerItem);
}
finally
{
if (lockHasBeenTaken)
{
spinLock.Exit();
}
}
});
}
public DefaultService(IWorkerFactory workerFactory)
{
_workerFactory = workerFactory;
}
public WorkerFactoryThreadPool(ThreadPoolConfiguration configuration, IWorkerFactory workerFactory)
: base(configuration)
{
_workerFactory = workerFactory;
}
public PersistentServerPort(IPAddress listeningAddress, short listeningPort, IWorkerFactory <TPacket> clientWorkerFactory)
: base(listeningAddress, listeningPort)
{
_clientWorkerFactory = clientWorkerFactory;
}
public void SetWorkerFactory(IWorkerFactory workerFactory)
{
_workerFactory = workerFactory;
}
private void ParseParameters(string[] args)
{
string currentArg, optionValue;
for (int i = 0; i < args.Length; i++)
{
currentArg = args[i++];
optionValue = args[i];
switch (currentArg)
{
case "-t": runningSecs = Int32.Parse(optionValue); break;
case "-w": nrOfThreads = Int32.Parse(optionValue); break;
case "-x": executor = (IExecutor)Activator.CreateInstance(Type.GetType(optionValue)); break;
case "-n": numberOfNodesPerTrx = Int32.Parse(optionValue); break;
case "-f":
workerFactory = (IWorkerFactory)Activator.CreateInstance(Type.GetType(optionValue));
redBlackFactory = (IRedBlackFactory)workerFactory;
break;
case "-u": updatesTax = Int32.Parse(optionValue); break;
case "-v": valueToWrite = Int32.Parse(optionValue); break;
}
}
}
public PlotlyLineSplitterBackgroundWrapper(IWorkerFactory workerFactory)
{
_workerFactory = workerFactory;
}
public LocalPoolProvider(IWorkerFactory <IWorker> workerFactory)
{
_workerFactory = workerFactory;
}
public ViewController(IView view, IWorkerFactory factory)
{
this.view = view;
this.factory = factory;
this.view.ClearView();
}
// Entry point
public static int Main(string[] args, ISimpleLineWriter output)
{
var start = DateTime.Now;
var slicingOptions = new SlicingOptions(args);
// we use it to parse the clousot options, and to split the work
var clousot = new NewCCI2Driver(slicingOptions.remainingArgs.ToArray(), output);
if (!clousot.CheckOptions())
{
return(-1);
}
var errorCode = 0;
WorkerPool workerPool = null;
IQueue queue = null;
IWorkerFactory localWorkerFactory = null;
List <IWorkerFactory> remoteWorkerFactories = null;
Func <SliceDefinition, ISliceWorkResult> workOnSlice = null;
Dictionary <ISliceId, int> failedRegressions = null;
var localWorkers = slicingOptions.LocalWorkers;
var remoteWorkers = slicingOptions.RemoteWorkers;
var workers = localWorkers + remoteWorkers;
// If we have workers, we create a Worker factory
if (workers > 0)
{
IDB db;
if (remoteWorkers > 0 || clousot.options.useCache)
{
// Use Clousot Database
db = new StdDB(clousot.options);
}
else
{
// In-memory database
db = new MemorySingletonDB();
}
workerPool = new WorkerPool("Worker", canCancel: false);
queue = new FIFOQueue(workerPool, db);
// When a job is done, it choses which jobs to put in the queue (e.g., analyze the dependencies)
var scheduler =
clousot.options.InferObjectInvariantsOnlyForReadonlyFields?
new LazySchedulerForObjectInvariants(queue, db) : // use LazySchedulerForObjectInvariants for global fixpoint computation including object invariants
new LazyScheduler(queue, db); // use LazyScheduler for the global fixpoint computation
//var scheduler = new NoloopScheduler(queue);
// Usual cache
var clousotDB = slicingOptions.useDB ? db : null;
var argsForWorker = clousot.argsForWorker.ToFList();
if (localWorkers > 0)
{
if (slicingOptions.cci1)
{
localWorkerFactory = new Clousot1WorkerFactory(scheduler, argsForWorker, output, clousotDB);
}
else
{
localWorkerFactory = new Clousot2WorkerFactory(scheduler, argsForWorker, output, clousotDB);
}
// TODO: use a lighter version of ClousotMain since options are already checked here
}
if (remoteWorkers > 0) // so far 1 factory per remote worker but we can do better
{
// TODO: specifiy, for each address the number of workers
// We have a list, because we can have several addresses
remoteWorkerFactories = slicingOptions.serviceAddress.Select(addr => new Clousot2SWorkerFactory(scheduler, argsForWorker, output, addr)).ToList <IWorkerFactory>();
}
if (clousot.options.IsRegression)
{
failedRegressions = new Dictionary <ISliceId, int>();
}
// fail if any work fails
scheduler.OnWorkDone += (sliceId, returnCode) =>
{
if (errorCode >= 0)
{
if (returnCode < 0) // special error code, keep only one
{
errorCode = returnCode;
}
else
{
int prevValue;
if (clousot.options.IsRegression)
{
lock (failedRegressions)
{
Contract.Assume(failedRegressions != null);
if (failedRegressions.TryGetValue(sliceId, out prevValue))
{
output.WriteLine("[Regression] We already analyzed {0} with outcome {1}. Now we update the outcome to {2}", sliceId.Dll, prevValue, returnCode);
}
failedRegressions[sliceId] = returnCode;
}
}
errorCode += returnCode; // regression error count, additive
}
}
};
// What we do for each slice. Two things:
// 1. Register the slice in the db
// 2. Add to the queue (via the scheduler, who decides how to do it)
workOnSlice = sliceDef =>
{
var sliceId = db.RegisterSlice(sliceDef);
scheduler.FeedQueue(new ISliceId[] { sliceId });
return(null);
};
}
ISlicerResult slicerResult = null;
if (slicingOptions.sliceFirst)
{
slicerResult = clousot.SplitWork(workOnSlice);
output.WriteLine("Slicing time: {0}", DateTime.Now - start);
}
if (workerPool != null)
{
if (localWorkerFactory != null)
{
for (var i = 0; i < localWorkers; i++)
{
workerPool.CreateWorker(localWorkerFactory);
}
}
if (remoteWorkerFactories != null)
{
foreach (var factory in remoteWorkerFactories)
{
workerPool.CreateWorker(factory);
}
}
}
if (!slicingOptions.sliceFirst)
{
slicerResult = clousot.SplitWork(workOnSlice);
output.WriteLine("Slicing time and thread creation time : {0}", DateTime.Now - start);
}
if (workerPool != null)
{
// workerPool != null ==> queue != null
Contract.Assume(queue != null);
workerPool.WaitAllAnd(queue.EmptyQueueWaitHandle);
// Something else can arrive at the queue, so we want to stop all of them
workerPool.StopAll();
}
if (slicerResult != null)
{
var errors = slicerResult.GetErrors();
if (errors.Any())
{
foreach (var errMessage in errors)
{
output.WriteLine(errMessage);
}
errorCode = errors.Count();
}
}
output.WriteLine("Total analysis time: {0}", DateTime.Now - start);
var returnValue = errorCode;
if (failedRegressions != null && clousot.options.IsRegression && errorCode >= 0)
{
returnValue = failedRegressions.Where(pair => pair.Value != 0).Select(pair => Math.Abs(pair.Value)).Sum();
}
#if DEBUG
if (clousot.options.IsRegression)
{
Console.WriteLine("[Regression] Returned value {0}", returnValue);
}
#endif
return(returnValue);
}
public void SetWorkerFactory(IWorkerFactory workerFactory)
{
_workerFactory = workerFactory;
}
public WorkerPool(int maxWorker, IWorkerFactory workerFactory, IWorkerArgumentStore workerArgumentStore)
{
this.maxWorkerThread = maxWorker;
this.workerFactory = workerFactory;
this.workerArgumentStore = workerArgumentStore;
}
