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. 159
