We present Piko, a framework for designing, optimizing, and retargeting implementations of graphics pipelines on multiple architectures. Piko programmers express a graphics pipeline by organizing the computation within each stage into spatial bins and specifying a scheduling preference for these bins. Our compiler, Pikoc, compiles this input into an optimized implementation targeted to a massively-parallel GPU or a multicore CPU. Piko manages work granularity in a programmable and flexible manner, allowing programmers to build load-balanced parallel pipeline implementations, to exploit spatial and producer-consumer locality in a pipeline implementation, and to explore tradeoffs between these considerations. We demonstrate that Piko can implement a wide range of pipelines, including rasterization, Reyes, ray tracing, rasterization/ray tracing hybrid, and deferred rendering. Piko allows us to implement efficient graphics pipelines with relative ease and to quickly explore design alternatives by modifying the spatial binning configurations and scheduling preferences for individual stages, all while delivering real-time performance that is within a factor six of state-of-the-art rendering systems.

In this paper we explore strategies for screen-space tiling in programmable rendering pipelines on modern GPUs. The need for tiling arises from the inherent unpredictability of workload size in many rendering pipelines. While it additionally also reduces the bandwidth demand of the rendering operations and increases locality of memory accesses, we focus on meeting resource limits in programmable rendering. We show that by ensuring load balance, dynamic tiling in a modern programmable GPU pipeline delivers performance improvements over traditional static tiling techniques. We explore prediction and splitting algorithms for adaptive tiling schemes and demonstrate that even approximate estimates of tile bounds can reduce tiling overhead. We evaluate the above optimizations by implementing them for a three GPU-based tiled renderers while keeping our observations general enough so that they are applicable to other forms of rendering as well.

Abstract We present a strategy for parallelizing the composite and filter operations suitable for an order‐independent rendering pipeline implemented on a modern graphics processor. Conventionally, this task is parallelized across pixels/subpixels, but serialized along individual depth layers. However, our technique extends the domain of parallelization to individual fragments (samples), avoiding a serial dependence on the number of depth layers, which can be a constraint for scenes with high depth complexity. As a result, our technique scales with the number of fragments and can sustain a consistent and predictable throughput in scenes with both low and high depth complexity, including those with a high variability of depth complexity within a single frame. We demonstrate composite/filter performance in excess of 50M fragments/sec for scenes with more than 1500 semi‐transparent layers.

A good random number generator is essential for many graphics applications. As more such applications move onto parallel processing, it is vital that a good parallel random number generator be used. Unfortunately, most random number generators today are still sequential, exposing performance bottlenecks and denying random accessibility for parallel computations. Furthermore, popular parallel random number generators are still based off sequential methods and can exhibit statistical bias.