Beispiel #1
0
        public void CanUseGraphValueResolver_ToResolveValues_InAJob(NodeSet.RenderExecutionModel computeType)
        {
            using (var results = new NativeArray <float>(1, Allocator.Persistent))
                using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(computeType))
                {
                    var root = set.Create <RenderPipe>();

                    GraphValue <float> rootValue = set.CreateGraphValue(root, RenderPipe.KernelPorts.Output);

                    for (int i = 0; i < 100; ++i)
                    {
                        set.SendMessage(root, RenderPipe.SimulationPorts.Input, i);

                        set.Update();

                        GraphValueReadbackJob job;

                        job.Value    = rootValue;
                        job.Result   = results;
                        job.Resolver = set.GetGraphValueResolver(out var valueResolverDependency);

                        set.InjectDependencyFromConsumer(job.Schedule(valueResolverDependency));

                        // Automatically fences before CopyWorlds. Results is accessible now.
                        set.Update();

                        Assert.AreEqual(i, results[0]);
                        Assert.AreEqual(i, set.GetValueBlocking(rootValue));
                    }

                    set.Destroy(root);
                    set.ReleaseGraphValue(rootValue);
                }
        }
Beispiel #2
0
        public void ResolvedGraphBuffers_AreReadOnly()
        {
            using (var results = new NativeArray <int>(1, Allocator.Persistent))
                using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(NodeSet.RenderExecutionModel.MaximallyParallel))
                {
                    var root = set.Create <RenderPipeAggregate>();

                    GraphValue <Aggregate> rootValue = set.CreateGraphValue(root, RenderPipeAggregate.KernelPorts.Output);

                    Aggregate aggr = default;
                    aggr.InputPlusOneI = Buffer <int> .SizeRequest(1);

                    set.SetBufferSize(root, RenderPipeAggregate.KernelPorts.Output, aggr);

                    set.Update();

                    CheckReadOnlyNess_OfResolvedGraphBuffer job;

                    job.Value    = rootValue;
                    job.Result   = results;
                    job.Resolver = set.GetGraphValueResolver(out var valueResolverDependency);

                    set.InjectDependencyFromConsumer(job.Schedule(valueResolverDependency));

                    set.Update();

                    Assert.AreEqual(1, results[0]);

                    set.Destroy(root);
                    set.ReleaseGraphValue(rootValue);
                }
        }
Beispiel #3
0
        public void CanUseGraphValueResolver_ToResolveAggregate_WithBuffers_InAJob(int bufferLength)
        {
            using (var results = new NativeArray <int>(bufferLength + 1, Allocator.Persistent))
                using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(NodeSet.RenderExecutionModel.MaximallyParallel))
                {
                    var root = set.Create <RenderPipeAggregate>();

                    GraphValue <Aggregate> rootValue = set.CreateGraphValue(root, RenderPipeAggregate.KernelPorts.Output);

                    for (int i = 0; i < 20; ++i)
                    {
                        set.SetData(root, RenderPipeAggregate.KernelPorts.Input, i);

                        Aggregate aggr = default;
                        aggr.InputPlusOneI = Buffer <int> .SizeRequest(bufferLength);

                        set.SetBufferSize(root, RenderPipeAggregate.KernelPorts.Output, aggr);

                        set.Update();

                        GraphAggregateReadbackJob job;

                        job.Value    = rootValue;
                        job.Result   = results;
                        job.Resolver = set.GetGraphValueResolver(out var valueResolverDependency);

                        set.InjectDependencyFromConsumer(job.Schedule(valueResolverDependency));

                        // Automatically fences before CopyWorlds. Results is accessible now.
                        set.Update();

                        for (int z = 0; z < bufferLength + 1; ++z)
                        {
                            Assert.AreEqual(i + z, results[z]);
                        }
                    }

                    set.Destroy(root);
                    set.ReleaseGraphValue(rootValue);
                }
        }
Beispiel #4
0
        public void UpdatedBufferSize_InAggregate_ReflectsInDependent_ReadbackJob()
        {
            const int k_MaxBufferLength = 20;

            using (var results = new NativeArray <int>(1, Allocator.Persistent))
                using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(NodeSet.RenderExecutionModel.MaximallyParallel))
                {
                    var root = set.Create <RenderPipeAggregate>();

                    GraphValue <Aggregate> rootValue = set.CreateGraphValue(root, RenderPipeAggregate.KernelPorts.Output);

                    // Test increasing buffer sizes, then decreasing
                    foreach (var i in Enumerable.Range(0, k_MaxBufferLength).Concat(Enumerable.Range(0, k_MaxBufferLength).Reverse()))
                    {
                        Aggregate aggr = default;
                        aggr.InputPlusOneI = Buffer <int> .SizeRequest(i);

                        set.SetBufferSize(root, RenderPipeAggregate.KernelPorts.Output, aggr);

                        set.Update();

                        GraphBufferSizeReadbackJob job;

                        job.Value    = rootValue;
                        job.Result   = results;
                        job.Resolver = set.GetGraphValueResolver(out var valueResolverDependency);

                        set.InjectDependencyFromConsumer(job.Schedule(valueResolverDependency));

                        // Automatically fences before CopyWorlds. Results is accessible now.
                        set.Update();

                        Assert.AreEqual(i, results[0], "Buffer size mismatch between expected and actual");
                    }

                    set.Destroy(root);
                    set.ReleaseGraphValue(rootValue);
                }
        }
Beispiel #5
0
        public void CanResolveGraphValues_OnMainThread_AfterFencing_ResolverDependencies()
        {
            const int k_BufferSize = 5;

            using (var set = new RenderGraphTests.PotentiallyJobifiedNodeSet(NodeSet.RenderExecutionModel.MaximallyParallel))
            {
                var root = set.Create <RenderPipeAggregate>();

                GraphValue <Aggregate> rootValue = set.CreateGraphValue(root, RenderPipeAggregate.KernelPorts.Output);

                Aggregate aggr = default;
                aggr.InputPlusOneI = Buffer <int> .SizeRequest(k_BufferSize);

                set.SetBufferSize(root, RenderPipeAggregate.KernelPorts.Output, aggr);

                set.Update();

                var resolver = set.GetGraphValueResolver(out var valueResolverDependency);
                valueResolverDependency.Complete();

                var renderGraphAggr = /* ref readonly */ resolver.Resolve(rootValue);
                var array           = renderGraphAggr.InputPlusOneI.ToNative(resolver);

                Assert.AreEqual(k_BufferSize, array.Length);
                int readback = 0;
                Assert.DoesNotThrow(() => readback = array[k_BufferSize - 1]);

                // After this, secondary invalidation should make all operations impossible on current resolver
                // and anything that has been resolved from it
                set.Update();

                Assert.Throws <InvalidOperationException>(() => resolver.Resolve(rootValue));
                Assert.Throws <InvalidOperationException>(() => readback = array[k_BufferSize - 1]);

                set.Destroy(root);
                set.ReleaseGraphValue(rootValue);
            }
        }