Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/blend_minmax_factor.py

@@ -0,0 +1,37 @@
+'''OpenGL extension AMD.blend_minmax_factor
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.blend_minmax_factor to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The EXT_blend_minmax extension extended the GL's blending functionality
+	to allow the blending equation to be specified by the application. That
+	extension introduced the MIN_EXT and MAX_EXT blend equations, which caused the
+	result of the blend equation to become the minimum or maximum of the source
+	color and destination color, respectively.
+	
+	The MIN_EXT and MAX_EXT blend equations, however, do not include the source
+	or destination blend factors in the arguments to the min and max functions.
+	This extension provides two new blend equations that produce the minimum
+	or maximum of the products of the source color and source factor, and the
+	destination color and destination factor.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/blend_minmax_factor.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.blend_minmax_factor import *
+from OpenGL.raw.GL.AMD.blend_minmax_factor import _EXTENSION_NAME
+
+def glInitBlendMinmaxFactorAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/conservative_depth.py

@@ -0,0 +1,39 @@
+'''OpenGL extension AMD.conservative_depth
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.conservative_depth to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	There is a common optimization for hardware accelerated implementation of
+	OpenGL which relies on an early depth test to be run before the fragment
+	shader so that the shader evaluation can be skipped if the fragment ends
+	up being discarded because it is occluded.
+	
+	This optimization does not affect the final rendering, and is typically
+	possible when the fragment does not change the depth programmatically.
+	(i.e.: it does not write to the built-in gl_FragDepth output). There are,
+	however a class of operations on the depth in the shader which could
+	still be performed while allowing the early depth test to operate.
+	
+	This extension allows the application to pass enough information to the
+	GL implementation to activate such optimizations safely.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/conservative_depth.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.conservative_depth import *
+from OpenGL.raw.GL.AMD.conservative_depth import _EXTENSION_NAME
+
+def glInitConservativeDepthAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/debug_output.py

@@ -0,0 +1,88 @@
+'''OpenGL extension AMD.debug_output
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.debug_output to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension allows the GL to notify applications when various
+	debug events occur in contexts that have been created with the debug
+	flag, as provided by WGL_ARB_create_context and GLX_ARB_create_context.
+	
+	These events are represented in the form of enumerable messages with an
+	included human-readable translation.  Examples of debug events include
+	incorrect use of the GL, warnings of undefined behavior, and performance
+	warnings.
+	
+	A message is uniquely identified by a category and an implementation-
+	dependent ID within that category.  Message categories are general and are
+	used to organize large groups of similar messages together.  Examples of
+	categories include GL errors, performance warnings, and deprecated
+	functionality warnings.  Each message is also assigned a severity level
+	that denotes roughly how "important" that message is in comparison to
+	other messages across all categories.  For example, notification of a GL
+	error would have a higher severity than a performance warning due to
+	redundant state changes.
+	
+	Messages are communicated to the application through an application-defined
+	callback function that is called by the GL implementation on each debug
+	message.  The motivation for the callback routine is to free application
+	developers from actively having to query whether any GL error or other
+	debuggable event has happened after each call to a GL function.  With a
+	callback, developers can keep their code free of debug checks, and only have
+	to react to messages as they occur.  In order to support indirect rendering,
+	a message log is also provided that stores copies of recent messages until
+	they are actively queried.
+	
+	To control the volume of debug output, messages can be disabled either
+	individually by ID, or entire groups of messages can be turned off based
+	on category or severity.
+	
+	The only requirement on the minimum quantity and type of messages that
+	implementations of this extension must support is that a message must be
+	sent notifying the application whenever any GL error occurs.  Any further
+	messages are left to the implementation.  Implementations do not have
+	to output messages from all categories listed by this extension
+	in order to support this extension, and new categories can be added by
+	other extensions.
+	
+	This extension places no restrictions or requirements on any additional
+	functionality provided by the debug context flag through other extensions. 
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/debug_output.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.debug_output import *
+from OpenGL.raw.GL.AMD.debug_output import _EXTENSION_NAME
+
+def glInitDebugOutputAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glDebugMessageEnableAMD.ids size not checked against count
+glDebugMessageEnableAMD=wrapper.wrapper(glDebugMessageEnableAMD).setInputArraySize(
+    'ids', None
+)
+# INPUT glDebugMessageInsertAMD.buf size not checked against length
+glDebugMessageInsertAMD=wrapper.wrapper(glDebugMessageInsertAMD).setInputArraySize(
+    'buf', None
+)
+# glDebugMessageCallbackAMD.userParam is OUTPUT without known output size
+glGetDebugMessageLogAMD=wrapper.wrapper(glGetDebugMessageLogAMD).setOutput(
+    'lengths',size=lambda x:(x,),pnameArg='count',orPassIn=True
+).setOutput(
+    'message',size=lambda x:(x,),pnameArg='bufsize',orPassIn=True
+).setOutput(
+    'ids',size=lambda x:(x,),pnameArg='count',orPassIn=True
+).setOutput(
+    'categories',size=lambda x:(x,),pnameArg='count',orPassIn=True
+).setOutput(
+    'severities',size=lambda x:(x,),pnameArg='count',orPassIn=True
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/depth_clamp_separate.py

@@ -0,0 +1,34 @@
+'''OpenGL extension AMD.depth_clamp_separate
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.depth_clamp_separate to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The extension ARB_depth_clamp introduced the ability to control
+	the clamping of the depth value for both the near and far plane.
+	One limitation is that the control was for both planes at the
+	same time; some applications can benefit from having clamping
+	enabled for only one of the two planes, in order to save
+	fillrate for the other plane by clipping the geometry.
+	
+	This extension provides exactly such functionality.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/depth_clamp_separate.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.depth_clamp_separate import *
+from OpenGL.raw.GL.AMD.depth_clamp_separate import _EXTENSION_NAME
+
+def glInitDepthClampSeparateAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/draw_buffers_blend.py

@@ -0,0 +1,34 @@
+'''OpenGL extension AMD.draw_buffers_blend
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.draw_buffers_blend to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension builds upon the ARB_draw_buffers and EXT_draw_buffers2
+	extensions. In ARB_draw_buffers (part of OpenGL 2.0), separate values
+	could be written to each color buffer.  This was further enhanced by
+	EXT_draw_buffers2 by adding in the ability to enable blending and to set
+	color write masks independently per color output.
+	
+	This extension provides the ability to set individual blend equations and
+	blend functions for each color output.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/draw_buffers_blend.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.draw_buffers_blend import *
+from OpenGL.raw.GL.AMD.draw_buffers_blend import _EXTENSION_NAME
+
+def glInitDrawBuffersBlendAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/gcn_shader.py

@@ -0,0 +1,23 @@
+'''OpenGL extension AMD.gcn_shader
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.gcn_shader to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/gcn_shader.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.gcn_shader import *
+from OpenGL.raw.GL.AMD.gcn_shader import _EXTENSION_NAME
+
+def glInitGcnShaderAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/gpu_shader_int64.py

@@ -0,0 +1,90 @@
+'''OpenGL extension AMD.gpu_shader_int64
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.gpu_shader_int64 to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/gpu_shader_int64.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.gpu_shader_int64 import *
+from OpenGL.raw.GL.AMD.gpu_shader_int64 import _EXTENSION_NAME
+
+def glInitGpuShaderInt64AMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+# INPUT glUniform1i64vNV.value size not checked against count
+glUniform1i64vNV=wrapper.wrapper(glUniform1i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform2i64vNV.value size not checked against None
+glUniform2i64vNV=wrapper.wrapper(glUniform2i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform3i64vNV.value size not checked against None
+glUniform3i64vNV=wrapper.wrapper(glUniform3i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform4i64vNV.value size not checked against None
+glUniform4i64vNV=wrapper.wrapper(glUniform4i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform1ui64vNV.value size not checked against count
+glUniform1ui64vNV=wrapper.wrapper(glUniform1ui64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform2ui64vNV.value size not checked against None
+glUniform2ui64vNV=wrapper.wrapper(glUniform2ui64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform3ui64vNV.value size not checked against None
+glUniform3ui64vNV=wrapper.wrapper(glUniform3ui64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glUniform4ui64vNV.value size not checked against None
+glUniform4ui64vNV=wrapper.wrapper(glUniform4ui64vNV).setInputArraySize(
+    'value', None
+)
+glGetUniformi64vNV=wrapper.wrapper(glGetUniformi64vNV).setOutput(
+    'params',size=_glgets._glget_size_mapping,pnameArg='location',orPassIn=True
+)
+# OUTPUT glGetUniformui64vNV.params COMPSIZE(program,location) 
+# INPUT glProgramUniform1i64vNV.value size not checked against count
+glProgramUniform1i64vNV=wrapper.wrapper(glProgramUniform1i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform2i64vNV.value size not checked against None
+glProgramUniform2i64vNV=wrapper.wrapper(glProgramUniform2i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform3i64vNV.value size not checked against None
+glProgramUniform3i64vNV=wrapper.wrapper(glProgramUniform3i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform4i64vNV.value size not checked against None
+glProgramUniform4i64vNV=wrapper.wrapper(glProgramUniform4i64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform1ui64vNV.value size not checked against count
+glProgramUniform1ui64vNV=wrapper.wrapper(glProgramUniform1ui64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform2ui64vNV.value size not checked against None
+glProgramUniform2ui64vNV=wrapper.wrapper(glProgramUniform2ui64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform3ui64vNV.value size not checked against None
+glProgramUniform3ui64vNV=wrapper.wrapper(glProgramUniform3ui64vNV).setInputArraySize(
+    'value', None
+)
+# INPUT glProgramUniform4ui64vNV.value size not checked against None
+glProgramUniform4ui64vNV=wrapper.wrapper(glProgramUniform4ui64vNV).setInputArraySize(
+    'value', None
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/interleaved_elements.py

@@ -0,0 +1,56 @@
+'''OpenGL extension AMD.interleaved_elements
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.interleaved_elements to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	    The glDrawElements function and its variants (instanced and indirect,
+	for example) allow OpenGL to draw indexed arrays of vertices. Since its
+	inception, OpenGL has supported unsigned bytes, unsigned shorts and
+	unsigned integers as index types. However, all enabled vertex arrays may
+	be represented by at most one shared index.
+	
+	    A common scenario in graphics rendering is that several faces share
+	a vertex where, for each face some properties of a vertex (position and
+	texture coordinates, for example) should be common but others must be
+	unique (colors, normals, and so on). Consider a mesh of a cube with
+	per-face normals, for example. There are 8 vertices and 6 normals, and 12
+	triangles (where each face of the cube is represented as two triangles).
+	To render this cube, we must compute the 24 unique permutations of
+	position and normal and build a new element list to index into it. In
+	fact, any advantage of indexed draw is lost here as the number of required
+	permutations is equal to the final vertex count required to draw the
+	object.
+	
+	    This extension allows OpenGL to process multi-component packed element
+	data. The maximum size of a vertex's index data is not increased, but the
+	facility to store 2 16-bit or 2 or 4 8-bit indices per vertex is introduced.
+	Each vertex attribute is given a swizzle property to allow its index to
+	be sourced from one of up to 4 channels of index data. This effectively
+	allows an application to supply multiple interleaved streams of index data
+	to OpenGL. Each vertex attribute is given a 'channel selector' to select
+	one of the up to 4 channels of vertex index information presented to
+	OpenGL. This enables the use-case described above and many more.
+	The swizzle parameter is also applied to vertex indices passed to shaders,
+	and updates to the definition of base vertex parameters and primitive
+	restart are applied.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/interleaved_elements.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.interleaved_elements import *
+from OpenGL.raw.GL.AMD.interleaved_elements import _EXTENSION_NAME
+
+def glInitInterleavedElementsAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/multi_draw_indirect.py

@@ -0,0 +1,37 @@
+'''OpenGL extension AMD.multi_draw_indirect
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.multi_draw_indirect to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	The ARB_draw_indirect extension (included in OpenGL 4.0) introduced
+	mechanisms whereby the parameters for a draw function may be provided in
+	a structure contained in a buffer object rather than as parameters to the
+	drawing procedure. This is known as an indirect draw and is exposed as two
+	new functions, glDrawArraysIndirect and glDrawElementsIndirect. Each of
+	these functions generates a single batch of primitives.
+	
+	This extension builds on this functionality by providing procedures to
+	invoke multiple draws from a single procedure call. This allows large
+	batches of drawing commands to be assembled in server memory (via a buffer
+	object) which may then be dispatched through a single function call.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/multi_draw_indirect.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.multi_draw_indirect import *
+from OpenGL.raw.GL.AMD.multi_draw_indirect import _EXTENSION_NAME
+
+def glInitMultiDrawIndirectAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/name_gen_delete.py

@@ -0,0 +1,52 @@
+'''OpenGL extension AMD.name_gen_delete
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.name_gen_delete to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension simply creates 2 new entry-points that name generic
+	creation and deletion of names.  The intent is to go away from API
+	functionality that provides a create/delete function for each specific 
+	object.  
+	
+	For example: 
+	    glGenTextures/glDeleteTextures/glIsTexture
+	    glGenBuffers/glDeleteBuffers/IsBuffer
+	    glGenFramebuffers/glDeleteFramebuffers/IsFramebuffer
+	
+	Instead, everything is created using one entry-point GenNamesAMD and
+	everything is now deleted with another entry-point DeleteNamesAMD with
+	the appropriate identifier set.  In addition, everything can now be 
+	queried with IsNameAMD.
+	
+	This alleviates the problem we may eventually encounter where we have
+	many Gen/Delete/Is functions where 3 might suffice.  All that is needed
+	in the new case is to add a valid identifier to the accepted parameters
+	list.
+	
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/name_gen_delete.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.name_gen_delete import *
+from OpenGL.raw.GL.AMD.name_gen_delete import _EXTENSION_NAME
+
+def glInitNameGenDeleteAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glGenNamesAMD=wrapper.wrapper(glGenNamesAMD).setOutput(
+    'names',size=lambda x:(x,),pnameArg='num',orPassIn=True
+)
+# INPUT glDeleteNamesAMD.names size not checked against num
+glDeleteNamesAMD=wrapper.wrapper(glDeleteNamesAMD).setInputArraySize(
+    'names', None
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/occlusion_query_event.py

@@ -0,0 +1,23 @@
+'''OpenGL extension AMD.occlusion_query_event
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.occlusion_query_event to provide a more 
+Python-friendly API
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/occlusion_query_event.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.occlusion_query_event import *
+from OpenGL.raw.GL.AMD.occlusion_query_event import _EXTENSION_NAME
+
+def glInitOcclusionQueryEventAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/performance_monitor.py

@@ -0,0 +1,71 @@
+'''OpenGL extension AMD.performance_monitor
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.performance_monitor to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension enables the capture and reporting of performance monitors.
+	Performance monitors contain groups of counters which hold arbitrary counted 
+	data.  Typically, the counters hold information on performance-related
+	counters in the underlying hardware.  The extension is general enough to
+	allow the implementation to choose which counters to expose and pick the
+	data type and range of the counters.  The extension also allows counting to 
+	start and end on arbitrary boundaries during rendering.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/performance_monitor.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.performance_monitor import *
+from OpenGL.raw.GL.AMD.performance_monitor import _EXTENSION_NAME
+
+def glInitPerformanceMonitorAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+glGetPerfMonitorGroupsAMD=wrapper.wrapper(glGetPerfMonitorGroupsAMD).setOutput(
+    'numGroups',size=(1,),orPassIn=True
+).setOutput(
+    'groups',size=lambda x:(x,),pnameArg='groupsSize',orPassIn=True
+)
+glGetPerfMonitorCountersAMD=wrapper.wrapper(glGetPerfMonitorCountersAMD).setOutput(
+    'numCounters',size=(1,),orPassIn=True
+).setOutput(
+    'maxActiveCounters',size=(1,),orPassIn=True
+).setOutput(
+    'counters',size=lambda x:(x,),pnameArg='counterSize',orPassIn=True
+)
+glGetPerfMonitorGroupStringAMD=wrapper.wrapper(glGetPerfMonitorGroupStringAMD).setOutput(
+    'groupString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True
+).setOutput(
+    'length',size=(1,),orPassIn=True
+)
+glGetPerfMonitorCounterStringAMD=wrapper.wrapper(glGetPerfMonitorCounterStringAMD).setOutput(
+    'length',size=(1,),orPassIn=True
+).setOutput(
+    'counterString',size=lambda x:(x,),pnameArg='bufSize',orPassIn=True
+)
+glGetPerfMonitorCounterInfoAMD=wrapper.wrapper(glGetPerfMonitorCounterInfoAMD).setOutput(
+    'data',size=_glgets._glget_size_mapping,pnameArg='pname',orPassIn=True
+)
+glGenPerfMonitorsAMD=wrapper.wrapper(glGenPerfMonitorsAMD).setOutput(
+    'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True
+)
+glDeletePerfMonitorsAMD=wrapper.wrapper(glDeletePerfMonitorsAMD).setOutput(
+    'monitors',size=lambda x:(x,),pnameArg='n',orPassIn=True
+)
+glSelectPerfMonitorCountersAMD=wrapper.wrapper(glSelectPerfMonitorCountersAMD).setOutput(
+    'counterList',size=lambda x:(x,),pnameArg='numCounters',orPassIn=True
+)
+glGetPerfMonitorCounterDataAMD=wrapper.wrapper(glGetPerfMonitorCounterDataAMD).setOutput(
+    'data',size=lambda x:(x,),pnameArg='dataSize',orPassIn=True
+).setOutput(
+    'bytesWritten',size=(1,),orPassIn=True
+)
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/pinned_memory.py

@@ -0,0 +1,35 @@
+'''OpenGL extension AMD.pinned_memory
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.pinned_memory to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	This extension defines an interface that allows improved control
+	of the physical memory used by the graphics device.
+	
+	It allows an existing page of system memory allocated by the application
+	to be used as memory directly accessible to the graphics processor. One
+	example application of this functionality would be to be able to avoid an
+	explicit synchronous copy with sub-system of the application; for instance
+	it is possible to directly draw from a system memory copy of a video
+	image.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/pinned_memory.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.pinned_memory import *
+from OpenGL.raw.GL.AMD.pinned_memory import _EXTENSION_NAME
+
+def glInitPinnedMemoryAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION

vllm/lib/python3.10/site-packages/OpenGL/GL/AMD/query_buffer_object.py

@@ -0,0 +1,48 @@
+'''OpenGL extension AMD.query_buffer_object
+
+This module customises the behaviour of the 
+OpenGL.raw.GL.AMD.query_buffer_object to provide a more 
+Python-friendly API
+
+Overview (from the spec)
+	
+	Statistics about the operation of the OpenGL pipeline, such as the number
+	of samples that passed the depth test, the elapsed time between two events
+	or the number of vertices written to a transform feedback buffer may
+	be retrieved from the GL through query objects. The current value of a
+	query object may be retrieved by the application through the OpenGL API.
+	Should the result returned by the API be required for use in a shader,
+	it must be passed back to the GL via a program uniform or some other
+	mechanism. This requires a round-trip from the GPU to the CPU and back.
+	
+	This extension introduces a mechanism whereby the current value of a query
+	result may be retrieved into a buffer object instead of client memory.
+	This allows the query result to be made available to a shader without a
+	round-trip to the CPU for example by subsequently using the buffer object
+	as a uniform buffer, texture buffer or other data store visible to the
+	shader. This functionality may also be used to place the results of
+	many query objects into a single, large buffer and then map or otherwise
+	read back the entire buffer at a later point in time, avoiding a per-query
+	CPU-GPU synchronization event.
+	
+	The result of any query object type supported by the GL implementation
+	may be retrieved into a buffer object. The implementation will determine
+	the most efficient method of copying the query result to the buffer.
+
+The official definition of this extension is available here:
+http://www.opengl.org/registry/specs/AMD/query_buffer_object.txt
+'''
+from OpenGL import platform, constant, arrays
+from OpenGL import extensions, wrapper
+import ctypes
+from OpenGL.raw.GL import _types, _glgets
+from OpenGL.raw.GL.AMD.query_buffer_object import *
+from OpenGL.raw.GL.AMD.query_buffer_object import _EXTENSION_NAME
+
+def glInitQueryBufferObjectAMD():
+    '''Return boolean indicating whether this extension is available'''
+    from OpenGL import extensions
+    return extensions.hasGLExtension( _EXTENSION_NAME )
+
+
+### END AUTOGENERATED SECTION