aboutsummaryrefslogtreecommitdiffstats
path: root/doc/Implementation/MultiThreading.txt
blob: 272204d94dcae3a2ae137eeb6d2f5418ded4cf52 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

Don't miss 
    Current 'violations' of synchronization/memory-barriers
    using explicit locking:
below ..

Locking
=========

Interface AbstractGraphicsDevice: lock() / unlock()

    - Used to exclusively lock the device
    - Current implementations: 
        - X11GraphicsDevice: XLockDisplay/XUnlockDisplay

    - Shall only be used, where race conditions may happen with
      device toolkit calls in regards to windowing resources,
      ie create/destroy .. etc

    - We call XInitThreads ASAP and a global X11 lock 
      is not necessary.

    - To ensure XInitThreads can be issued at first,
      GLProfile.initSingleton() shall be called
      in the static initializer block of the main class.

      TODO: 
      However, we have to investigate how to incooperate this
      with Applet loading.
      If such call ain't possible, a workaround could be to not
      call XInitThreads() and utilize AWT locks.

Interface NativeWindow: lockSurface() / unlockSurface()

    - Used to exclusively lock the surface

    - Implementations: 

        - JAWTWindow:
            - Recursive Lock
            - JAWT SurfaceLock

        - NEWT Window:
            - Recursive Lock
            - May have platform specific surface lock, currently: None


GLContext/GLDrawable Locking:

    - MakeCurrent: NativeWindow:lockSurface()
    - Release: NativeWindow:unlockSurface()

    - Create/Destroy/Realize/Swap: 
        - NativeWindow:lockSurface()
            - CreateImpl/DestroyImpl/Realize/Swap
        - NativeWindow:unlockSurface()

    - The Window impl. class shall lock the window recursive lock
      for all modifying operations.
      This should be the same lock as surfaceHandle!


Summary:

    Locking is implemented in the platform agnostic code layer.

    Locks and Order:
        1: - NativeWindow Surface/Window Lock
            - Locked: 
                - [makeCurrent .. release]
                - create/destroy  

    GLContextImpl:
        - makeCurrent
            - Surface i       - out only in error

        - release
            - Surface o - makeCurrentImpl

        - create
            - Surface i/o

        - destroy
            - Surface i/o

        - copy
            - Surface i/o

        - setSwapIntervalImpl
            - Surface i/o


    GLDrawableImpl
        - setRealizedImpl
            - Surface i/o

        - swapBuffersImpl
            - [Surface i/o] - if not locked already

+++

Complying with synchronization/memory-barriers
using explicit locking:

- NativeSurface's handle access

Current 'violations' of synchronization/memory-barriers
using explicit locking:

- Using 'volatile' to avoid locking for read-only access
  with rare write access

    - GLAutoDrawable's drawable reference

    - GLAutoDrawable's context reference
        Since 7f7a23dd0ddf106e6f0c69fc2a05ff92ac56200e

    - GLContext's contextHandle
        Since 7f7a23dd0ddf106e6f0c69fc2a05ff92ac56200e

    - GLDrawableImpl's realized
        Used for Pre-locking queries, whether drawable is realized

- Misc 'volatile' usage: