Beispiel #1
0
        private IRingBuffer InstantiateBuffer()
        {
            var buffer = new ManyToOneRingBuffer(new UnsafeBuffer(BufferSize + RingBufferDescriptor.TrailerLength));

            _buffers.Add(buffer);
            return(buffer);
        }
Beispiel #2
0
 public Worker(int countDown, ManualResetEventSlim wait, ManyToOneRingBuffer buffer, CancellationToken token)
 {
     _countDown = countDown;
     _wait      = wait;
     _buffer    = buffer;
     _token     = token;
 }
        public void SetUp()
        {
            _buffer = A.Fake <IAtomicBuffer>();

            A.CallTo(() => _buffer.Capacity).Returns(TotalBufferLength);

            _ringBuffer = new ManyToOneRingBuffer(_buffer);
        }
Beispiel #4
0
        public unsafe void Actors()
        {
            using (var buffer =
                       new ManyToOneRingBuffer(new UnsafeBuffer(1024.Megabytes() + RingBufferDescriptor.TrailerLength)))
            {
                var someBytes = stackalloc byte[1];
                buffer.Write(5, new ByteChunk(someBytes, 1));
                buffer.Read((a, b) => { }, 1);

                var module = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("ActorsTestsDynAssembly"),
                                                                           AssemblyBuilderAccess.Run).DefineDynamicModule("main");
                var counter  = new StructSizeCounter();
                var registry =
                    new ActorRegistry(new[]
                                      { Tuple.Create(new ActorDescriptor(new Handler()), (IRingBuffer)buffer, new ActorId(1)) });
                var writer = MessageWriterBuilder.Build(counter, registry.GetMessageTypeId, new[] { typeof(A) }, module);

                var bus = new Bus(new ActorId(2), registry, 20, writer);

                var msg = new A();
                bus.Publish(ref msg);

                // publication is prepared do it

                var howMany    = 200000000;
                var oneMiliion = 1000000;

                using (var scheduler = new RoundRobinThreadAffinedTaskScheduler(4))
                {
                    var wait = new ManualResetEventSlim();
                    var t    = new CancellationToken();

                    var p1                = CreateProducer(wait, t, howMany, bus, scheduler);
                    var p2                = CreateProducer(wait, t, howMany, bus, scheduler);
                    var producentCount    = 2;
                    var totalMessageCount = howMany * producentCount;

                    var worker   = new Worker(totalMessageCount, wait, buffer, t);
                    var consumer = Task.Factory.StartNew(worker.DoWhile, t, TaskCreationOptions.LongRunning, scheduler);

                    GC.Collect(2, GCCollectionMode.Forced);

                    var sw = Stopwatch.StartNew();
                    wait.Set();

                    Task.WaitAll(p1, p2, consumer);

                    sw.Stop();
                    Console.WriteLine(
                        $"{howMany} messages written by each of {producentCount} producers and consumed in {sw.Elapsed}");
                    Console.WriteLine(
                        $"One million in {TimeSpan.FromMilliseconds(sw.Elapsed.TotalMilliseconds*oneMiliion/totalMessageCount)}");
                }
            }
        }
Beispiel #5
0
        public void SetUp()
        {
            _buffer = Substitute.For <IUnsafeBuffer>();
            _buffer.Size.Returns(TotalBufferLength);

            _buffer.GetAtomicLong(Arg.Any <long>()).Returns(ci => new AtomicLong((byte *)ci.Arg <long>()));
            _buffer.GetAtomicInt(Arg.Any <long>()).Returns(ci => new AtomicInt((byte *)ci.Arg <long>()));

            _atomicLong      = Substitute.For <Mocks.IAtomicLong>();
            Mocks.AtomicLong = _atomicLong;
            _atomicInt       = Substitute.For <Mocks.IAtomicInt>();
            Mocks.AtomicInt  = _atomicInt;

            _ringBuffer = new ManyToOneRingBuffer(_buffer);
        }
Beispiel #6
0
        public unsafe void Setup()
        {
            _buffer = new ManyToOneRingBuffer(new UnsafeBuffer(1024.Megabytes() + RingBufferDescriptor.TrailerLength));
            var someBytes = stackalloc byte[1];

            _buffer.Write(5, new ByteChunk(someBytes, 1));
            _buffer.Read((a, b) => { }, 1);

            var module = AppDomain.CurrentDomain.DefineDynamicAssembly(
                new AssemblyName("ActorsTestsDynAssembly"),
                AssemblyBuilderAccess.Run).DefineDynamicModule("main");
            var counter  = new StructSizeCounter();
            var registry =
                new ActorRegistry(
                    new[]
                    { Tuple.Create(new ActorDescriptor(new Handler()), (IRingBuffer)_buffer, new ActorId(1)) });
            var writer = MessageWriterBuilder.Build(counter, registry.GetMessageTypeId, new[] { typeof(A) }, module);

            _bus = new Bus(new ActorId(2), registry, 20, writer);
        }
 public void Setup()
 {
     conductorBuffer = new ManyToOneRingBuffer(new UnsafeBuffer(new byte[RingBufferDescriptor.TrailerLength + 1024]));
     conductor       = new DriverProxy(conductorBuffer);
 }
 public void Setup()
 {
     conductorBuffer = new ManyToOneRingBuffer(new UnsafeBuffer(BufferUtil.AllocateDirect(RingBufferDescriptor.TrailerLength + 1024)));
     conductor       = new DriverProxy(conductorBuffer, CLIENT_ID);
 }
Beispiel #9
0
 private void InitializeInstanceFields()
 {
     _unsafeBuffer = new UnsafeBuffer(_byteBuffer);
     _ringBuffer   = new ManyToOneRingBuffer(_unsafeBuffer);
 }
Beispiel #10
0
 private void InitializeInstanceFields()
 {
     _unsafeBuffer = new UnsafeBuffer(BufferUtil.AllocateDirectAligned(16 * 1024 + RingBufferDescriptor.TrailerLength, BitUtil.CACHE_LINE_LENGTH));
     _ringBuffer   = new ManyToOneRingBuffer(_unsafeBuffer);
 }