public void ChannelOptimizations_Properties_Roundtrip() { var co = new UnboundedChannelOptions(); Assert.False(co.SingleReader); Assert.False(co.SingleWriter); co.SingleReader = true; Assert.True(co.SingleReader); Assert.False(co.SingleWriter); co.SingleReader = false; Assert.False(co.SingleReader); co.SingleWriter = true; Assert.False(co.SingleReader); Assert.True(co.SingleWriter); co.SingleWriter = false; Assert.False(co.SingleWriter); co.SingleReader = true; co.SingleWriter = true; Assert.True(co.SingleReader); Assert.True(co.SingleWriter); Assert.False(co.AllowSynchronousContinuations); co.AllowSynchronousContinuations = true; Assert.True(co.AllowSynchronousContinuations); co.AllowSynchronousContinuations = false; Assert.False(co.AllowSynchronousContinuations); }
private static async Task Listen(EndPoint endPoint, int bufferSize) { var listener = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); listener.Bind(endPoint); listener.Listen(100); Logger.Info("listening on {}", endPoint); var channelOptions = new UnboundedChannelOptions { SingleReader = true, SingleWriter = true }; while (true) { var socket = await listener.AcceptAsync(); var channel = Channel.CreateUnbounded <double>(channelOptions); ReadFromClient(socket, channel.Writer, bufferSize).FireAndForget( e => Logger.Warn("read from client error: {}", new[] { e }) ); WriteToClient(socket, channel.Reader).FireAndForget( e => Logger.Warn("write to client error: {}", new[] { e }) ); } }
// [Benchmark] public void ThreadingChannel() { var opt2 = new UnboundedChannelOptions(); opt2.AllowSynchronousContinuations = false; var channel = Channel.CreateUnbounded <int>(opt2); Task.WaitAll( Task.WhenAll(Enumerable.Range(0, WTaskNum).Select(async(idx) => { await Task.Yield(); for (int i = 0; i < LoopNum / WTaskNum; i++) { channel.Writer.TryWrite(i); } })).ContinueWith(t => channel.Writer.TryComplete()) , Task.WhenAll(Enumerable.Range(0, TaskNum).Select(async(idx) => { await Task.Yield(); while (await channel.Reader.WaitToReadAsync().ConfigureAwait(false)) { await Task.Yield(); while (channel.Reader.TryRead(out var item)) { } } })) ); }
public void SettingBench() { var opts = new UnboundedChannelOptions(); opts.SingleReader = SingleReader; opts.SingleWriter = SingleWriter; var channel = Channel.CreateUnbounded <int>(opts); Task.WaitAll( Task.Run(async() => { await Task.Yield(); for (int i = 0; i < LoopNum; i++) { channel.Writer.TryWrite(i); } }).ContinueWith(t => channel.Writer.TryComplete()), Task.Run(async() => { await Task.Yield(); while (await channel.Reader.WaitToReadAsync().ConfigureAwait(false)) { while (channel.Reader.TryRead(out var item)) { ; } } }) ); }
public void AllowAsyncBench() { var opts = new UnboundedChannelOptions(); opts.AllowSynchronousContinuations = AllowAsync; var channel = Channel.CreateUnbounded <int>(opts); { Task.WaitAll( Task.WhenAll(Enumerable.Range(0, WriteTaskNum).Select(async(idx) => { for (int i = 0; i < LoopNum / WriteTaskNum; i++) { await Task.Yield(); channel.Writer.TryWrite(i); } return(0); })).ContinueWith(t => channel.Writer.TryComplete()) , Task.WhenAll(Enumerable.Range(0, ReadTaskNum).Select(async(idx) => { while (await channel.Reader.WaitToReadAsync().ConfigureAwait(false)) { while (channel.Reader.TryRead(out var item)) { await Task.Yield(); } } })) ); } }
public void ChannelBench() { var opt2 = new UnboundedChannelOptions(); opt2.AllowSynchronousContinuations = false; opt2.SingleReader = IsSingleReader; var channel = Channel.CreateUnbounded <int>(opt2); Task.WaitAll( Task.WhenAll(Enumerable.Range(0, TaskNum).Select(async idx => { await channel.Writer.WaitToWriteAsync(); for (int i = 0; i < LoopNum / TaskNum; i++) { channel.Writer.TryWrite(1); } })).ContinueWith(t => channel.Writer.Complete()) , Task.Run(() => { for (int i = 0; i < LoopNum; i++) { while (!channel.Reader.TryRead(out var item)) { } } }) ); }
public Subscription(uint extension) { var options = new UnboundedChannelOptions(); options.SingleReader = true; Queue = Channel.CreateUnbounded <NotificationMessage>(options); Extension = extension; }
public ChannelQueue(int capacity = int.MaxValue) { _capacity = capacity; var options = new UnboundedChannelOptions(); _channel = Channel.CreateUnbounded <T>(options); _items = 0; }
public Task <object> CreateChannel(string type, UnboundedChannelOptions options) { var method = this.GetChannelMethod(Type.GetType(type), false, true); var channel = method.Invoke(method, new object[] { options }); return(Task.FromResult(channel)); }
/// <summary> /// Creates a new UnboundedSingleConsumerChannelStrategy. /// </summary> public UnboundedSingleConsumerChannelStrategy() { options = new UnboundedChannelOptions() { AllowSynchronousContinuations = false, SingleWriter = false, SingleReader = true }; }
public ChannelBlock(UnboundedChannelOptions options, Func <TOut, TOut> optionalfirstStep = null) { Guard.AgainstNull(options, nameof(options)); _logger = LogHelper.LoggerFactory.CreateLogger <ChannelBlock <TOut> >(); _channel = Channel.CreateUnbounded <TOut>(options); _targetBlock = new TransformBlock <TOut, TOut>(optionalfirstStep ?? ((input) => input)); _sourceFromTargetBlock = (ISourceBlock <TOut>)_targetBlock; Completion = _targetBlock.Completion; }
public async Task Run() { var unboundedChannelOptions = new UnboundedChannelOptions(); unboundedChannelOptions.SingleWriter = true; var channel = Channel.CreateUnbounded <int>(unboundedChannelOptions); var channelWriter = channel.Writer; await Task.WhenAll(Task.Run(() => Produce(channelWriter, 1000)), Task.Run(() => Read(channel.Reader, "R1")), Task.Run(() => Read(channel.Reader, "R2"))); }
public DejarixLoggerProvider() { var options = new UnboundedChannelOptions { SingleReader = true, SingleWriter = false, AllowSynchronousContinuations = false }; _channel = Channel.CreateUnbounded <string>(options); }
public LogMessageChannel() { var options = new UnboundedChannelOptions { SingleReader = true, SingleWriter = false }; _channel = Channel.CreateUnbounded <LogMessageContext>(options); _channel.Reader.Completion.ContinueWith(_ => Completed = true); }
public static (ChannelCommunicator client, ChannelCommunicator server) Create() { var options = new UnboundedChannelOptions { SingleReader = true, SingleWriter = true, }; var upstream = Channel.CreateUnbounded <object>(options); var downstream = Channel.CreateUnbounded <object>(options); return(new ChannelCommunicator(downstream.Reader, upstream.Writer), new ChannelCommunicator(upstream.Reader, downstream.Writer)); }
/// <summary> /// Inits the specified source. /// </summary> /// <param name="source">The source.</param> /// <param name="loggerName">Name of the logger.</param> /// <param name="configXml">The config XML.</param> public void Init(IGenericCommunicationService source, string loggerName, XElement configXml) { this.source = source; this.log = source.Logger; this.name = loggerName; this.messageFormat = source.Serializer.MessageFormat; if (dataStreamQueue == null) { UnboundedChannelOptions channelOptions = new UnboundedChannelOptions(); channelOptions.SingleReader = true; channelOptions.SingleWriter = false; dataStreamQueue = Channel.CreateUnbounded <StreamLogItem>(channelOptions); queueWriter = dataStreamQueue.Writer; } else { throw new InvalidOperationException("Logger \"" + name + "\" already initialized!"); } // load config XElement targetDirElement; if (configXml != null && (targetDirElement = configXml.Element("TargetDir")) != null) { this.TargetDir = targetDirElement.Value; } else { if (!string.IsNullOrEmpty(this.TargetDir)) { this.TargetDir = Path.GetFullPath(this.TargetDir); } else { this.TargetDir = Environment.CurrentDirectory; } } XElement keepStreamLogsDaysElement; if (configXml != null && (keepStreamLogsDaysElement = configXml.Element("KeepStreamLogsDays")) != null) { keepStreamLogsDays = int.Parse(keepStreamLogsDaysElement.Value); } // start logging Task.Run(StoreLogItemsThread); }
public ChannelBlockEngine( Func <TIn, Task <TOut> > workBodyAsync, int maxDegreeOfParallelism, bool ensureOrdered, UnboundedChannelOptions options, TaskScheduler taskScheduler = null, CancellationToken token = default) : this(workBodyAsync, maxDegreeOfParallelism, ensureOrdered, taskScheduler) { _channelBlock = new ChannelBlock <TIn>(options); _channelBlock.LinkTo(_workBlock); _channelBlock.StartReadChannel(token); }
internal static IServiceCollection RegisterOutputChannel(this IServiceCollection services) { return(services.AddSingleton <FunctionsHostOutputChannel>(s => { UnboundedChannelOptions outputOptions = new UnboundedChannelOptions { SingleWriter = false, SingleReader = true, AllowSynchronousContinuations = true }; return new FunctionsHostOutputChannel(System.Threading.Channels.Channel.CreateUnbounded <StreamingMessage>(outputOptions)); })); }
/// <summary>Creates an unbounded channel subject to the provided options.</summary> /// <typeparam name="T">Specifies the type of data in the channel.</typeparam> /// <param name="options">Options that guide the behavior of the channel.</param> /// <returns>The created channel.</returns> public static Channel <T> CreateUnbounded <T>(UnboundedChannelOptions options) { if (options is null) { throw new ArgumentNullException(nameof(options)); } if (options.SingleReader) { return(new SingleConsumerUnboundedChannel <T>(!options.AllowSynchronousContinuations)); } return(new UnboundedChannel <T>(!options.AllowSynchronousContinuations)); }
public void ThreadingChannelWriteOnly() { var opt2 = new UnboundedChannelOptions(); opt2.AllowSynchronousContinuations = false; var channel = Channel.CreateUnbounded <int>(opt2); Task.WhenAll(Enumerable.Range(0, WTaskNum).Select(async(idx) => { await Task.Yield(); for (int i = 0; i < LoopNum / WTaskNum; i++) { channel.Writer.TryWrite(i); } })).ContinueWith(t => channel.Writer.TryComplete()).Wait(); }
/// <summary> /// Initializes a new instance of the <see cref="RuntimeHandler"/> class. /// </summary> /// <param name="options">The test server's options.</param> /// <param name="cancellationToken">The cancellation token that is signalled when request listening should stop.</param> internal RuntimeHandler(LambdaTestServerOptions options, CancellationToken cancellationToken) { _cancellationToken = cancellationToken; _options = options; // Support multi-threaded access to the request queue, although the default // usage scenario would be a single reader and writer from a test method. var channelOptions = new UnboundedChannelOptions() { SingleReader = false, SingleWriter = false, }; _requests = Channel.CreateUnbounded <LambdaTestRequest>(channelOptions); _responses = new ConcurrentDictionary <string, Channel <LambdaTestResponse> >(StringComparer.Ordinal); }
public JobProgressUpdater( IJobStore jobStore, Job job, ILogger <JobProgressUpdater> logger) { _jobStore = EnsureArg.IsNotNull(jobStore, nameof(jobStore)); _job = EnsureArg.IsNotNull(job, nameof(job)); _logger = EnsureArg.IsNotNull(logger, nameof(logger)); var channelOptions = new UnboundedChannelOptions { SingleReader = true, SingleWriter = false, }; _progressChannel = Channel.CreateUnbounded <TaskContext>(channelOptions); }
public void Setup() { var options = new UnboundedChannelOptions(); _producer = new Producer <int>(); _consumers = new List <Consumer <int> >(); for (int i = 0; i < Consumers; ++i) { _consumers.Add(new Consumer <int>()); } foreach (var consumer in _consumers) { _producer.LinkTo(consumer, options); } }
public void ThreadingChannel() { var opt2 = new UnboundedChannelOptions(); opt2.AllowSynchronousContinuations = false; opt2.SingleReader = true; var channel = Channel.CreateUnbounded <int>(opt2); for (int i = 0; i < LoopNum; i++) { channel.Writer.TryWrite(i); } for (int i = 0; i < LoopNum; i++) { channel.Reader.TryRead(out var x); } }
/// <summary> /// Creates a new UnboundedMultiConsumerChannelStrategy. /// </summary> /// <param name="maxChannelConsumers">Maximum number of consumers allowed or null if unbound.</param> public UnboundedMultiConsumerChannelStrategy(uint?maxChannelConsumers) { offeringOptions = new UnboundedChannelOptions() { AllowSynchronousContinuations = false, SingleWriter = true, SingleReader = true }; receivingOptions = new UnboundedChannelOptions() { AllowSynchronousContinuations = false, SingleWriter = false, SingleReader = true }; StartReceiving(maxChannelConsumers); }
public ChannelExecutor(int concurrencyLimit) { var channelOptions = new UnboundedChannelOptions { AllowSynchronousContinuations = true, SingleReader = concurrencyLimit == 1, SingleWriter = false }; _channel = Channel.CreateUnbounded <IFuture>(channelOptions); _runTasks = new Task[concurrencyLimit]; for (var i = 0; i < concurrencyLimit; i++) { _runTasks[i] = Task.Run(RunFromChannel); } }
public GrpcNode(IMessageFabric messageFabric, NodeContext context) { _messageFabric = messageFabric; _context = context; _remoteTopology = new RemoteNodeTopology(this, messageFabric); var outputOptions = new UnboundedChannelOptions { SingleWriter = false, SingleReader = true, AllowSynchronousContinuations = true }; _channel = System.Threading.Channels.Channel.CreateUnbounded <TransportMessage>(outputOptions); Writer = _channel.Writer; }
public ChannelExecutor(int concurrencyLimit, bool allowSynchronousContinuations = true) { _concurrencyLimit = concurrencyLimit; var channelOptions = new UnboundedChannelOptions { AllowSynchronousContinuations = allowSynchronousContinuations, SingleReader = true, SingleWriter = false }; _channel = Channel.CreateUnbounded <IFuture>(channelOptions); _syncLock = new object(); _limit = new SemaphoreSlim(concurrencyLimit); _readerTask = Task.Run(() => ReadFromChannel()); }
public ChannelTaskScheduler(ExtendedActorSystem system) { //config channel-scheduler var config = system.Settings.Config.GetConfig("akka.channel-scheduler"); _maximumConcurrencyLevel = ThreadPoolConfig.ScaledPoolSize( config.GetInt("parallelism-min"), config.GetDouble("parallelism-factor", 1.0D), // the scalar-based factor to scale the threadpool size to config.GetInt("parallelism-max")); _maximumConcurrencyLevel = Math.Max(_maximumConcurrencyLevel, 1); _maxWork = Math.Max(config.GetInt("work-max", _maxWork), 3); //min 3 normal work in work-loop _workInterval = config.GetInt("work-interval", _workInterval); _workStep = config.GetInt("work-step", _workStep); //create task schedulers var channelOptions = new UnboundedChannelOptions() { AllowSynchronousContinuations = true, SingleReader = _maximumConcurrencyLevel == 1, SingleWriter = false }; _highScheduler = new PriorityTaskScheduler(Channel.CreateUnbounded <Task>(channelOptions), TaskSchedulerPriority.AboveNormal); _normalScheduler = new PriorityTaskScheduler(Channel.CreateUnbounded <Task>(channelOptions), TaskSchedulerPriority.Normal); _lowScheduler = new PriorityTaskScheduler(Channel.CreateUnbounded <Task>(channelOptions), TaskSchedulerPriority.Low); _idleScheduler = new PriorityTaskScheduler(Channel.CreateUnbounded <Task>(channelOptions), TaskSchedulerPriority.Idle); //prefill coworker array _coworkers = new Task[_maximumConcurrencyLevel - 1]; for (var i = 0; i < _coworkers.Length; i++) { _coworkers[i] = Task.CompletedTask; } //init paused timer _timer = new Timer(ScheduleCoWorkers, "timer", Timeout.Infinite, Timeout.Infinite); //start main worker _controlTask = Task.Factory.StartNew(ControlAsync, _cts.Token, TaskCreationOptions.DenyChildAttach | TaskCreationOptions.LongRunning, TaskScheduler.Default).Unwrap(); }
public ChannelExecutor(int concurrencyLimit, bool allowSynchronousContinuations) { var channelOptions = new UnboundedChannelOptions { AllowSynchronousContinuations = allowSynchronousContinuations, SingleReader = concurrencyLimit == 1, SingleWriter = false }; _channel = Channel.CreateUnbounded <IFuture>(channelOptions); _runTasks = new Task[concurrencyLimit]; _syncLock = new object(); for (var i = 0; i < concurrencyLimit; i++) { _runTasks[i] = Task.Run(() => RunFromChannel()); } }