One embodiment of the present invention sets forth a method for sharing graphics objects between a compute unified device architecture (CUDA) application programming interface (API) and a graphics API. The CUDA API includes calls used to alias graphics objects allocated by the graphics API and, subsequently, synchronize accesses to the graphics objects. When an application program emits a “register” call that targets a particular graphics object, the CUDA API ensures that the graphics object is in the device memory, and maps the graphics object into the CUDA address space. Subsequently, when the application program emits “map” and “unmap” calls, the CUDA API respectively enables and disables accesses to the graphics object through the CUDA API. Further, the CUDA API uses semaphores to synchronize accesses to the shared graphics object. Finally, when the application program emits an “unregister” call, the CUDA API configures the computing system to disregard interoperability constraints.
Legal claims defining the scope of protection. Each claim is shown in both the original legal language and a plain English translation.
1. A method for synchronizing access to a memory buffer, the method comprising: causing a semaphore buffer associated with the memory buffer to be allocated at a first memory location accessible to both a first driver and a second driver; causing the memory buffer to be accessible to the first driver; receiving a request to cause the memory buffer to be accessible to the second driver; in response to receiving the request, determining that the memory buffer is not accessible to both the first driver and the second driver, moving the memory buffer to a second memory location that is also accessible to both the first driver and the second driver, and marking the memory buffer as registered to retain the memory buffer at the second memory location; causing the execution of commands transmitted by the second driver to a processing unit to be suspended until information stored in the semaphore buffer has been modified to indicate that the first driver has completed accessing the memory buffer; and causing the information stored in the semaphore buffer to be modified to indicate that the first driver has completed accessing the memory buffer.
The invention is a method for coordinating access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.
2. The method of claim 1 , wherein the step of causing information stored in the semaphore buffer to be modified to indicate that the first driver has completed accessing the memory buffer comprises inserting, by the first driver, a semaphore release command referencing the semaphore buffer into a graphics push buffer of commands for execution by the processing unit.
As an extension to the method for coordinating access to a shared memory buffer (described as: a method for coordinating access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the first driver signals its completion by inserting a "semaphore release command" into a "graphics push buffer" of commands destined for the processing unit. This command references the semaphore buffer, updating its state to indicate that the first driver has finished accessing the shared memory.
3. The method of claim 1 , wherein the step of causing the execution of commands transmitted by the second driver to be suspended comprises inserting, by the second driver, a semaphore acquire command referencing the semaphore buffer into a push buffer of commands for execution by the processing unit.
Complementing the method for coordinating access to a shared memory buffer (described as: a method for coordinating access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the second driver pauses its own commands by inserting a "semaphore acquire command" into its own "push buffer" of commands for the processing unit. This command references the same semaphore buffer, causing the processing unit to wait until the semaphore buffer indicates that the first driver has completed its access to the shared memory.
4. The method of claim 1 , further comprising the steps of: receiving a request to cause the memory buffer to be accessible to the first driver; causing the execution of commands transmitted by the first driver to the processing unit to be suspended until information stored in the semaphore buffer has been modified to indicate that the second driver has completed accessing the memory buffer; and causing the information stored in the semaphore buffer to be modified to indicate that the second driver has completed accessing the memory buffer.
Expanding on the method for coordinating access to a shared memory buffer (described as: a method for coordinating access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the invention also manages scenarios where the *first* driver needs to re-access the memory buffer *after* the second driver has used it. The first driver's commands are suspended until the semaphore buffer signals that the second driver is done. The second driver modifies the semaphore buffer when it has completed its work, allowing the first driver to resume.
5. The method of claim 1 , further comprising: determining that processing tasks associated with the memory buffer are complete; and unmarking the memory buffer as registered to disregard interoperability constraints for the memory buffer.
Building upon the method for coordinating access to a shared memory buffer (described as: a method for coordinating access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the invention includes a mechanism to release the memory buffer from interoperability constraints. After processing tasks associated with the memory buffer are complete, the system "unmarks" the memory buffer as "registered." This action signifies that the memory buffer is no longer subject to the synchronization requirements imposed by the first and second drivers, allowing for optimized memory management.
6. A non-transitory computer-readable medium including instructions that, when executed by a processing unit, cause the processing unit to synchronize access to a memory buffer, by performing the steps of: causing a semaphore buffer associated with the memory buffer to be allocated at a first memory location accessible to both a first driver and a second driver; causing the memory buffer to be accessible to the first driver; receiving a request to cause the memory buffer to be accessible to the second driver; in response to receiving the request, determining that the memory buffer is not accessible to both the first driver and the second driver, moving the memory buffer to a second memory location that is also accessible to both the first driver and the second driver, and marking the memory buffer as registered to retain the memory buffer at the second memory location; causing the execution of commands transmitted by the second driver to a processing unit to be suspended until information stored in the semaphore buffer has been modified to indicate that the first driver has completed accessing the memory buffer; and causing the information stored in the semaphore buffer to be modified to indicate that the first driver has completed accessing the memory buffer.
The invention is a non-transitory computer-readable medium containing instructions to synchronize access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.
7. The non-transitory computer-readable medium of claim 6 , wherein the step of causing information stored in the semaphore buffer to be modified to indicate that the first driver has completed accessing the memory buffer comprises inserting, by the first driver, a semaphore release command referencing the semaphore buffer into a graphics push buffer of commands for execution by the processing unit.
As an extension to the computer-readable medium for coordinating access to a shared memory buffer (described as: The invention is a non-transitory computer-readable medium containing instructions to synchronize access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the first driver signals its completion by inserting a "semaphore release command" into a "graphics push buffer" of commands destined for the processing unit. This command references the semaphore buffer, updating its state to indicate that the first driver has finished accessing the shared memory.
8. The non-transitory computer-readable medium of claim 6 , wherein the step of causing the execution of commands transmitted by the second driver to be suspended comprises inserting, by the second driver, a semaphore acquire command referencing the semaphore buffer into a push buffer of commands for execution by the processing unit.
Complementing the computer-readable medium for coordinating access to a shared memory buffer (described as: The invention is a non-transitory computer-readable medium containing instructions to synchronize access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the second driver pauses its own commands by inserting a "semaphore acquire command" into its own "push buffer" of commands for the processing unit. This command references the same semaphore buffer, causing the processing unit to wait until the semaphore buffer indicates that the first driver has completed its access to the shared memory.
9. The non-transitory computer-readable medium of claim 6 , further comprising the steps of: receiving a request to cause the memory buffer to be accessible to the first driver; causing the execution of commands transmitted by the first driver to the processing unit to be suspended until information stored in the semaphore buffer has been modified to indicate that the second driver has completed accessing the memory buffer; causing the information stored in the semaphore buffer to be modified to indicate that the second driver has completed accessing the memory buffer.
Expanding on the computer-readable medium for coordinating access to a shared memory buffer (described as: The invention is a non-transitory computer-readable medium containing instructions to synchronize access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the invention also manages scenarios where the *first* driver needs to re-access the memory buffer *after* the second driver has used it. The first driver's commands are suspended until the semaphore buffer signals that the second driver is done. The second driver modifies the semaphore buffer when it has completed its work, allowing the first driver to resume.
10. The non-transitory computer-readable medium of claim 6 , further comprising: determining that processing tasks associated with the memory buffer are complete; and unmarking the memory buffer as registered to disregard interoperability constraints for the memory buffer.
Building upon the computer-readable medium for coordinating access to a shared memory buffer (described as: The invention is a non-transitory computer-readable medium containing instructions to synchronize access to a shared memory buffer between two drivers. First, a "semaphore buffer" is created in memory accessible to both drivers. This buffer acts as a flag for synchronization. The memory buffer to be shared is initially made accessible to the first driver. When the second driver requests access, the system checks if both drivers can access it simultaneously. If not, the memory buffer is moved to a shared memory location and marked as "registered" to prevent it from being moved. The second driver's commands are paused until the semaphore buffer indicates the first driver is done. Finally, the first driver modifies the semaphore buffer to signal completion.), the invention includes a mechanism to release the memory buffer from interoperability constraints. After processing tasks associated with the memory buffer are complete, the system "unmarks" the memory buffer as "registered." This action signifies that the memory buffer is no longer subject to the synchronization requirements imposed by the first and second drivers, allowing for optimized memory management.
11. A computing device configured to synchronize access to a memory buffer, the computing device comprising: a processing unit; a graphics processing unit (GPU) coupled to the processing unit; a first driver; a second driver; and an API configured to: cause a semaphore buffer associated with the memory buffer to be allocated at a first memory location accessible to both the first driver and the second driver, cause the memory buffer to be accessible to the first driver, receive a request to cause the memory buffer to be accessible to the second driver, in response to receiving the request, determine that the memory buffer is not accessible to both the first driver and the second driver, move the memory buffer to a second memory location that is also accessible to both the first driver and the second driver, and mark the memory buffer as registered to retain the memory buffer at the second memory location, cause the execution of commands transmitted by the second driver to the GPU to be suspended until information stored in the semaphore buffer has been modified to indicate that the first driver has completed accessing the memory buffer, and cause the information stored in the semaphore buffer to be modified to indicate that the first driver has completed accessing the memory buffer.
The invention is a computing device that synchronizes access to a shared memory buffer between two drivers (first driver and second driver), comprising a processing unit and a GPU. A "semaphore buffer" is allocated in memory accessible to both drivers. The memory buffer to be shared is initially accessible to the first driver. When the second driver requests access, the system checks simultaneous accessibility. If not possible, the memory buffer is moved to a shared memory location and marked as "registered". Commands from the second driver to the GPU are paused until the semaphore buffer signals completion by the first driver. The first driver then modifies the semaphore buffer to indicate completion.
12. The computing device of claim 11 , wherein, to cause information stored in the semaphore buffer to be modified to indicate that the first driver has completed accessing the memory buffer, the first driver is configured to insert a semaphore release command referencing the semaphore buffer into a graphics push buffer of commands for execution by the GPU.
As an extension to the computing device for coordinating access to a shared memory buffer (described as: The invention is a computing device that synchronizes access to a shared memory buffer between two drivers (first driver and second driver), comprising a processing unit and a GPU. A "semaphore buffer" is allocated in memory accessible to both drivers. The memory buffer to be shared is initially accessible to the first driver. When the second driver requests access, the system checks simultaneous accessibility. If not possible, the memory buffer is moved to a shared memory location and marked as "registered". Commands from the second driver to the GPU are paused until the semaphore buffer signals completion by the first driver. The first driver then modifies the semaphore buffer to indicate completion.), the first driver signals its completion by inserting a "semaphore release command" into a "graphics push buffer" of commands destined for the GPU. This command references the semaphore buffer, updating its state to indicate that the first driver has finished accessing the shared memory.
13. The computing device of claim 11 , wherein, to cause the execution of commands transmitted by the second driver to be suspended, the second driver is configured to insert a semaphore acquire command referencing the semaphore buffer into a push buffer of commands for execution by the GPU.
Complementing the computing device for coordinating access to a shared memory buffer (described as: The invention is a computing device that synchronizes access to a shared memory buffer between two drivers (first driver and second driver), comprising a processing unit and a GPU. A "semaphore buffer" is allocated in memory accessible to both drivers. The memory buffer to be shared is initially accessible to the first driver. When the second driver requests access, the system checks simultaneous accessibility. If not possible, the memory buffer is moved to a shared memory location and marked as "registered". Commands from the second driver to the GPU are paused until the semaphore buffer signals completion by the first driver. The first driver then modifies the semaphore buffer to indicate completion.), the second driver pauses its own commands by inserting a "semaphore acquire command" into its own "push buffer" of commands for the GPU. This command references the same semaphore buffer, causing the GPU to wait until the semaphore buffer indicates that the first driver has completed its access to the shared memory.
14. The computing device of claim 11 , wherein the API is further configured to: receive a request to cause the memory buffer to be accessible to the first driver; cause the execution of commands transmitted by the first driver to the GPU to be suspended until information stored in the semaphore buffer has been modified to indicate that the second driver has completed accessing the memory buffer; and cause the information stored in the semaphore buffer to be modified to indicate that the second driver has completed accessing the memory buffer.
Expanding on the computing device for coordinating access to a shared memory buffer (described as: The invention is a computing device that synchronizes access to a shared memory buffer between two drivers (first driver and second driver), comprising a processing unit and a GPU. A "semaphore buffer" is allocated in memory accessible to both drivers. The memory buffer to be shared is initially accessible to the first driver. When the second driver requests access, the system checks simultaneous accessibility. If not possible, the memory buffer is moved to a shared memory location and marked as "registered". Commands from the second driver to the GPU are paused until the semaphore buffer signals completion by the first driver. The first driver then modifies the semaphore buffer to indicate completion.), the invention also manages scenarios where the *first* driver needs to re-access the memory buffer *after* the second driver has used it. The first driver's commands are suspended until the semaphore buffer signals that the second driver is done. The second driver modifies the semaphore buffer when it has completed its work, allowing the first driver to resume.
Cooperative Patent Classification codes for this invention. Click any code to explore related patents in that topic.
February 14, 2008
September 17, 2013
Browse 5M+ US patents with plain-English claim translations and AI-generated analysis.