KR102605313B1 - Early virtualization context switching for virtualized accelerated processing devices - Google Patents

Abstract

A technology for efficient time sharing of resources in a virtualized accelerated processing device (“APD”) is provided. In the virtualization scheme implemented in APD, different virtual machines are assigned different “time slices” to use the APD. When a time-slice expires, APD performs a virtualization context switch by stopping operation on the current virtual machine (“VM”) and starting operation on another VM. Typically, each VM is allocated a fixed length of time, after which a virtualization context switch is performed. This fixed length of time can lead to inefficiencies. Therefore, in some situations, a virtualization context switch is performed “early” in response to the VM no longer having work to do in the APD and the APD being idle. This virtualization context switch is "early" in the sense that the virtualization context switch is performed before the fixed time length for the time-slice expires.

Description

Early virtualization context switching for virtualized accelerated processing devices

Cross-reference to related applications

This application claims priority from U.S. General Application No. 15/637,800, filed June 29, 2017, the contents of which are incorporated by reference as if fully set forth herein.

Computer virtualization is a technology in which a single set of hardware is shared between different virtual instances of a computer system. Each instance - a virtual machine ("VM") - thinks it owns the entire hardware computer system, but in reality the computer system's hardware resources are shared among the different VMs. Advances in virtualization continue, including advances in virtualization for devices other than CPUs, system memory, etc.

A more detailed understanding can be obtained from the following description given by way of example in conjunction with the accompanying drawings.
1 is a block diagram of an example device in which one or more features of the present disclosure may be implemented.
2 shows details of accelerated processing devices and devices involved in virtualization, according to an example.
FIG. 3 is a block diagram illustrating additional details of the graphics processing pipeline shown in FIG. 2.
FIG. 4 is a block diagram illustrating features of the device of FIG. 1 related to performing an early virtualization context switch, according to an example.
5 is a flow diagram of a method for performing an early virtualization context switch, according to an example.

An efficient time sharing technique of resources is provided in a virtualized accelerated processing device (“APD”). In the virtualization scheme implemented in APD, different virtual machines are assigned different “time-slices” to use the APD. When a time-slice expires, APD performs a virtualization context switch by stopping operation on the current virtual machine (“VM”) and starting operation on another VM. Different time-slices are associated with different functions (eg, virtual functions - Peripheral Component Interconnect Express (“PCIe”) addressing parameters).

Typically, each VM is allocated a fixed length of time after which a virtualization context switch is performed. This fixed length of time can lead to inefficiency. For example, in some situations, a VM has no more work to do and is idle, but there is still some time left in the current time-slice for this VM. Therefore, in some situations, a virtualization context switch is performed “early” in response to a VM that has no more work to do on the APD and the APD is idle. This virtualization context switch is "early" in the sense that the virtualization context switch is performed before the fixed time length of the time slice expires.

In some implementations, the APD waits for a timeout period after detecting that the APD is idle and has no more work to do before performing an early virtualization context switch. If additional work is received during this timeout period and there is sufficient time remaining in the current time-slice, no premature virtualization context switch is performed. Instead, APD is allowed to perform this task by fetching a new task. If no additional work is received during this timeout period, an early virtualization context switch is performed.

In some implementations, after an early virtualization context switch is performed for a function, the APD does not re-schedule that function in the APD if no work has been received since the early virtualization context switch was performed. In some examples, a doorbell mechanism is implemented that, when a memory mapped "doorbell" address is written, notifies the APD that a task is ready for a particular function. Different doorbells (and therefore different doorbell addresses) are associated with different virtual functions. Therefore, if no doorbell for a particular function is received after an early virtualization context switch occurs for that function, the APD will resume work on that function the next time a "turn" occurs in the virtualization time-slicing scheme for the APD. don't run

1 is a block diagram of an example device 100 in which one or more features of the present disclosure may be implemented. Device 100 may include, for example, a computer, gaming device, handheld device, set-top box, television, mobile phone, or tablet computer. Device 100 may include a processor 102 (also referred to as a “host processor”), memory 104, storage 106, one or more input devices 108, and one or more output devices 110. . Device 100 may optionally include an input driver 112 and an output driver 114. It is understood that device 100 may include additional components not shown in FIG. 1 .

In various alternatives, processor 102 includes a central processing unit (CPU), a graphics processing unit (GPU), a CPU and a GPU located on the same die, or one or more processor cores, each processor core being a CPU or GPU. It can be. In various alternatives, memory 104 is located on the same die as processor 102 or is located separately from processor 102. Memory 104 includes volatile or non-volatile memory, such as random access memory (RAM), dynamic RAM, or cache.

Storage device 106 includes a fixed or removable storage device, such as a hard disk drive, solid state drive, optical disk, or flash drive. Input device 108 may include, without limitation, a keyboard, keypad, touch screen, touch pad, detector, microphone, accelerometer, gyroscope, biometric scanner, or network connection (e.g., transmission of wireless IEEE 802 signals and/or Includes a wireless local area network card for reception. Output device 110 may include, without limitation, a display, speaker, printer, haptic feedback device, one or more lights, antennas, or network connections (e.g., a wireless local area network card for transmitting and/or receiving wireless IEEE 802 signals). ) includes

Input driver 112 communicates with processor 102 and input device 108 and enables processor 102 to receive input from input device 108. Output driver 114 communicates with processor 102 and output device 110 and enables processor 102 to send output to output device 110. Note that input driver 112 and output driver 114 are optional components, and device 100 will operate in the same manner if input driver 112 and output driver 114 are not present. Output driver 114 includes an accelerated processing device (“APD”) 116 coupled to display device 118. The APD is configured to accept computational commands and graphics rendering commands from processor 102, process these computational and graphics rendering commands, and provide pixel output to display device 118 for display. As described in more detail below, APD 116 includes one or more parallel processing units configured to perform computations according to a single-instruction-multiple-data (“SIMD”) paradigm. Accordingly, although various functions are described herein as being performed by or in conjunction with APD 116, in various alternatives, functions described as being performed by APD 116 may additionally or alternatively be performed by a host processor. It is not driven by processor 102 (e.g., processor 102) but is performed by another computing device with similar capabilities configured to provide graphical output to display device 118. For example, it is contemplated that any processing system that performs processing tasks according to the SIMD paradigm may be configured to perform the functions described herein. Alternatively, computational systems that do not perform processing tasks according to the SIMD paradigm are contemplated to perform the functions described herein.

The processor 102 is configured to support a virtualization scheme in which multiple virtual machines run on the processor 102. Each virtual machine (“VM”) “appears” to the software running on the VM as a completely “real” hardware computer system, but is actually a virtualized computing environment that can share devices 100 with other virtual machines. Includes. Virtualization can be supported entirely by software, partly by hardware and partly by software, or entirely by hardware. APD 116 supports virtualization, meaning that APD 116 can be shared among multiple virtual machines running on processor 102, each VM having a complete view of the physical hardware APD 116. “Believes” you have ownership.

2 shows details of device 100 and APD 116 related to virtualization, according to an example. Processor 102 supports multiple virtual machines. The dedicated host virtual machine 202 is not a “general purpose” VM like the guest VM 204 but instead provides support for virtualization of the APD 116 for use by the guest VM 204. Hypervisor 206 provides virtualization support for virtual machines, including managing resources allocated to virtual machines, spawning and killing virtual machines, handling system calls, managing access to peripheral devices, memory, and page tables. It includes various features, such as management, and various other functions.

APD 116 supports virtualization by allowing time-based sharing of APD 116 between virtual machines. In APD 116, host VM 202 is mapped to physical function 208 and guest VM 204 is mapped to virtual function 210. “Physical functions” are essentially addressing parameters in the Peripheral Component Interconnect Express (“PCIe”) standard. More specifically, the physical function allows communications involving a device coupled to the PCIe interconnect fabric to specify a particular physical function of the device such that the device can treat the communication according to the function specifically assigned to the physical function. In one example, the physical functions relate to regular graphics rendering on a graphics processing device, such as APD 116. Although a single physical function is described herein, the teachings of this disclosure apply to APD 116 with more than one physical function activated.

Virtual functions are a feature of the PCIe standard that facilitates hardware virtualization and acts as an addressing parameter in the PCIe standard. Typically, a set of virtual functions is associated with specific physical functions. Each virtual machine is assigned a different virtual function, and hypervisor 206 manages the correlation between VMs and virtual functions. This correlation between virtual functions and virtual machines 202 is largely the same in the system of Figure 2, except that the host VM 202 can access physical functions 208 as well as any of the different virtual functions 210. It's true. In this respect, the host VM 202 serves as a kind of “master virtual machine” for APD virtualization. In some systems, the host VM 202 is not present, and the functions of the host VM 202 described herein are instead performed by the hypervisor 206 (the GPU virtualization driver 121 operates in the hypervisor 206). This is why it is shown as a dotted line). Note that although virtual functions are sometimes described herein as being associated with virtual machines, it is also possible for physical functions to be associated with one or more virtual machines. Typically, the host VM 202 is considered “associated” with a physical function and the guest VM 204 is associated with a virtual function. Because it is possible for virtual and physical functions to behave in similar ways in some contexts, the term "function" within the designators "virtual" or "physical" can refer to either virtual functions or physical functions, or collectively both virtual and physical functions. refers to For example, in some cases, APD 116 may be said to time-share operations between functions, meaning that APD 116 may have different virtual functions and, if APD 116 actively participates in time-sharing, physical functions. This means that time is divided between the two. It is not necessary for a physical function to participate in this time sharing, but it is possible for such a physical function to participate.

As explained above, physical functions and virtual functions are addressing parameters in PCIe. Transactions over PCIe are associated with physical functions and, optionally, additionally with virtual functions. Addressing over PCIe can be done explicitly through the bus-device-function number paradigm, but this addressing paradigm is typically reserved for device configuration (e.g. PCIe device listing) or other situations. More generally, and in standard operation, transactions over PCIe are done by memory address, and the PCIe fabric routes the transaction to the appropriate device and physical function and/or virtual function based on the memory map. In this scenario, the VM will access a memory address and the hypervisor or translation layer will translate the provided memory address in the guest physical memory address space to an address in the system physical memory address space that is mapped to APD 116. This translated address does not explicitly contain a representation of the virtual function, but is mapped to a specific virtual function through a memory map and routed to that virtual function by the PCIe fabric's routing function. Transactions over PCIe done through memory-mapped addresses do not explicitly specify virtual or physical function numbers.

This disclosure includes reference to guest and system physical address spaces. The relationship between these address spaces will be explained. The system physical address space is the “true” physical address space of device 100. Hypervisor 206 has access to this address space, but this address space is hidden from the VM. The guest physical address space is the virtualized “physical” address space “seen” by a particular guest VM 204. That is, to the guest VM 204, the guest physical address space appears to be the actual physical address space. The third address space - guest virtual memory - represents a typical virtual memory address space that exists in the computer system but in a virtualized environment of a VM. The system physical address space and The mapping between guest physical address spaces is managed by hypervisor 206 and the mapping between guest virtual address spaces and guest physical address spaces is managed by operating system 120.

Sharing APD 116 between different virtual machines is achieved by time-sharing the operations of APD 116 between different virtual machines, with different virtual functions (or physical functions) being assigned to different virtual machines. The virtualization scheduler 212 performs tasks related to time-sharing the APD 116, such as scheduling a new virtual machine for operation by switching from work on the current virtual machine when the execution time assigned to this virtual machine has elapsed. . Although APD 116 is shared between different virtual machines, each virtual machine knows that it has a separate instance of the actual hardware APD 116.

Although the terms “virtual function” and “physical function” refer to addressing parameters of the PCIe standard, because these functions are mapped to different VMs, a logical instance of APD 116 assigned to a particular virtual machine is herein referred to as a virtual function. Or it will be referred to as a physical function. That is, this disclosure may use terminology such as “a virtual function performs a task” (or a physical function) or “an action is performed on or on a virtual function” (or a physical function), which terminology refers to APD ( 116) should be read to mean that this task is performed during the time-slice allocated to the VM associated with this particular virtual or physical function or on behalf of the VM associated with this virtual or physical function.

Host VM 202 and guest VM 204 have an operating system 120 . Host VM 202 has a management application 123 and GPU virtualization driver 121. Guest VM 204 has an application 126, an operating system 120, and a GPU driver 122. These elements control various aspects of the operation of processor 102 and APD 116.

As described above, host VM 202 configures aspects of virtualization in APD 116 for guest VM 204. Accordingly, the host VM 202 includes an operating system 120 that supports execution of other elements such as management applications 123 and GPU virtualization drivers 121. The GPU virtualization driver 121 is not a typical graphics driver that simply transmits and sends graphics rendering (or other) commands to the APD 116 without understanding the virtualization aspects of the APD 116. Instead, GPU virtualization driver 121 communicates with APD 116 to configure various aspects of APD 116 for virtualization. In one example, GPU virtualization driver 121 manages parameters related to the time-slicing mechanism for sharing APD 116 between different VMs, such as how much time there is in each time-slice and when to switch between different virtual functions. Control parameters such as how it is performed, and other aspects. Note that GPU virtualization driver 121 may also issue conventional graphics rendering commands to APD 116 or perform other tasks not directly related to configuration of APD 116. Management application 123 performs one or more tasks for managing virtualization and/or involving data from two or more different guest VMs 204 . In one example, the host VM 202 performs a desktop compositing function through the management application 123, where the desktop compositing function accesses rendered frames from different guest VMs 204 and composites these frames into a single output view. .

Guest VM 204 includes an operating system 120, GPU drivers 122, and applications 126. Operating system 120 is any type of operating system that may run on processor 102. The GPU driver 122 controls the operation of the APD 116 for the guest VM 204 on which the GPU driver 122 is running to process tasks such as graphics rendering tasks or other tasks. It is a “native” driver for APD 116 in that it transmits to APD 116. A native driver may be an unmodified or slightly modified version of a device driver for a GPU that exists in a bare-bone, non-virtualized compute system.

Although GPU virtualization driver 121 is described as being included within host VM 202, in other implementations, GPU virtualization driver 121 is instead included in hypervisor 206. In this implementation, host VM 202 may not exist and the functions of host VM 202 may be performed by hypervisor 206.

The operating system 120 of the host VM 202 and the guest VM 204 provides support to the operating system in a virtualized environment, such as communicating with hardware, managing resources and file systems, managing virtual memory, managing the network stack, and many other functions. Performs standard functions for GPU driver 122 may be configured to provide an application programming interface (“API”) to software (e.g., application 126) to access various features of APD 116, for example, to access any particular guest VM (“API”). Controls the operation of the APD 116 for 204). Driver 122 may also provide just-in-time (JIT) processing to compile programs for execution by processing components of APD 116 (e.g., SIMD unit 138, discussed in more detail below). Includes compiler. For any particular guest VM 204, GPU driver 122 controls functions on APD 116 associated with that guest VM 204, but not with respect to other VMs.

APD 116 executes commands and programs for selected functions, such as graphical operations and non-graphical operations, as long as they are suitable for parallel processing. APD 116 may be used to perform graphics pipeline operations such as pixel operations, geometric calculations, and render images on display device 118 based on commands received from processor 102. APD 116 also executes computational processing operations not directly related to graphics operations, such as operations related to video, physics simulations, computational fluid dynamics, or other tasks based on commands received from processor 102. Command processor 213 accepts commands from processor 102 (or another source) and performs the tasks associated with these commands into various elements of APD 116, such as graphics processing pipeline 134 and compute unit 132. delegate to The VM uses the doorbell memory 214 to notify the APD 116 about new tasks for execution via the doorbell mechanism.

APD 116 includes a compute unit 132 that includes one or more SIMD units 138 configured to perform operations in a parallel manner at the request of processor 102 according to the SIMD paradigm. The SIMD paradigm is one in which multiple processing elements share a single program control flow unit and program counter, thereby executing the same program, but with different data. In one example, each SIMD unit 138 includes 16 lanes, each lane executing the same instructions concurrently with other lanes of SIMD unit 138 but with different data. Lanes can be switched off with predication if not all lanes need to execute a given command. Predicates can also be used to execute programs with branching control flow. More specifically, for programs with conditional branches or other instructions whose control flow is based on computations performed by individual lanes, predicates of lanes corresponding to control flow paths that are not currently executing, and Sequence of execution allows arbitrary control flow.

The basic unit of execution in computation unit 132 is the work-item. Each work-item represents a single instantiation of a program to be executed in parallel on a specific lane. Work-items may be executed simultaneously as a “wavefront” in a single SIMD processing unit 138. One or more wavefronts are included in a “workgroup,” which contains a set of work-items designated to execute the same program. A task group can be executed by executing each wavefront that makes up the task group. Alternatively, the wavefronts run sequentially on a single SIMD unit 138 or partially or completely in parallel on different SIMD units 138. A wavefront can be considered the largest set of work-items that can be executed simultaneously on a single SIMD unit 138. Accordingly, if a command received from processor 102 indicates that a particular program must be parallelized to the extent that it cannot be executed simultaneously on a single SIMD unit 138, then that program may be parallelized on two or more SIMD units 138 or parallelized on the same SIMD unit 138. ) into serialized (or parallelized and serialized if necessary) wavefronts. Scheduler 136 is configured to perform operations related to scheduling various wavefronts on different compute units 132 and SIMD units 138.

The parallelism provided by compute unit 132 is suitable for graphics-related operations such as pixel value calculations, vertex transformations, and other graphics operations. Accordingly, in some cases, graphics pipeline 134, which accepts graphics processing commands from processor 102, provides computational tasks to compute units 132 for execution in parallel.

Computation unit 132 may also be used to supplement processing that is not graphics-related or performed as part of the “normal” operation of graphics pipeline 134 (e.g., to supplement processing performed for the operation of graphics pipeline 134). It is used to avoid performing computational tasks (custom operations performed for this purpose). Application 126 or other software running on processor 102 transmits programs defining these computational tasks to APD 116 for execution.

Notification that new work is ready to be performed at APD 116 is made via a doorbell mechanism. More specifically, to notify APD 116 that a new task is ready, an entity (e.g., processor 102) writes a doorbell to doorbell memory 214. The doorbell contains a pointer to a command buffer indicating the memory address of the command to be fetched and processed.

In one implementation, the doorbell includes the address of the head of a circular buffer. The address of the tail is maintained separately by the APD 116. When the head and tail pointers are the same, no new command can be fetched. When an entity writes a doorbell with a head greater than the tail pointer, the command to be fetched is found at the address between the head and tail. APD 116 consumes commands in the command buffer by adjusting the tail pointer as the command is fetched. When the head and tail pointers are the same again, there are no new commands available in the command buffer. In this implementation, the doorbell acts as a notification that a task is ready to be performed and as an indication of the memory address where the command will be found. Optionally, a doorbell written to doorbell memory 214 is marked as processed when the task indicated by that doorbell is completed or when a new doorbell is written to doorbell memory 214. In other implementations, the doorbell may serve only as an indication that a job has been fetched and is ready to run, and the indication of the location of this job is determined independently of the value provided by the doorbell. In yet other implementations, the doorbell may be used for any alternative or additional purpose.

The doorbell mechanism operates asynchronously with respect to which virtual machines are currently scheduled to work on APD 116. This means that a particular virtual machine may place a doorbell in doorbell memory 214 when a task for a VM other than the VM that placed the doorbell in doorbell memory 214 is running on APD 116. This asynchronous operation occurs because execution by software running on processor 102 (e.g., software running on a VM) is scheduled independently compared to the time-sliced tasks on APD 116.

As described above, virtualization scheduler 212 manages time sharing of APD 116 among different virtual machines. At each time-slice, virtualization scheduler 212 allows work on the virtual machine associated with this time-slice to continue in APD 116. Virtualization scheduler 212 manages time-slices on APD 116 for VMs (both host VMs 202 and guest VMs 204) that share APD 116. Virtualization scheduler 212 tracks time-slices, stops work on APD 116 when a time-slice for a particular VM expires, and starts work on the VM with the next time slice. Accordingly, virtualization scheduler 212 switches between different VMs that have work to run on APD 116. The act of switching between different VMs is referred to herein as “virtualization context switching”. The virtualization scheduler selects different VMs to perform tasks based on a scheduling scheme. In one example, the scheduling scheme is a round robin scheme. In this scheme, each VM is given a turn on the APD 116, and the order in which the VMs are given is repeated. Other technically feasible scheduling schemes are of course possible.

To initiate work during a specific time-slice associated with a specific VM, the virtualization scheduler 212 causes the command processor 213 to issue commands for the graphics processing pipeline 134 and/or for general-purpose computational tasks to the specific VM. It fetches from an address specified by the doorbell memory 214. The command processor 213 then causes the APD 116 to execute these commands. The fetched command is pointed to by the doorbell stored in the doorbell memory 214.

When virtualization scheduler 212 determines that a time-slice for a VM with work currently running on APD 116 has expired, virtualization scheduler 212 causes APD 116 to not accept any new work and Causes work to be completed (e.g., without accepting new work pointed to by a doorbell stored in doorbell memory 214 and already "in progress" in graphics processing pipeline 134 and/or compute unit 138). Completing a task involves causing the work currently in progress in the APD 116 to be completed and the final output value to be written to the target memory location. For example, in graphics rendering, the output The pixel will be written to the frame buffer (or other rendering target). Alternatively, or in some situations, instead of completing the task, the function/VM will receive a "turn" back on the APD 116 to return the status for the task in progress. can be saved and restored again.

After work is completed for a particular VM, virtualization scheduler 212 moves on to the time-slice for the next VM, where command processor 213 fetches tasks for that VM based on the contents of doorbell memory 214. and execute these tasks directly in graphics processing pipeline 134 and/or computation unit 132 (e.g., for general purpose computation). This process of stopping execution of tasks for expired time-slices and starting tasks for the next VM is performed repeatedly to provide time sharing of APD 116 to different VMs.

In addition to stopping work on one VM and starting work on another VM, virtualization context switching also involves saving state for the VM being switched and loading state for the VM being switched. Generally, state includes values stored across or for the APD 116 that manage aspects of the workflow executed on the APD 116. In various examples, states may include values stored in registers that control how graphics are rendered, how SIMD operations are executed, how shaders are run, and various other aspects of operation on APD 116. . Saving state involves writing the state from an in-use location (where the state value actually affects the operation of APD 116) to a stored state location for the VM. Loading state means loading the state from a stored state location for the VM to a location in use. In some implementations, stored state locations are in memory (such as general-purpose memory on APD 116), and in-use locations include various memory elements such as registers within APD 116, private memory, etc.

Note that other parts of APD 116 are not specifically described as their functionality is in the context of virtualized operations as described above and no virtualization has occurred to execute commands fetched by command processor 213. For example, the graphics processing pipeline 134 performs operations related to graphics rendering in response to graphics rendering commands fetched by the command processor 213. For at least some of the graphics rendering commands associated with the graphics processing pipeline 134 and/or for general-purpose compute operations, the SIMD scheduler 136 may be configured to: Generates and manages wavefronts for execution on SIMD unit 138. In the example, the command is a command that renders a particular geometry using a particular pixel shader program, among other facilities in the graphics processing pipeline 134. The graphics processing pipeline 134 processes geometry through various stages of the graphics processing pipeline 134, such as the input assembler stage 302, the hull shader stage 306, the tessellator stage 308, and the pixel shader stage. At stage 316, the geometry is processed with a specific pixel shader in SIMD unit 138. SIMD scheduler 136 manages and schedules wavefronts for pixel shaders for execution.

FIG. 3 is a block diagram illustrating additional details of the graphics processing pipeline 134 shown in FIG. 2. The graphics processing pipeline 134 includes stages, each performing a specific function. Stages represent a subdivision of the functionality of the graphics processing pipeline 134. Each stage is implemented partially or fully as a shader program executing in compute unit 132, or partially or fully implemented external to compute unit 132 as fixed-function, non-programmable hardware.

The input assembler stage 302 reads primitive data from a buffer filled by the user (e.g., a buffer filled by requests from software executing by the processor 102, such as application 126), and the pipeline Assembles the data into primitives for use by the rest. The input assembler stage 302 may generate different types of primitives based on primitive data contained in a buffer filled by the user. The input assembler stage 302 formats the assembled primitives for use by the rest of the pipeline.

The vertex shader stage 304 processes vertices of primitives assembled by the input assembler stage 302. Vertex shader stage 304 performs various per-vertex operations such as transformation, skinning, morphing, and per-vertex lighting. Transformation operations include various operations that transform the coordinates of vertices. These operations include one or more of modeling transformations, viewing transformations, projection transformations, perspective splitting, and viewport transformations. Here, such transformations are considered to modify the coordinates or "position" of the vertex on which the transformation is performed. Other operations in the vertex shader stage 304 modify properties other than coordinates.

Vertex shader stage 304 is partially or fully implemented as a vertex shader program to be executed on one or more compute units 132. The vertex shader program is provided by processor 102 and is based on a program pre-written by a computer programmer. Driver 122 compiles these computer programs to produce vertex shader programs in a format suitable for execution within compute unit 132.

The hull shader stage 306, tessellator stage 308, and domain shader stage 310 work together to implement tessellation, which turns simple primitives into more complex primitives by subdividing the primitives. The hull shader stage 306 generates patches for tessellation based on input primitives. The tessellator stage 308 generates a set of samples for the patch. The domain shader stage 310 calculates vertex positions for vertices corresponding to samples for patching. Hull shader stage 306 and domain shader stage 310 may be implemented as shader programs to be executed in compute unit 132.

The geometry shader stage 312 performs vertex operations for each primitive. A variety of different types of operations are available in geometry shaders, including operations such as point sprint scaling, dynamic particle system behavior, fur-fin generation, shadow volume generation, single pass render-cube map, per-primitive data swapping, and per-primitive data setup. It may be performed by stage 312. In some cases, shader programs executing in compute unit 132 perform operations for geometry shader stage 312.

A rasterizer stage 314 is created upstream by accepting simple primitives and rasterizing them. Rasterization consists of determining which screen pixels (or sub-pixel samples) will be covered by a particular primitive. Rasterization is performed by fixed-function hardware.

Pixel shader stage 316 calculates output values for screen pixels based on primitives generated upstream and the results of rasterization. The pixel shader stage 316 can apply a texture from texture memory. Operations on the pixel shader stage 316 are performed by shader programs executing in compute unit 132.

The output merge stage 318 accepts the output from the pixel shader stage 316 and merges these outputs, performing operations such as z-testing and alpha blending to determine the final color for the screen pixels.

Referring back to Figure 2, in some cases, the current function terminates its work and becomes "idle" before the amount of time allocated to the time-slice for that function expires. In some situations in this scenario, virtualization scheduler 212 performs a virtualization context switch “early.” More specifically, after learning the children and before the time-slice ends, virtualization scheduler 212 causes a virtualization context switch from the current function to the next function. The purpose of performing an early virtualization context switch is to allow other functions to perform work when the current function no longer has work to do. By performing a virtualization context switch to a subsequent function, rather than idling the APD 116 for the remainder of the time-slice for the current function, the resources of the APD 116 are used to perform useful work instead of being idle. In addition to performing a virtualization context switch early when it learns that the current function is idle, virtualization scheduler 212 also performs a subsequent next turn if the function has not received any work since the early virtualization context switch was performed. You can skip it. Whether a function has received a task is determined through the doorbell mechanism described throughout this disclosure.

FIG. 4 is a block diagram illustrating features of device 100 associated with performing an early virtualization context switch, according to an example. Many elements of device 100 are depicted in FIG. 4 , including early virtualization context switch unit 402 , shown as included within virtualization scheduler 212 . Early virtualization context switch unit 402 may be implemented in hardware, software, or any combination thereof. Additionally, although the early virtualization context switch unit 402 is shown within the virtualization scheduler 212, it is noted that the present disclosure is not intended to limit the physical placement of the components that perform the functions of the early virtualization context switch unit 402. do. 5 is a flow diagram of a method for performing an early virtualization context switch, according to an example. Although the operation of Figure 5 has been described with respect to the system of Figures 1-4, method 500 performed in steps as shown or in any other technically feasible order by any system is within the scope of this disclosure. must be understood as belonging. Figures 4 and 5 are discussed together below.

Early virtualization context switch unit 402 determines when it is appropriate to perform an “early virtualization context switch,” the state of graphics processor pipeline 134, or for compute-only tasks, SIMD scheduler 136 and compute unit 134. ), communicates with and coordinates with the command processor 213 to determine, based on the status of. The state of the graphics pipeline 134 at least in some cases includes the state of the SIMD scheduler 136, but if non-graphics computation work is outstanding, the decision whether to perform an early virtualization context switch can be made alternatively or graphically. In addition to the state of the processing pipeline 134, it depends on the state of the SIMD scheduler 136 and the computation unit 134.

The command processor 213 is an entity that receives requests to perform work from the APD 116 and dispatches the work to the graphics processing pipeline 134 and/or SIMD scheduler 136. More broadly, command processor 213 controls workflow at a high level on graphics processing pipeline 134 and SIMD scheduler 136. As part of this workflow control, command processor 213 receives job completion reports from various sub-units of graphics processing pipeline 134 and SIMD scheduler 136. More specifically, for any work outstanding on graphics processing pipeline 134 or SIMD scheduler 136, command processor 213 receives notification when such work is completed. Additionally, the command processor 213 keeps track of which tasks are outstanding in the graphics processing pipeline 134 and SIMD scheduler 136. By correlating task completion reports with pending task tracking, command processor 213 tracks information indicating whether graphics processing pipeline 134 and SIMD scheduler 136 are idle or performing work. SIMD scheduler 136 is considered idle if there is no work outstanding on compute unit 132. Accordingly, in the phrase “SIMD scheduler 136 is idle,” due to SIMD scheduler 136's role as the coordinator of functions in compute unit 132, SIMD scheduler 136 is idle for compute unit 132. It acts as a proxy. In one example, once all outstanding work has completed in graphics processing pipeline 134 and SIMD scheduler 136, command processor 213 considers graphics processing pipeline 134 and SIMD scheduler 136 to be idle.

Even when the graphics processing pipeline 134 and SIMD scheduler 136 are idle, there may be work for the command processor 213 to process. For example, graphics processing pipeline 134 and SIMD scheduler 136 may become idle when command processor 213 detects that there is a new doorbell to process. Accordingly, APD 116 is not considered fully idle until graphics processing pipeline 134 and SIMD scheduler 136 are idle and waiting to be processed, or until no doorbells are currently being processed. When command processor 213 detects that this condition occurs, command processor 213 is considered to have made an “idle decision,” shown as step 502 in FIG. 5.

When making an “idle decision,” command processor 213 provides an indication of this idle decision to virtualization scheduler 212. Upon receiving this notification, virtualization scheduler 212 initiates an early virtualization context switch decision sequence. The early virtualization context switch decision sequence determines whether an early virtualization context switch (a virtualization context switch before the time assigned to the time-slice for the current function) should occur, followed by an early virtualization context switch if an early virtualization context switch should occur. It performs several functions to accomplish this.

In one implementation, the early virtualization context switch decision includes waiting for a timeout period after receiving an idle indication from command processor 213 and determining whether a doorbell is received within this timeout period (this determination is shown in FIG. 5 (shown as step 504). If no doorbell for the current function reaches APD 116 during this timeout period, the virtualization scheduler initiates an early virtualization context switch (step 508). An early virtualization context switch is essentially a "regular" context switch, as described elsewhere in this disclosure, including saving state for the current function, loading state for the next function, and allowing operations on the next function to be performed. "Performed as a virtualization context switch.

Initiating an early virtualization context switch also includes sending a command to the command processor 213 to stop fetching tasks based on the doorbell in the doorbell memory 214 received after a timeout period has expired. Includes. The time at which the virtualization scheduler 212 determines that no doorbell has been received within the timeout period and sends a command to the command processor 213 to stop fetching the task and prevent the command processor 213 from fetching the task. There is a slight delay between receiving the command to stop. If a doorbell is received during this delay period, command processor 213 ignores the doorbell, or, if command processor 213 had begun fetching jobs based on the doorbell, it stops fetching. This interruption will include resetting the state associated with the command processor 213 to the state it was in before the command processor 213 began processing this doorbell. For example, if a pointer to a command buffer pointed by a doorbell (e.g., a tail pointer) is updated to process the doorbell, the command processor 213 stores these pointers as values before processing the doorbell. Reset.

Referring back to step 504, if a doorbell is received by APD 116 during the timeout period, the method 500 proceeds to step 506. At step 506, virtualization scheduler 212 determines whether a “significant” amount of time remains in the time-slice for the current function. A “significant” amount of time is an amount of time above the threshold. In an implementation, the threshold is equal to (or approximately equal to) the delay period during which command processor 213 determines whether a doorbell is received after APD 116 becomes idle. If there is more time remaining in the current time-slice than the critical delay period remaining, the method 500 proceeds to step 510 such that the virtualization scheduler 212 does not cause a premature virtualization context switch and instead causes the APD 116 to Allows processing of tasks referenced by the doorbell. Referring back to step 506, if there is no amount of time remaining in the current time slice greater than the threshold, the method 500 proceeds to step 508, where virtualization scheduler 212 performs an early virtualization context switch.

After performing a virtualization context switch for a function, if it is the turn for the function but the doorbell has not been received, the virtualization scheduler 212 skips this function and resumes another function (e.g., a “next” function in the scheduling scheme). Schedule work on .

In the discussion above, the word "early" in the term "early virtualization context switch" means indicating that the virtualization context switch will occur before the amount of time allocated to the current function expires.

It should be understood that many modifications are possible based on the disclosure herein. For example, although PCIe is described herein as a specific interconnection fabric, any other technologically feasible interconnection fabric may alternatively be used. Although features and elements are described above in specific combinations, each feature or element may be used alone or in various combinations with or without other features and elements.

The provided methods may be implemented in a general-purpose computer, processor, or processor core. Suitable processors include, for example, a general-purpose processor, a dedicated processor, a conventional processor, a digital signal processor (DSP), a plurality of microprocessors, one or more microprocessors associated with a DSP core, a controller, a microcontroller, or an Application Specific Integrated Circuits (ASIC). , Field Programmable Gate Arrays (FPGA) circuits, any other type of integrated circuit (IC), and/or state machines. Such processors may be manufactured by constructing a manufacturing process using the results of processed Hardware Description Language (HDL) instructions and other intermediate data, including a netlist (such instructions that may be stored on a computer-readable medium). The result of this processing may be a maskwork used in a semiconductor manufacturing process to fabricate a processor embodying the features of the present disclosure.

The methods or flow diagrams provided herein may be implemented as a computer program, software, or firmware incorporated into a non-transitory computer-readable storage medium for execution by a general-purpose computer or processor. Examples of non-transitory computer readable storage media include read only memory (ROM), random access memory (RAM), registers, cache memory, semiconductor memory devices, magnetic media such as internal hard disks and removable disks, magneto-optical media, and optical media such as CD-ROM and digital versatile disk (DVD) disks.

Claims (20)

1. A method of performing an early virtualization context switch in a virtualized accelerated processing device (“APD”), comprising:
determining that the APD is idle prior to completion of a time-slice for a current function associated with performing operations on a virtual machine on the virtualized APD;
In response to the determination, performing an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing a state in the APD for the current function;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
The steps for determining that the APD is children are:
Determining that there is no outstanding work on the graphics processing pipeline of the APD and that there is no outstanding work on the compute units of the APD. The method of claim 1, wherein starting work on the subsequent functionality includes:
fetching commands based on doorbells for the subsequent function; and
and executing the commands for the subsequent function. delete The method of claim 1, wherein determining that the APD is idle comprises determining that no doorbell is processed or received while there is no outstanding work on the APD's graphics processing pipeline and no outstanding work on the APD's compute units. A method further comprising determining not to do so. The method of claim 1, wherein determining that the APD is idle further comprises determining that no doorbell is received during a timeout period after the APD is idle. 1. A method of performing an early virtualization context switch in a virtualized accelerated processing device (“APD”), comprising:
determining that the APD is idle prior to completion of a time-slice for a current function associated with performing operations on a virtual machine on the virtualized APD;
In response to the determination, performing an early virtualization context switch with a subsequent function, the early virtualization context switch comprising:
storing a state in the APD for the current function;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
In response to the second time-slice for the second function completing without the APD being idle being longer than the timeout period, the second time-slice for the second function completing without performing a premature virtualization context switch. A method, comprising steps to complete. 1. A method of performing an early virtualization context switch in a virtualized accelerated processing device (“APD”), comprising:
determining that the APD is idle prior to completion of a time-slice for a current function associated with performing operations on a virtual machine on the virtualized APD;
In response to the determination, performing an early virtualization context switch with a subsequent function, the early virtualization context switch comprising:
storing a state in the APD for the current function;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
determining that the APD has become idle during a second time-slice for a second function;
determining that a doorbell is received during a timeout period after the APD becomes idle during the second time-slice for the second function; and
A method comprising: performing operations associated with the doorbell instead of performing an early virtualization context switch. 1. A method of performing an early virtualization context switch in a virtualized accelerated processing device (“APD”), comprising:
determining that the APD is idle prior to completion of a time-slice for a current function associated with performing operations on a virtual machine on the virtualized APD;
In response to the determination, performing an early virtualization context switch with a subsequent function, the early virtualization context switch comprising:
storing a state in the APD for the current function;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
determining that the APD has become idle during a second time-slice for a second function;
receiving a doorbell during a timeout period after the APD becomes idle during the second time-slice for the second function; and
In response to determining that less than a threshold amount of time remains in the second time-slice, performing an early virtualization context switch despite receiving the doorbell. 1. A method of performing an early virtualization context switch in a virtualized accelerated processing device (“APD”), comprising:
determining that the APD is idle prior to completion of a time-slice for a current function associated with performing operations on a virtual machine on the virtualized APD;
In response to the determination, performing an early virtualization context switch with a subsequent function, the early virtualization context switch comprising:
storing a state in the APD for the current function;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
After performing the virtualization context switch, determining, based on a scheduling scheme, that the virtual machine will be given a turn on the APD again; and
In response to determining that no doorbell for the virtual machine has been received since performing the virtualization context switch, skipping the turn for the virtual machine. An accelerated processing device (“APD”) capable of performing an early virtualization context switch, the APD comprising one or more parallel processing units, the APD comprising:
a graphics processing pipeline and a plurality of computational units, including one or more parallel processing units, configured to perform a task;
a command processor including a first processor configured to issue commands related to the task to the plurality of computational units and the graphics processing pipeline; and
As a virtualization scheduler,
determine that the APD is idle prior to completion of a time-slice for a current function associated with performing work on a virtual machine in the APD;
In response to the determination, the virtualization scheduler includes a second processor configured to perform an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing the status of the current function in the APD;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
wherein the virtualization scheduler is configured to determine that the APD is idle by determining that there is no outstanding work for the APD's graphics processing pipeline and no outstanding work for the APD's compute units. The method of claim 10, wherein the virtualization scheduler:
fetch commands based on doorbells for the subsequent function;
An accelerated processing device configured to initiate work on a successor function by executing the commands for the successor function. delete The method of claim 10, wherein the virtualization scheduler:
further configured to determine that the APD is idle by determining that no doorbell is processed or received while there is no outstanding work on the graphics processing pipeline of the APD and no outstanding work on the computational units of the APD. Accelerated processing device. The method of claim 10, wherein the virtualization scheduler:
and determine that the APD is idle by determining that no doorbell is received during a timeout period after the APD becomes idle. An accelerated processing device (“APD”) capable of performing an early virtualization context switch, the APD comprising one or more parallel processing units, the APD comprising:
a graphics processing pipeline and a plurality of computational units, including one or more parallel processing units, configured to perform a task;
a command processor including a first processor configured to issue commands related to the task to the plurality of computational units and the graphics processing pipeline; and
As a virtualization scheduler,
determine that the APD is idle prior to completion of a time-slice for a current function associated with performing work on a virtual machine in the APD;
In response to the determination, the virtualization scheduler includes a second processor configured to perform an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing the status of the current function in the APD;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
The virtualization scheduler is configured to, in response to the second time-slice for the second function completing without the APD being idle, being longer than a timeout period, the second time-slice does not perform a premature virtualization context switch. An accelerated processing device configured to complete the second function. An accelerated processing device (“APD”) capable of performing an early virtualization context switch, the APD comprising one or more parallel processing units, the APD comprising:
a graphics processing pipeline and a plurality of computational units, including one or more parallel processing units, configured to perform a task;
a command processor including a first processor configured to issue commands related to the task to the plurality of computational units and the graphics processing pipeline; and
As a virtualization scheduler,
determine that the APD is idle prior to completion of a time-slice for a current function associated with performing work on a virtual machine in the APD;
In response to the determination, the virtualization scheduler includes a second processor configured to perform an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing the status of the current function in the APD;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
the virtualization scheduler determines that the APD has become idle during a second time-slice for a second function;
determine that a doorbell has been received during a timeout period after the APD has become idle during the second time-slice for the second function; and
An accelerated processing device configured to cause the APD to perform tasks associated with the doorbell instead of performing a premature virtualization context switch. An accelerated processing device (“APD”) capable of performing an early virtualization context switch, the APD comprising one or more parallel processing units, the APD comprising:
a graphics processing pipeline and a plurality of computational units, including one or more parallel processing units, configured to perform a task;
a command processor including a first processor configured to issue commands related to the task to the plurality of computational units and the graphics processing pipeline; and
As a virtualization scheduler,
determine that the APD is idle prior to completion of a time-slice for a current function associated with performing work on a virtual machine in the APD;
In response to the determination, the virtualization scheduler includes a second processor configured to perform an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing the status of the current function in the APD;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
the virtualization scheduler determines that the APD has become idle during a second time-slice for a second function;
detect a doorbell during a timeout period after the APD becomes idle during the second time-slice for the second function; and
In response to determining that less than a threshold amount of time remains in the second time-slice, the accelerated processing device is configured to perform an early virtualization context switch despite receiving the doorbell. An accelerated processing device (“APD”) capable of performing an early virtualization context switch, the APD comprising one or more parallel processing units, the APD comprising:
a graphics processing pipeline and a plurality of computational units, including one or more parallel processing units, configured to perform a task;
a command processor including a first processor configured to issue commands related to the task to the plurality of computational units and the graphics processing pipeline; and
As a virtualization scheduler,
determine that the APD is idle prior to completion of a time-slice for a current function associated with performing work on a virtual machine in the APD;
In response to the determination, the virtualization scheduler includes a second processor configured to perform an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing the status of the current function in the APD;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
After performing the virtualization context switch, the virtualization scheduler determines that the virtual machine will be given a turn on the APD again, based on a scheduling scheme; and
In response to determining that no doorbell for the virtual machine has been received since performing the virtualization context switch, skip the turn for the virtual machine. As a device,
A processor configured to run a plurality of virtual machines; and
An accelerated processing device (“APD”) capable of performing an early virtualization context switch, the APD comprising one or more parallel processing units, the APD:
a graphics processing pipeline and a plurality of computational units, including one or more parallel processing units, configured to perform a task;
a command processor including a first processor configured to issue commands related to the task to the plurality of computational units and the graphics processing pipeline; and
As a virtualization scheduler,
determine that the APD is idle prior to completion of a time-slice for a current function associated with performing work on a virtual machine in the APD;
In response to the determination, the virtualization scheduler includes a second processor configured to perform an early virtualization context switch with a subsequent function, wherein the early virtualization context switch:
storing the status of the current function in the APD;
loading state for the subsequent function in the APD; and
Initiating work on the subsequent function in the APD,
wherein determining that the APD is idle includes determining that there is no work outstanding on the graphics processing pipeline of the APD and that there is no work outstanding on the compute units of the APD. The method of claim 19, wherein the virtualization scheduler:
by fetching commands based on doorbells for the subsequent function; and
The device is configured to start working on the successor function by executing the commands for the successor function.

Images