Hubbry Logo
Tiled renderingTiled renderingMain
Open search
Tiled rendering
Community hub
Tiled rendering
logo
7 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Contribute something
Tiled rendering
Tiled rendering
Tiled rendering
View on Wikipedia
from Wikipedia

Tiled rendering is the process of subdividing a computer graphics image by a regular grid in optical space and rendering each section of the grid, or tile, separately. The advantage to this design is that the amount of memory and bandwidth is reduced compared to immediate mode rendering systems that draw the entire frame at once. This has made tile rendering systems particularly common for low-power handheld device use. Tiled rendering is sometimes known as a "sort middle" architecture, because it performs the sorting of the geometry in the middle of the graphics pipeline instead of near the end.[1]

Basic concept

[edit]

Creating a 3D image for display consists of a series of steps. First, the objects to be displayed are loaded into memory from individual models. The system then applies mathematical functions to transform the models into a common coordinate system, the world view. From this world view, a series of polygons (typically triangles) is created that approximates the original models as seen from a particular viewpoint, the camera. Next, a compositing system produces an image by rendering the triangles and applying textures to the outside. Textures are small images that are painted onto the triangles to produce realism. The resulting image is then combined with various special effects, and moved into a frame buffer, which video hardware then scans to produce the displayed image. This basic conceptual layout is known as the display pipeline.

Each of these steps increases the amount of memory needed to hold the resulting image. By the time it reaches the end of the pipeline the images are so large that typical graphics card designs often use specialized high-speed memory and a very fast computer bus to provide the required bandwidth to move the image in and out of the various sub-components of the pipeline. This sort of support is possible on dedicated graphics cards, but as power and size budgets become more limited, providing enough bandwidth becomes expensive in design terms.

Tiled renderers address this concern by breaking down the image into sections known as tiles, and rendering each one separately. This reduces the amount of memory needed during the intermediate steps, and the amount of data being moved about at any given time. To do this, the system sorts the triangles making up the geometry by location, allowing to quickly find which triangles overlap the tile boundaries. It then loads just those triangles into the rendering pipeline, performs the various rendering operations in the GPU, and sends the result to the frame buffer. Very small tiles can be used, 16×16 and 32×32 pixels are popular tile sizes, which makes the amount of memory and bandwidth required in the internal stages small as well. And because each tile is independent, it naturally lends itself to simple parallelization.

In a typical tiled renderer, geometry must first be transformed into screen space and assigned to screen-space tiles. This requires some storage for the lists of geometry for each tile. In early tiled systems, this was performed by the CPU, but all modern hardware contains hardware to accelerate this step. The list of geometry can also be sorted front to back, allowing the GPU to use hidden surface removal to avoid processing pixels that are hidden behind others, saving on memory bandwidth for unnecessary texture lookups.[2]

There are two main disadvantages of the tiled approach. One is that some triangles may be drawn several times if they overlap several tiles. This means the total rendering time would be higher than an immediate-mode rendering system. There are also possible issues when the tiles have to be stitched together to make a complete image, but this problem was solved long ago[citation needed]. More difficult to solve is that some image techniques are applied to the frame as a whole, and these are difficult to implement in a tiled render where the idea is to not have to work with the entire frame. These tradeoffs are well known, and of minor consequence for systems where the advantages are useful; tiled rendering systems are widely found in handheld computing devices.

Tiled rendering should not be confused with tiled/nonlinear framebuffer addressing schemes, which make adjacent pixels also adjacent in memory.[3] These addressing schemes are used by a wide variety of architectures, not just tiled renderers.

Early work

[edit]

Much of the early work on tiled rendering was done as part of the Pixel Planes 5 architecture (1989).[4][5]

The Pixel Planes 5 project validated the tiled approach and invented a lot of the techniques now viewed as standard for tiled renderers. It is the work most widely cited by other papers in the field.

The tiled approach was also known early in the history of software rendering. Implementations of Reyes rendering often divide the image into "tile buckets".

Commercial products – Desktop and console

[edit]

Early in the development of desktop GPUs, several companies developed tiled architectures. Over time, these were largely supplanted by immediate-mode GPUs with fast custom external memory systems.

Major examples of this are:

Examples of non-tiled architectures that use large on-chip buffers are:

  • Xbox 360 (2005): the GPU contains an embedded 10 MB eDRAM; this is not sufficient to hold the raster for an entire 1280×720 image with 4× multisample anti-aliasing, so a tiling solution is superimposed when running in HD resolutions and 4× MSAA is enabled.[15]
  • Xbox One (2013): the GPU contains an embedded 32 MB eSRAM, which can be used to hold all or part of an image. It is not a tiled architecture, but is flexible enough that software developers can emulate tiled rendering.[16][failed verification]

Commercial products – Embedded

[edit]

Due to the relatively low external memory bandwidth, and the modest amount of on-chip memory required, tiled rendering is a popular technology for embedded GPUs. Current examples include:

Tile-based immediate mode rendering (TBIM):

Tile-based deferred rendering (TBDR):

Vivante produces mobile GPUs which have tightly coupled frame buffer memory (similar to the Xbox 360 GPU described above). Although this can be used to render parts of the screen, the large size of the rendered regions means that they are not usually described as using a tile-based architecture.

See also

[edit]

References

[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Tiled rendering

View on Grokipedia
from Grokipedia
Tiled rendering is a technique used in graphics processing units (GPUs) to divide the rendering target, such as a screen or , into small rectangular regions called , which are processed sequentially to minimize usage and improve efficiency. This approach involves a two-stage process: first, a binning pass sorts (like triangles) into the they overlap, and second, each is rasterized and shaded independently using on-chip before being written to the final . By confining rendering operations to local , tiled rendering avoids frequent accesses to slower off-chip , making it particularly suitable for power-constrained devices like mobile GPUs. The technique originated in the 1990s with early implementations by companies like PowerVR and Gigapixel, who developed tile-based architectures to address bandwidth limitations in embedded systems. PowerVR's tile-based deferred rendering (TBDR), for instance, deferred shading until visibility was determined per tile, a method that gained prominence in mobile GPUs from vendors such as , , and . Over time, variants emerged, including tile-based immediate rendering (TBIR) in desktop GPUs like NVIDIA's Maxwell and Pascal architectures, which rasterize and shade tiles without full deferral but still buffer outputs on-die for efficiency. GPUs, starting with the A11 chip, enhanced TBDR with features like imageblocks for per-pixel data and tile shaders that integrate compute operations, further optimizing for high-performance mobile rendering. Key benefits of tiled rendering include reduced power consumption—critical for battery-powered devices, where mobile GPUs operate at 3-6 watts compared to hundreds for desktops—and higher performance through overdraw reduction, as shaders execute only on visible fragments within a tile. It contrasts with immediate-mode rendering (IMR) architectures, which process across the entire frame without tiling, leading to higher bandwidth demands and less efficiency in memory-limited environments. Today, tiled rendering dominates mobile and XR platforms, such as Meta Quest devices and Samsung Galaxy hardware, enabling complex 3D scenes despite constrained resources like 1-5 MB of on-chip memory.

Fundamentals

Definition and Principles

Tiled rendering, also known as tile-based rendering, is a processing technique that divides the screen space into a of small rectangular , typically measuring 16x16 or 32x32 pixels, and renders each independently to optimize usage and bandwidth efficiency. This approach processes the entire scene geometry once to determine which overlap each , avoiding the need for full-framebuffer reads and writes during . By confining rendering operations to local on-chip for each , tiled rendering reduces external traffic, which is particularly beneficial in power-constrained environments. The core principles revolve around a two-pass : first, a binning stage where vertex-shaded primitives are sorted and assigned to relevant based on their screen-space coverage, creating compact per-tile lists of contributing . In the second stage, each is rasterized and in isolation, performing hidden surface removal—such as depth testing—entirely within on-chip buffers to eliminate occluded fragments early and prevent unnecessary shading computations. This deferred aspect ensures that only occurs for visible surfaces, further minimizing redundant work and bandwidth demands, as intermediate data like depth and color values remain local until the is complete. Tile size selection balances several factors, including the degree of parallelism across shader cores, the on-chip required for tile buffers, and overhead from handling tile boundaries, such as edge artifacts or additional primitive tests. Smaller tiles enhance locality and reduce memory per tile but increase binning overhead and boundary computations, while larger tiles improve coherence for complex scenes at the cost of higher local storage needs.

Comparison to Immediate Mode Rendering

Immediate mode rendering, also known as immediate-mode rendering or , processes graphics primitives in the order they are submitted by the application, immediately transforming vertices, rasterizing triangles, and writing fragment data directly to an off-chip in main memory. This approach results in high demands, particularly due to overdraw—where multiple fragments are processed and written for the same —and frequent texture fetches that traverse the for each fragment across the entire screen. In contrast, tiled rendering divides the screen into small rectangular tiles (typically 16x16 or 32x32 pixels) and processes each tile independently using on-chip tile buffers for local storage of , and other fragment data, minimizing external memory accesses until the tile is complete. This enables early depth and testing confined to the tile, rejecting occluded fragments before computations, unlike immediate mode's scene-wide processing that applies tests after full rasterization. Tiled rendering thus achieves lower bandwidth by localizing operations, while immediate mode relies on global memory for updates, exacerbating latency in bandwidth-constrained environments like mobile GPUs. Bandwidth savings in tiled rendering arise because only tile-local is stored on-chip before a single write-back to . In immediate mode, bandwidth scales with the full screen resolution times an overdraw factor (often 2-4x in complex scenes), leading to repeated off-chip reads and writes for depth, textures, and colors. Tiled rendering reduces bandwidth through on-chip buffering, depending on scene . A key trade-off lies in parallelism: tiled rendering supports fine-grained parallelism at the tile level, allowing multiple to be processed concurrently on GPU cores with reduced contention, but it introduces binning overhead to assign to tiles. Immediate mode, conversely, enables coarser-grained parallelism across entire or draw calls without this preprocessing, facilitating simpler driver implementations but at the cost of inefficient resource utilization in overdraw-heavy scenarios.

Historical Development

Early Concepts and Research

The Pixel Planes project, initiated in 1981 at the by Henry Fuchs and John Poulton, marked a foundational effort in developing efficient hardware for rendering. This VLSI-oriented design introduced pixel-parallel processing, where computations such as and visibility tests occur directly at the pixel level using specialized memory chips, aiming to overcome bandwidth limitations in traditional frame buffers. By distributing processing across pixels, the approach enabled real-time interaction with three-dimensional images, laying early groundwork for localized rendering strategies that would influence tiled methods. Building on this, Fuchs and Poulton's 1985 work further advanced deferred techniques within the Pixel Planes framework, demonstrating algorithms for fast rendering of spheres, , textures, transparencies, and image enhancements. These methods deferred complex shading operations until after visibility resolution, reducing redundant computations and memory accesses in hardware prototypes. This deferred approach highlighted the potential for separating geometric from pixel filling, a core principle that would later integrate with tiling to optimize bandwidth in resource-constrained systems. Tiling concepts emerged prominently in the Pixel Planes 5 , detailed in a 1989 publication by Fuchs, Poulton, and collaborators, which subdivided the screen into 128×128 pixel patches processed by multiple SIMD renderers. This tile-based subdivision allowed independent handling of primitives per patch, with simulations validating high performance—up to 150,000 Phong-shaded triangles per second per renderer—while minimizing global memory bandwidth through on-chip SRAM and local VRAM operations. Academic prototypes and simulations demonstrated substantial reductions in frame buffer traffic by localizing pixel updates, achieving efficient rendering of complex scenes with up to 1 million triangles per second across multiple renderers. Earlier scan-line algorithms, such as those developed by Kevin Weiler in the late and extended through the , contributed to the evolution toward tiled rendering by employing recursive image subdivision for hidden surface removal. Weiler's area sorting method divided the viewport into smaller windows to resolve visibility, shifting from one-dimensional scan-line traversal to two-dimensional regions that better accommodated and complex interactions. This progression from linear scan-lines to 2D tiles improved coherence exploitation and reduced overdraw in simulations, paving the way for hardware-efficient tiled pipelines.

Commercial Milestones

The first commercial implementation of tiled rendering in consumer graphics hardware arrived with the PowerVR PCX1 chipset, released in 1996 by VideoLogic (later ), which introduced full tile-based deferred rendering (TBDR) for personal computers. This architecture divided the screen into tiles to reduce , enabling efficient on limited hardware of the era. The PCX1 powered add-in cards like the M3D and 3Dlabs Oxygen VX1, marking an early shift toward bandwidth-optimized rendering in desktop GPUs. Concurrently, in the late 1990s, Gigapixel developed tile-based rendering technology, including the GigaMan engine announced in 1999, though it was not released commercially before the company's acquisition by in 2000. In the late 1990s, tiled rendering entered the console market through the Sega Dreamcast, launched in 1998, which utilized the PowerVR2 (CLX2) GPU—a second-generation TBDR design capable of rendering up to 7 million polygons per second at resolution. This console's adoption highlighted tiled rendering's advantages in power-constrained embedded systems, influencing future handheld and mobile designs. The 2000s saw further expansion into mobile devices, with ARM's acquisition of Falanx MicroSystems in 2006 leading to the GPU family, which integrated TBDR for low-power embedded applications starting with the Mali-55 and Mali-200 series. Console milestones continued with the in 2011, featuring a quad-core PowerVR SGX543MP4+ GPU that advanced TBDR with support for 2.0 and improved texture handling, delivering up to 28 GFLOPS of performance while maintaining efficiency for portable gaming. Post-2010, tiled rendering's adoption surged in mobile GPUs driven by stringent power and bandwidth constraints in smartphones, becoming the preferred architecture for optimizing overdraw and memory access in battery-limited environments. By the late , it dominated mobile GPUs from vendors like (Mali series), (PowerVR), and (Adreno), which together captured the majority of the mobile market.

Technical Implementation

Tile-Based Rendering Pipeline

The tile-based rendering pipeline structures the graphics processing into sequential stages that partition the screen into small rectangular tiles, typically 16x16 or 32x32 pixels, to enable localized computations and minimize memory traffic. This approach processes input primitives through geometry preparation, spatial organization, and tile-specific rendering, culminating in framebuffer updates. By confining fragment operations to on-chip memory during tile processing, the pipeline enhances efficiency in bandwidth-limited systems. In the first stage, transforms input , such as triangles, by executing vertex shaders to compute screen-space positions and attributes. are then culled based on view frustum, back-face orientation, or other early rejection criteria to discard irrelevant . The binning substage follows, where each culled primitive undergoes overlap tests—often using axis-aligned bounding boxes or precise computations—against the grid of screen ; overlapping multiple tiles are assigned to all relevant bins, resulting in replication across those tile lists. The second stage focuses on per-tile rasterization, where the iterates over each in parallel or sequentially. For a specific , only the primitives from its bin are loaded and rasterized using techniques like edge equations or hierarchical traversal to generate fragments representing covered pixels within the tile boundaries. This step computes fragment coverage masks and interpolates attributes, ensuring that outside the tile is ignored to avoid unnecessary computations. In the third stage, shading and blending occur entirely within the tile's on-chip buffer. Generated fragments are shaded via fragment shaders to determine final colors and material properties, followed by depth and stencil tests to resolve visibility among overlapping fragments. Surviving fragments are then blended according to the active rendering state, such as , before the tile buffer is resolved—through operations like if enabled—and merged into the main via a single write-back pass. The binning process incurs overhead from managing bin lists and replicating straddling primitives, which can increase memory usage in scenes with high primitive counts or large tiles; efficient overlap tests and hierarchical bin structures help balance this cost against the benefits of localized processing. Pipeline variants include immediate tiling, which skips off-chip binning by processing tiles directly in a single pass to reduce latency, and full deferred tiling, which delays fragment shading until after visibility determination to shade only visible surfaces.

Deferred Shading Techniques

Deferred shading techniques in tiled rendering separate the determination of visible geometry from the computationally intensive process, enabling significant efficiency gains particularly in bandwidth-constrained environments. In tile-based deferred rendering (TBDR), visibility is resolved per tile through hidden surface removal (HSR) using an on-chip depth buffer after rasterizing binned primitives; fragment is then performed only on visible fragments, writing results to an on-chip color buffer. This approach avoids shading hidden surfaces and confines all operations to fast local memory, reducing external memory accesses. Tile memory can also support advanced deferred shading passes, where developers populate on-chip geometry buffers (G-buffers) storing attributes like depth, surface normals, and for visible pixels within a . is determined during the HSR stage, and subsequent lighting passes shade only visible fragments using this data, further minimizing bandwidth. Implementations vary by vendor; for example, PowerVR hardware performs fixed shading after HSR, while Apple GPUs use features like imageblocks to enable flexible G-buffer storage in tile memory for multi-pass deferred techniques. Additionally, hierarchical is employed during the geometry pass to perform early rejection of occluded fragments at multiple resolution levels, further unnecessary data before it reaches the tile buffer. This hierarchical approach builds a of depth information, enabling rapid visibility tests that reject entire groups of primitives or fragments per . The fundamental algorithm for TBDR can be expressed conceptually as Shade(f)=Material(L,V)×Visibility(f)\text{Shade}(f) = \text{Material}(L, V) \times \text{Visibility}(f), where ff represents a fragment, LL denotes lighting parameters, VV includes view-dependent factors, and visibility is resolved post-HSR using the tile's depth buffer. Shading computations are deferred until after this visibility determination, ensuring that material evaluations—such as diffuse, specular, or physically-based models—are applied solely to fragments that contribute to the final image. This separation allows for flexible lighting integration, where multiple light sources can be processed efficiently per tile without re-rasterizing geometry. Advanced variants of TBDR extend these principles to handle and data efficiency. Multi-sample anti-aliasing (MSAA) is integrated at the level by storing multiple samples per in the on-chip buffer, resolving coverage masks during the visibility pass to shade only unique visible samples and reduce artifacts without excessive memory overhead. Compression techniques further optimize buffers by exploiting spatial coherence, such as for depth values. These enhancements maintain while preserving the bandwidth savings inherent to TBDR. By deferring shading until visibility is fully resolved per , TBDR effectively addresses overdraw challenges in scenes with high fragment density, such as those featuring complex geometry or dense foliage, through early and on-chip processing. This makes it particularly suitable for resource-limited hardware, where traditional rendering might incur prohibitive costs.

Applications

Desktop and Console GPUs

In desktop and console GPUs, tiled rendering has evolved into hybrid architectures that balance high-throughput with bandwidth , particularly in power-rich environments where access costs remain a bottleneck despite ample compute resources. introduced tiled rasterization in its Maxwell architecture starting in 2014, buffering geometry data on-chip within small screen-space tiles (typically 16x16 pixels) to minimize external accesses during the rasterization . This approach, carried forward in subsequent architectures like Pascal and beyond, reduces the need for multiple round-trips to DRAM by keeping rasterizer outputs local until tile completion, yielding significant bandwidth savings in geometry-heavy workloads. Prior to full desktop adoption, 's series (pre-2015 models like Tegra 4) employed hybrid tiled rendering in mobile-oriented SoCs, combining tile-based with immediate-mode elements to handle variable geometry loads while maintaining compatibility with desktop Kepler cores. AMD Radeon GPUs, beginning with the (GCN) architecture around 2011, support partial tiling through compute shaders for targeted optimizations, enabling software-based techniques rather than full-pipeline tile-based deferred rendering. In RDNA architectures (introduced 2019 and refined through RDNA 4 in 2025), developers leverage compute shaders to implement tiled light culling and passes, dividing the screen into tiles to cull irrelevant lights or shadows per region, which is especially effective for compute-intensive effects like volumetric rendering. This software-driven partial tiling allows flexibility in large scenes, avoiding the overhead of hardware-mandated full tiling while still achieving localized bandwidth reductions by processing tiles independently in programs. Console GPUs, built on custom variants, integrate tiled techniques for high-fidelity rendering under fixed hardware constraints. The Series X and S (launched 2020) utilize 12's tiled resource management to enable sparse virtual texturing, where textures are divided into tiles loaded on-demand, reducing and bandwidth for massive open-world environments without compromising resolution. This feature, combined with the GPU's native tiled rasterization, supports efficient handling of high-detail assets in titles emphasizing dynamic lighting. Such binning reduces draw calls and overdraw, as demonstrated in multi-platform engines like those in , where z-binning against tile boundaries improves volumetric performance in tiled setups. Hybrid models predominate in these platforms, merging tiled rasterization or compute with traditional immediate-mode rendering to accommodate expansive scenes that exceed pure tile-based limits. For instance, tile-based compute shaders handle or light culling in isolated passes, while the main raster processes full-frame immediately, allowing seamless scaling for open-world with millions of primitives. This combination mitigates the geometry sorting overhead of full tiling, enabling higher throughput in desktop and console titles. Performance benefits include notable bandwidth efficiency, with NVIDIA's tiled rasterization delivering reductions in memory traffic for rasterization-bound workloads, as seen in compute-heavy scenarios akin to those in 2077's ray-traced passes. AMD's compute-based tiling similarly yields bandwidth savings in deferred lighting, enhancing frame rates in bandwidth-limited configurations without altering core architecture. From 2020 to 2025, tiled rendering has increasingly integrated with ray tracing through optimized BVH traversal in hybrid pipelines, where screen-space tiles guide acceleration structure culls to focus ray queries on visible regions. NVIDIA's and Ada architectures (2020 onward) use tiled raster outputs to inform BVH builds, reducing traversal costs by 20-40% in dynamic scenes via on-chip tile data reuse. This continues in the Blackwell architecture (2024). AMD's (2022) and RDNA 4 (2025) extend this with compute shaders for tiled BVH refits, enabling real-time updates in ray-traced titles while maintaining compatibility with APIs. These advancements, highlighted in high-impact works like treelet-based BVH traversal, underscore tiled rendering's role in scaling ray tracing for desktop and console interactivity.

Mobile and Embedded Devices

Tiled rendering has become the dominant in mobile GPUs due to its efficiency in bandwidth-constrained and power-limited environments. ARM's G-series GPUs, introduced in 2008, employ full tile-based deferred rendering (TBDR), dividing the screen into small tiles—typically 16x16 or 32x32 pixels—to process and locally, minimizing external accesses and reducing power draw compared to immediate-mode alternatives. Similarly, Qualcomm's Adreno GPUs, integrated into Snapdragon SoCs since the early 2010s, utilize a tile-based approach with FlexRender technology, which dynamically adjusts tile sizes and switches between binned and direct rendering modes to optimize for varying workloads, enhancing efficiency in devices like smartphones and tablets. Apple's A-series processors, starting from the A4 in 2010, feature custom-designed GPUs that leverage TBDR tailored to the Metal API, enabling seamless integration of advanced shading techniques while maintaining low latency and power efficiency; this architecture processes tiles on-chip, supporting features like efficient multisample anti-aliasing (MSAA) and contributing to sustained performance in graphics-intensive apps without excessive battery drain. By 2025, tiled rendering dominates smartphone GPUs, facilitating smooth 60 fps gameplay at resolutions up to 4K on external displays while consuming under 5W, as seen in flagship SoCs like the Snapdragon 8 series and Apple A18. In embedded systems, tiled rendering supports power-sensitive applications such as automotive in NVIDIA's Drive PX platforms, which incorporate tiled rasterization from Pascal-era GPUs to handle real-time 3D visualizations with minimal overhead. ' PowerVR Rogue architecture, used in IoT devices, applies TBDR to deliver scalable in constrained environments like smart sensors and wearables, where on-chip tile buffers reduce data movement. Optimizations like dynamic tile sizing adapt to varying display resolutions, while mechanisms deactivate idle tile processing units, further lowering energy use in these integrated SoCs.

Advantages and Challenges

Performance and Efficiency Gains

Tiled rendering significantly reduces usage by eliminating redundant fetches due to overdraw, as fragments are processed on-chip within each before writing to external . In fill-rate limited scenes with high overdraw, this approach can achieve reductions of up to 90% and average bandwidth reductions of 48% through techniques like early discard of redundant s, compared to immediate-mode rendering that requires multiple off-chip accesses per . Measurements across various workloads show an average total external data reduction by a factor of approximately 2, with back (from rasterizer to ) decreasing by up to 2.71 times in scenes prone to overdraw. Power efficiency gains stem from minimizing DRAM accesses, which are energy-intensive; on-chip tile processing consumes roughly 10 times less power per access than external operations. Tile-based architectures in mobile GPUs demonstrate higher compared to desktop immediate-mode GPUs, enabling longer battery life in graphics-intensive applications. For instance, optimizations in tile-based deferred rendering have been shown to reduce overall by 37% in real-time rendering scenarios on mobile hardware. Latency improvements arise from parallel tile rendering, which allows independent processing of screen regions and reduces pipeline stalls caused by overdraw in immediate-mode systems; the effective scales with the number of tiles divided by the overdraw ratio, as hidden surfaces are discarded early without external intervention. This parallelism is particularly beneficial in complex scenes, where it can lower average by 13.5% and yield up to 1.15x overall in commercial gaming applications. Empirical comparisons highlight power savings in tile-based GPUs, contributing to extended battery in demanding games under similar levels. These benefits scale with increasing resolution and scene complexity, as higher counts amplify overdraw and bandwidth demands; in VR scenarios, tiled rendering supports up to 4x effective gains by efficiently handling the dual high-resolution eye buffers and foveated techniques without proportional memory overhead increases. As of 2024, advancements in APIs like have enhanced tiled rendering efficiency on mobile GPUs through better support for render passes and dynamic rendering, reducing overhead in multi-subpass scenarios and improving memory access patterns.

Limitations and Optimizations

One key limitation of tiled rendering is the binning overhead, where primitives are sorted into tile lists, which can become significant with complex scenes containing many large or overlapping triangles that span multiple tiles, leading to repeated processing and increased geometry throughput demands. This overhead grows with scene complexity, potentially consuming a notable portion of the rendering budget in mobile GPUs. Another challenge arises in handling transparent objects, as alpha blending disrupts the deferred nature of tiled rendering by requiring back-to-front sorting across the entire scene to ensure correct compositing, rather than per-tile processing, which can eliminate bandwidth savings and force full-frame buffer reads and writes. Bandwidth spikes occur during tile buffer flushes to main memory, particularly at tile boundaries or when mid-render access to the framebuffer is needed for effects like post-processing, resulting in sudden high memory traffic that undermines the architecture's efficiency goals. Alpha blending further exacerbates inefficiencies by necessitating frequent framebuffer accesses, which prevent the use of on-chip tile memory and revert to higher-bandwidth immediate-mode-like behavior in tile-based deferred architectures. To mitigate binning overhead, adaptive binning techniques employ hierarchical structures, where coarser levels of are used for initial primitive assignment before refining to finer , reducing redundant for large and improving in complex scenes. Compression algorithms, such as applied to tile-local data like depth or color values, enable efficient storage in on-chip buffers; for instance, lightweight integer compression schemes using delta differences can achieve substantial reductions in data footprint for sorted or semi-sorted tile contents, though exact ratios depend on workload characteristics. Software mitigations include extensions like Vulkan's VK_EXT_shader_tile_image, which grant fragment shaders rasterization-order access to on-chip tile image data, allowing developers to optimize custom blending or effects without full flushes. Hybrid rendering modes address edge cases, such as high-overdraw transparency passes, by dynamically switching between tile-based deferred rendering and rendering paths to balance bandwidth savings with flexibility in scenarios like compute-heavy post-effects.

References

  1. https://developer.samsung.com/galaxy-gamedev/resources/articles/gpu-framebuffer.html
  2. https://developers.meta.com/horizon/documentation/unity/gpu-tiled/
  3. https://developer.apple.com/documentation/metal/tailor-your-apps-for-apple-gpus-and-tile-based-deferred-rendering
  4. https://www.realworldtech.com/tile-based-rasterization-nvidia-gpus/
  5. https://docs.unity3d.com/6000.3/Documentation/Manual/xr-graphics-on-tile-rendering.html
  6. https://developer.arm.com/documentation/102662/latest/Tile-based-GPUs
  7. https://docs.imgtec.com/starter-guides/powervr-architecture/html/topics/the-powervr-advantage.html
  8. https://developer.arm.com/Architectures/5th%20Gen%20Arm%20GPU%20Architecture
  9. https://blog.imaginationtech.com/a-look-at-the-powervr-graphics-architecture-tile-based-rendering/
  10. http://www.cs.unc.edu/~fuchs/publications/FastSpheres%2CShadows85.pdf
  11. https://dl.acm.org/doi/10.1145/74334.74341
  12. https://blog.imaginationtech.com/powervr-at-25-the-story-of-a-graphics-revolution/
  13. https://vintage3d.org/pcx1.php
  14. https://www.vogons.org/viewtopic.php?t=84267
  15. https://www.theregister.com/2000/03/28/3dfx_to_grab_gigapixel/
  16. https://www.copetti.org/writings/consoles/dreamcast/
  17. https://segaretro.org/Sega_Dreamcast/Hardware_comparison
  18. https://www.highperformancegraphics.org/previous/www_2010/media/Hot3D/HPG2010_Hot3D_ARM.pdf
  19. https://www.psdevwiki.com/vita/Graphics
  20. https://gadgetversus.com/graphics-card/imagination-powervr-sgx543-mp4-plus-specs/
  21. https://www.qualcomm.com/content/dam/qcomm-martech/dm-assets/documents/Snapdragon-8-Elite-Gen-5-product-brief.pdf
  22. https://www.rastergrid.com/blog/gpu-tech/2021/07/gpu-architecture-types-explained/
  23. https://gfxcourses.stanford.edu/cs248a/winter24content/media/gpuhardware/18_mobilegpu.pdf
  24. https://www.techpowerup.com/231129/on-nvidias-tile-based-rendering
  25. https://www.nvidia.com/docs/io/90715/tegra_multiprocessor_architecture_white_paper.pdf
  26. https://gpuopen.com/learn/tiledlighting11-directx-11-sdk-sample/
  27. https://gpuopen.com/learn/rdna-performance-guide/
  28. https://devblogs.microsoft.com/directx/announcing-directx-12-ultimate/
  29. https://research.activision.com/publications/archives/improved-culling-for-tiled-and-clustered-rendering-in-call-of-dutyinfinite-warfare
  30. https://developer.nvidia.com/discover/ray-tracing
  31. https://www.amd.com/content/dam/amd/en/documents/radeon-tech-docs/instruction-set-architectures/rdna3-shader-instruction-set-architecture-feb-2023_0.pdf
  32. https://www.amd.com/content/dam/amd/en/documents/radeon-tech-docs/instruction-set-architectures/rdna4-instruction-set-architecture.pdf
  33. https://people.ece.ubc.ca/aamodt/publications/papers/chou.asplos2025.pdf
  34. https://docs.qualcomm.com/bundle/publicresource/topics/80-78185-2/overview.html
  35. https://www.imaginationtech.com/products/gpu/graphics-architecture/powervr-rogue/
  36. https://www.researchgate.net/publication/220714349_Memory_Bandwidth_Requirements_of_Tile-Based_Rendering
  37. https://people.ac.upc.edu/jmanel/papers/hpca-2019-RE.pdf
  38. https://developer.arm.com/community/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/the-mali-gpu-an-abstract-machine-part-2---tile-based-rendering
  39. https://people.ac.upc.edu/jmanel/papers/anglada-phdthesis.pdf
  40. https://ieeexplore.ieee.org/document/10764580
  41. https://upcommons.upc.edu/bitstreams/56e02643-6bf1-42c9-8a5d-03d04516890d/download
  42. https://www.design-reuse.com/news/3518-imagination-s-powervr-graphics-provide-huge-performance-boost-and-power-savings-in-mediatek-s-new-helio-x30-chipset/
  43. https://developers.meta.com/horizon/blog/optimizing-oculus-go-for-performance/
  44. https://medium.com/androiddevelopers/efficient-render-passes-on-tile-based-rendering-hardware-621070158e40
  45. https://developer.arm.com/cfs-file/__key/communityserver-blogs-components-weblogfiles/00-00-00-20-66/siggraph_5F00_mmg_5F00_2024_5F00_Mobile101.pdf
Add your contribution
Related Hubs
Contribute something
User Avatar
No comments yet.