docs/specs/MESA_multithread_makecurrent.spec

   1 Name
   2
   3     MESA_multithread_makecurrent
   4
   5 Name Strings
   6
   7     GLX_MESA_multithread_makecurrent
   8
   9 Contact
  10
  11     Eric Anholt (eric@anholt.net)
  12
  13 Status
  14
  15     Not shipping.
  16
  17 Version
  18
  19     Last Modified Date:  21 February 2011
  20
  21 Number
  22
  23     TBD
  24
  25 Dependencies
  26
  27     OpenGL 1.0 or later is required.
  28     GLX 1.3 or later is required.
  29
  30 Overview
  31
  32     The GLX context setup encourages multithreaded applications to
  33     create a context per thread which each operate on their own
  34     objects in parallel, and leaves synchronization for write access
  35     to shared objects up to the application.
  36
  37     For some applications, maintaining per-thread contexts and
  38     ensuring that the glFlush happens in one thread before another
  39     thread starts working on that object is difficult.  For them,
  40     using the same context across multiple threads and protecting its
  41     usage with a mutex is both higher performance and easier to
  42     implement.  This extension gives those applications that option by
  43     relaxing the context binding requirements.
  44
  45     This new behavior matches the requirements of AGL, while providing
  46     a feature not specified in WGL.
  47
  48 IP Status
  49
  50     Open-source; freely implementable.
  51
  52 Issues
  53
  54     None.
  55
  56 New Procedures and Functions
  57
  58     None.
  59
  60 New Tokens
  61
  62     None.
  63
  64 Changes to Chapter 2 of the GLX 1.3 Specification (Functions and Errors)
  65
  66     Replace the following sentence from section 2.2 Rendering Contexts:
  67         In addition, a rendering context can be current for only one
  68         thread at a time.
  69     with:
  70         In addition, an indirect rendering context can be current for
  71         only one thread at a time.  A direct rendering context may be
  72         current to multiple threads, with synchronization of access to
  73         the context thruogh the GL managed by the application through
  74         mutexes.
  75
  76 Changes to Chapter 3 of the GLX 1.3 Specification (Functions and Errors)
  77
  78     Replace the following sentence from section 3.3.7 Rendering Contexts:
  79         If ctx is current to some other thread, then
  80         glXMakeContextCurrent will generate a BadAccess error.
  81     with:
  82         If ctx is an indirect context current to some other thread,
  83         then glXMakeContextCurrent will generate a BadAccess error.
  84
  85     Replace the following sentence from section 3.5 Rendering Contexts:
  86         If ctx is current to some other thread, then
  87         glXMakeCurrent will generate a BadAccess error.
  88     with:
  89         If ctx is an indirect context current to some other thread,
  90         then glXMakeCurrent will generate a BadAccess error.
  91
  92 GLX Protocol
  93
  94     None.  The GLX extension only extends to direct rendering contexts.
  95
  96 Errors
  97
  98     None.
  99
 100 New State
 101
 102     None.
 103
 104 Issues
 105
 106     (1) What happens if the app binds a context/drawable in multiple
 107         threads, then binds a different context/thread in one of them?
 108
 109     As with binding a new context from the current thread, the old
 110     context's refcount is reduced and the new context's refcount is
 111     increased.
 112
 113     (2) What happens if the app binds a context/drawable in multiple
 114         threads, then binds None/None in one of them?
 115
 116     The GLX context is unreferenced from that thread, and the other
 117     threads retain their GLX context binding.
 118
 119     (3) What happens if the app binds a context/drawable in 7 threads,
 120         then destroys the context in one of them?
 121
 122     As with GLX context destruction previously, the XID is destroyed
 123     but the context remains usable by threads that have the context
 124     current.
 125
 126     (4) What happens if the app binds a new drawable/readable with
 127         glXMakeCurrent() when it is already bound to another thread?
 128
 129     The context becomes bound to the new drawable/readable, and
 130     further rendering in either thread will use the new
 131     drawable/readable.
 132
 133     (5) What requirements should be placed on the user managing contexts
 134         from multiple threads?
 135
 136     The intention is to allow multithreaded access to the GL at the
 137     minimal performance cost, so requiring that the GL do general
 138     synchronization (beyond that already required by context sharing)
 139     is not an option, and synchronizing of GL's access to the GL
 140     context between multiple threads is left to the application to do
 141     across GL calls.  However, it would be unfortunate for a library
 142     doing multithread_makecurrent to require that other libraries
 143     share in synchronization for binding of their own contexts, so the
 144     refcounting of the contexts is required to be threadsafe.
 145
 146     (6) Does this apply to indirect contexts?
 147
 148     This was ignored in the initial revision of the spec.  Behavior
 149     for indirect contexts is left as-is.
 150
 151 Revision History
 152
 153     20 November 2009 Eric Anholt - initial specification
 154     22 November 2009 Eric Anholt - added issues from Ian Romanick.
 155     3 February 2011 Eric Anholt - updated with resolution to issues 1-3
 156     3 February 2011 Eric Anholt - added issue 4, 5
 157     21 February 2011 Eric Anholt - Include glXMakeCurrent() sentence
 158     along with glXMakeContextCurrent() for removal.