Adding NVIDIA multicast2 extensions
Adding new NVIDIA extensions
GL_NVX_gpu_multicast2
GL_NVX_progress_fence
WGL_NV_multigpu_context
diff --git a/api/GL/glext.h b/api/GL/glext.h
index d72cc75..60f204f 100644
--- a/api/GL/glext.h
+++ b/api/GL/glext.h
@@ -9998,6 +9998,40 @@
#endif
#endif /* GL_NV_gpu_multicast */
+/* NVX_gpu_multicast2 */
+#ifndef GL_NVX_gpu_multicast2
+#define GL_NVX_gpu_multicast2 1
+#define GL_UPLOAD_GPU_MASK_NV 0x954A
+typedef void (GLAPIENTRYP PFNGLUPLOADGPUMASKNVXPROC) (GLbitfield mask);
+typedef void (GLAPIENTRYP PFNGLMULTICASTVIEWPORTARRAYVNVXPROC) (GLuint gpu, GLuint first, GLsizei count, const GLfloat *v);
+typedef void (GLAPIENTRYP PFNGLMULTICASTVIEWPORTPOSITIONWSCALENVXPROC) (GLuint gpu, GLuint index, GLfloat xcoeff, GLfloat ycoeff);
+typedef void (GLAPIENTRYP PFNGLMULTICASTSCISSORARRAYVNVXPROC) (GLuint gpu, GLuint first, GLsizei count, const GLint *v);
+typedef void (GLAPIENTRYP PFNGLASYNCCOPYBUFFERSUBDATANVXPROC) (GLsizei waitSemaphoreCount, const GLuint *waitSemaphoreArray, const GLuint64 *waitValues, GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size, GLsizei signalSemaphoreCount, const GLuint *signalSemaphoreArray, const GLuint64 *signalValues);
+typedef void (GLAPIENTRYP PFNGLASYNCCOPYIMAGESUBDATANVXPROC) (GLsizei waitSemaphoreCount, const GLuint *waitSemaphoreArray, const GLuint64 *waitValues, GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLuint srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLuint dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth, GLsizei signalSemaphoreCount, const GLuint *signalSemaphoreArray, const GLuint64 *signalValues);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI void GLAPIENTRY glUploadGpuMaskNVX(GLbitfield mask);
+GLAPI void GLAPIENTRY glMulticastViewportArrayvNVX(GLuint gpu, GLuint first, GLsizei count, const GLfloat *v);
+GLAPI void GLAPIENTRY glMulticastViewportPositionWScaleNVX(GLuint gpu, GLuint index, GLfloat xcoeff, GLfloat ycoeff);
+GLAPI void GLAPIENTRY glMulticastScissorArrayvNVX(GLuint gpu, GLuint first, GLsizei count, const GLint *v);
+GLAPI void GLAPIENTRY glAsyncCopyBufferSubDataNVX(GLsizei waitSemaphoreCount, const GLuint *waitSemaphoreArray, const GLuint64 *waitValues, GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size, GLsizei signalSemaphoreCount, const GLuint *signalSemaphoreArray, const GLuint64 *signalValues);
+GLAPI void GLAPIENTRY glAsyncCopyImageSubDataNVX(GLsizei waitSemaphoreCount, const GLuint *waitSemaphoreArray, const GLuint64 *waitValues, GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLuint srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLuint dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth, GLsizei signalSemaphoreCount, const GLuint *signalSemaphoreArray, const GLuint64 *signalValues);
+#endif
+#endif /* GL_NVX_gpu_multicast2 */
+
+#ifndef GL_NVX_progress_fence
+#define GL_NVX_progress_fence 1
+typedef GLuint(GLAPIENTRYP PFNGLCREATEPROGRESSFENCENVXPROC) (void);
+typedef void (GLAPIENTRYP PFNGLSIGNALSEMAPHOREUI64NVXPROC) (GLuint signalGpu, GLsizei semaphoreCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray);
+typedef void (GLAPIENTRYP PFNGLWAITSEMAPHOREUI64NVXPROC) (GLuint waitGpu, GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray);
+typedef void (GLAPIENTRYP PFNGLCLIENTWAITSEMAPHOREUI64NVXPROC) (GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray);
+#ifdef GL_GLEXT_PROTOTYPES
+GLAPI GLuint GLAPIENTRY glCreateProgressFenceNVX(void);
+GLAPI void GLAPIENTRY glSignalSemaphoreui64NVX(GLuint signalGpu, GLsizei semaphoreCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray);
+GLAPI void GLAPIENTRY glWaitSemaphoreui64NVX(GLuint waitGpu, GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray);
+GLAPI void GLAPIENTRY glClientWaitSemaphoreui64NVX(GLsizei fenceObjectCount, const GLuint *semaphoreArray, const GLuint64 *fenceValueArray);
+#endif
+#endif /* GL_NVX_progress_fence */
+
#ifndef GL_NV_gpu_program4
#define GL_NV_gpu_program4 1
#define GL_MIN_PROGRAM_TEXEL_OFFSET_NV 0x8904
diff --git a/api/GL/wgl.h b/api/GL/wgl.h
index 46d1881..da62e1b 100644
--- a/api/GL/wgl.h
+++ b/api/GL/wgl.h
@@ -939,6 +939,16 @@
#endif
#endif /* WGL_OML_sync_control */
+#ifndef WGL_NV_multigpu_context
+#define WGL_NV_multigpu_context 1
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_NV 0x20AA
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_NONE_NV 0x0000
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV 0x20AB
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV 0x20AC
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV 0x20AD
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV 0x20AE
+#endif /* WGL_NV_multigpu_context */
+
#ifdef __cplusplus
}
#endif
diff --git a/api/GL/wglext.h b/api/GL/wglext.h
index 5c858df..2dc9b01 100755
--- a/api/GL/wglext.h
+++ b/api/GL/wglext.h
@@ -848,6 +848,16 @@
#endif
#endif /* WGL_OML_sync_control */
+#ifndef WGL_NV_multigpu_context
+#define WGL_NV_multigpu_context 1
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_NV 0x20AA
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_NONE_NV 0x0000
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV 0x20AB
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV 0x20AC
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV 0x20AD
+#define WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV 0x20AE
+#endif /* WGL_NV_multigpu_context */
+
#ifdef __cplusplus
}
#endif
diff --git a/extensions/NV/WGL_NV_multigpu_context.txt b/extensions/NV/WGL_NV_multigpu_context.txt
new file mode 100644
index 0000000..c150206
--- /dev/null
+++ b/extensions/NV/WGL_NV_multigpu_context.txt
@@ -0,0 +1,146 @@
+Name
+
+ NV_multigpu_context
+
+Name Strings
+
+ WGL_NV_multigpu_context
+
+Contact
+
+ Ralf Biermann (rbiermann 'at' nvidia.com)
+
+Contributors
+
+ Joshua Schnarr, NVIDIA
+ Ingo Esser, NVIDIA
+ Robert Menzel, NVIDIA
+
+Notice
+
+ Copyright (c) 2019 NVIDIA
+
+Status
+
+ Complete.
+
+Version
+
+ Last Modified Date: 2019-05-29
+ Author Revision: 4
+
+Number
+
+ OpenGL Extension #542
+
+Dependencies
+
+ WGL_NV_multigpu_context is written against the
+ WGL_ARB_create_context specification, which is required.
+
+ This extension interacts with NV_gpu_multicast.
+ This extension interacts with WGL_ARB_make_current_read.
+
+Overview
+
+ This extension allows the creation of an OpenGL context in a multi-GPU
+ environment with a specified multi-GPU strategy (known as SLI mode) which
+ takes precedence over process-wide multi-GPU mode settings.
+
+ The multi-GPU mode denotes vendor specific techniques to allow distributed
+ rendering on multiple GPUs, further called AFR (alternate frame rendering)
+ and Multicast (as defined in NV_gpu_multicast).
+
+ OpenGL supports multiple contexts. The semantics of switching contexts
+ is generally left to window system binding APIs such as WGL, GLX and EGL.
+ The extension WGL_NV_multigpu_context allows to specify a preferred
+ multi-GPU rendering mode per context, thus context switching can also
+ switch the current multi-GPU rendering mode.
+
+ The implementation is platform dependent and the actual multi-GPU rendering
+ mode of the created context may vary on different hardware and operation
+ system platforms.
+
+New Procedures and Functions
+
+ None
+
+New Tokens (WGL)
+
+ Accepted as an attribute name in the <*attrib_list> argument to
+ wglCreateContextAttribsARB:
+
+ WGL_CONTEXT_MULTIGPU_ATTRIB_NV 0x20AA
+
+ Accepted as an attribute value for WGL_CONTEXT_MULTIGPU_ATTRIB_NV in
+ the <*attrib_list> argument to wglCreateContextAttribsARB:
+
+ WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV 0x20AB
+ WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV 0x20AC
+ WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV 0x20AD
+ WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV 0x20AE
+
+Additions to WGL_ARB_create_context and WGL_ARB_make_current_read
+
+ Add a new paragraph to the description of wglCreateContextAttribsARB, as
+ defined by WGL_ARB_create_context:
+
+ "The attribute name WGL_CONTEXT_MULTIGPU_ATTRIB_NV indicates the
+ preferred multi-GPU rendering mode for the OpenGL context.
+ This specified mode precedes other selected configuration settings."
+
+ Add a new paragraph to the description of wglMakeCurrent and
+ wglMakeContextCurrentARB:
+
+ "With OpenGL on Windows, a thread can only have one current rendering context
+ and a device context can only be used by a single thread at a time.
+ Violating this by using the same device context with multiple rendering
+ contexts does not normally return an error, but can lead to undefined and
+ undesirable behavior.
+ When multigpu context attributes are used, however, wglMakeCurrent and
+ wglMakeContextCurrentARB will return FALSE and set ERROR_INVALID_OPERATION
+ if a HDC passed to the function is already current with a rendering context
+ using an alternate multigpu attribute."
+
+GLX Protocol
+
+ None.
+
+Errors for WGL
+
+ A GL error ERROR_INVALID_PARAMETER is generated when a value for
+ WGL_CONTEXT_MULTIGPU_ATTRIB_NV passed into a wglCreateContextAttribsARB
+ attribute list is not an accepted value.
+
+ A GL error ERROR_NOT_SUPPORTED is generated when an unsupported SLI rendering
+ mode value is passed as value of attribute WGL_CONTEXT_MULTIGPU_ATTRIB_NV in a
+ wglCreateContextAttribsARB attribute list.
+
+ A GL error ERROR_NOT_SUPPORTED is generated when passing a device context HDC
+ to wglMakeCurrent or wglMakeContextCurrentARB if the HDC is already current with
+ a rendering context using a multigpu attribute in a different thread.
+
+New State
+
+ None.
+
+Issues
+
+ 1. Is MULTICAST mode supported in a multi-display configuration where displays attached
+ to multiple GPUs are linked together in a desktop configuration spanning multiple GPUs?
+
+ RESOLVED: Not by default.
+
+ A dedicated attribute value WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV has to be
+ specified when a linked multi-GPU display configuration is considered for multicast rendering
+ by the application creating the context.
+
+
+Revision History
+
+ Rev. Date Author Changes
+ ---- ---------- -------- ---------------------------------------------
+ 1 2017-02-21 rbiermann Initial draft
+ 2 2018-09-17 rbiermann Updated attribute list and spec proposal
+ 3 2019-05-08 rbiermann Added multi-display multicast mode
+ 4 2019-05-29 rbiermann Added behavior of multithreaded wglMakeCurrent
\ No newline at end of file
diff --git a/extensions/NVX/NVX_gpu_multicast2.txt b/extensions/NVX/NVX_gpu_multicast2.txt
new file mode 100644
index 0000000..3e5ea98
--- /dev/null
+++ b/extensions/NVX/NVX_gpu_multicast2.txt
@@ -0,0 +1,244 @@
+Name
+
+ NVX_gpu_multicast2
+
+Name Strings
+
+ GL_NVX_gpu_multicast2
+
+Contact
+
+ Joshua Schnarr, NVIDIA Corporation (jschnarr 'at' nvidia.com)
+ Ingo Esser, NVIDIA Corporation (iesser 'at' nvidia.com)
+
+Contributors
+
+ Robert Menzel, NVIDIA
+ Ralf Biermann, NVIDIA
+
+Status
+
+ Complete.
+
+Version
+
+ Last Modified Date: July 19, 2019
+ Author Revision: 7
+
+Number
+
+ OpenGL Extension #540
+
+Dependencies
+
+ This extension is written against the OpenGL 4.6 specification
+ (Compatibility Profile), dated October 24, 2016.
+
+ This extension requires NV_gpu_multicast.
+
+ This extension requires EXT_device_group.
+
+ This extension requires NV_viewport_array.
+
+ This extension requires NV_clip_space_w_scaling.
+
+ This extension requires NVX_progress_fence.
+
+
+Overview
+
+ This extension provides additional mechanisms that influence multicast rendering which is
+ simultaneous rendering to multiple GPUs.
+
+New Procedures and Functions
+
+ uint AsyncCopyImageSubDataNVX(
+ sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *waitValueArray,
+ uint srcGpu, GLbitfield dstGpuMask,
+ uint srcName, GLenum srcTarget, int srcLevel, int srcX, int srcY, int srcZ,
+ uint dstName, GLenum dstTarget, int dstLevel, int dstX, int dstY, int dstZ,
+ sizei srcWidth, sizei srcHeight, sizei srcDepth,
+ sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray);
+
+ sync AsyncCopyBufferSubDataNVX(
+ sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *fenceValueArray,
+ uint readGpu, GLbitfield writeGpuMask,
+ uint readBuffer, uint writeBuffer,
+ GLintptr readOffset, GLintptr writeOffset, sizeiptr size,
+ sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray);
+
+ void UploadGpuMaskNVX(bitfield mask);
+
+ void MulticastViewportArrayvNVX(uint gpu, uint first, sizei count, const float *v);
+
+ void MulticastScissorArrayvNVX(uint gpu, uint first, sizei count, const int *v);
+
+ void MulticastViewportPositionWScaleNVX(uint gpu, uint index, float xcoeff, float ycoeff);
+
+
+New Tokens
+
+ Accepted by the <pname> parameter of GetIntegerv and GetInteger64v:
+
+ UPLOAD_GPU_MASK_NVX 0x954A
+
+Additions to Chapter 20 (Multicast Rendering) added to the OpenGL 4.5 (Compatibility Profile)
+Specification by NV_gpu_multicast
+
+ Additions to Section 20.1 (Controlling Individual GPUs)
+
+ Texture data uploads using the functions TexImage1D, TexImage2D, TexImage3D,
+ TexSubImage1D, TexSubImage2D and TexSubImage3D are restricted to a specific set of GPUs with
+
+ void UploadGpuMaskNVX(bitfield mask);
+
+ Buffer object data uploads using the functions BufferStorage, NamedBufferStorage,
+ BufferSubData and NamedBufferSubData are restricted to a specific set of GPUs with
+
+ void UploadGpuMaskNVX(bitfield mask);
+
+ The following errors apply to UploadGpuMaskNVX:
+
+ INVALID_VALUE is generated
+ * if <mask> is zero,
+ * if <mask> is not zero and <mask> is greater than or equal to 2^n, where n is equal
+ to MULTICAST_GPUS_NV
+
+ If the command does not generate an error, UPLOAD_GPU_MASK_NVX is set to <mask>. The default
+ value of UPLOAD_GPU_MASK_NVX is (2^n)-1.
+
+ Modify Section 20.2 (Multi-GPU Buffer Storage)
+
+ Append the following paragraphs:
+
+ To initiate a copy of buffer data without waiting for it to complete, use the following command:
+
+ void AsyncCopyBufferSubDataNVX(
+ sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *fenceValueArray,
+ uint readGpu, GLbitfield writeGpuMask,
+ uint readBuffer, uint writeBuffer,
+ GLintptr readOffset, GLintptr writeOffset, sizeiptr size,
+ sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray);
+
+ This command behaves equivalently to MulticastCopyBufferSubDataNV, except that it may be
+ performed concurrently with commands submitted in the future.
+ Fence semaphore objects created with CreateProgressFenceNVX are used for synchronization of one or
+ multiple copies.
+ An array of <waitSemaphoreCount> synchronization objects can be specified in the <waitSemaphoresArray>
+ parameter as a pointer to the array of semaphore objects.
+ The copy will wait for all fence semaphores in the <waitSemaphoreArray> array to be reach or exceed
+ their corresponding fence value in <fenceValueArray> before starting the transfer.
+ A signal operation for each of the <signalSemaphoreCount> semaphores in <signalSemaphoresArray> is written
+ after the copy with the corresponding fence value in <signalValueArray>.
+ To wait for the copy to complete, use WaitSemaphoreui64NVX or ClientWaitSemaphoreui64NVX to wait
+ for the semaphores in <signalSemaphoreArray> to be signalled with the fence values in <signalValueArray>.
+
+ Modify Section 20.3.1 (Copying Image Data Between GPUs)
+
+ Insert the following paragraphs above the line starting "To copy pixel values":
+
+ To initiate a copy of texel data without waiting for it to complete, use the following command:
+
+ void AsyncCopyImageSubDataNVX(
+ sizei waitSemaphoreCount, const uint *waitSemaphoreArray, const uint64 *waitValueArray,
+ uint srcGpu, GLbitfield dstGpuMask,
+ uint srcName, GLenum srcTarget, int srcLevel, int srcX, int srcY, int srcZ,
+ uint dstName, GLenum dstTarget, int dstLevel, int dstX, int dstY, int dstZ,
+ sizei srcWidth, sizei srcHeight, sizei srcDepth,
+ sizei signalSemaphoreCount, const uint *signalSemaphoreArray, const uint64 *signalValueArray);
+
+ This command behaves equivalently to MulticastCopyImageSubDataNV, except that it may be
+ performed concurrently with commands submitted in the future.
+ Fence semaphore objects created with CreateProgressFenceNVX are used for synchronization of one or
+ multiple copies. An array of <waitSemaphoreCount> synchronization objects can be specified in the
+ <waitSemaphoreArray> parameter as a pointer to the array of semaphore objects.
+ The copy will wait for all fence semaphores in the <waitSemaphoresArray> array to be reach or exceed
+ their corresponding fence value in <fenceValueArray> before starting the transfer.
+ A signal operation for each of the <signalSemaphoreCount> semaphores in <signalSemaphoreArray> is written
+ after the copy with the corresponding fence value in <signalValueArray>.
+ To wait for the copy to complete, use WaitSemaphoreui64NVX or ClientWaitSemaphoreui64NVX to wait
+ for the semaphores in <signalSemaphoresArray> to be signalled with the fence values in <signalValueArray>.
+
+Additions to Chapter 13 (Fixed-Function Vertex Post-Processing) added to the OpenGL 4.5 (Compatibility Profile)
+
+ Modify Section 13.6 (Coordinate transformations)
+
+ Viewport transformation parameters for multiple viewports are specified using
+
+ MulticastViewportArrayvNVX(uint gpu, uint first, sizei count, const float * v);
+
+ where the array of viewport parameters can be controlled for each multicast GPU, respectively.
+
+ A set of scissor rectangles that are each applied to the corresponding viewport is specified
+ using
+
+ MulticastScissorArrayvNVX(uint gpu, uint first, sizei count, const int *v);
+
+ where the rectangle parameters can be controlled for each multicast GPU, respectively.
+
+
+ If VIEWPORT_POSITION_W_SCALE_NV is enabled, the w coordinates for each
+ primitive sent to a given viewport will be scaled as a function of
+ its x and y coordinates using the following equation:
+
+ w' = xcoeff * x + ycoeff * y + w;
+
+ The coefficients for "x" and "y" used in the above equation depend on the
+ viewport index and can be controlled for each multicast GPU, respectively, by the command
+
+ MulticastViewportPositionWScaleNVX(uint gpu, uint index, float xcoeff, float ycoeff);
+
+ An error INVALID_VALUE error is generated if <gpu> is greater than or equal to MULTICAST_GPUS_NV.
+
+Additions to the OpenGL Shading Language Specification, Version 4.50
+
+ Including the following line in a shader can be used to enumerate multicast GPUs
+ by using the shader built-in variable gl_DeviceIndex:
+
+ #extension GL_EXT_device_group : enable
+
+ Each multicast GPU contains a unique device index in the gl_DeviceIndex variable.
+
+Errors
+
+ Relaxation of INVALID_ENUM errors
+ ---------------------------------
+ GetIntegerv and GetInteger64v now accept new tokens as
+ described in the "New Tokens" section.
+
+New State
+
+ Additions to Table 23.6 Buffer Object State
+ Initial
+ Get Value Type Get Command Value Description Sec. Attribute
+ -------------------------- ------ ----------- ----- ----------------------- ---- ---------
+ UPLOAD_GPU_MASK_NVX Z+ GetIntegerv * Mask of GPUs that 6.2 -
+ restricts buffer data
+ writes
+ * See section 6.2
+
+
+New Implementation Dependent State
+
+ None.
+
+Sample Code
+
+ None.
+
+Issues
+
+ None.
+
+Revision History
+
+ Rev. Date Author Changes
+ ---- -------- -------- -----------------------------------------------
+ 1 09/20/17 jschnarr initial draft
+ 2 02/23/18 rbiermann updated draft with new functions
+ 3 05/23/18 rbiermann updated draft with new ViewportArray and AsyncCopy functions
+ 4 06/08/18 rbiermann added NVX_progress_fence for synchronization objects
+ 5 08/15/18 rbiermann updated draft with gl_deviceIndex
+ 6 04/16/19 rbiermann updated draft with UploadGpuMaskNVX
+ 7 07/19/19 rbiermann updated draft with modifications of UploadGpuMaskNVX section
+
diff --git a/extensions/NVX/NVX_progress_fence.txt b/extensions/NVX/NVX_progress_fence.txt
new file mode 100644
index 0000000..3721ed9
--- /dev/null
+++ b/extensions/NVX/NVX_progress_fence.txt
@@ -0,0 +1,182 @@
+Name
+
+ NVX_progress_fence
+
+Name Strings
+
+ GL_NVX_progress_fence
+
+Contributors
+
+ Ingo Esser, NVIDIA
+ Joshua Schnarr, NVIDIA
+ Ralf Biermann, NVIDIA
+
+Contact
+
+ Ralf Biermann, NVIDIA corporation (rbiermann'at' nvidia.com)
+
+Status
+
+ Complete.
+
+Version
+
+ Last Modified Date: August 15, 2018
+ Author Revision: 2
+
+Number
+
+ OpenGL Extension #541
+
+Dependencies
+
+ This extension is written against the OpenGL 4.5 and OpenGL ES 3.2 specifications.
+
+ This extension requires EXT_external_objects.
+
+ This extension requires EXT_external_objects_win32
+
+ This extension interacts with NV_gpu_multicast.
+
+Overview
+
+ This extension uses the concept of GL semaphores as defined in
+ GL_EXT_semaphore to better coordinate operations between multiple
+ GPU command streams. A semaphore type called "progress fence" is
+ derived from the GL semaphore. The progress fence semaphore is
+ created by CreateProgressFenceNVX() returning the name of a newly
+ created semaphore object. Like other semaphores, these are signaled
+ by the GL server. Each signal operation is queued in the GPU command
+ stream with an associated fence value that is written to the semaphore
+ at the completion of a signal operation.
+
+ A GL server wait can be added to the command stream using WaitSemaphoreui64NVX.
+ This blocks the GPU until the progress fence semaphore reaches or exceeds the
+ specified fence value.
+
+ A GL client wait can be initiated using ClientWaitSemaphoreui64NVX.
+ This blocks the CPU until the specified fence value is reached.
+
+New Procedures and Functions
+
+ uint CreateProgressFenceNVX();
+
+ void SignalSemaphoreui64NVX(uint signalGpu,
+ sizei fenceObjectCount,
+ const uint *semaphoreArray,
+ const uint64 *fenceValueArray);
+
+ void WaitSemaphoreui64NVX(uint waitGpu,
+ sizei fenceObjectCount,
+ const uint *semaphoreArray,
+ const uint64 *fenceValueArray);
+
+ void ClientWaitSemaphoreui64NVX(sizei fenceObjectCount,
+ const uint *semaphoreArray,
+ const uint64 *fenceValueArray);
+
+New Types
+
+ None
+
+New Tokens
+
+ None
+
+Additions to Chapter 4 of the OpenGL 4.5 Specification (Event Model)
+
+ Addition to Section 4.2, "Semaphore Objects
+
+
+ A command
+
+ uint CreateProgressFenceNVX();
+
+ creates a named progress fence semaphore object.
+
+ A set of progress fence objects can be deleted by passing the names in the
+ array <semaphores> to the command
+
+ void DeleteSemaphoresEXT(sizei n, const uint *semaphores);
+
+ Progress fence operations can be performed on named semaphore objects. The
+ command
+
+ void SignalSemaphoreui64NVX(uint signalGpu,
+ sizei fenceObjectCount,
+ const uint *semaphoreArray,
+ const uint64 *fenceValueArray);
+
+ SignalSemaphoreui64NVX inserts a signal operation for each of the <fenceObjectCount>
+ semaphores in <semaphoreArray>. Each signal writes the corresponding fence value in
+ <fenceValueArray>.
+
+ If the GL context uses NV_gpu_multicast to control multiple GPUs, the
+ <signalGpu> parameter is required to specify the GPU that signals the
+ fence value to the fence object. Otherwise <signalGpu> must be 0.
+
+ If a value in <semaphoreArray> is not the name of a semaphore object,
+ an INVALID_VALUE error is generated.
+
+ If NV_gpu_multicast is supported, an INVALID_VALUE error is generated if <signalGpu>
+ is greater than or equal to MULTICAST_GPUS_NV. Otherwise, an INVALID_VALUE error is
+ generated if <signalGpu> != 0.
+
+ The command
+
+ void WaitSemaphoreui64NVX(uint waitGpu,
+ sizei fenceObjectCount,
+ const uint *semaphoreArray,
+ const uint64 *fenceValueArray);
+
+ inserts a wait command into the GL server command stream of a specified GPU <waitGpu>
+ for each of the <fenceObjectCount> progress fence objects in <semaphoreArray> which
+ blocks <waitGpu> until all fence objects reach or exceed the associated fence value
+ in <fenceValueArray>.
+
+ If a value in <semaphoreArray> is not the name of a semaphore object,
+ an INVALID_VALUE error is generated.
+
+ The command
+
+ void ClientWaitSemaphoreui64NVX(sizei fenceObjectCount,
+ const uint *semaphoreArray,
+ const uint64 *fenceValueArray);
+
+ blocks the CPU until each of the <fenceObjectCount> fence objects in a
+ specified array <semaphoreArray> reaches the corresponding fence value
+ in <fenceValueArray>, respectively.
+
+ If a value in <semaphoreArray> is not the name of a semaphore object,
+ an INVALID_VALUE error is generated.
+
+ The commands SignalSemaphoreui64NVX, WaitSemaphoreui64NVX and
+ ClientWaitSemaphoreui64NVX accept semaphore object names as input in
+ <semaphoreArray> that were created by CreateProgressFenceNVX or imported
+ from a handle of the type HANDLE_TYPE_D3D12_FENCE_EXT.
+ If a value in <semaphoreArray> is not the name of such a semaphore object,
+ an INVALID_VALUE error is generated.
+
+ The command
+
+ boolean IsSemaphoreEXT(uint semaphore);
+
+ can be used with progress fence semaphores and returns TRUE if <semaphore>
+ is the name of a semaphore as defined in EXT_external_objects.
+
+Issues
+
+ 1) Are Vulkan semaphores imported via the GL_EXT_memory_object_win32 supported
+ by GL_NVX_progress_fence as input parameters?
+
+ RESOLVED: No. As Vulkan semaphores currently do not support progress fence
+ operation, these are not compatible with progress fence semaphores.
+
+Revision History
+
+ Revision 1, 2018-08-14 (Ralf Biermann)
+ - Initial specification proposal.
+
+ Revision 2, 2018-08-15 (Ralf Biermann)
+ - Adding Vulkan semaphore limitation to Issues.
diff --git a/extensions/glext.php b/extensions/glext.php
index 2fa2314..5f8b8ae 100644
--- a/extensions/glext.php
+++ b/extensions/glext.php
@@ -1017,4 +1017,10 @@
</li>
<li value=539><a href="extensions/EXT/EXT_texture_shadow_lod.txt">GL_EXT_texture_shadow_lod</a>
</li>
+<li value=540><a href="extensions/NVX/NVX_gpu_multicast2.txt">GL_NVX_gpu_multicast2</a>
+</li>
+<li value=541><a href="extensions/NVX/NVX_progress_fence.txt">GL_NVX_progress_fence</a>
+</li>
+<li value=542><a href="extensions/NV/WGL_NV_multigpu_context.txt">WGL_NV_multigpu_context</a>
+</li>
</ol>
diff --git a/extensions/registry.py b/extensions/registry.py
index 1240db3..be6bb9e 100644
--- a/extensions/registry.py
+++ b/extensions/registry.py
@@ -3421,6 +3421,18 @@
'supporters' : { 'NVIDIA' },
'url' : 'extensions/NV/NV_gpu_multicast.txt',
},
+ 'GL_NVX_gpu_multicast2' : {
+ 'number' : 540,
+ 'flags' : { 'public' },
+ 'supporters' : { 'NVIDIA' },
+ 'url' : 'extensions/NVX/NVX_gpu_multicast2.txt',
+ },
+ 'GL_NVX_progress_fence' : {
+ 'number' : 541,
+ 'flags' : { 'public' },
+ 'supporters' : { 'NVIDIA' },
+ 'url' : 'extensions/NVX/NVX_progress_fence.txt',
+ },
'GL_NV_gpu_program4' : {
'number' : 322,
'flags' : { 'public' },
@@ -5513,4 +5525,10 @@
'supporters' : { 'KHR' },
'url' : 'extensions/OML/WGL_OML_sync_control.txt',
},
+ 'WGL_NV_multigpu_context' : {
+ 'number' : 542,
+ 'flags' : { 'public' },
+ 'supporters' : { 'NVIDIA' },
+ 'url' : 'extensions/NV/WGL_NV_multigpu_context.txt',
+ },
}
diff --git a/xml/gl.xml b/xml/gl.xml
index 463cdfe..7052565 100644
--- a/xml/gl.xml
+++ b/xml/gl.xml
@@ -47793,6 +47793,25 @@
<command name="glMulticastGetQueryObjectui64vNV"/>
</require>
</extension>
+ <extension name="GL_NVX_gpu_multicast2" supported="gl">
+ <require>
+ <enum name="GL_UPLOAD_GPU_MASK_NV"/>
+ <command name="glUploadGpuMaskNVX"/>
+ <command name="glMulticastViewportArrayvNVX"/>
+ <command name="glMulticastViewportPositionWScaleNVX"/>
+ <command name="glMulticastScissorArrayvNVX"/>
+ <command name="glAsyncCopyBufferSubDataNVX"/>
+ <command name="glAsyncCopyImageSubDataNVX"/>
+ </require>
+ </extension>
+ <extension name="GL_NVX_progress_fence" supported="gl">
+ <require>
+ <command name="glCreateProgressFenceNVX"/>
+ <command name="glSignalSemaphoreui64NVX"/>
+ <command name="glWaitSemaphoreui64NVX"/>
+ <command name="glClientWaitSemaphoreui64NVX"/>
+ </require>
+ </extension>
<extension name="GL_NV_memory_attachment" supported="gl|glcore|gles2">
<require>
<enum name="GL_ATTACHED_MEMORY_OBJECT_NV"/>
diff --git a/xml/reg.pyc b/xml/reg.pyc
new file mode 100644
index 0000000..66073ec
--- /dev/null
+++ b/xml/reg.pyc
Binary files differ
diff --git a/xml/wgl.xml b/xml/wgl.xml
index c3b3630..ab018e4 100644
--- a/xml/wgl.xml
+++ b/xml/wgl.xml
@@ -1985,5 +1985,14 @@
<command name="wglWaitForSbcOML"/>
</require>
</extension>
+ <extension name="WGL_NV_multigpu_context" supported="wgl">
+ <require>
+ <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_NV"/>
+ <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_SINGLE_NV"/>
+ <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_AFR_NV"/>
+ <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_MULTICAST_NV"/>
+ <enum name="WGL_CONTEXT_MULTIGPU_ATTRIB_MULTI_DISPLAY_MULTICAST_NV"/>
+ </require>
+ </extension>
</extensions>
</registry>
