WO2021158483A1 - Système et procédé de rendu efficace multi-gpu de géométrie par prétest contre des régions d'écran entrelacées avant le rendu - Google Patents

Système et procédé de rendu efficace multi-gpu de géométrie par prétest contre des régions d'écran entrelacées avant le rendu Download PDF

Info

Publication number
WO2021158483A1
WO2021158483A1 PCT/US2021/016079 US2021016079W WO2021158483A1 WO 2021158483 A1 WO2021158483 A1 WO 2021158483A1 US 2021016079 W US2021016079 W US 2021016079W WO 2021158483 A1 WO2021158483 A1 WO 2021158483A1
Authority
WO
WIPO (PCT)
Prior art keywords
geometry
rendering
gpu
gpus
pieces
Prior art date
Application number
PCT/US2021/016079
Other languages
English (en)
Other versions
WO2021158483A8 (fr
Inventor
Mark E. Cerny
Florian STRAUSS
Tobias BERGHOFF
Original Assignee
Song Interactive Entertainment Inc.
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority claimed from US16/780,722 external-priority patent/US11080814B1/en
Priority claimed from US16/780,745 external-priority patent/US20210241414A1/en
Priority claimed from US16/780,680 external-priority patent/US11263718B2/en
Application filed by Song Interactive Entertainment Inc. filed Critical Song Interactive Entertainment Inc.
Priority to JP2022546703A priority Critical patent/JP7334358B2/ja
Priority to CN202180023019.6A priority patent/CN115298686B/zh
Priority to EP21707864.1A priority patent/EP4100922A1/fr
Publication of WO2021158483A1 publication Critical patent/WO2021158483A1/fr
Publication of WO2021158483A8 publication Critical patent/WO2021158483A8/fr
Priority to JP2023132609A priority patent/JP7481556B2/ja

Links

Classifications

    • A—HUMAN NECESSITIES
    • A63—SPORTS; GAMES; AMUSEMENTS
    • A63F—CARD, BOARD, OR ROULETTE GAMES; INDOOR GAMES USING SMALL MOVING PLAYING BODIES; VIDEO GAMES; GAMES NOT OTHERWISE PROVIDED FOR
    • A63F13/00—Video games, i.e. games using an electronically generated display having two or more dimensions
    • A63F13/50—Controlling the output signals based on the game progress
    • A63F13/52—Controlling the output signals based on the game progress involving aspects of the displayed game scene
    • A—HUMAN NECESSITIES
    • A63—SPORTS; GAMES; AMUSEMENTS
    • A63F—CARD, BOARD, OR ROULETTE GAMES; INDOOR GAMES USING SMALL MOVING PLAYING BODIES; VIDEO GAMES; GAMES NOT OTHERWISE PROVIDED FOR
    • A63F13/00—Video games, i.e. games using an electronically generated display having two or more dimensions
    • A63F13/30—Interconnection arrangements between game servers and game devices; Interconnection arrangements between game devices; Interconnection arrangements between game servers
    • A63F13/35—Details of game servers
    • A63F13/355—Performing operations on behalf of clients with restricted processing capabilities, e.g. servers transform changing game scene into an encoded video stream for transmitting to a mobile phone or a thin client
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
    • G06T1/00—General purpose image data processing
    • G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
    • G—PHYSICS
    • G09—EDUCATION; CRYPTOGRAPHY; DISPLAY; ADVERTISING; SEALS
    • G09G—ARRANGEMENTS OR CIRCUITS FOR CONTROL OF INDICATING DEVICES USING STATIC MEANS TO PRESENT VARIABLE INFORMATION
    • G09G5/00—Control arrangements or circuits for visual indicators common to cathode-ray tube indicators and other visual indicators
    • G09G5/36—Control arrangements or circuits for visual indicators common to cathode-ray tube indicators and other visual indicators characterised by the display of a graphic pattern, e.g. using an all-points-addressable [APA] memory
    • G09G5/363—Graphics controllers
    • A—HUMAN NECESSITIES
    • A63—SPORTS; GAMES; AMUSEMENTS
    • A63F—CARD, BOARD, OR ROULETTE GAMES; INDOOR GAMES USING SMALL MOVING PLAYING BODIES; VIDEO GAMES; GAMES NOT OTHERWISE PROVIDED FOR
    • A63F2300/00—Features of games using an electronically generated display having two or more dimensions, e.g. on a television screen, showing representations related to the game
    • A63F2300/20—Features of games using an electronically generated display having two or more dimensions, e.g. on a television screen, showing representations related to the game characterised by details of the game platform
    • A63F2300/203—Image generating hardware
    • A—HUMAN NECESSITIES
    • A63—SPORTS; GAMES; AMUSEMENTS
    • A63F—CARD, BOARD, OR ROULETTE GAMES; INDOOR GAMES USING SMALL MOVING PLAYING BODIES; VIDEO GAMES; GAMES NOT OTHERWISE PROVIDED FOR
    • A63F2300/00—Features of games using an electronically generated display having two or more dimensions, e.g. on a television screen, showing representations related to the game
    • A63F2300/50—Features of games using an electronically generated display having two or more dimensions, e.g. on a television screen, showing representations related to the game characterized by details of game servers
    • A63F2300/55—Details of game data or player data management
    • A63F2300/5593—Details of game data or player data management involving scheduling aspects
    • G—PHYSICS
    • G09—EDUCATION; CRYPTOGRAPHY; DISPLAY; ADVERTISING; SEALS
    • G09G—ARRANGEMENTS OR CIRCUITS FOR CONTROL OF INDICATING DEVICES USING STATIC MEANS TO PRESENT VARIABLE INFORMATION
    • G09G2360/00—Aspects of the architecture of display systems
    • G09G2360/06—Use of more than one graphics processor to process data before displaying to one or more screens
    • G—PHYSICS
    • G09—EDUCATION; CRYPTOGRAPHY; DISPLAY; ADVERTISING; SEALS
    • G09G—ARRANGEMENTS OR CIRCUITS FOR CONTROL OF INDICATING DEVICES USING STATIC MEANS TO PRESENT VARIABLE INFORMATION
    • G09G2360/00—Aspects of the architecture of display systems
    • G09G2360/08—Power processing, i.e. workload management for processors involved in display operations, such as CPUs or GPUs
    • G—PHYSICS
    • G09—EDUCATION; CRYPTOGRAPHY; DISPLAY; ADVERTISING; SEALS
    • G09G—ARRANGEMENTS OR CIRCUITS FOR CONTROL OF INDICATING DEVICES USING STATIC MEANS TO PRESENT VARIABLE INFORMATION
    • G09G2360/00—Aspects of the architecture of display systems
    • G09G2360/12—Frame memory handling
    • G09G2360/122—Tiling

Definitions

  • the present disclosure is related to graphic processing, and more specifically for multi-GPU collaboration when rendering an image for an application.
  • the cloud gaming server may be configured to provide resources to one or more clients and/or applications. That is, the cloud gaming server may be configured with resources capable of high throughput. For example, there are limits to the performance that an individual graphics processing unit (GPU) can attain. To render even more complex scenes or use even more complex algorithms (e.g. materials, lighting, etc.) when generating a scene, it may be desirable to use multiple GPUs to render a single image. However, usage of those graphics processing units equally is difficult to achieve.
  • GPU graphics processing unit
  • Embodiments of the present disclosure relate to using multiple GPUs in collaboration to render a single image, such as multi-GPU rendering of geometry for an application by pretesting against screen regions, which may be interleaved, before rendering.
  • Embodiments of the present disclosure disclose a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs. Screen regions are interleaved.
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the method includes assigning a GPU a piece of geometry of an image frame generated by an application for geometry testing.
  • the method includes performing geometry testing at the GPU to generate information regarding the piece of geometry and its relation to each of the plurality of screen regions.
  • the method includes rendering the piece of geometry using the information at each of the plurality of GPUs, where using the information can include, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a non-transitory computer-readable medium for performing a method including program instructions for rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the computer-readable medium including program instructions for dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs, wherein screen regions in the plurality of screen regions are interleaved.
  • the computer readable medium including program instructions for assigning a GPU a piece of geometry of an image frame generated by an application for geometry pretesting.
  • the computer readable medium including program instructions for performing the geometry pretesting at the GPU to generate information regarding the piece of geometry and its relation to each of the plurality of screen regions.
  • the computer readable medium including program instructions for using the information at each of the plurality of GPUs when rendering the image frame.
  • a computer system including a processor and memory coupled to the processor and having stored therein instructions that, if executed by the computer system, cause the computer system to execute a method for graphics processing.
  • the method including rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method including dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs, wherein screen regions in the plurality of screen regions are interleaved.
  • the method including assigning a GPU a piece of geometry of an image frame generated by an application for geometry pretesting.
  • the method including performing the geometry pretesting at the GPU to generate information regarding the piece of geometry and its relation to each of the plurality of screen regions.
  • the method including using the information at each of the plurality of GPUs when rendering the image frame.
  • Embodiments of the present disclosure disclose a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes performing geometry testing at a pretest GPU on a plurality of pieces of geometry of an image frame generated by an application to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the method includes rendering the plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a non-transitory computer-readable medium for performing a method including program instructions for rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the computer-readable medium including program instructions for dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the computer-readable medium including program instructions for performing geometry testing at a pretest GPU on a plurality of pieces of geometry of an image frame generated by an application to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the computer-readable medium including program instructions for rendering the plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a computer system including a processor and memory coupled to the processor and having stored therein instructions that, if executed by the computer system, cause the computer system to execute a method for graphics processing.
  • the method including rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes performing geometry testing at a pretest GPU on a plurality of pieces of geometry of an image frame generated by an application to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the method includes rendering the plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • Embodiments of the present disclosure disclose a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes rendering a first plurality of pieces of geometry at the plurality of GPUs during a rendering phase of a previous image frame generated by an application.
  • the method includes generating statistics for the rendering of the previous image frame.
  • the method includes assigning based on the statistics a second plurality of pieces of geometry of a current image frame generated by the application to the plurality of GPUs for geometry testing.
  • the method includes performing geometry testing at a current image frame on the second plurality of pieces of geometry to generate information regarding each piece of the second plurality of pieces of geometry and its relation to each of the plurality of screen regions, wherein the geometry testing is performed at each of the plurality of GPUs based on the assigning.
  • the method includes rendering the second plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the second plurality of pieces of geometry, where using the information can include, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a non-transitory computer-readable medium for performing a method including program instructions for rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the computer-readable medium including program instructions for dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the computer-readable medium including program instructions for rendering a first plurality of pieces of geometry at the plurality of GPUs during a rendering phase of a previous image frame generated by an application.
  • the computer-readable medium including program instructions for generating statistics for the rendering of the previous image frame.
  • the computer-readable medium including program instructions for assigning based on the statistics a second plurality of pieces of geometry of a current image frame generated by the application to the plurality of GPUs for geometry testing.
  • the computer-readable medium including program instructions for performing geometry testing at a current image frame on the second plurality of pieces of geometry to generate information regarding each piece of the second plurality of pieces of geometry and its relation to each of the plurality of screen regions, wherein the geometry testing is performed at each of the plurality of GPUs based on the assigning.
  • the computer-readable medium including program instructions for rendering the second plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the second plurality of pieces of geometry, where using the information can include, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a computer system including a processor and memory coupled to the processor and having stored therein instructions that, if executed by the computer system, cause the computer system to execute a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes rendering a first plurality of pieces of geometry at the plurality of GPUs during a rendering phase of a previous image frame generated by an application.
  • the method includes generating statistics for the rendering of the previous image frame.
  • the method includes assigning based on the statistics a second plurality of pieces of geometry of a current image frame generated by the application to the plurality of GPUs for geometry testing.
  • the method includes performing geometry testing at a current image frame on the second plurality of pieces of geometry to generate information regarding each piece of the second plurality of pieces of geometry and its relation to each of the plurality of screen regions, wherein the geometry testing is performed at each of the plurality of GPUs based on the assigning.
  • the method includes rendering the second plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the second plurality of pieces of geometry, where using the information can include, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • Embodiments of the present disclosure disclose a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the method includes setting a first state configuring one or more shaders to perform the geometry testing.
  • the method includes performing geometry testing at the plurality of GPUs on the plurality of pieces of geometry to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the method includes setting a second state configuring the one or more shaders to perform rendering.
  • the method includes rendering the plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a non-transitory computer-readable medium for performing a method including program instructions for rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the computer-readable medium including program instructions for dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the computer-readable medium including program instructions for assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the computer-readable medium including program instructions for setting a first state configuring one or more shaders to perform the geometry testing.
  • the computer- readable medium including program instructions for performing geometry testing at the plurality of GPUs on the plurality of pieces of geometry to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the computer-readable medium including program instructions for setting a second state configuring the one or more shaders to perform rendering.
  • the computer-readable medium including program instructions for rendering the plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a computer system including a processor and memory coupled to the processor and having stored therein instructions that, if executed by the computer system, cause the computer system to execute a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the method includes setting a first state configuring one or more shaders to perform the geometry testing.
  • the method includes performing geometry testing at the plurality of GPUs on the plurality of pieces of geometry to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the method includes setting a second state configuring the one or more shaders to perform rendering.
  • the method includes rendering the plurality of pieces of geometry at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • Embodiments of the present disclosure disclose a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the method includes interleaving a first set of shaders to perform geometry testing and rendering on a first set of pieces of geometry with a second set of shaders to perform geometry testing and rendering on a second set of pieces of geometry.
  • the geometry testing generates corresponding information regarding each piece of geometry in the first set or second set and its relation to each of the plurality of screen regions.
  • the corresponding information is used by the plurality of GPUs to render each piece of geometry in first set or second set, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a non-transitory computer-readable medium for performing a method including program instructions for rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the computer-readable medium including program instructions for dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the computer-readable medium including program instructions for assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the computer-readable medium including program instructions for interleaving a first set of shaders to perform geometry testing and rendering on a first set of pieces of geometry with a second set of shaders to perform geometry testing and rendering on a second set of pieces of geometry.
  • the geometry testing generates corresponding information regarding each piece of geometry in the first set or second set and its relation to each of the plurality of screen regions.
  • the corresponding information is used by the plurality of GPUs to render each piece of geometry in first set or second set, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not overlap any screen region assigned to a given GPU.
  • a computer system including a processor and memory coupled to the processor and having stored therein instructions that, if executed by the computer system, cause the computer system to execute a method for graphics processing.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs).
  • the method includes dividing responsibility for the rendering of geometry of the graphics between the plurality of GPUs based on a plurality of screen regions, each GPU having a corresponding division of the responsibility which is known to the plurality of GPUs.
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • the method includes interleaving a first set of shaders to perform geometry testing and rendering on a first set of pieces of geometry with a second set of shaders to perform geometry testing and rendering on a second set of pieces of geometry.
  • the geometry testing generates corresponding information regarding each piece of geometry in the first set or second set and its relation to each of the plurality of screen regions.
  • the corresponding information is used by the plurality of GPUs to render each piece of geometry in first set or second set, where using the information includes, for example, skipping rendering entirely if it has been determined that the piece of geometry does not
  • FIG. 1 is a diagram of a system for providing gaming over a network between one or more cloud gaming servers configured for implementing multiple GPUs in collaboration to render a single image, including multi-GPU (graphics processing unit) rendering of geometry for an application by pretesting the geometry against screen regions, which may be interleaved, in accordance with embodiments of the present disclosure.
  • multi-GPU graphics processing unit
  • FIG. 2 is a diagram of a multi-GPU architecture wherein multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • FIG. 3 is a diagram of multiple graphics processing unit resources configured for multi-GPU rendering of geometry for an application by pretesting the geometry against screen regions, which may be interleaved, in accordance with one embodiment of the present disclosure.
  • FIG. 4 is a diagram of a rendering architecture implementing a graphics pipeline that is configured for multi-GPU processing, such that multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • FIG. 5 is a flow diagram illustrating a method for graphics processing including multi-GPU rendering of geometry for an application by pretesting against interleaved screen regions before rendering, in accordance with one embodiment of the present disclosure.
  • FIG. 6A is a diagram of a screen that is subdivided into quadrants when performing multi-GPU rendering, in accordance with one embodiment of the present disclosure.
  • FIG. 6B is a diagram of a screen that is subdivided into a plurality of interleaved regions when performing multi-GPU rendering, in accordance with one embodiment of the present disclosure.
  • FIG. 7A is a diagram of a rendering command buffer that is shared by multiple GPUs that collaborate to render a single image frame including a pretesting of geometry portion and a rendering portion, in accordance with one embodiment of the present disclosure.
  • FIG. 7B-1 illustrates an image including four objects rendered by multiple GPUs, and shows the screen region responsibilities for each GPU when rendering the objects of the image, in accordance with one embodiment of the present disclosure.
  • FIG. 7B-2 is a table illustrating the rendering performed by each GPU when rendering the four objects of FIG. 7B-1, in accordance with one embodiment of the present disclosure.
  • FIG. 7C is a diagram illustrating the performing of pretesting geometry and rendering of the geometry as performed by one or more GPUs when rendering an image frame through collaboration of multiple GPUs (e.g., the image of FIG. 7B-1), in accordance with one embodiment of the present disclosure.
  • FIG. 8A illustrates object testing against screen regions when multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • FIG. 8B illustrates testing of portions of an object against screen regions when multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • FIG. 9A-9C illustrates various strategies for assigning screen regions to corresponding GPUs when multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • FIG. 10 is a diagram illustrating various distributions of GPU assignment for performing geometry pretesting on a plurality of pieces of geometry, in accordance with embodiments of the present disclosure.
  • FIG. 11 A is a diagram illustrating the pretesting and rendering of geometry of a previous image frame by a plurality of GPUs, and the use of statistics collected during rendering to influence the assignment of pretesting of geometry of a current image frame to the plurality of GPUs in the current image frame, in accordance with one embodiment of the present disclosure.
  • FIG. 11 A is a diagram illustrating the pretesting and rendering of geometry of a previous image frame by a plurality of GPUs, and the use of statistics collected during rendering to influence the assignment of pretesting of geometry of a current image frame to the plurality of GPUs in the current image frame, in accordance with one embodiment of the present disclosure.
  • FIG. 11 A is a diagram illustrating the pretesting and rendering of geometry of a previous image frame by a plurality of GPUs, and the use of statistics collected during rendering to influence the
  • 1 IB is a flow diagram illustrating a method for graphics processing including pretesting and rendering of geometry of a previous image frame by a plurality of GPUs, and the use of statistics collected during rendering to influence the assignment of pretesting of geometry of a current image frame to the plurality of GPUs in the current image frame, in accordance with one embodiment of the present disclosure.
  • FIG. 12A is a diagram illustrating the use of shaders configured to perform both pretesting and rendering of geometry of an image frame in two passes through a portion of the command buffer, in accordance with one embodiment of the present disclosure.
  • FIG. 12B is a flow diagram illustrating a method for graphics processing including performing both pretesting and rendering of geometry of an image frame using the same set of shaders in two passes through a portion of the command buffer, in accordance with one embodiment of the present disclosure.
  • FIG. 13A is a diagram illustrating the use of shaders configured to perform both geometry testing and rendering, wherein geometry test and render performed for different sets of pieces of geometry are interleaved using separate portions of a corresponding command buffer, in accordance with one embodiment of the present disclosure.
  • FIG. 13B is a flow diagram illustrating a method for graphics processing including interleaving pretesting and rendering of geometry of an image frame for different sets of pieces geometry using separate portions of a corresponding command buffer, in accordance with one embodiment of the present disclosure.
  • FIG. 14 illustrates components of an example device that can be used to perform aspects of the various embodiments of the present disclosure.
  • various embodiments of the present disclosure describe methods and systems configured for performing multi-GPU rendering of geometry for an application by pretesting the geometry against screen regions, which may be interleaved. Multiple GPUs collaborate to generate an image. Responsibility for rendering is divided between a plurality of the GPUs based on screen regions. Prior to rendering the geometry, the GPUs generate information regarding the geometry and its relation to the screen regions. This allows the GPUs to more efficiently render the geometry or avoid rendering it altogether. As an advantage, for example this allows the multiple
  • GPUs to render more complex scenes and/or images in the same amount of time.
  • an interactive application or “game” or “video game” or “gaming application” is meant to represent any type of interactive application that is directed through execution of input commands.
  • an interactive application includes applications for gaming, word processing, video processing, video game processing, etc. Further, the terms introduced above are interchangeable.
  • GPUs may collaborate when rendering geometry for an application.
  • FIG. 1 is a diagram of a system for performing multi-GPU processing when rendering an image (e.g. image frame) for an application, in accordance with one embodiment of the present disclosure.
  • the system is configured to provide gaming over a network between one or more cloud gaming servers, and more specifically is configured for the collaboration of multiple GPUs to render a single image of an application, in accordance with embodiments of the present disclosure.
  • Cloud gaming includes the execution of a video game at the server to generate game rendered video frames, which are then sent to a client for display.
  • system 100 is configured for efficient multi-GPU rendering of geometry for an application by pretesting against screen regions, which may be interleaved, before rendering.
  • FIG. 1 illustrates the implementation of multi-GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system
  • FIG. 1 illustrates the implementation of multi-GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system
  • FIG. 1 illustrates the implementation of multi-GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system
  • FIG. 1 illustrates the implementation of multi-GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system
  • FIG. 1 illustrates the implementation of multi-GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system
  • multi-GPU rendering of geometry may be performed using physical GPUs, or virtual GPUs, or a combination of both, in various embodiments (e.g. in a cloud gaming environment or within a stand-alone system).
  • virtual machines e.g., virtual machines
  • a hypervisor of a host hardware (e.g. located at a data center) utilizing one or more components of a hardware layer, such as multiple CPUs, memory modules, GPUs, network interfaces, communication components, etc.
  • These physical resources may be arranged in racks, such as racks of CPUs, racks of GPUs, racks of memory, etc., wherein the physical resources in the racks may be accessed using top of rack switches facilitating a fabric for assembling and accessing of components used for an instance (e.g. when building the virtualized components of the instance).
  • a hypervisor can present multiple guest operating systems of multiple instances that are configured with virtual resources.
  • each of the operating systems may be configured with a corresponding set of virtualized resources supported by one or more hardware resources (e.g. located at a corresponding data center).
  • each operating system may be supported with a virtual CPU, multiple virtual GPUs, virtual memory, virtualized communication components, etc.
  • a configuration of an instance that may be transferred from one data center to another data center to reduce latency.
  • GPU utilization defined for the user or game can be utilized when saving a user’s gaming session.
  • the GPU utilization can include any number of configurations described herein to optimize the fast rendering of video frames for a gaming session.
  • the GPU utilization defined for the game or the user can be transferred between data centers as a configurable setting. The ability to transfer the GPU utilization setting enables for efficient migration of game play from data center to data center in case the user connects to play games from different geo locations.
  • System 100 provides gaming via a cloud game network 190, wherein the game is being executed remote from client device 110 (e.g. thin client) of a corresponding user that is playing the game, in accordance with one embodiment of the present disclosure.
  • System 100 may provide gaming control to one or more users playing one or more games through the cloud game network 190 via network 150 in either single-player or multi-player modes.
  • the cloud game network 190 may include a plurality of virtual machines (VMs) running on a hypervisor of a host machine, with one or more virtual machines configured to execute a game processor module utilizing the hardware resources available to the hypervisor of the host.
  • Network 150 may include one or more communication technologies.
  • network 150 may include 5 th Generation (5G) network technology having advanced wireless communication systems.
  • 5G 5 th Generation
  • communication may be facilitated using wireless technologies.
  • technologies may include, for example, 5G wireless communication technologies.
  • 5G is the fifth generation of cellular network technology.
  • 5G networks are digital cellular networks, in which the service area covered by providers is divided into small geographical areas called cells. Analog signals representing sounds and images are digitized in the telephone, converted by an analog to digital converter and transmitted as a stream of bits. All the 5G wireless devices in a cell communicate by radio waves with a local antenna array and low power automated transceiver (transmitter and receiver) in the cell, over frequency channels assigned by the transceiver from a pool of frequencies that are reused in other cells.
  • the local antennas are connected with the telephone network and the Internet by a high bandwidth optical fiber or wireless backhaul connection.
  • 5G networks are just an example type of communication network, and embodiments of the disclosure may utilize earlier generation wireless or wired communication, as well as later generation wired or wireless technologies that come after 5G.
  • the cloud game network 190 includes a game server 160 that provides access to a plurality of video games.
  • Game server 160 may be any type of server computing device available in the cloud, and may be configured as one or more virtual machines executing on one or more hosts.
  • game server 160 may manage a virtual machine supporting a game processor that instantiates an instance of a game for a user.
  • a plurality of game processors of game server 160 associated with a plurality of virtual machines is configured to execute multiple instances of one or more games associated with gameplays of a plurality of users.
  • back-end server support provides streaming of media (e.g. video, audio, etc.) of gameplays of a plurality of gaming applications to a plurality of corresponding users.
  • game server 160 is configured to stream data (e.g. rendered images and/or frames of a corresponding gameplay) back to a corresponding client device 110 through network 150.
  • data e.g. rendered images and/or frames of a corresponding gameplay
  • a computationally complex gaming application may be executing at the back-end server in response to controller inputs received and forwarded by client device 110.
  • Each server is able to render images and/or frames that are then encoded (e.g. compressed) and streamed to the corresponding client device for display.
  • a plurality of users may access cloud game network 190 via communication network 150 using corresponding client devices 110 configured for receiving streaming media.
  • client device 110 may be configured as a thin client providing interfacing with a back end server (e.g. cloud game network 190) configured for providing computational functionality (e.g. including game title processing engine 111).
  • client device 110 may be configured with a game title processing engine and game logic for at least some local processing of a video game, and may be further utilized for receiving streaming content as generated by the video game executing at a back-end server, or for other content provided by back-end server support.
  • the game title processing engine includes basic processor based functions for executing a video game and services associated with the video game. In that case, the game logic may be stored on the local client device 110 and is used for executing the video game.
  • Each of the client devices 110 may be requesting access to different games from the cloud game network.
  • cloud game network 190 may be executing one or more game logics that are built upon a game title processing engine 111, as executed using the CPU resources 163 and GPU resources 365 of the game server 160.
  • game logic 115a in cooperation with game title processing engine 111 may be executing on game server 160 for one client
  • game logic 115b in cooperation with game title processing engine 111 may be executing on game server 160 for a second client
  • game logic 115n in cooperation with game title processing engine 111 may be executing on game server 160 for an Nth client.
  • client device 110 of a corresponding user is configured for requesting access to games over a communication network 150, such as the internet, and for rendering for display images (e.g. image frame) generated by a video game executed by the game server 160, wherein encoded images are delivered to the client device 110 for display in association with the corresponding user.
  • a communication network 150 such as the internet
  • client device 110 may be interacting through client device 110 with an instance of a video game executing on game processor of game server 160.
  • an instance of the video game is executed by the game title processing engine 111.
  • Corresponding game logic (e.g. executable code) 115 implementing the video game is stored and accessible through a data store (not shown), and is used to execute the video game.
  • Game title processing engine 111 is able to support a plurality of video games using a plurality of game logics (e.g. gaming application), each of which is selectable by the user.
  • client device 110 is configured to interact with the game title processing engine 111 in association with the gameplay of a corresponding user, such as through input commands that are used to drive gameplay.
  • client device 110 may receive input from various types of input devices, such as game controllers, tablet computers, keyboards, gestures captured by video cameras, mice, touch pads, etc.
  • Client device 110 can be any type of computing device having at least a memory and a processor module that is capable of connecting to the game server 160 over network 150.
  • the back-end game title processing engine 111 is configured for generating rendered images, which is delivered over network 150 for display at a corresponding display in association with client device 110.
  • the game rendered images may be delivered by an instance of a corresponding game (e.g.
  • client device 110 is configured for receiving encoded images (e.g. encoded from game rendered images generated through execution of a video game), and for displaying the images that are rendered on display 11.
  • display 11 includes an HMD (e.g. displaying VR content).
  • the rendered images may be streamed to a smartphone or tablet, wirelessly or wired, direct from the cloud based services or via the client device 110 (e.g. PlayStation ® Remote Play).
  • game server 160 and/or the game title processing engine 111 includes basic processor based functions for executing the game and services associated with the gaming application.
  • game server 160 includes central processing unit (CPU) resources 163 and graphics processing unit (GPU) resources 365 that are configured for performing processor based functions include 2D or 3D rendering, physics simulation, scripting, audio, animation, graphics processing, lighting, shading, rasterization, ray tracing, shadowing, culling, transformation, artificial intelligence, etc.
  • CPU central processing unit
  • GPU graphics processing unit
  • the CPU and GPU group may implement services for the gaming application, including, in part, memory management, multi thread management, quality of service (QoS), bandwidth testing, social networking, management of social friends, communication with social networks of friends, communication channels, texting, instant messaging, chat support, etc.
  • one or more applications share a particular GPU resource.
  • multiple GPU devices may be combined to perform graphics processing for a single application that is executing on a corresponding CPU.
  • cloud game network 190 is a distributed game server system and/or architecture.
  • a distributed game engine executing game logic is configured as a corresponding instance of a corresponding game.
  • the distributed game engine takes each of the functions of a game engine and distributes those functions for execution by a multitude of processing entities. Individual functions can be further distributed across one or more processing entities.
  • the processing entities may be configured in different configurations, including physical hardware, and/or as virtual components or virtual machines, and/or as virtual containers, wherein a container is different from a virtual machine as it virtualizes an instance of the gaming application running on a virtualized operating system.
  • the processing entities may utilize and/or rely on servers and their underlying hardware on one or more servers (compute nodes) of the cloud game network 190, wherein the servers may be located on one or more racks.
  • the coordination, assignment, and management of the execution of those functions to the various processing entities are performed by a distribution synchronization layer.
  • the distribution synchronization layer is able to efficiently execute (e.g. through load balancing) those functions across the distributed processing entities, such that critical game engine components/functions are distributed and reassembled for more efficient processing.
  • FIG. 2 is a diagram of an exemplary multi-GPU architecture 200 wherein multiple GPUs collaborate to render a single image of a corresponding application, in accordance with one embodiment of the present disclosure. It is understood that many architectures are possible in various embodiments of the present disclosure in which multiple GPUs collaborate to render a single image though not explicitly described or shown. For example, multi-GPU rendering of geometry for an application by performing region testing while rendering may be implemented between one or more cloud gaming servers of a cloud gaming system, or may be implemented within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • the multi-GPU architecture 200 includes a CPU 163 and multiple GPUs configured for multi-GPU rendering of a single image for an application, and/or each image in a sequence of images for the application.
  • CPU 163 and GPU resources 365 are configured for performing processor based functions include 2D or 3D rendering, physics simulation, scripting, audio, animation, graphics processing, lighting, shading, rasterization, ray tracing, shadowing, culling, transformation, artificial intelligence, etc., as previously described.
  • GPUs are shown in GPU resources 365 of the multi-GPU architecture 200, though any number of GPUs may be utilized when rendering images for an application.
  • Each GPU is connected via a high speed bus 220 to a corresponding dedicated memory, such as random access memory (RAM).
  • RAM random access memory
  • GPU-A is connected to memory 210A (e.g., RAM) via bus 220
  • GPU-B is connected to memory 210B (e.g., RAM) via bus 220
  • GPU-C is connected to memory 210C (e.g., RAM) via bus 220
  • GPU-D is connected to memory 210D (e.g., RAM) via bus 220.
  • each GPU is connected to each other via bus 240 that depending on the architecture may be approximately equal in speed or slower than bus 220 used for communication between a corresponding GPU and its corresponding memory.
  • bus 240 may be approximately equal in speed or slower than bus 220 used for communication between a corresponding GPU and its corresponding memory.
  • GPU-A is connected to each of GPU-B, GPU-C, and GPU-D via bus 240.
  • GPU-B is connected to each of GPU-A, GPU-C, and GPU-D via bus 240.
  • GPU-C is connected to each of GPU-A, GPU-B, and GPU-D via bus 240.
  • GPU-D is connected to each of GPU-A, GPU-B, and GPU-C via bus 240.
  • CPU 163 connects to each of the GPUs via a lower speed bus 230 (e.g., bus 230 is slower than bus 220 used for communication between a corresponding GPU and its corresponding memory).
  • bus 230 is slower than bus 220 used for communication between a corresponding GPU and its corresponding memory.
  • CPU 163 is connected to each of GPU-A, GPU-B, GPU- C, and GPU-D.
  • FIG. 3 is a diagram of graphics processing unit resources 365 configured for multi- GPU rendering of geometry for an image frame generated by an application by pretesting against screen regions, which may by interleaved, before rendering, in accordance with one embodiment of the present disclosure.
  • game server 160 may be configured to include GPU resources 365 in the cloud game network 190 of FIG. 1.
  • GPU resources 365 includes multiple GPUs, such as GPU 365a, GPU 365b ... GPU 365n.
  • various architectures may include multiple GPUs collaborating to render a single image by performing multi-GPU rendering of geometry for an application through region testing while rendering, such as implementing multi-GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system, or implementing multi-GPU rendering of geometry within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • game server 160 is configured to perform multi- GPU processing when rendering a single image of an application, such that multiple GPUs collaborate to render a single image, and/or render each of one or more images of a sequence of images when executing an application.
  • game server 160 may include a CPU and GPU group that is configured to perform multi-GPU rendering of each of one or more images in a sequence of images of the application, wherein one CPU and GPU group could be implementing graphics and/or rendering pipelines for the application, in one embodiment.
  • the CPU and GPU group could be configured as one or more processing devices.
  • the GPU and GPU group may include CPU 163 and GPU resources 365, which are configured for performing processor based functions include 2D or 3D rendering, physics simulation, scripting, audio, animation, graphics processing, lighting, shading, rasterization, ray tracing, shadowing, culling, transformation, artificial intelligence, etc.
  • GPU resources 365 are responsible and/or configured for rendering of objects (e.g. writing color or normal vector values for a pixel of the object to multiple render targets - MRTs) and for execution of synchronous compute kernels (e.g. full screen effects on the resulting MRTs); the synchronous compute to perform, and the objects to render are specified by commands contained in rendering command buffers 325 that the GPU will execute.
  • GPU resources 365 is configured to render objects and perform synchronous compute (e.g. during the execution of synchronous compute kernels) when executing commands from the rendering command buffers 325, wherein commands and/or operations may be dependent on other operations such that they are performed in sequence.
  • GPU resources 365 are configured to perform synchronous compute and/or rendering of objects using one or more rendering command buffers 325 (e.g. rendering command buffer 325a, rendering buffer 325b ... rendering command buffer 325n).
  • Each GPU in the GPU resources 365 may have their own command buffers, in one embodiment.
  • the GPUs in GPU resources 365 may use the same command buffer or the same set of command buffers.
  • each of the GPUs in GPU resources 365 may support the ability for a command to be executed by one GPU, but not by another.
  • rendering command buffer 325a may support flags 330a
  • rendering command buffer 325b may support flags 330b
  • rendering command buffer 325n may support flags 330n.
  • Performance of synchronous compute e.g. execution of synchronous compute kernels
  • rendering of objects are part of the overall rendering. For example, if the video game is running at 60Hz (e.g. 60 frames per second), then all object rendering and execution of synchronous compute kernels for an image frame typically must complete within approximately
  • each of the rendering command buffers 325 contains commands of various types, including commands that affect a corresponding GPU configuration (e.g. commands that specify the location and format of a render target), as well as commands to render objects and/or execute synchronous compute kernels.
  • commands that affect a corresponding GPU configuration e.g. commands that specify the location and format of a render target
  • synchronous compute performed when executing synchronize compute kernels may include performing full screen effects when the objects have all been rendered to one or more corresponding multiple render targets (MRTs).
  • GPU resources 365 when GPU resources 365 render objects for an image frame, and/or execute synchronous compute kernels when generating the image frame, the GPU resources 365 are configured via the registers of each GPU 365a, 365b ... 365n.
  • GPU 365a is configured via its registers 340 (e.g. register 340a, register 340b ... register 340n) to perform that rendering or compute kernel execution in a certain way. That is, the values stored in registers 340 define the hardware context (e.g. GPU configuration or GPU state) for GPU 365a when executing commands in rendering command buffers 325 used for rendering objects and/or executing synchronous compute kernels for an image frame.
  • Each of the GPUs in GPU resources 365 may be similarly configured, such that GPU 365b is configured via its registers 350 (e.g., register 350a, register 350b ... register 350n) to perform that rendering or compute kernel execution in a certain way; ... and GPU 365n is configured via its registers 370 (e.g., register 370a, register 370b ... register 370n) to perform that rendering or compute kernel execution in a certain way.
  • registers 350 e.g., register 350a, register 350b ... register 350n
  • GPU 365n is configured via its registers 370 (e.g., register 370a, register 370b ... register 370n) to perform that rendering or compute kernel execution in a certain way.
  • GPU configuration includes the location and format of render targets (e.g. MRTs).
  • other examples of GPU configuration include operating procedures. For instance, when rendering an object, the Z- value of each pixel of the object can be compared to the Z-buffer in various ways. For example, the object pixel is written only if the object Z- value matches the value in the Z-buffer. Alternatively, the object pixel could be written only if the object Z- value is the same or less than the value in the Z-buffer. The type of test being performed is defined within the GPU configuration. [0075] FIG.
  • FIG. 4 is a simplified diagram of a rendering architecture implementing a graphics pipeline 400 that is configured for multi-GPU processing, such that multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • the graphics pipeline 400 is illustrative of the general process for rendering images using 3D (three dimensional) polygon rendering processes.
  • the graphics pipeline 400 for a rendered image outputs corresponding color information for each of the pixels in a display, wherein the color information may represent texture and shading (e.g., color, shadowing, etc.).
  • Graphics pipeline 400 may be implementable within the client device 110, game server 160, game title processing engine 111, and/or GPU resources 365 of FIGS. 1 and 3.
  • various architectures may include multiple GPUs collaborating to render a single image by performing multi- GPU rendering of geometry for an application through region testing while rendering, such as implementing multi- GPU rendering of geometry between one or more cloud gaming servers of a cloud gaming system, or implementing multi-GPU rendering of geometry within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • the graphics pipeline receives input geometries 405.
  • the geometry processing stage 410 receives the input geometries 405.
  • the input geometries 405 may include vertices within a 3D gaming world, and information corresponding to each of the vertices.
  • a given object within the gaming world can be represented using polygons (e.g., triangles) defined by vertices, wherein the surface of a corresponding polygon is then processed through the graphics pipeline 400 to achieve a final effect (e.g., color, texture, etc.).
  • Vertex attributes may include normal (e.g., which direction is perpendicular to the geometry at that location), color (e.g., RGB - red, green, and blue triple, etc.), and texture coordinate/mapping information.
  • the geometry processing stage 410 is responsible for (and capable of) both vertex processing (e.g. via a vertex shader) and primitive processing.
  • the geometry processing stage 410 may output sets of vertices that define primitives and deliver them to the next stage of the graphics pipeline 400, as well as positions (to be precise, homogeneous coordinates) and various other parameters for those vertices.
  • the positions are placed in the position cache 450 for access by later shader stages.
  • the other parameters are placed in the parameter cache 460, again for access by later shader stages.
  • Various operations may be performed by the geometry processing stage 410, such as performing lighting and shadowing calculations for the primitives and/or polygons.
  • the geometry stage can perform backface culling, and/or clipping (e.g. testing against the view frustum), thereby reducing the load on downstream stages (e.g., rasterization stage 420, etc.).
  • the geometry stage may generate primitives (e.g. with functionality equivalent to a traditional geometry shader).
  • the primitives output by the geometry processing stage 410 are fed into the rasterization stage 420 that converts the primitives into a raster image composed of pixels.
  • the rasterization stage 420 is configured to project objects in the scene to a two- dimensional (2D) image plane defined by the viewing location in the 3D gaming world (e.g., camera location, user eye location, etc.).
  • 2D two- dimensional
  • the rasterization stage 420 looks at each primitive and determines which pixels are affected by the corresponding primitive.
  • the rasterizer 420 partitions the primitives into pixel sized fragments, wherein each fragment corresponds to a pixel in the display. It is important to note that one or more fragments may contribute to the color of a corresponding pixel when displaying an image.
  • additional operations may also be performed by the rasterization stage 420 such as clipping (identify and disregard fragments that are outside the viewing frustum) and culling (disregard fragments that are occluded by closer objects) to the viewing location.
  • clipping identify and disregard fragments that are outside the viewing frustum
  • culling disregard fragments that are occluded by closer objects
  • the geometry processing stage 410 and/or rasterization stage 420 may be configured to identify and disregard primitives that are outside the viewing frustum as defined by the viewing location in the gaming world.
  • the pixel processing stage 430 uses the parameters created by the geometry processing stage, as well as other data, to generate values such as the resulting color of the pixel.
  • the pixel processing stage 430 at its core performs shading operations on the fragments to determine how the color and brightness of a primitive varies with available lighting.
  • pixel processing stage 430 may determine depth, color, normal and texture coordinates (e.g., texture details) for each fragment, and may further determine appropriate levels of light, darkness, and color for the fragments.
  • pixel processing stage 430 calculates the traits of each fragment, including color and other attributes (e.g., z-depth for distance from the viewing location, and alpha values for transparency).
  • the pixel processing stage 430 applies lighting effects to the fragments based on the available lighting affecting the corresponding fragments. Further, the pixel processing stage 430 may apply shadowing effects for each fragment.
  • the output of the pixel processing stage 430 includes processed fragments (e.g., texture and shading information) and is delivered to the output merger stage 440 in the next stage of the graphics pipeline 400.
  • the output merger stage 440 generates a final color for the pixel, using the output of the pixel processing stage 430, as well as other data, such as a value already in memory.
  • the output merger stage 440 may perform optional blending of values between fragments and/or pixels determined from the pixel processing stage 430, and values already written to an MRT for that pixel.
  • Color values for each pixel in the display may be stored in a frame buffer (not shown). These values are scanned to the corresponding pixels when displaying a corresponding image of the scene.
  • the display reads color values from the frame buffer for each pixel, row-by-row, from left-to-right or right-to-left, top-to-bottom or bottom-to-top, or any other pattern, and illuminates pixels using those pixel values when displaying the image.
  • flow diagram 500 of FIG. 5 illustrates a method for graphics processing when implementing multi-GPU rendering of geometry for an image frame generated by an application by pretesting the geometry against interleaved screen regions before rendering, in accordance with one embodiment of the present disclosure. In that manner, multiple GPU resources are used to efficiently perform rendering of objects when executing an application.
  • various architectures may include multiple GPUs collaborating to render a single image by performing multi-GPU rendering of geometry for an application through region testing while rendering, such as within one or more cloud gaming servers of a cloud gaming system, or within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • the method includes rendering graphics for an application using a plurality of graphics processing units (GPUs) that collaborate to generate an image.
  • GPUs graphics processing units
  • multi- GPU processing is performed when rendering a single image frame and/or each of one or more image frames of a sequence of image frames for a real-time application.
  • the method includes dividing responsibility for the rendering geometry of the graphics between the plurality of GPUs based on a plurality of screen regions. That is, each GPU has a corresponding division of the responsibility (e.g., corresponding screen region) which is known to all the GPUs. More specifically, each of the GPUs is responsible for rendering geometry in a corresponding set of screen regions of the plurality of screen regions, wherein the corresponding set of screen regions includes one or more screen regions. For example, a first GPU has the first division of responsibility for rendering objects in a first set of screen regions. Also, a second GPU has a second division of responsibility for rendering objects in a second set of screen regions. This is repeatable for remaining GPUs.
  • each GPU has a corresponding division of the responsibility (e.g., corresponding screen region) which is known to all the GPUs. More specifically, each of the GPUs is responsible for rendering geometry in a corresponding set of screen regions of the plurality of screen regions, wherein the corresponding set of screen regions includes one or more screen regions. For example, a
  • the method includes assigning a first GPU a first piece of geometry of an image frame generated during execution an application for geometry testing.
  • an image frame may include one or more objects, wherein each object may be defined by one or more pieces of geometry. That is, geometry pretesting and rendering are performed on a piece of geometry that is an entire object, in one embodiment. In other embodiments, geometry pretesting and rendering are performed on a piece of geometry that is a portion of an entire object.
  • each of the plurality of GPUs is assigned to a corresponding portion of the geometry associated with an image frame.
  • every portion of the geometry is assigned to a corresponding GPU for purposes of geometry pretesting.
  • the geometry may be evenly assigned between the plurality of GPUs, in one embodiment. For example, if there are four GPUs in the plurality, then each of the GPUs may process a quarter of the geometry in an image frame. In other embodiments, the geometry may be unevenly assigned between the plurality of GPUs. For example, in the example of using four GPUs for multi-GPU rendering of an image frame, one GPU may process more geometry of an image frame than another GPU.
  • the method includes performing geometry pretesting at the first GPU to generate information for how the piece of geometry relates to the plurality of screen regions.
  • the first GPU generates information for the piece of geometry, and how it relates to each of the plurality of screen regions.
  • geometry pretesting by the first GPU may determine whether or not the piece of geometry overlaps a particular screen region that is assigned to a corresponding GPU for object rendering.
  • the first piece of geometry may overlap screen regions for which other GPUs are responsible for object rendering, and/or may overlap screen regions for which the first GPU is responsible for object rendering.
  • the geometry testing is performed by shaders in a corresponding command buffer executed by the first GPU before performing rendering of the geometry by any of the plurality of GPUs.
  • the geometry testing is performed by hardware, e.g. in the rasterization stage 420 of the graphics pipeline 400.
  • Geometry pretesting is typically in embodiments performed simultaneously for all geometry of a corresponding image frame by the plurality of GPUs. That is, each GPU performs geometry pretesting for its portion of the geometry of a corresponding image frame. In that manner, geometry pretesting by the GPUs allows each GPU to know which pieces of geometry to render, and also which pieces of geometry to skip. In particular, when a corresponding GPU performs geometry pretesting, it tests its portion of the geometry against the screen regions of each of the plurality of GPUs used for rendering the image frame. For example, if there are four GPUs, then each GPU may perform geometry testing on a quarter of the geometry of the image frame, especially if the geometry is assigned evenly to the GPUs for purposes of geometry testing.
  • the information generated indicates how all the geometry (e.g. pieces of geometry) in the image frame relates to screen regions of all GPUs, wherein screen regions are each assigned to a corresponding GPU for object rendering, and/or wherein rendering may be performed on pieces of geometry (e.g. an entire object or a portion of an object).
  • the method includes using the information at each of the plurality of GPUs when rendering the piece of geometry (e.g. to include fully rendering the piece of geometry or skipping the rendering of that piece of geometry). That is, the information is used at each of the plurality of GPUs to render the piece of geometry, wherein test results (e.g. information) of the geometry are sent to other GPUs, such that the information is known to each of the GPUs.
  • the geometry e.g. pieces of geometry
  • the image frame is typically in embodiments rendered simultaneously by the plurality of GPUs.
  • that GPU will render that piece of geometry based on the information.
  • the piece of geometry does not overlap any screen region assigned to the corresponding GPU for object rendering
  • that GPU can skip rendering of that piece of geometry based on the information.
  • the information allows all GPUs to more efficiently render geometry in an image frame, and/or to avoid rendering that geometry altogether.
  • the rendering may be performed by shaders in a corresponding command buffer as executed by the plurality of GPUs.
  • the shaders may be configured to perform one or both of geometry testing and/or rendering, based on corresponding GPU configurations.
  • a corresponding rendering GPU receives corresponding information in time to use it, that GPU will use the information when deciding which geometry to render within a corresponding image, in accordance with one embodiment of the present disclosure. That is, the information may be taken as a hint. Otherwise, the rendering GPU will process the piece of geometry as it ordinarily would.
  • the information may indicate whether the geometry overlaps any screen region assigned to a rendering GPU (e.g. a second GPU)
  • the rendering GPU may skip rendering the geometry entirely.
  • the second GPU may skip rendering of at least those pieces of geometry that do not overlap any of the screen regions assigned to the second GPU for object rendering.
  • the information may indicate that there is overlapping for the geometry, in which case the second or rendering GPU would render the geometry. Also, the information may indicate that certain pieces of the geometry overlap any the screen region assigned to the second or rendering GPU for object rendering. In that case, the second or rendering GPU would render only those pieces of the geometry that overlap. In still another embodiment, if there is no information, or if the information is not generated or received in time, the second GPU would perform rendering normally (e.g., render the geometry). As such, information provided as a hint may increase overall efficiency of the graphics processing system if received in time. If the information is not received in time, the graphics processing system will still operate properly in the absence of such information ⁇
  • one GPU e.g. a pretest GPU
  • the dedicated GPU is not used for rendering objects (e.g. pieces of geometry) in the corresponding image frame.
  • graphics for an application are rendered using a plurality of GPUs, as previously described.
  • responsibility for rendering geometry of the graphics is divided between the plurality of GPUs based on a plurality of screen regions, which may be interleaved, wherein each GPU has a corresponding division of the responsibility which is known to the plurality of GPUs.
  • Geometry testing is performed at a pretest GPU on a plurality of pieces of geometry of an image frame generated by an application in order to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the plurality of pieces of geometry are rendered at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry. That is, the information is used when rendering each of the pieces of geometry by a corresponding rendering GPU from the GPUs used to render the image frame.
  • FIGS. 6A-6B show renderings to screens that are subdivided into regions and sub- regions, purely for purposes of illustration. It is understood that the number of subdivided regions and/or sub-regions is selectable for efficient multi-GPU processing of an image and/or each of one or more images of a sequence of images. That is, the screen may be subdivided into two or more regions, wherein each region may be further divided into sub-regions. In one embodiment of the present disclosure, the screen is subdivided into four quadrants as shown in FIG. 6A. In another embodiment of the present disclosure, the screen is subdivided into a larger number of interleaved regions as shown in FIG 6B. The discussion of FIGS.
  • FIGS. 7A-7C and FIGS 8A-8B show more efficient rendering, according to some embodiments of the invention.
  • FIG. 6A is a diagram of a screen 610A that is subdivided into quadrants
  • screen 610A is subdivided into four quadrants (e.g. A, B, C, and D). Each quadrant is assigned to one of the four GPUs [GPU-A, GPU-B, GPU-C, and GPU-D], in a one-to-one relationship. For example, GPU-A is assigned to quadrant A, GPU-B is assigned to quadrant B, GPU-C is assigned to quadrant C, and GPU-D is assigned to quadrant D.
  • the geometry can be culled.
  • CPU 163 can check a bounding box against each quadrant’s frustum, and request each GPU to render only the objects that overlap its corresponding frustum.
  • each GPU is responsible for rendering only a portion of the geometry.
  • screen 610 shows pieces of geometry, wherein each piece is a corresponding object, wherein screen 610 shows objects 611 - 617 (e.g. pieces of geometry).
  • GPU-A will render no objects, as no objects overlap Quadrant A.
  • GPU-B will render objects 615 and 616 (as a portion of object 615 is present in Quadrant B, the CPU’s culling test will correctly conclude that GPU-B must render it).
  • GPU-C will render objects 611 and 612.
  • GPU-D will render objects 612, 613, 614, 615 and 617.
  • the amount of work that each GPU must perform may be very different, as a disproportionate amount of geometry may be in one quadrant in some situations.
  • quadrant A does not have any pieces of geometry
  • quadrant D has five pieces of geometry, or at least portions of at least five pieces of geometry.
  • GPU-A assigned to quadrant A would be idle, while GPU-D assigned to quadrant D would be disproportionately busy when rendering objects in the corresponding image.
  • FIG. 6B illustrates another technique when subdividing a screen into regions.
  • screen 610B is subdivided into a plurality of interleaved regions when performing multi- GPU rendering of a single image or each of one or more images in a sequence of images.
  • screen 610B is subdivided into a larger number of interleaved regions (e.g. greater than the four quadrants), while using the same amount of GPUs for rendering (e.g. four).
  • the objects (611-617) shown in screen 610A are also shown in screen 610B in the same corresponding locations.
  • GPU-A e.g. GPU-A, GPU-B, GPU-C, and GPU-D
  • Each of the GPUs is responsible for rendering geometry overlapping a corresponding region. That is, each GPU is assigned to a corresponding set of regions.
  • GPU-A is responsible for each of the regions labeled A in a corresponding set
  • GPU-B is responsible for each of regions labeled B in a corresponding set
  • GPU-C is responsible for each of regions labeled C in a corresponding set
  • GPU-D is responsible for each of regions labeled D in a corresponding set.
  • the regions are interleaved in a particular pattern. Because of the interleaving (and higher number) of regions, the amount of work that each GPU must perform may be much more balanced.
  • the pattern of interleaving of screen 610B includes alternating rows including regions A - B - A - B and so on, and regions C - D - C - D and so on.
  • Other patterns of interleaving the regions is supported in embodiments of the present disclosure.
  • patterns may include repeated sequences of regions, evenly distributed regions, uneven distribution of regions, repeatable rows of sequences of regions, random sequences of regions, random rows of sequences of regions, etc.
  • each GPU must still process most or all of the geometry. For example, it may be difficult to check object bounding boxes against all of the regions that a GPU is responsible for. Also, even if bounding boxes can be checked in a timely manner, due to small regions size, the result will be that each GPU likely has to process most of the geometry because every object in an image overlaps at least one regions of each of the GPUs (e.g. a GPU processes an entire object even though only a portion of the object overlaps at least one region in a set of regions assigned to that GPU).
  • FIGS. 7A-7C are diagrams illustrating the use of multiple GPUs to render a single image, and/or each of at least one or more images in a sequence of images, in embodiments of the present disclosure.
  • the selection of four GPUs is made purely for ease of illustrating multi- GPU rendering when rendering an image while executing an application, and it is understood that any number of GPUs may be used for multi-GPU rendering in various embodiments.
  • FIG. 7A is a diagram of a rendering command buffer 700A that is shared by multiple GPUs that collaborate to render a single image frame, in accordance with one embodiment of the present disclosure. That is, in the present example the multiple GPUs each use the same rendering command buffer (e.g., buffer 700A), and each of the GPUs execute all commands in the rendering command buffer. A plurality of commands (complete set) is loaded into rendering command buffer 700A, and is used for rendering a corresponding image frame. It is understood that one or more rendering command buffers may be used to generate a corresponding image frame.
  • the multiple GPUs each use the same rendering command buffer (e.g., buffer 700A), and each of the GPUs execute all commands in the rendering command buffer.
  • a plurality of commands (complete set) is loaded into rendering command buffer 700A, and is used for rendering a corresponding image frame. It is understood that one or more rendering command buffers may be used to generate a corresponding image frame.
  • the CPU generates one or more draw calls for the image frame, wherein the draw calls include commands placed into one or more rendering command buffers for execution by one or more GPUs of the GPU resources 365 of FIG. 3 when performing multi-GPU rendering of a corresponding image.
  • the CPU 163 may request one or more GPUs to generate all or some of the draw calls used for rendering a corresponding image.
  • the entire set of commands may be shown in FIG. 7 A that are contained within the rendering command buffer 700A, or FIG. 7A may show a portion of the entire set of commands contained within the rendering command buffer 700 A.
  • GPUs typically in embodiments render simultaneously when performing multi-GPU rendering of an image or each of one or more images in a sequence of images. Rendering of an image can be broken down into multiple phases. In each of the phases, the GPUs need to be synchronized, such that a faster GPU must wait until the slower GPUs complete.
  • the commands shown in FIG. 7A for the rendering command buffer 700A shows one phase.
  • the rendering command buffer 700 A may include commands for one or more phases when rendering an image, FIG. 7 A only shows a portion of all the commands, such that commands for the other phases are not shown.
  • FIG. 7A In the piece of the rendering command buffer 700A shown in FIG. 7 A that illustrates one phase, there are four objects to be rendered (e.g., object 0, object 1, object 2, and object 3), as is shown in FIG. 7B-1.
  • objects to be rendered e.g., object 0, object 1, object 2, and object 3
  • the piece of the rendering command buffer 700A shown in FIG. 7A includes commands for geometry testing, rendering of objects (e.g. pieces of geometry) and commands for configuring state of the one or more rendering GPUs that are executing commands from rendering command buffer 700A.
  • the piece of rendering command buffer 700A shown in FIG. 7A includes commands (710-728) used for geometry pretesting, rendering objects and/or executing synchronous compute kernels when rendering a corresponding image for a corresponding application.
  • the geometry pretesting, and rendering of objects for that image and/or the execution of synchronous compute kernels must be performed within a frame period.
  • Two processing sections are shown in the rendering command buffer 700A.
  • processing section 1 includes pretesting or geometry testing 701
  • section 2 includes rendering 702.
  • Section 1 includes performing geometry testing 701 of objects in the image frame, wherein each object may be defined by one or more pieces of geometry. Pretesting or geometry testing 701 may be performed by one or more shaders. For example, each GPU used in multi- GPU rendering of a corresponding image frame is assigned a portion of the geometry of the image frame to perform geometry testing, wherein every portion may be assigned for pretesting, in one embodiment. The assigned portion may include one or more pieces of geometry, wherein the each piece may include an entire object, or may include a portion of an object (e.g., vertex, primitive, etc.).
  • geometry testing is performed on a piece of geometry to generate information on how that piece of geometry relates to each of the plurality of screen regions. For example, geometry testing may determine whether a piece of geometry overlaps a particular screen region assigned to a corresponding GPU for object rendering.
  • geometry testing 701 (e.g., pretesting of geometry) of section 1 includes commands for configuring a state of the one or more GPUs executing commands from the rendering command buffer 700A, and commands for performing geometry testing.
  • the GPU state of each GPU is configured before the GPUs perform geometry testing on corresponding objects.
  • commands 710, 713, and 715 are each used for configuring a GPU state of the one or more GPUs for purposes of executing commands for geometry testing.
  • command 710 configures GPU state so that geometry testing commands 711-712 can be properly performed, wherein command 711 performs geometry testing on object 0, and command 712 performs geometry testing on object 1.
  • command 713 configures GPU state so that geometry testing command 714 can perform geometry testing for object 2.
  • command 715 configures GPU state so that geometry testing command 716 can perform geometry testing for object 3. It is understood that a GPU state may be configured for one or more geometry testing commands (e.g., testing commands 711 and 712).
  • the GPU state may be modified throughout the processing of commands in the rendering command buffer 700A, each subsequent section of commands may be used for configuring the GPU state.
  • the GPU state may be set in a variety of ways.
  • the CPU or GPU could set a value in random access memory (RAM), wherein the GPU would check the value in RAM.
  • RAM random access memory
  • the state could be internal to the GPU, such as when a command buffer is called as a subroutine twice with internal GPU state being different between the two subroutine calls.
  • Section 2 includes performing rendering 702 of objects in the image frame, wherein pieces of geometry are rendered). Rendering 702 may be performed by one or more shaders in the command buffer 700A. As shown in FIG. 7A, rendering 702 of section 2 includes commands for configuring a state of the one or more GPUs executing commands from the rendering command buffer 700 A, and commands for performing the rendering. In particular, the
  • GPU state of each GPU is configured before the GPUs render corresponding objects (e.g. pieces of geometry).
  • objects e.g. pieces of geometry.
  • commands 721, 723, 725, and 727 are each used for configuring a
  • command 721 configures GPU state so that rendering command 722 can render object 0; command 723 configures GPU state so that rendering command 724 can render object 1; command 725 configures GPU state so that rendering command 726 can render object 2; and command 727 configures GPU state so that rendering command 728 can render object 3.
  • FIG. 7A shows that GPU state is configured for each rendering command (e.g., render object 0, etc.), it is understood that a GPU state may be configured for one or more rendering commands.
  • each GPU used in multi-GPU rendering of a corresponding image frame renders corresponding pieces of geometry based on the information generated during geometry pretesting.
  • the information known to each of the GPUs provides relationships between objects and screen regions.
  • a GPU may use that information if received in a timely fashion for purposes of efficiently rendering those pieces of geometry.
  • the information when a piece of geometry overlaps any screen region or regions assigned to a corresponding GPU for object rendering, that GPU performs rendering for that piece of geometry.
  • the information may indicate that a first GPU should skip rendering a piece of geometry entirely (e.g., the piece of geometry does not overlap any screen region that the first GPU is assigned responsibility for object rendering).
  • each GPU only renders pieces of geometry that overlap the screen region or regions to which it is responsible for object rendering.
  • the information is provided as a hint to each of the GPUs, such that the information is considered by each GPU that is performing rendering pieces of geometry if received before rendering begins.
  • rendering proceeds normally if the information is not received in time, such as the corresponding piece of geometry is rendered fully by a corresponding GPU regardless of whether that piece of geometry overlaps any screen regions that are assigned to the GPU for object rendering.
  • each GPU is responsible for rendering objects in a corresponding set of regions, wherein the corresponding set includes one or more regions.
  • rendering command buffer 700A is shared by multiple GPUs that collaborate to render a single image. That is, the GPUs used for multi-GPU rendering of a single image or each of one or more images in a sequence of images share a common command buffer.
  • each GPU might have its own command buffer.
  • each of the GPUs might be rendering somewhat different sets of objects.
  • the multiple GPUs can still use the same command buffer (e.g., sharing one command buffer), as long as the command buffer supports the ability for a command to be executed by one GPU but not by another, as previously described.
  • execution of a command in the shared rendering command buffer 700 A may be limited to one of the rendering GPUs. This could be accomplished in a variety of ways.
  • flags may be used on a corresponding command to indicate which GPUs should execute it.
  • predication may be implemented in the rendering command buffer using bits to say which GPU does what under which condition. An example of predication includes — “If this is GPU-A, then skip the following X commands”.
  • the multiple GPUs may still use the same command buffer. For example, when the regions are relatively small, each GPU may still render all of the objects, as previously described.
  • FIG. 7B-1 illustrates a screen 700B showing an image including four objects that are rendered by multiple GPUs using the rendering command buffer 700A of FIG. 7A, in accordance with one embodiment of the present disclosure.
  • Multi-GPU rendering of geometry is performed for an application by pretesting the geometry against screen regions, which may be interleaved, before rendering pieces of geometry corresponding to objects in an image frame, in accordance with one embodiment of the present disclosure.
  • responsibility for rendering of geometry is divided up by screen region between the multiple GPUs, wherein the plurality of screen regions is configured to reduce imbalance of rendering time between the plurality of GPUs.
  • screen 700B shows the screen region responsibilities for each GPU when rendering the objects of the image.
  • GPUs are used for rendering objects in the image shown in screen 700B.
  • Screen 700B is divided more finely than by quadrants as shown in FIG. 6A, in an effort to balance pixel and vertex load between the GPUs.
  • screen 700B is divided into regions, that may be interleaved.
  • the interleaving includes multiple rows of regions.
  • Each of rows 731 and 733 includes region A alternating with region B.
  • Each of rows 732 and 734 includes region C alternating with region D. More particularly, rows including regions A and B alternate with rows including regions C and D, in a pattern.
  • each of the plurality of screen regions is uniformly sized. In one embodiment, each of the plurality of screen regions is not uniform in size. In still another embodiment, the number and sizing of a plurality of screen regions changes dynamically.
  • Each of the GPUs is responsible for rendering of objects in a corresponding set of regions, wherein each set may include one or more regions.
  • GPU-A is responsible for rendering of objects in each of the A regions in a corresponding set
  • GPU-B is responsible for rendering of objects in each of the B regions in a corresponding set
  • GPU-C is responsible for rendering of objects in each of the C regions in a corresponding set
  • GPU-D is responsible for rendering of objects in each of the D regions in a corresponding set.
  • FIG. 7B-2 illustrates a table showing the rendering performed by each GPU when rendering the four objects of FIG. 7B-1, in accordance with one embodiment of the present disclosure.
  • object 0 is rendered by GPU-B
  • object 1 is rendered by GPU-C and GPU-D
  • object 2 is rendered by GPU-A, GPU-B, and GPU-D
  • object 3 is rendered by GPU-B, GPU-C, and GPU-D.
  • GPU A needs to render object 2 only
  • GPU D needs to render objects 1, 2 and 3.
  • FIG. 7C is a diagram illustrating the rendering of each object as performed by each GPU when multiple GPUs collaborate to render a single image frame, such as the image frame 700B shown in FIG. 7B-1, in accordance with one embodiment of the present disclosure.
  • FIG. 7C shows the rendering process of objects 0-3 as performed by each of the four GPUs (e.g., GPU-A, GPU-B, GPU-C, and GPU-D) using the shared rendering command buffer 700 A of FIG. 7A.
  • Rendering timing diagram 700C-1 shows multi-GPU rendering of objects 0-3 of a corresponding image in one phase of rendering, wherein each of the GPUs perform rendering in the absence of any information regarding the overlap between objects 0-3 and the screen regions.
  • Rendering timing diagram 700C-2 shows multi-GPU rendering of objects 0-3 of the corresponding image in the same phase of rendering, wherein information generated during geometry testing of screen regions (e.g. performed before rendering) are shared with each of the GPUs used for rendering objects 0-3 through a corresponding GPU pipeline.
  • Each of rendering timing diagrams 700C-1 and 700C-2 show the time taken by each GPU to process each piece of geometry (e.g., perform geometry testing and rendering).
  • a piece of geometry is an entire object.
  • a piece of geometry may be a portion of an object.
  • FIG. 7C shows the rendering of pieces of geometry, wherein each piece of geometry corresponds to an object (e.g. in its entirety).
  • objects e.g. pieces of geometry
  • objects that have no geometry e.g. a primitive of the object
  • at least one screen region e.g. in a corresponding set of regions
  • objects that have geometry that overlaps at least one screen region (e.g. in a corresponding set of regions) of a corresponding GPU are represented by boxes drawn with solid lines.
  • Rendering timing diagram 700C-1 shows rendering of objects 0-3 using the four
  • GPUs e.g. GPU-A, GPU-B, GPU-C, and GPU-D.
  • Vertical line 755a indicates the start of the phase of rendering for the objects
  • vertical line 755b shows the end of the phase of rendering for the objects in rendering timing diagram 700C-1.
  • the start and end points along timeline 740 for the phase of rendering shown represent synchronization points, wherein each of the four GPUs are synchronized when executing a corresponding GPU pipeline. For instance, at vertical line 755b indicating the end of the phase of rendering, all GPUs must wait for the slowest GPU (e.g. GPU-B) to finish rendering objects 0-3 through the corresponding graphics pipeline before moving to the next phase of rendering.
  • the slowest GPU e.g. GPU-B
  • Geometry pretesting is not performed in rendering timing diagram 700C-1. As such, each of the GPUs must process each of the objects through the corresponding graphics pipeline.
  • a GPU may not fully render an object through the graphics pipeline if there are no pixels to be drawn for the object in any region assigned (e.g. in a corresponding set) to the corresponding GPU for object rendering. For example, when an object does not overlap, only the geometry processing stage of the graphics pipeline is executed. However, this still takes some time for processing.
  • GPU-A does not fully render objects 0, 1, and 3, because they do not overlap any screen regions (e.g. in a corresponding set) assigned to GPU-A for object rendering.
  • the rendering of these three objects is shown in boxes with dashed lines indicating that at least the geometry processing stage is performed, but the graphics pipeline is not fully performed.
  • GPU-A fully renders object 2 because that object overlaps at least one screen region assigned to GPU-A for rendering.
  • the rendering of object 2 is shown in a box with solid lines indicating that all of the stages of the corresponding graphics pipeline are performed.
  • GPU-B does not fully render object 1 (shown with a box with dashed lines) (i.e.
  • GPU-C does not fully render objects 0 and 2 (shown with boxes with dashed lines) (i.e. performing at least geometry processing stage), but fully renders objects (shown with boxes with solid lines) because those objects overlap at least one screen region (e.g. in a corresponding set) assigned to GPU-B for rendering.
  • GPU-D does not fully render object 0 (shown with a box with dashed lines) (i.e.
  • Rendering timing diagram 700C-2 shows geometry pretesting 701 ’ and rendering 702’ of objects 0-3 using multiple GPUs.
  • Vertical line 750a indicates the start of the phase of rendering (e.g. including geometry pretesting and rendering) for the objects, and vertical line 750b shows the end of the phase of rendering for the objects in rendering timing diagram 700C- 2.
  • the start and end points along timeline 740 for the phase of rendering shown in timing diagram 700C-2 represent synchronization points, wherein each of the four GPUs are synchronized when executing a corresponding GPU pipeline, as previously described. For instance, at vertical line 750b indicating the end of the phase of rendering, all GPUs must wait for the slowest GPU (e.g. GPU-B) to finish rendering objects 0-3 through the corresponding graphics pipeline before moving to the next phase of rendering.
  • the slowest GPU e.g. GPU-B
  • geometry pretesting 701’ is performed by the GPUs, wherein each GPU performs geometry pretesting for a subset of the geometry of the image frame against all the screen regions, wherein each screen region is assigned to a corresponding GPU for object rendering.
  • each of the GPUs is assigned to a corresponding portion of the geometry associated with the image frame.
  • Geometry pretesting generates information about how a particular piece of geometry relates to each of the screen regions, such as whether or not a piece of geometry overlaps any screen regions (e.g. in a corresponding set) assigned to a corresponding GPU for object rendering. That information is shared with each of the GPUs used for rendering the image frame. For example, geometry pretesting 701’ shown in FIG.
  • 7C includes having GPU-A perform geometry pretesting for object 0, having GPU-B perform geometry pretesting for object 1, having GPU-C perform geometry pretesting for object 2, and having GPU-D perform geometry pretesting for object 3.
  • the time for performing geometry pretesting may vary. For example, geometry pretesting of object 0 takes less time than to perform geometry pretesting on object 1. This may be due to object sizing, the number of screen regions that are overlapped, etc.
  • each GPU After geometry pretesting, each GPU performs rendering for all objects or pieces of geometry that intersect their screen regions. In one embodiment, each GPU begins the rendering of its pieces of geometry as soon as geometry testing is finished. That is, there is no synchronization point between the geometry testing and the rendering. This is possible because the geometry testing information being generated is treated as a hint rather than a hard dependency. For example, GPU-A begins rendering object 2 before GPU-B has finished geometry pretesting object 1, and as such before GPU-B begins rendering objects 0, 2, and 3. [00128] Vertical line 750a is aligned with vertical line 755a, such that each of the rendering timing diagrams 700C-1 and 700C-2 begin at the same time to render objects 0-1.
  • a speed increase 745 when rendering objects 0-3 is realized when performing multi-GPU rendering of geometry of an image for an application including pretesting geometry against screen regions before rendering, and providing the results of the geometry pretesting as information (e.g. hints). As shown, speed increase 745 is the time difference between vertical line 750b of timing diagram 700C-2 and vertical line 755b of timing diagram 700C-1.
  • the speed increase is realized through the generation and sharing of information generated during geometry pretesting.
  • GPU-A generates information indicating that object 0 need only be rendered by GPU-B.
  • GPU-B generates information indicating that object 0 need only be rendered by GPU-B.
  • GPU-A e.g. GPU-A, GPU-C, and
  • GPU-D may skip rendering of object 0 entirely, as object 0 does not overlap any regions (e.g. in corresponding sets) assigned to those GPUs for object rendering. For example, these GPUs need not perform the geometry processing stage, whereas without geometry pretesting this stage was processed even though these GPUs would not fully render object 0, as is shown in timing diagram 700C-1. Also, during geometry pretesting GPU-B generates information indicating that object 1 should be rendered by GPU-C and GPU-D, and that GPU-A and GPU-B may skip rendering of object 1 entirely, as object 1 does not overlap any region (e.g. in respective corresponding sets) assigned to GPU-A or GPU-B for object rendering. Also, during geometry pretesting GPU-C generates information indicating that object 2 should be rendered by GPU-A,
  • GPU-B, and GPU-D may skip rendering of object 2 entirely, as object 2 does not overlap any region (e.g. in a corresponding set) assigned to GPU-C for object rendering.
  • GPU-D generates information indicating that object 3 should be rendered by GPU-B, GPU-C, and GPU-D, and that GPU-A may skip rendering of object 3 entirely, as object 3 does not overlap any region (e.g. in a corresponding set) assigned to GPU-A for object rendering.
  • each GPU can determine which objects to render. As such, after geometry pretesting is performed and results from the testing is shared with all the GPUs, then each GPU has information with regards to which objects or pieces of geometry need to be rendered by the corresponding GPU. For example, GPU-A renders object 2; GPU-B renders objects 0, 2, and 3; GPU-C renders objects 1 and 3; and GPU-D renders objects 1, 2, and 3.
  • GPU A performs geometry processing for object 1, and determines that object 1 can be skipped by GPU-B, as object 1 does not overlap any region (e.g. in a corresponding set) assigned to GPU-B for object rendering.
  • object 1 is not fully rendered by GPU-A, as it does not overlap any region (e.g. in a corresponding set) assigned to GPU-A for object rendering. Since the determination that there is no overlap of object 1 by any region assigned to GPU-B is made before GPU-B begins geometry processing for object 1, GPU-B skips the rendering of object 1.
  • FIGS. 8A-8B show object testing against screen regions 820 A and 820B, wherein the screen regions may be interleaved (e.g. screen regions 820A and 820B show a portion of a display).
  • multi-GPU rendering of objects is performed for a single image frame, or each of one or more image frames in a sequence of image frames by performing geometry testing before rendering objects in the screen.
  • GPU-A is assigned responsibility for rendering objects in screen region 820A.
  • GPU-B is assigned responsibility for rendering objects in screen region 820B.
  • Information is generated for “pieces of geometry,” wherein the pieces of geometry can be an entire object or portions of objects.
  • a piece of geometry can be an object 810, or portions of object 810.
  • FIG. 8A illustrates object testing against screen regions when multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • the pieces of geometry can be objects, such that the pieces correspond to the geometry used by or generated by a corresponding draw call.
  • object 810 may be determined to overlap region 820A. That is, portion 810A of object 810 overlaps region 820A. In that case, GPU-A is tasked to render object 810.
  • object 810 may be determined to overlap region 820B. That is, portion 810B of object 810 overlaps region 820B. In that case, GPU-B is also tasked to render object 810.
  • FIG. 8B illustrates testing of portions of an object against screen regions and/or screen sub-regions when multiple GPUs collaborate to render a single image frame, in accordance with one embodiment of the present disclosure.
  • the pieces of geometry can be portions of objects.
  • object 810 may be split into pieces, such that the geometry used by or generated by a draw call is subdivided into smaller pieces of geometry.
  • the pieces of geometry are each roughly the size for which the position cache and/or parameter cache are allocated.
  • the information e.g. hint or hints
  • the information are generated for those smaller pieces of geometry during geometry testing, wherein the information is used by the rendering GPU, as previously described.
  • object 810 is split into smaller objects, such that the pieces of geometry used for region testing corresponds to these smaller objects.
  • object 810 is split into pieces of geometry “a”, “b”, “c”, “d”, “e”, and “f”.
  • GPU-A renders only pieces of geometry “a”, “b”, “c”, “d”, and “e”. That is, GPU-A can skip rendering piece of geometry “f”.
  • GPU-B renders only pieces of geometry “d,” “e”, and “f.” That is, GPU-B can skip rendering pieces of geometry “a”, “b”, and “c”.
  • the geometry processing stage is configured to perform both vertex processing and primitive processing, it is possible to perform geometry pretesting on a piece of geometry using the shaders in the geometry processing stage.
  • the geometry processing stage generates the information (e.g. hint), such as by testing a bounding frustum for the geometry against GPU screen regions, that may be performed by software shader operations.
  • this test is accelerated through the use of a dedicated instruction or instructions implemented through hardware, thereby implementing a software/hardware solution. That is, the dedicated instruction or instructions is used to accelerate the generation of the information regarding the piece of geometry and its relation to screen regions.
  • the homogeneous coordinates of the vertices of the primitive of a piece of geometry are provided as inputs to the instruction for geometry pretesting in the geometry processing stage.
  • the testing may generate a Boolean return value for each GPU that indicates whether or not the primitive overlaps any screen region (e.g. in a corresponding set) assigned to that GPU for object rendering.
  • the information e.g. hint
  • the information generated during geometry pretesting regarding the corresponding piece of geometry and its relation to screen regions is generated by shaders in the geometry processing stage.
  • the geometry pretesting on a piece of geometry can be performed in a hardware rasterization stage.
  • a hardware scan converter may be configured to perform geometry pretesting, such that the scan converter generates information regarding all the screen regions assigned to the plurality of GPUs for object rendering of the corresponding image frame.
  • the pieces of geometry can be primitives. That is, the portions of objects used for geometry pretesting may be primitives. As such, the information generated during geometry pretesting (e.g. hint) by one GPU indicates whether or not individual triangles (e.g. representing primitives) need to be rendered by another rendering GPU.
  • the information generated during geometry pretesting and shared by the GPUs used for rendering includes a number of primitives (e.g. a surviving primitive count) that overlap any screen region (e.g. in a corresponding set) that is assigned to a corresponding GPU for object rendering.
  • the information may also include the number of vertices used for building or defining those primitives. That is, the information includes a surviving vertex count.
  • when rendering the corresponding rendering GPU may use the supplied vertex count to allocate space in the position cache and parameter cache. For example, vertices that are not needed do not have any allocated space, which may increase the efficiency of rendering, in one embodiment.
  • the information generated during geometry pretesting includes the specific primitives (e.g. surviving primitives as an exact match) that overlap any screen region (e.g. in a corresponding set) assigned to the corresponding GPU for object rendering. That is, the information generated for the rendering GPU includes a specific set of primitives for rendering. The information may also include the specific vertices used for building or defining those primitives. That is, the information generated for the rendering GPU includes a specific set of vertices for rendering. This information may, for example, save the other rendering GPU time during its geometry processing stage when rendering the piece of geometry.
  • processing overhead either software or hardware
  • a piece of geometry e.g., an object or portions of the object
  • a piece of geometry may include triangles that are large.
  • each GPU used for multi-GPU rendering of an image frame or each of one or more image frames in a sequence of image frames will need to render those pieces of geometry. That is, the information may be generated or not generated depending on the properties of the corresponding piece of geometry.
  • 9A-9C illustrates various strategies for assigning screen regions to corresponding GPUs when multiple GPUs collaborate to render a single image, in accordance with one embodiment of the present disclosure.
  • various techniques may be used when dividing the screen into regions, such as increasing or decreasing the number of regions (e.g., to choose the correct amount of regions), interleaving regions, increasing or decreasing the number of regions for interleaving, selecting a particular pattern when interleaving regions, etc.
  • the multiple GPUs are configured to perform multi-GPU rendering of geometry for an image frame generated by an application by pretesting the geometry against interleaved screen regions before rendering objects in a corresponding image.
  • 9A-9C are designed to reduce any imbalance of rendering time between the plurality of GPUs.
  • the complexity of the test e.g. overlap a corresponding screen region
  • the bold box 910 is the outline of a corresponding screen or display used when rendering the image.
  • each of the plurality of screen regions or plurality of regions is uniformly sized. In one embodiment, each of the plurality of screen regions is not uniform in size. In still another embodiment, the number and sizing screen regions in a plurality of screen regions changes dynamically.
  • FIG. 9A illustrates a straightforward pattern 900A for screen 910.
  • Each of the screen regions is uniformly sized.
  • the size of each of the regions may be a rectangle of a dimension that is a power of 2 pixels.
  • each region may be 256x256 pixels in size.
  • the region assignment is a checkerboard pattern, with one row of A and B regions alternated with another row of B and C regions.
  • the pattern 900A may be easily tested during geometry pretesting. However, there may be some rendering inefficiencies. For example, the screen area assigned to each GPU is substantially different (i.e., there is less coverage for screen region C and region D in screen 910), which may lead to an imbalance in the rendering time for each GPU.
  • FIG. 9B illustrates pattern 900B of screen regions for screen 910.
  • Each of the screen or sub regions is uniformly sized.
  • the screen regions are assigned and distributed so as to reduce the imbalance of rendering time between the GPUs. For example, assignment of GPUs to screen regions in pattern 900B results in nearly equal amounts of screen pixels assigned to each GPU across screen 910. That is, the screen regions are assigned to GPUs in such a way as to equalize screen area or coverage in screen 910. For example, if each region may be 256x256 pixels in size, each of the regions have approximately the same coverage in screen 910.
  • the set of screen regions A covers an area 6x256x256 pixels in size
  • the set of screen regions B covers an area 5.75x256x256 pixels in size
  • the set of screen regions C covers an area 5.5x256x256 pixels in size
  • the set of screen regions D covers an area 5.5x256x256 pixels in size.
  • FIG. 9C illustrates pattern 900C of screen regions for screen 910.
  • Each of the screen regions is not uniform in size. That is, screen regions for which GPUs are assigned responsibility for rendering objects may not be uniform in size.
  • screen 910 is divided such that each GPU is assigned to an identical number of pixels. For example, iff a 4K display (3840x2160) were to be divided equally into four regions vertically, then each region would be 520 pixels tall. However, typically GPUs perform many operations in 32x32 blocks of pixels, and 520 pixels is not a multiple of 32 pixels.
  • pattern 900C may include blocks that are at a height of 512 pixels (a multiple of 32), and other blocks that are at a height of 544 pixels (also a multiple of 32), in one embodiment. Other embodiments may use differently sized blocks.
  • Pattern 900C shows equal amounts of screen pixels assigned to each GPU, by using non-uniform screen regions.
  • the needs of the application when performing rendering of images change over time, and the screen regions are chosen dynamically. For example, if it is known that most of the rendering time is spent on the lower half of the screen, then it would be advantageous to assign regions in such a way that nearly equal amounts of screen pixels in the lower half of the display are assigned to each GPU used for rendering the corresponding image. That is, the regions assigned to each of the GPUs used for rendering the corresponding image may be changed dynamically. For instance, the changes may be applied based on game modes, different games, size of screen, pattern chosen for the regions, etc.
  • FIG. 10 is a diagram illustrating various distributions of the assignment of GPUs to pieces of geometry for purposes of performing geometry pretesting, in accordance with one embodiment of the present disclosure. That is, FIG. 10 shows the distribution of responsibility for the generation of information during geometry pretesting between multiple GPUs.
  • each GPU is assigned to a corresponding portion of the geometry of an image frame, wherein that portion may be further partitioned into objects, portions of objects, geometry, pieces of geometry, etc.
  • Geometry pretesting includes determining whether or not a particular piece of geometry overlaps any screen region or screen regions that is assigned to a corresponding GPU for object rendering.
  • Geometry pretesting is typically performed in embodiments simultaneously for all geometry (e.g. all pieces of geometry) of a corresponding image frame by the GPUs. In that manner, geometry testing is performed collaboratively by the GPUs allows each GPU to know which pieces of geometry to render, and which pieces of geometry to skip rendering, as previously described.
  • each piece of geometry may be an object, portion of an object, etc.
  • the pieces of geometry may be portions of objects, such as pieces roughly the size at which the position and/or parameter caches are allocated, as previously described.
  • object 0 e.g. as specified to be rendered by commands 722 in the rendering command buffer 700A
  • object 1 e.g. as specified to be rendered by commands 724 in the rendering command buffer 700A
  • object 2 e.g. as specified to be rendered by commands 724 in the rendering command buffer 700A
  • the pieces may be ordered (e.g., a-o) for purposes of distributing responsibility for geometry testing to the GPUs.
  • Distribution 1010 (e.g. the ABCDABCDABCD... row) shows an even distribution of the responsibility for performing geometry testing between a plurality of GPUs.
  • one GPU take the first quarter of the geometry (e.g. in a block, such as GPU A takes the first four pieces of the approximately sixteen total pieces including “a”, “b”, “c” and “d” for geometry testing), and the second GPU take the second quarter, etc., assignment to GPUs is interleaved. That is, successive pieces of geometry are assigned to different GPUs.
  • Distribution 1020 (e.g., the ABBCDABBCDABBCD... row) shows an asymmetric distribution of the responsibility for performing geometry testing between a plurality of GPUs.
  • the asymmetric distribution may be advantageous when certain GPUs have more time to perform geometry testing than other GPUs when rendering a corresponding image frame. For example, one GPU may have finished rendering objects for the previous frame or frames of a scene earlier than the other GPUs, and therefore (since it is anticipated it will finish earlier this frame as well) it can be assigned more pieces of geometry for performing geometry testing. Again, the assignment to GPUs is interleaved. As shown, GPU-B is assigned more pieces of geometry for geometry pretesting than other GPUs.
  • FIGS. 11 A-l IB illustrate the use of statistics for one or more image frames when assigning responsibility for performing geometry testing between a plurality of GPUs. For example, based on statistics some GPUs may process more or fewer pieces of geometry during geometry testing to generate information useful when rendering.
  • FIG. 11 A is a diagram illustrating the pretesting and rendering of geometry of a previous image frame by a plurality of GPUs, and the use of statistics collected during rendering to influence the assignment of pretesting of geometry of a current image frame to the plurality of GPUs in the current image frame, in accordance with one embodiment of the present disclosure.
  • GPU-B processes twice as many pieces of geometry (e.g. during pretesting) than the other GPUs (e.g. GPU-A, GPU-C, and GPU-D).
  • the distribution and assignment of more pieces of geometry to GPU-B to perform geometry pretesting in a current image frame is based on statistics collected during rendering of the previous image frame, or previous image frames.
  • timing diagram 1100A shows geometry pretesting 701A and rendering 702A for a previous image frame, wherein four GPUs (e.g. GPU-A, GPU-B, GPU-C, and GPU- D) are used for both processes.
  • the assignment of the geometry (e.g. pieces of geometry) of the previous image frame is evenly distributed between the GPUs. This is shown by the roughly balanced performances of geometry pretesting 701A by each of the GPUs.
  • Rendering statistics collected from one or more image frames may be used in determining how to perform geometry testing and rendering of a current image frame. That is, the statistics may be provided as information for use when performing geometry testing and rendering of a subsequent image frame (e.g. the current image frame). For example, statistics collected during rendering of the objects (e.g. pieces of geometry) of the previous image frame may indicate that GPU-B has finished rendering earlier than the other GPUs. In particular, GPU-B has idle time 1130A after rendering its portion of the geometry that overlaps any screen region (e.g. in a corresponding set) assigned to GPU-B for object rendering. Each of the other GPU-A, GPU-C, and GPU-D perform rendering approximately up to the end 710 of the corresponding frame period of the previous image frame.
  • the statistics collected during rendering of the objects (e.g. pieces of geometry) of the previous image frame may indicate that GPU-B has finished rendering earlier than the other GPUs.
  • GPU-B has idle time 1130A after rendering its portion of the geometry that overlaps any screen region (e
  • the previous image frame and the current image frame may be generated for a particular scene when executing an application.
  • the objects from scene to scene may be approximately similar in number and location.
  • the time for performing geometry pretesting and rendering would be similar for GPUs between multiple image frames in a sequence of image frames. That is, it is reasonable to presume that GPU-B will also have idle time when performing geometry testing and rendering in the current image frame, based on the statistics.
  • GPU-B may be assigned more pieces of geometry for geometry pretesting in the current frame. For example, by having GPU-B process more pieces of geometry during geometry pretesting, the result is that GPU-B finishes at approximately the same time as the other GPUs after rendering objects in the current image frame.
  • each of the GPU-A, GPU-B, GPU-C, and GPU-D perform rendering approximately up to the end 711 of the corresponding frame period of the current image frame.
  • the total time to render the current image frame is reduced, such that it takes less time to render the current image frame when using rendering statistics.
  • statistics for the rendering of the previous frame and/or previous frames may be used to tune the geometry pretesting, such as the distribution of the assignment of the geometry (e.g. pieces of geometry) between the GPUs in the current image frame.
  • FIG. 1 IB is a flow diagram 1100B illustrating a method for graphics processing including pretesting and rendering of geometry of a previous image frame by a plurality of GPUs, and the use of statistics collected during rendering to influence the assignment of pretesting of geometry of a current image frame to the plurality of GPUs in the current image frame, in accordance with one embodiment of the present disclosure.
  • the diagram of FIG. 11 A illustrates the use of statistics in the method of flow diagram 1100B to determine the distribution of assignments of geometry (e.g. pieces of geometry) between the GPUs for an image frame.
  • various architectures may include multiple GPUs collaborating to render a single image by performing multi-GPU rendering of geometry for an application, such as within one or more cloud gaming servers of a cloud gaming system, or within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • the method includes rendering graphics for an application using a plurality of GPUs, as previously described.
  • the method includes dividing responsibility for rendering geometry of the graphics between the plurality of GPUs based on a plurality of screen regions.
  • Each GPU has a corresponding division of the responsibility which is known to the plurality of GPUs.
  • each of the GPUs is responsible for rendering geometry in a corresponding set of screen regions of the plurality of screen regions, wherein the corresponding set of screen regions includes one or more screen regions, as previously described.
  • the screen regions are interleaved (e.g. when a display is divided into sets of screen regions for geometry pretesting and rendering).
  • the method includes rendering a first plurality of pieces of geometry at the plurality of GPUs of a previous image frame generated by an application.
  • timing diagram 1100A illustrates the timing of performing geometry testing of pieces of geometry and rendering of objects (e.g. pieces of geometry) in the previous image frame.
  • the method includes generating statistics for the rendering of the previous image frame. That is, statistics may be collected when rendering the previous image frame.
  • the method includes assigning based on the statistics a second plurality of pieces of geometry of a current image frame generated by the application to the plurality of GPUs for geometry testing. That is, those statistics may be used to assign the same, fewer, or more pieces of geometry for geometry testing to a particular GPU when rendering the next, or current image frame. In some cases, the statistics may indicate that the pieces in the second plurality of pieces of geometry should be assigned evenly to the plurality of GPUs when performing geometry testing.
  • the statistics may indicate that the pieces in the second plurality of pieces of geometry should be assigned unevenly to the plurality of GPUs when performing geometry testing.
  • timeline 1100A statistics may indicate that GPU-B finishes rendering before any of the other GPUs in the previous image frame.
  • a first GPU e.g. GPU-B
  • a second GPU e.g. GPU-A
  • the first GPU e.g. GPU-B
  • GPU-B renders one or more pieces of the first plurality of pieces of geometry that overlap any screen region assigned to the first GPU for object rendering
  • the second GPU e.g. GPU-A
  • more pieces of geometry may be assigned to the first GPU for geometry pretesting when rendering the current image frame.
  • a first number of the second plurality of pieces of geometry may be assigned to the first GPU (e.g.
  • GPU-B for geometry testing
  • a second number of the second plurality of pieces of geometry may be assigned to the second GPU (e.g., GPU-A) for geometry testing, wherein the first number is higher than the second number (if the time imbalance is sufficiently large, then GPU-A may be assigned no pieces at all).
  • GPU-B processes more pieces of geometry than GPU-A during geometry testing.
  • timing diagram 1100B shows that GPU-B has been assigned more pieces of geometry, and spends more time performing geometry testing than the other GPUs.
  • the method includes performing geometry pretesting at a current image frame on the second plurality of pieces of geometry to generate information regarding each piece of the second plurality of pieces of geometry and its relation to each of the plurality of screen regions.
  • the geometry pretesting is performed at each of the plurality of GPUs based on the assigning.
  • Geometry pretesting is performed at a pretest GPU on a plurality of pieces of geometry of an image frame generated by an application in order to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • the method includes using the information generated for each of the second plurality of pieces of geometry to render the plurality of pieces of geometry during a rendering phase (e.g.
  • Rendering is typically performed in embodiments simultaneously at each of the GPUs.
  • the plurality of pieces of geometry of the current image frame is rendered at each of the plurality of GPUs using the information generated for each of the pieces of geometry.
  • the distribution of pieces of geometry to GPUs for generation of the information is dynamically adjusted. That is, an assignment of pieces of geometry for a current image frame for performing geometry pretesting may be dynamically adjusted during the rendering of the current image frame. For example, in the example of timing diagram 1100B, it may be determined that GPU-A was performing geometry pretesting of its assigned pieces of geometry at a rate slower than expected. As such, the pieces of geometry assigned to GPU-A for geometry pretesting can be reassigned on-the-fly, such as reassigning a piece of geometry from GPU-A to GPU-B, such that GPU-B is now tasked to perform geometry pretesting on that piece of geometry, during the frame period used for rendering the current image frame.
  • FIGS. 12A-12B illustrate another strategy for processing rendering command buffers.
  • a command buffer contains commands for geometry pretesting on objects (e.g. pieces of geometry), followed by commands for rendering of the objects (e.g., pieces of geometry).
  • FIGS. 12A-12B show a geometry pretesting and rendering strategy that uses shaders that are capable of performing either operation depending on GPU configuration.
  • FIG. 12A is a diagram illustrating the use of shaders configured to perform both pretesting and rendering of geometry of an image frame in two passes through a portion of the command buffer 1200A, in accordance with one embodiment of the present disclosure. That is, the shaders used for performing commands in the command buffer 1200A may be configured to perform either geometry pretesting when properly configured, or to perform rendering when properly configured.
  • the portion of the command buffer 1200A shown in FIG. 12A is executed twice, with different actions resulting from each execution; the first execution results in performing geometry pretesting, and the second execution results in performing rendering of the geometry.
  • This can be accomplished in a variety of ways, e.g. the portion of the command buffer depicted in 1200A can be explicitly called twice as a subroutine, with different state (e.g. a register setting or value in RAM) explicitly set to different values prior to each call.
  • the portion of the command buffer depicted in 1200A can be implicitly executed twice, e.g. by using special commands to mark beginning and end of the portion to execute twice, and to implicitly set a different configuration (e.g. a register setting) for the first and second executions of the portion of the command buffer.
  • a different configuration e.g. a register setting
  • the commands in the portion of the command buffer 1200A are executed (e.g., commands that set state or commands that execute a shader), based on GPU state, the results of the commands are different (e.g. result in performing geometry pretesting vs. performing rendering). That is, the commands in the command buffer 1200A may be configured for geometry pretesting or rendering.
  • command buffer 1200A includes commands for configuring a state of the one or more GPUs executing commands from the rendering command buffer 1200A, and commands for executing a shader that performs either geometry pretesting or rendering depending on the state.
  • commands 1210, 1212, 1214, and 1216 are each used for configuring a state of the one or more GPUs for purposes of executing a shader that performs either geometry pretesting or rendering depending on the state.
  • command 1210 configures GPU state so that shader 0 may be executed via commands 1211 and perform either geometry pretesting or rendering.
  • command 1212 configures GPU state so that shader 1 may be executed via commands 1213 to perform geometry pretesting or rendering.
  • command 1214 configures GPU state so that shader 2 may be executed via commands 1215 to perform either geometry pretesting or rendering.
  • command 1216 configures GPU state so that shader 3 may be may be executed via commands 1217 to perform either geometry pretesting or rendering.
  • shader 0 is configured to perform geometry pretesting on object 0 (e.g. a piece of geometry) (e.g. based on the objects shown in FIG. 7B-1)
  • shader 1 is configured to perform geometry pretesting on object 1
  • shader 2 is configured to perform geometry pretesting on object 2
  • shader 3 is configured to perform geometry pretesting on object 3.
  • commands may be skipped or interpreted differently.
  • certain commands that set state may be skipped based on GPU state that is set explicitly or implicitly as described above; e.g. if configuring the shader 0 executed via command 1210 requires less GPU state to be configured for geometry pretesting than when it is configured for rendering of geometry, then it may be beneficial to skip setting the unnecessary portions of the GPU state as setting of GPU state may carry an overhead.
  • certain commands that set state may be interpreted differently based on GPU state that is set explicitly or implicitly as described above; e.g. if shader 0 executed via command 1210 requires different GPU state to be configured for geometry pretesting than when it is configured for rendering of geometry, or if shader 0 executed via command 1210 requires an input that is different for geometry pretesting and for rendering of geometry.
  • the shaders configured for geometry pretesting do not allocate space in the position and parameter caches, as previously described.
  • a single shader is used to perform either the pretesting or the rendering. This could be done in a variety of ways, such as via external hardware state that the shader could check (e.g. as set explicitly or implicitly as described above), or via an input to the shader (e.g. as set by a command that is interpreted differently in the first and second passes through the command buffer).
  • shader 0 is configured to perform rendering of object 0 (e.g. a piece of geometry) (e.g. based on the objects shown in FIG. 7B-1).
  • shader 1 is configured to perform rendering of object 1
  • shader 2 is configured to perform rendering of object 2
  • shader 3 is configured to perform rendering of object 3.
  • FIG. 12B is a flow diagram 1200B illustrating a method for graphics processing including performing both pretesting and rendering of geometry of an image frame using the same set of shaders in two passes through a portion of the command buffer, in accordance with one embodiment of the present disclosure.
  • various architectures may include multiple GPUs collaborating to render a single image by performing multi-GPU rendering of geometry for an application, such as within one or more cloud gaming servers of a cloud gaming system, or within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • the method includes rendering graphics for an application using a plurality of GPUs, as previously described.
  • the method includes dividing responsibility for rendering geometry of the graphics between the plurality of GPUs based on a plurality of screen regions.
  • Each GPU has a corresponding division of the responsibility which is known to the plurality of GPUs.
  • each of the GPUs is responsible for rendering geometry in a corresponding set of screen regions of the plurality of screen regions, wherein the corresponding set of screen regions includes one or more screen regions, as previously described.
  • the screen regions are interleaved (e.g. when a display is divided into sets of screen regions for geometry pretesting and rendering).
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • each of the plurality of GPUs is assigned to a corresponding portion of the geometry associated with an image frame for purpose of geometry testing.
  • the assignments of pieces of geometry may be evenly or unevenly distributed, wherein each portion includes one or more pieces of geometry, or potentially no pieces of geometry at all, in embodiments.
  • the method includes loading first GPU state configuring one or more shaders to perform the geometry pretesting. For example, depending on GPU state, a corresponding shader may be configured to perform different operations. As such, the first GPU state configures corresponding shaders to perform geometry pretesting. In the example of FIG.
  • this can be set in a variety of ways, e.g. by explicitly or implicitly setting state externally to the portion of the command buffer depicted in 1200A, as described above.
  • the command buffer depicted in 1200A as described above.
  • GPU state may be set in a variety of ways.
  • the CPU or GPU could set a value in random access memory (RAM), wherein the GPU would check the value in RAM.
  • RAM random access memory
  • the state could be internal to the GPU, such as when a command buffer is called as a subroutine twice with internal GPU state being different between the two subroutine calls.
  • commands 1210 in FIG. 12A can be interpreted differently or skipped based on the state set explicitly or implicitly as described above. Based on this first GPU state, shader
  • command 1211 is configured to perform geometry pretesting.
  • the method includes performing geometry pretesting at the plurality of
  • GPUs on the plurality of pieces of geometry to generate information regarding each piece of geometry and its relation to each of the plurality of screen regions.
  • geometry pretesting may determine whether a piece of geometry overlaps any screen regions
  • each GPU is able to know which pieces of geometry to render, and which pieces of geometry to skip. This ends the first traversal through the command buffer, wherein shaders may be configured to perform each of geometry pretesting and/or rendering, depending on GPU state.
  • the method includes loading second GPU state configuring the one or more shaders to perform rendering.
  • a corresponding shader may be configured to perform different operations.
  • the second GPU state configures corresponding shaders (the same shaders previously used to perform geometry pretesting) to perform rendering.
  • shader 0 executed by command 1211 is configured to perform rendering.
  • the method includes at each of the plurality of GPUs using the information generated for each of the plurality of pieces of geometry when rendering the plurality of pieces of geometry (e.g. to include fully rendering a piece of geometry or skipping the rendering of that piece of geometry at a corresponding GPU).
  • the information may indicate whether a piece of geometry overlaps any screen region (e.g. in a corresponding set) that are assigned to a corresponding GPU for object rendering. That information may be used for rendering each of the plurality of pieces of geometry at each of the plurality of GPUs, such that each GPU can efficiently render only pieces of geometry that overlap at least one screen (e.g. in a corresponding set) assigned to that corresponding GPU for object rendering.
  • shaders may be configured to perform each of geometry pretesting and/or rendering, depending on GPU state.
  • FIGS. 13A-13B illustrate another strategy for processing rendering command buffers.
  • FIGS. 7A-7C show a geometry testing and rendering strategy that uses shaders capable of performing either geometry pretesting or rendering, and wherein the processes of geometry pretesting and rendering are interleaved for different sets of pieces of geometry, in accordance with embodiments of the present disclosure.
  • FIG. 13A is a diagram illustrating the use of shaders configured to perform both geometry pretesting and rendering, wherein geometry pretesting and rendering performed for different sets of pieces of geometry are interleaved using separate portions of a corresponding command buffer 1300A, in accordance with one embodiment of the present disclosure. That is, rather than executing the portion of the command buffer 1300A start to finish, the command buffer 1300A is dynamically configured and executed, so that geometry pretesting and rendering are interleaved for different sets of pieces of geometry. For example, in a command buffer, some shaders (e.g.
  • executed via commands 1311 and 1313) are configured for performing geometry pretesting on a first set of pieces of geometry, wherein after geometry testing is performed those same shaders (e.g. executed by commands 1311 and 1313) are then configured for performing rendering.
  • other shaders e.g. executed via commands 1315 and 1317
  • the command buffer After rendering is performed on the first set of pieces of geometry, other shaders (e.g. executed via commands 1315 and 1317) in the command buffer are configured for performing geometry pretesting on a second set of pieces of geometry, wherein after geometry pretesting is performed those same shaders (e.g. executed via commands 1315 and 1317) are then configured for performing rendering, and rendering is performed using those commands on the second set of pieces of geometry.
  • the benefit of this strategy is that imbalance between GPUs can be addressed dynamically, such as by using asymmetric interleaving of geometry testing throughout the rendering. An example of asymmetric interleaving of geometry testing was previously introduced in distribution 102 of FIG. 10.
  • the configuration e.g. via a register setting or a value in RAM
  • the configuration occurs implicitly, which is to say that an aspect of the GPU configuration happens externally to the command buffer.
  • a GPU register may be set to 0 (indicating that geometry pretesting should occur) or 1
  • the interleaved traversal of the command buffer and the setting of this register may be controlled by the GPU based on numbers of objects processed, primitives processed, imbalance between the GPUs, etc. Alternatively, a value in RAM could be used.
  • this external configuration meaning set externally to the command buffer
  • the commands in the portion of the command buffer 1300A are executed (e.g., commands that set state or commands that execute a shader), based on GPU state, the results of the commands are different (e.g. result in performing geometry pretesting vs. performing rendering).
  • the commands in the command buffer 1300 A may be configured for geometry pretesting
  • command buffer 1300A includes commands for configuring a state of the one or more GPUs executing commands from rendering command buffer 1300A, and commands for executing a shader that performs either geometry pretesting or rendering depending on the state.
  • commands 1310, 1312, 1314, and 1316 are each used for configuring a state of GPUs for purposes of executing a shader that performs either geometry pretesting or rendering depending on the state.
  • command buffer 1310 configures GPU state so that shader 0 may be executed via commands 1311 either for performing geometry pretesting or rendering of object 0.
  • command buffer 1312 configures GPU state so that shader 1 may be executed via commands 1313 either for performing geometry pretesting or rendering of object 1.
  • command buffer 1314 configures GPU state so that shader 2 may be executed via commands 1315 either for performing geometry pretesting or rendering of object 2.
  • command buffer 1316 configures GPU state so that shader 3 may be executed via commands 1317 either for performing geometry pretesting or rendering of object 3.
  • Geometry pretesting and rendering may be interleaved for different sets of pieces of geometry.
  • command buffer 1300A may be configured to perform geometry pretesting and rendering of objects 0 and 1 first, and then command buffer 1300A is configured to perform geometry pretesting and rendering of objects 2 and 3 second.
  • section 1 shows a first traversal through command buffer 1300A.
  • shader 0 is configured to perform geometry pretesting on object 0 (e.g. a piece of geometry) (e.g.
  • shader 1 is configured to perform geometry pretesting on object 1.
  • Section 2 shows a second traversal through command buffer 1300A.
  • the corresponding shaders Based on GPU state set implicitly as described above, as well as GPU state as configured by commands 1310 and 1312, the corresponding shaders perform rendering. For example, shader 0 is configured to now perform rendering of object 0, and shader 1 is configured to now perform rendering of object 1.
  • FIG. 13 A Interleaving of the performance of geometry pretesting and rendering on different sets of pieces of geometry is shown in FIG. 13 A.
  • section 3 shows a third partial traversal through command buffer 1300A.
  • the corresponding shaders Based on GPU state set implicitly as described above, as well as GPU state as configured by commands 1314 and 1316, the corresponding shaders perform geometry pretesting.
  • shader 2 (executed via commands 1315) performs geometry testing on object 2 (e.g. a piece of geometry) (e.g. based on objects shown in FIGS. 7B-1), and shader 3 (executed via commands 1317) performs geometry testing on object 3.
  • Section 4 shows a fourth partial traversal through command buffer 1300A.
  • shader 2 (executed via commands 1315) performs rendering of object 2
  • shader 3 (executed via commands 1317) performs rendering of object 3.
  • commands may be skipped or interpreted differently.
  • certain commands that set state may be skipped based on GPU state that is set implicitly as described above; e.g. if configuring the shader 0 executed via command 1310 requires less GPU state to be configured for geometry testing than when it is configured for rendering of geometry, then it may be beneficial to skip setting the unnecessary portions of the GPU state as setting of GPU state may carry an overhead.
  • certain commands that set state may be interpreted differently based on GPU state that is set implicitly as described above; e.g. if shader 0 executed via command 1310 requires different GPU state to be configured for geometry testing than when it is configured for rendering of geometry, or if shader 0 executed via command 1310 requires an input that is different for geometry testing and for rendering of geometry.
  • the shaders configured for geometry pretesting do not allocate space in the position and parameter caches, as previously described.
  • a single shader is used to perform either the pretesting or the rendering. This could be done in a variety of ways, such as via external hardware state that the shader could check (e.g. as set implicitly as described above), or via an input to the shader (e.g. as set by a command that is interpreted differently in the first and second passes through the command buffer).
  • FIG. 13B is a flow diagram illustrating a method for graphics processing including interleaving pretesting and rendering of geometry of an image frame for different sets of pieces geometry using separate portions of a corresponding command buffer, in accordance with one embodiment of the present disclosure.
  • various architectures may include multiple GPUs collaborating to render a single image by performing multi- GPU rendering of geometry for an application, such as within one or more cloud gaming servers of a cloud gaming system, or within a stand-alone system, such as a personal computer or gaming console that includes a high-end graphics card having multiple GPUs, etc.
  • the method includes rendering graphics for an application using a plurality of GPUs, as previously described.
  • the method includes dividing responsibility for rendering geometry of the graphics between the plurality of GPUs based on a plurality of screen regions.
  • Each GPU has a corresponding division of the responsibility which is known to the plurality of GPUs.
  • each of the GPUs is responsible for rendering geometry in a corresponding set of screen regions of the plurality of screen regions, wherein the corresponding set of screen regions includes one or more screen regions, as previously described.
  • the screen regions are interleaved (e.g. when a display is divided into sets of screen regions for geometry pretesting and rendering).
  • the method includes assigning a plurality of pieces of geometry of an image frame to the plurality of GPUs for geometry testing.
  • each of the plurality of GPUs is assigned to a corresponding portion of the geometry associated with an image frame for purpose of geometry testing.
  • the assignments of pieces of geometry may be evenly or unevenly distributed, wherein each portion includes one or more pieces of geometry, or potentially no pieces of geometry at all.
  • the method includes interleaving a first set of shaders in a command buffer with a second set of shaders, wherein the shaders are configured to perform both geometry pretesting and rendering.
  • the first set of shaders is configured to perform geometry pretesting and rendering on a first set of pieces of geometry.
  • the second set of shaders is configured to perform geometry pretesting and rendering on a second set of pieces of geometry.
  • geometry pretesting generates corresponding information regarding each piece of geometry in the first set or second set and its relation to each of the plurality of screen regions. The corresponding information is used by the plurality of GPUs to render each piece of geometry in first set or second set.
  • the GPU state may be set in a variety of ways in order to perform either geometry pretesting or rendering.
  • the CPU or GPU could set a value in random access memory (RAM), wherein the GPU would check the value in RAM.
  • RAM random access memory
  • the state could be internal to the GPU, such as when a command buffer is called as a subroutine twice with internal GPU state being different between the two subroutine calls.
  • the first set of shaders of a command buffer is configured to perform geometry pretesting on the first set of pieces of geometry, as previously described. Geometry pretesting is performed at the plurality of GPUs on the first set of pieces of geometry to generate first information regarding each piece of geometry in the first set and its relation to each of the plurality of screen regions. Then, the first set of shaders is configured to perform rendering of the first set of pieces of geometry, as previously described. Thereafter, the first information is used when rendering the plurality of pieces of geometry at each of the plurality of GPUs (e.g. to include fully rendering the first set of pieces of geometry or skipping the rendering of the first set of pieces of geometry at a corresponding GPU).
  • the information indicates which pieces of geometry overlap screen regions assigned to a corresponding GPU for object rendering.
  • the information may be used to skip rendering a piece of geometry at a GPU when that information indicates that the piece of geometry does to overlap any screen region (e.g. in a corresponding set) assigned to the GPU for object rendering.
  • the second set of shaders is then used for geometry testing and rendering of the second set of pieces of geometry.
  • the second set of shaders of a command buffer is configured to perform geometry pretesting on the second set of pieces of geometry, as previously described.
  • geometry testing is performed at the plurality of GPUs on the second set of pieces of geometry to generate second information regarding each piece of geometry in the second set and its relation to each of the plurality of screen regions.
  • the second set of shaders is configured to perform rendering of the second set of pieces of geometry, as previously described.
  • rendering of the second set of pieces of geometry is performed at each of the plurality of GPUs using the second information.
  • the information indicates which pieces of geometry overlap screen regions (e.g. of a corresponding set) assigned to a corresponding GPU for object rendering.
  • the plurality of GPUs are not explicitly synchronized with each other, e.g. one GPU may be rendering the first set of pieces of geometry while a second GPU is performing geometry pretesting on the second set of pieces of geometry.
  • FIG. 14 illustrates components of an example device 1400 that can be used to perform aspects of the various embodiments of the present disclosure.
  • FIG. 14 illustrates an exemplary hardware system suitable for multi-GPU rendering of geometry for an application by pretesting geometry against screen regions, which may be interleaved, before rendering objects for an image frame, in accordance with embodiments of the present disclosure.
  • This block diagram illustrates a device 1400 that can incorporate or can be a personal computer, a server computer, gaming console, mobile device, or other digital device, each of which is suitable for practicing an embodiment of the invention.
  • Device 1400 includes a central processing unit (CPU) 1402 for running software applications and optionally an operating system.
  • CPU 1402 may be comprised of one or more homogeneous or heterogeneous processing cores.
  • CPU 1402 is one or more general-purpose microprocessors having one or more processing cores. Further embodiments can be implemented using one or more CPUs with microprocessor architectures specifically adapted for highly parallel and computationally intensive applications, such as media and interactive entertainment applications, of applications configured for graphics processing during execution of a game.
  • Memory 1404 stores applications and data for use by the CPU 1402 and GPU 1416.
  • Storage 1406 provides non-volatile storage and other computer readable media for applications and data and may include fixed disk drives, removable disk drives, flash memory devices, and
  • User input devices 1408 communicate user inputs from one or more users to device 1400, examples of which may include keyboards, mice, joysticks, touch pads, touch screens, still or video recorders/cameras, and/or microphones.
  • Network interface 1409 allows device 1400 to communicate with other computer systems via an electronic communications network, and may include wired or wireless communication over local area networks and wide area networks such as the internet.
  • An audio processor 1412 is adapted to generate analog or digital audio output from instructions and/or data provided by the CPU 1402, memory 1404, and/or storage 1406.
  • the components of device 1400, including CPU 1402, graphics subsystem including GPU 1416, memory 1404, data storage 1406, user input devices 1408, network interface 1409, and audio processor 1412 are connected via one or more data buses 1422.
  • a graphics subsystem 1414 is further connected with data bus 1422 and the components of the device 1400.
  • the graphics subsystem 1414 includes at least one graphics processing unit (GPU) 1416 and graphics memory 1418.
  • Graphics memory 1418 includes a display memory (e.g. a frame buffer) used for storing pixel data for each pixel of an output image.
  • Graphics memory 1418 can be integrated in the same device as GPU 1416, connected as a separate device with GPU 1416, and/or implemented within memory 1404. Pixel data can be provided to graphics memory 1418 directly from the CPU 1402.
  • CPU 1402 provides the GPU 1416 with data and/or instructions defining the desired output images, from which the GPU 1416 generates the pixel data of one or more output images.
  • the data and/or instructions defining the desired output images can be stored in memory 1404 and/or graphics memory 1418.
  • the GPU 1416 includes 3D rendering capabilities for generating pixel data for output images from instructions and data defining the geometry, lighting, shading, texturing, motion, and/or camera parameters for a scene.
  • the GPU 1416 can further include one or more programmable execution units capable of executing shader programs.
  • the graphics subsystem 1414 periodically outputs pixel data for an image from graphics memory 1418 to be displayed on display device 1410, or to be projected by a projection system (not shown).
  • Display device 1410 can be any device capable of displaying visual information in response to a signal from the device 1400, including CRT, LCD, plasma, and OLED displays.
  • Device 1400 can provide the display device 1410 with an analog or digital signal, for example.
  • FIG. 1414 Other embodiments for optimizing the graphics subsystem 1414 could include multi- GPU rendering of geometry for an application by pretesting the geometry against screen regions, which may be interleaved, before rendering objects for an image frame.
  • the graphics subsystem 1414 could be configured as one or more processing devices.
  • the graphics subsystem 1414 may be configured to perform multi-GPU rendering of geometry for an application, wherein multiple graphics subsystems could be implementing graphics and/or rendering pipelines for a single application, in one embodiment.
  • the graphics subsystem 1414 includes multiple GPUs used for rendering an image or each of one or more images of a sequence of images when executing an application.
  • the graphics subsystem 1414 includes multiple GPU devices, which are combined to perform graphics processing for a single application that is executing on a corresponding CPU.
  • the multiple GPUs can perform multi-GPU rendering of geometry for an application by pretesting the geometry against screen regions, which may be interleaved, before rendering objects for an image frame.
  • the multiple GPUs can perform alternate forms of frame rendering, wherein GPU 1 renders a first frame, and GPU 2 renders a second frame, in sequential frame periods, and so on until reaching the last GPU whereupon the initial GPU renders the next video frame (e.g. if there are only two GPUs, then
  • GPU 1 renders the third frame). That is the GPUs rotate when rendering frames.
  • the rendering operations can overlap, wherein GPU 2 may begin rendering the second frame before GPU 1 finishes rendering the first frame.
  • the multiple GPU devices can be assigned different shader operations in the rendering and/or graphics pipeline.
  • a master GPU is performing main rendering and compositing. For example, in a group including three GPUs, master GPU 1 could perform the main rendering (e.g. a first shader operation) and compositing of outputs from slave GPU 2 and slave GPU 3, wherein slave GPU 2 could perform a second shader (e.g. fluid effects, such as a river) operation, the slave GPU 3 could perform a third shader (e.g.
  • each of the three GPUs could be assigned to different objects and/or parts of a scene corresponding to a video frame. In the above embodiments and implementations, these operations could be performed in the same frame period (simultaneously in parallel), or in different frame periods (sequentially in parallel).
  • the present disclosure describes methods and systems configured for multi-GPU rendering of geometry for an application by pretesting the geometry against screen regions, which may be interleaved, before rendering of objects for an image frame or each of one or more image frames in a sequence of image frames when executing an application.
  • Embodiments of the present disclosure may be practiced with various computer system configurations including hand-held devices, microprocessor systems, microprocessor- based or programmable consumer electronics, minicomputers, mainframe computers and the like. Embodiments of the present disclosure can also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a wire -based or wireless network.
  • embodiments of the present disclosure can employ various computer-implemented operations involving data stored in computer systems. These operations are those requiring physical manipulation of physical quantities. Any of the operations described herein that form part of embodiments of the present disclosure are useful machine operations. Embodiments of the disclosure also relate to a device or an apparatus for performing these operations.
  • the apparatus can be specially constructed for the required purpose, or the apparatus can be a general-purpose computer selectively activated or configured by a computer program stored in the computer.
  • various general-purpose machines can be used with computer programs written in accordance with the teachings herein, or it may be more convenient to construct a more specialized apparatus to perform the required operations.
  • the disclosure can also be embodied as computer readable code on a computer readable medium.
  • the computer readable medium is any data storage device that can store data, which can be thereafter be read by a computer system. Examples of the computer readable medium include hard drives, network attached storage (NAS), read-only memory, random- access memory, CD-ROMs, CD-Rs, CD-RWs, magnetic tapes and other optical and non-optical data storage devices.
  • the computer readable medium can include computer readable tangible medium distributed over a network-coupled computer system so that the computer readable code is stored and executed in a distributed fashion.

Landscapes

  • Engineering & Computer Science (AREA)
  • Multimedia (AREA)
  • Physics & Mathematics (AREA)
  • General Physics & Mathematics (AREA)
  • Theoretical Computer Science (AREA)
  • Computer Graphics (AREA)
  • Computer Hardware Design (AREA)
  • Image Generation (AREA)
  • Processing Or Creating Images (AREA)

Abstract

L'invention concerne un procédé de traitement graphique. Le procédé comprend le rendu de graphiques pour une application à l'aide d'une pluralité d'unités de traitement graphique (GPU). Le procédé comprend la division de la responsabilité pour le rendu de la géométrie des graphiques entre la pluralité de GPU sur la base d'une pluralité de régions d'écran qui sont entrelacées, chaque GPU ayant une division correspondante de la responsabilité qui est connue de la pluralité de GPU. Le procédé comprend l'attribution à une GPU d'une pièce de géométrie d'une trame d'image générée par une application pour un test préalable de géométrie. Le procédé comprend la réalisation d'un pré-test de géométrie au niveau de la GPU pour générer des informations concernant la pièce de géométrie et sa relation avec chacune de la pluralité de régions d'écran. Le procédé comprend l'utilisation des informations au niveau de chaque GPU de la pluralité de GPU lors du rendu de la trame d'image.
PCT/US2021/016079 2020-02-03 2021-02-01 Système et procédé de rendu efficace multi-gpu de géométrie par prétest contre des régions d'écran entrelacées avant le rendu WO2021158483A1 (fr)

Priority Applications (4)

Application Number Priority Date Filing Date Title
JP2022546703A JP7334358B2 (ja) 2020-02-03 2021-02-01 レンダリング前にインターリーブスクリーン領域に対して事前テストを行うことによってジオメトリの効率的なマルチｇｐｕレンダリングを行うシステム及び方法
CN202180023019.6A CN115298686B (zh) 2020-02-03 2021-02-01 通过在渲染前针对交错的屏幕区域进行预测试来进行几何图形的高效多gpu渲染的系统和方法
EP21707864.1A EP4100922A1 (fr) 2020-02-03 2021-02-01 Système et procédé de rendu efficace multi-gpu de géométrie par prétest contre des régions d'écran entrelacées avant le rendu
JP2023132609A JP7481556B2 (ja) 2020-02-03 2023-08-16 レンダリング前にインターリーブスクリーン領域に対して事前テストを行うことによってジオメトリの効率的なマルチｇｐｕレンダリングを行うシステム及び方法

Applications Claiming Priority (6)

Application Number Priority Date Filing Date Title
US16/780,745 2020-02-03
US16/780,722 2020-02-03
US16/780,722 US11080814B1 (en) 2020-02-03 2020-02-03 System and method for efficient multi-GPU rendering of geometry by pretesting against screen regions using prior frame information
US16/780,680 2020-02-03
US16/780,745 US20210241414A1 (en) 2020-02-03 2020-02-03 System and method for efficient multi-gpu rendering of geometry by pretesting against screen regions using configurable shaders
US16/780,680 US11263718B2 (en) 2020-02-03 2020-02-03 System and method for efficient multi-GPU rendering of geometry by pretesting against in interleaved screen regions before rendering

Publications (2)

Publication Number Publication Date
WO2021158483A1 true WO2021158483A1 (fr) 2021-08-12
WO2021158483A8 WO2021158483A8 (fr) 2022-11-24

Family

ID=74701593

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US2021/016079 WO2021158483A1 (fr) 2020-02-03 2021-02-01 Système et procédé de rendu efficace multi-gpu de géométrie par prétest contre des régions d'écran entrelacées avant le rendu

Country Status (4)

Country Link
EP (1) EP4100922A1 (fr)
JP (2) JP7334358B2 (fr)
CN (1) CN115298686B (fr)
WO (1) WO2021158483A1 (fr)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN114241161A (zh) * 2021-12-22 2022-03-25 中设数字技术股份有限公司 一种基于双gpu的bim模型渲染方法及渲染系统
CN117472672A (zh) * 2023-12-26 2024-01-30 四川弘智远大科技有限公司 基于gpu集成的云计算硬件加速测试系统及方法

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7616206B1 (en) * 2006-06-16 2009-11-10 Nvidia Corporation Efficient multi-chip GPU
US20110057935A1 (en) * 2009-09-10 2011-03-10 Mark Fowler Tiling Compaction in Multi-Processor Systems
WO2012010968A1 (fr) * 2010-07-19 2012-01-26 Ati Technologies Ulc Affichage d'images comprimées de type super pavé
WO2019040221A1 (fr) * 2017-08-22 2019-02-28 Qualcomm Incorporated Rendu d'une image à partir d'un graphisme informatique et au moyen de deux dispositifs informatiques de rendu
US20190206023A1 (en) * 2017-12-28 2019-07-04 Nvidia Corporation Multi-gpu frame rendering

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US8497865B2 (en) * 2006-12-31 2013-07-30 Lucid Information Technology, Ltd. Parallel graphics system employing multiple graphics processing pipelines with multiple graphics processing units (GPUS) and supporting an object division mode of parallel graphics processing using programmable pixel or vertex processing resources provided with the GPUS
JP2008071261A (ja) * 2006-09-15 2008-03-27 Toshiba Corp 画像処理システム及び画像処理方法
US9245496B2 (en) * 2012-12-21 2016-01-26 Qualcomm Incorporated Multi-mode memory access techniques for performing graphics processing unit-based memory transfer operations

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7616206B1 (en) * 2006-06-16 2009-11-10 Nvidia Corporation Efficient multi-chip GPU
US20110057935A1 (en) * 2009-09-10 2011-03-10 Mark Fowler Tiling Compaction in Multi-Processor Systems
WO2012010968A1 (fr) * 2010-07-19 2012-01-26 Ati Technologies Ulc Affichage d'images comprimées de type super pavé
WO2019040221A1 (fr) * 2017-08-22 2019-02-28 Qualcomm Incorporated Rendu d'une image à partir d'un graphisme informatique et au moyen de deux dispositifs informatiques de rendu
US20190206023A1 (en) * 2017-12-28 2019-07-04 Nvidia Corporation Multi-gpu frame rendering

Cited By (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN114241161A (zh) * 2021-12-22 2022-03-25 中设数字技术股份有限公司 一种基于双gpu的bim模型渲染方法及渲染系统
CN114241161B (zh) * 2021-12-22 2023-09-15 中设数字技术股份有限公司 一种基于双gpu的bim模型渲染方法及渲染系统
CN117472672A (zh) * 2023-12-26 2024-01-30 四川弘智远大科技有限公司 基于gpu集成的云计算硬件加速测试系统及方法
CN117472672B (zh) * 2023-12-26 2024-03-01 四川弘智远大科技有限公司 基于gpu集成的云计算硬件加速测试系统及方法

Also Published As

Publication number Publication date
CN115298686B (zh) 2023-10-17
WO2021158483A8 (fr) 2022-11-24
EP4100922A1 (fr) 2022-12-14
JP7481556B2 (ja) 2024-05-10
JP7334358B2 (ja) 2023-08-28
CN115298686A (zh) 2022-11-04
JP2023144060A (ja) 2023-10-06
JP2023505607A (ja) 2023-02-09

Similar Documents

Publication Publication Date Title
US11900500B2 (en) System and method for efficient multi-GPU rendering of geometry by subdividing geometry
JP7481556B2 (ja) レンダリング前にインターリーブスクリーン領域に対して事前テストを行うことによってジオメトリの効率的なマルチｇｐｕレンダリングを行うシステム及び方法
JP7481557B2 (ja) レンダリング中の領域テストによってジオメトリの効率的なマルチｇｐｕレンダリングを行うためのシステム及び方法
US20220005148A1 (en) System and method for efficient multi-gpu rendering of geometry by performing geometry analysis while rendering
WO2021158468A1 (fr) Système et procédé de rendu efficace multi-gpu de géométrie par analyse de géométrie pendant le rendu
US11847720B2 (en) System and method for performing a Z pre-pass phase on geometry at a GPU for use by the GPU when rendering the geometry
US20210241414A1 (en) System and method for efficient multi-gpu rendering of geometry by pretesting against screen regions using configurable shaders
US11869114B2 (en) Efficient multi-GPU rendering by testing geometry against screen regions before rendering using a pretest GPU
US11954760B2 (en) Assigning geometry for pretesting against screen regions for an image frame using prior frame information
US11961159B2 (en) Region testing of geometry while rendering for efficient multi-GPU rendering
US11508110B2 (en) System and method for efficient multi-GPU rendering of geometry by performing geometry analysis before rendering

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 21707864

Country of ref document: EP

Kind code of ref document: A1

ENP Entry into the national phase

Ref document number: 2022546703

Country of ref document: JP

Kind code of ref document: A

NENP Non-entry into the national phase

Ref country code: DE

ENP Entry into the national phase

Ref document number: 2021707864

Country of ref document: EP

Effective date: 20220905