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(); }
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; }
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 WorkerPool(int maxWorker, IWorkerFactory workerFactory, IWorkerArgumentStore workerArgumentStore) { this.maxWorkerThread = maxWorker; this.workerFactory = workerFactory; this.workerArgumentStore = workerArgumentStore; }