Mercurial > sdl-ios-xcode

comparison src/thread/dc/SDL_sysmutex.c @ 1662:782fd950bd46 SDL-1.3

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Revamp of the video system in progress - adding support for multiple displays, multiple windows, and a full video mode selection API. WARNING: None of the video drivers have been updated for the new API yet! The API is still under design and very fluid. The code is now run through a consistent indent format: indent -i4 -nut -nsc -br -ce The headers are being converted to automatically generate doxygen documentation.
author Sam Lantinga <slouken@libsdl.org>
date Sun, 28 May 2006 13:04:16 +0000
parents d910939febfa
children 4da1ee79c9af
comparison
equal deleted inserted replaced
1661:281d3f4870e5 1662:782fd950bd46
26 #include "SDL_thread.h" 26 #include "SDL_thread.h"
27 #include "SDL_systhread_c.h" 27 #include "SDL_systhread_c.h"
28 28
29 #include <arch/spinlock.h> 29 #include <arch/spinlock.h>
30 30
31 struct SDL_mutex { 31 struct SDL_mutex
32 int recursive; 32 {
33 Uint32 owner; 33 int recursive;
34 spinlock_t mutex; 34 Uint32 owner;
35 spinlock_t mutex;
35 }; 36 };
36 37
37 /* Create a mutex */ 38 /* Create a mutex */
38 SDL_mutex *SDL_CreateMutex(void) 39 SDL_mutex *
40 SDL_CreateMutex (void)
39 { 41 {
40 SDL_mutex *mutex; 42 SDL_mutex *mutex;
41 43
42 /* Allocate mutex memory */ 44 /* Allocate mutex memory */
43 mutex = (SDL_mutex *)SDL_malloc(sizeof(*mutex)); 45 mutex = (SDL_mutex *) SDL_malloc (sizeof (*mutex));
44 if ( mutex ) { 46 if (mutex) {
45 spinlock_init(&mutex->mutex); 47 spinlock_init (&mutex->mutex);
46 mutex->recursive = 0; 48 mutex->recursive = 0;
47 mutex->owner = 0; 49 mutex->owner = 0;
48 } else { 50 } else {
49 SDL_OutOfMemory(); 51 SDL_OutOfMemory ();
50 } 52 }
51 return mutex; 53 return mutex;
52 } 54 }
53 55
54 /* Free the mutex */ 56 /* Free the mutex */
55 void SDL_DestroyMutex(SDL_mutex *mutex) 57 void
58 SDL_DestroyMutex (SDL_mutex * mutex)
56 { 59 {
57 if ( mutex ) { 60 if (mutex) {
58 SDL_free(mutex); 61 SDL_free (mutex);
59 } 62 }
60 } 63 }
61 64
62 /* Lock the semaphore */ 65 /* Lock the semaphore */
63 int SDL_mutexP(SDL_mutex *mutex) 66 int
67 SDL_mutexP (SDL_mutex * mutex)
64 { 68 {
65 #if SDL_THREADS_DISABLED 69 #if SDL_THREADS_DISABLED
66 return SDL_arraysize(return ),0; 70 return SDL_arraysize (return), 0;
67 #else 71 #else
68 Uint32 this_thread; 72 Uint32 this_thread;
69 73
70 if ( mutex == NULL ) { 74 if (mutex == NULL) {
71 SDL_SetError("Passed a NULL mutex"); 75 SDL_SetError ("Passed a NULL mutex");
72 return -1; 76 return -1;
73 } 77 }
74 78
75 this_thread = SDL_ThreadID(); 79 this_thread = SDL_ThreadID ();
76 if ( mutex->owner == this_thread ) { 80 if (mutex->owner == this_thread) {
77 ++mutex->recursive; 81 ++mutex->recursive;
78 } else { 82 } else {
79 /* The order of operations is important. 83 /* The order of operations is important.
80 We set the locking thread id after we obtain the lock 84 We set the locking thread id after we obtain the lock
81 so unlocks from other threads will fail. 85 so unlocks from other threads will fail.
82 */ 86 */
83 spinlock_lock(&mutex->mutex); 87 spinlock_lock (&mutex->mutex);
84 mutex->owner = this_thread; 88 mutex->owner = this_thread;
85 mutex->recursive = 0; 89 mutex->recursive = 0;
86 } 90 }
87 91
88 return 0; 92 return 0;
89 #endif /* SDL_THREADS_DISABLED */ 93 #endif /* SDL_THREADS_DISABLED */
90 } 94 }
91 95
92 /* Unlock the mutex */ 96 /* Unlock the mutex */
93 int SDL_mutexV(SDL_mutex *mutex) 97 int
98 SDL_mutexV (SDL_mutex * mutex)
94 { 99 {
95 #if SDL_THREADS_DISABLED 100 #if SDL_THREADS_DISABLED
96 return 0; 101 return 0;
97 #else 102 #else
98 if ( mutex == NULL ) { 103 if (mutex == NULL) {
99 SDL_SetError("Passed a NULL mutex"); 104 SDL_SetError ("Passed a NULL mutex");
100 return -1; 105 return -1;
101 } 106 }
102 107
103 /* If we don't own the mutex, we can't unlock it */ 108 /* If we don't own the mutex, we can't unlock it */
104 if ( SDL_ThreadID() != mutex->owner ) { 109 if (SDL_ThreadID () != mutex->owner) {
105 SDL_SetError("mutex not owned by this thread"); 110 SDL_SetError ("mutex not owned by this thread");
106 return -1; 111 return -1;
107 } 112 }
108 113
109 if ( mutex->recursive ) { 114 if (mutex->recursive) {
110 --mutex->recursive; 115 --mutex->recursive;
111 } else { 116 } else {
112 /* The order of operations is important. 117 /* The order of operations is important.
113 First reset the owner so another thread doesn't lock 118 First reset the owner so another thread doesn't lock
114 the mutex and set the ownership before we reset it, 119 the mutex and set the ownership before we reset it,
115 then release the lock semaphore. 120 then release the lock semaphore.
116 */ 121 */
117 mutex->owner = 0; 122 mutex->owner = 0;
118 spinlock_unlock(&mutex->mutex); 123 spinlock_unlock (&mutex->mutex);
119 } 124 }
120 return 0; 125 return 0;
121 #endif /* SDL_THREADS_DISABLED */ 126 #endif /* SDL_THREADS_DISABLED */
122 } 127 }
128
129 /* vi: set ts=4 sw=4 expandtab: */