コード例 #1
0
        public void LockAfterAllThreadsDecrementAndOneThreadDecrementsASecondTime(int aThreadIndex, int bThreadIndex)
        {
            var primitive = new ThreadingPrimitive(2);

            Assert.That(async() => await RunWithTimeout(
                            () =>
            {
                primitive.DecrementAndWait(aThreadIndex);
                primitive.DecrementAndWait(aThreadIndex);
            },
                            () => primitive.DecrementAndWait(bThreadIndex)), Throws.TypeOf <TimeoutException>());
        }
コード例 #2
0
        public void ShouldContinueAfterMultipleThreadsDecrement(int[] threadIds)
        {
            var primitive = new ThreadingPrimitive(10);

            Assert.That(async() => await RunWithTimeout(
                            () => primitive.DecrementAndWait(threadIds[0]),
                            () => primitive.DecrementAndWait(threadIds[1]),
                            () => primitive.DecrementAndWait(threadIds[2]),
                            () => primitive.DecrementAndWait(threadIds[3]),
                            () => primitive.DecrementAndWait(threadIds[4]),
                            () => primitive.DecrementAndWait(threadIds[5]),
                            () => primitive.DecrementAndWait(threadIds[6]),
                            () => primitive.DecrementAndWait(threadIds[7]),
                            () => primitive.DecrementAndWait(threadIds[8]),
                            () => primitive.DecrementAndWait(threadIds[9])), Throws.Nothing);
        }
コード例 #3
0
        public ParallelPipeline(IReadOnlyList <PipelineStage> pipelineStages)
        {
            this.PipelineStages      = pipelineStages;
            this.MaxConcurrency      = this.PipelineStages.Max(stage => stage.Systems.Count);
            this.ExternalThreadIndex = this.MaxConcurrency;

            this.StartFramePrimitive = new ThreadingPrimitive(this.MaxConcurrency + 1, 10000);
            this.EndFramePrimitive   = new ThreadingPrimitive(this.MaxConcurrency + 1, 10000);

            this.StagePrimitive = new ThreadingPrimitive(this.MaxConcurrency);

            this.Threads = new Thread[this.MaxConcurrency];
            for (var i = 0; i < this.MaxConcurrency; i++)
            {
                this.Threads[i] = new Thread(threadIndex => this.ThreadStart(threadIndex));
                this.Threads[i].Start(i);
            }

            this.pipelineState = PipelineState.ReadyForNextRun;
        }
コード例 #4
0
        public void Continue()
        {
            var primitive = new ThreadingPrimitive(1);

            Assert.That(async() => await RunWithTimeout(() => primitive.DecrementAndWait(0)), Throws.Nothing);
        }
コード例 #5
0
        public void Lock(int threadIndex)
        {
            var primitive = new ThreadingPrimitive(2);

            Assert.That(async() => await RunWithTimeout(() => primitive.DecrementAndWait(threadIndex)), Throws.TypeOf <TimeoutException>());
        }