author  Sam Lantinga <slouken@libsdl.org> 
Sun, 13 Dec 2009 05:37:06 +0000  
changeset 3552  3889325ca987 
parent 3308  0e000afe3dc0 
child 3697  f7b03b6838cb 
permissions  rwrr 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

1 
/* 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

2 
SDL  Simple DirectMedia Layer 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

3 
Copyright (C) 19972009 Sam Lantinga 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

4 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

5 
This library is free software; you can redistribute it and/or 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

6 
modify it under the terms of the GNU Lesser General Public 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

7 
License as published by the Free Software Foundation; either 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

8 
version 2.1 of the License, or (at your option) any later version. 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

9 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

10 
This library is distributed in the hope that it will be useful, 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

11 
but WITHOUT ANY WARRANTY; without even the implied warranty of 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

12 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

13 
Lesser General Public License for more details. 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

14 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

15 
You should have received a copy of the GNU Lesser General Public 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

16 
License along with this library; if not, write to the Free Software 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

17 
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 021101301 USA 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

18 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

19 
Sam Lantinga 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

20 
slouken@libsdl.org 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

21 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

22 
Contributed by Bob Pendleton, bob@pendleton.com 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

23 
*/ 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

24 

3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

25 
#include "SDL_stdinc.h" 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

26 
#include "SDL_atomic.h" 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

27 

3552  28 
#define WIN32_LEAN_AND_MEAN 
29 
#include <windows.h> 

30 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

31 
#include "SDL_error.h" 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

32 

3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

33 
/* 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

34 
This file provides 32, and 64 bit atomic operations. If the 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

35 
operations are provided by the native hardware and operating system 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

36 
they are used. If they are not then the operations are emulated 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

37 
using the SDL spin lock operations. If spin lock can not be 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

38 
implemented then these functions must fail. 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

39 
*/ 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

40 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

41 
/* 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

42 
WIN32 VERSION. 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

43 

3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

44 
This makes use of native Windows atomic operations. 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

45 
*/ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

46 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

47 
/* 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

48 
Native spinlock routines. Because this is the dummy implementation 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

49 
these will always call SDL_SetError() and do nothing. 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

50 
*/ 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

51 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

52 
void 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

53 
SDL_AtomicLock(SDL_SpinLock *lock) 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

54 
{ 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

55 
long volatile * l = (long volatile *)lock; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

56 
Uint32 old = 0; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

57 
Uint32 new = 1; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

58 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

59 
old = InterlockedExchange(l, new); 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

60 
while(1 == old) 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

61 
{ 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

62 
old = InterlockedExchange(l, new); 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

63 
} 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

64 
} 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

65 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

66 
void 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

67 
SDL_AtomicUnlock(SDL_SpinLock *lock) 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

68 
{ 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

69 
long volatile * l = (long volatile *)lock; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

70 
Uint32 new = 0; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

71 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

72 
InterlockedExchange(l, new); 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

73 
} 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

74 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

75 
/* 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

76 
Note that platform specific versions can be built from this version 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

77 
by changing the #undefs to #defines and adding platform specific 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

78 
code. 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

79 
*/ 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

80 

3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

81 
#define nativeTestThenSet32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

82 
#define nativeClear32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

83 
#define nativeFetchThenIncrement32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

84 
#define nativeFetchThenDecrement32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

85 
#define nativeFetchThenAdd32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

86 
#define nativeFetchThenSubtract32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

87 
#define nativeIncrementThenFetch32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

88 
#define nativeDecrementThenFetch32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

89 
#define nativeAddThenFetch32 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

90 
#define nativeSubtractThenFetch32 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

91 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

92 
#undef nativeTestThenSet64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

93 
#undef nativeClear64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

94 
#undef nativeFetchThenIncrement64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

95 
#undef nativeFetchThenDecrement64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

96 
#undef nativeFetchThenAdd64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

97 
#undef nativeFetchThenSubtract64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

98 
#undef nativeIncrementThenFetch64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

99 
#undef nativeDecrementThenFetch64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

100 
#undef nativeAddThenFetch64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

101 
#undef nativeSubtractThenFetch64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

102 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

103 
/* 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

104 
If any of the operations are not provided then we must emulate some 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

105 
of them. That means we need a nice implementation of spin locks 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

106 
that avoids the "one big lock" problem. We use a vector of spin 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

107 
locks and pick which one to use based on the address of the operand 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

108 
of the function. 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

109 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

110 
To generate the index of the lock we first shift by 3 bits to get 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

111 
rid on the zero bits that result from 32 and 64 bit allignment of 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

112 
data. We then mask off all but 5 bits and use those 5 bits as an 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

113 
index into the table. 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

114 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

115 
Picking the lock this way insures that accesses to the same data at 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

116 
the same time will go to the same lock. OTOH, accesses to different 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

117 
data have only a 1/32 chance of hitting the same lock. That should 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

118 
pretty much eliminate the chances of several atomic operations on 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

119 
different data from waiting on the same "big lock". If it isn't 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

120 
then the table of locks can be expanded to a new size so long as 
3308
0e000afe3dc0
fixed a spelling error in the documentation.
Bob Pendleton <bob@pendleton.com>
parents:
3306
diff
changeset

121 
the new size is a power of two. 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

122 
*/ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

123 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

124 
static SDL_SpinLock locks[32] = { 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

125 
0, 0, 0, 0, 0, 0, 0, 0, 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

126 
0, 0, 0, 0, 0, 0, 0, 0, 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

127 
0, 0, 0, 0, 0, 0, 0, 0, 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

128 
0, 0, 0, 0, 0, 0, 0, 0, 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

129 
}; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

130 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

131 
static __inline__ void 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

132 
privateWaitLock(volatile void *ptr) 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

133 
{ 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

134 
#if SIZEOF_VOIDP == 4 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

135 
Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

136 
#elif SIZEOF_VOIDP == 8 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

137 
Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

138 
#endif 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

139 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

140 
SDL_AtomicLock(&locks[index]); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

141 
} 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

142 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

143 
static __inline__ void 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

144 
privateUnlock(volatile void *ptr) 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

145 
{ 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

146 
#if SIZEOF_VOIDP == 4 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

147 
Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

148 
#elif SIZEOF_VOIDP == 8 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

149 
Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

150 
#endif 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

151 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

152 
SDL_AtomicUnlock(&locks[index]); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

153 
} 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

154 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

155 
/* 32 bit atomic operations */ 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

156 

3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

157 
SDL_bool 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

158 
SDL_AtomicTestThenSet32(volatile Uint32 * ptr) 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

159 
{ 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

160 
#ifdef nativeTestThenSet32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

161 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

162 
Uint32 new = 1; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

163 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

164 
return 0 == InterlockedExchange(p, new); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

165 
#else 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

166 
SDL_bool result = SDL_FALSE; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

167 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

168 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

169 
result = (*ptr == 0); 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

170 
if (result) 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

171 
{ 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

172 
*ptr = 1; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

173 
} 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

174 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

175 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

176 
return result; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

177 
#endif 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

178 
} 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

179 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

180 
void 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

181 
SDL_AtomicClear32(volatile Uint32 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

182 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

183 
#ifdef nativeClear32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

184 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

185 
Uint32 new = 0; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

186 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

187 
InterlockedExchange(p, new); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

188 
#else 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

189 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

190 
*ptr = 0; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

191 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

192 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

193 
return; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

194 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

195 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

196 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

197 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

198 
SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

199 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

200 
#ifdef nativeFetchThenIncrement32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

201 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

202 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

203 
return InterlockedExchangeAdd(p, 1); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

204 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

205 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

206 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

207 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

208 
tmp = *ptr; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

209 
(*ptr)+= 1; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

210 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

211 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

212 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

213 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

214 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

215 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

216 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

217 
SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

218 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

219 
#ifdef nativeFetchThenDecrement32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

220 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

221 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

222 
return InterlockedExchangeAdd(p, 1); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

223 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

224 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

225 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

226 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

227 
tmp = *ptr; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

228 
(*ptr) = 1; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

229 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

230 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

231 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

232 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

233 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

234 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

235 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

236 
SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

237 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

238 
#ifdef nativeFetchThenAdd32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

239 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

240 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

241 
return InterlockedExchangeAdd(p, value); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

242 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

243 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

244 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

245 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

246 
tmp = *ptr; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

247 
(*ptr)+= value; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

248 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

249 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

250 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

251 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

252 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

253 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

254 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

255 
SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

256 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

257 
#ifdef nativeFetchThenSubtract32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

258 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

259 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

260 
return InterlockedExchangeAdd(p, (0  value)); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

261 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

262 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

263 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

264 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

265 
tmp = *ptr; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

266 
(*ptr)= value; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

267 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

268 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

269 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

270 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

271 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

272 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

273 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

274 
SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

275 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

276 
#ifdef nativeIncrementThenFetch32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

277 
long volatile * p = (LONG volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

278 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

279 
return InterlockedIncrement(p); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

280 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

281 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

282 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

283 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

284 
(*ptr)+= 1; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

285 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

286 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

287 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

288 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

289 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

290 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

291 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

292 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

293 
SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

294 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

295 
#ifdef nativeDecrementThenFetch32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

296 
long volatile * p = (LONG volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

297 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

298 
return InterlockedDecrement(p); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

299 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

300 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

301 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

302 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

303 
(*ptr)= 1; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

304 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

305 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

306 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

307 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

308 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

309 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

310 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

311 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

312 
SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

313 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

314 
#ifdef nativeAddThenFetch32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

315 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

316 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

317 
return InterlockedExchangeAdd(p, value) + value; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

318 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

319 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

320 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

321 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

322 
(*ptr)+= value; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

323 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

324 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

325 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

326 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

327 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

328 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

329 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

330 
Uint32 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

331 
SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

332 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

333 
#ifdef nativeSubtractThenFetch32 
3306
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

334 
long volatile * p = (long volatile *)ptr; 
a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

335 

a8ec88ff18c7
This version actaully should work on Windows.
Bob Pendleton <bob@pendleton.com>
parents:
3261
diff
changeset

336 
return InterlockedExchangeAdd(p, (0  value))  value; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

337 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

338 
Uint32 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

339 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

340 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

341 
(*ptr)= value; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

342 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

343 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

344 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

345 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

346 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

347 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

348 

3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

349 
/* 64 bit atomic operations */ 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

350 
#ifdef SDL_HAS_64BIT_TYPE 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

351 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

352 
SDL_bool 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

353 
SDL_AtomicTestThenSet64(volatile Uint64 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

354 
{ 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

355 
#ifdef nativeTestThenSet64 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

356 
#else 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

357 
SDL_bool result = SDL_FALSE; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

358 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

359 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

360 
result = (*ptr == 0); 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

361 
if (result) 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

362 
{ 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

363 
*ptr = 1; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

364 
} 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

365 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

366 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

367 
return result; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

368 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

369 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

370 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

371 
void 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

372 
SDL_AtomicClear64(volatile Uint64 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

373 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

374 
#ifdef nativeClear64 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

375 
#else 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

376 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

377 
*ptr = 0; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

378 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

379 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

380 
return; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

381 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

382 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

383 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

384 
Uint64 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

385 
SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

386 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

387 
#ifdef nativeFetchThenIncrement64 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

388 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

389 
Uint64 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

390 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

391 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

392 
tmp = *ptr; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

393 
(*ptr)+= 1; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

394 
privateUnlock(ptr); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

395 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

396 
return tmp; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

397 
#endif 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

398 
} 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

399 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

400 
Uint64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

401 
SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

402 
{ 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

403 
#ifdef nativeFetchThenDecrement64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

404 
#else 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

405 
Uint64 tmp = 0; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

406 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

407 
privateWaitLock(ptr); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

408 
tmp = *ptr; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

409 
(*ptr) = 1; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

410 
privateUnlock(ptr); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

411 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

412 
return tmp; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

413 
#endif 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

414 
} 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

415 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

416 
Uint64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

417 
SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

418 
{ 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

419 
#ifdef nativeFetchThenAdd64 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

420 
#else 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

421 
Uint64 tmp = 0; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

422 

72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

423 
privateWaitLock(ptr); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

424 
tmp = *ptr; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

425 
(*ptr)+= value; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

426 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

427 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

428 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

429 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

430 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

431 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

432 
Uint64 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

433 
SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

434 
{ 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

435 
#ifdef nativeFetchThenSubtract64 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

436 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

437 
Uint64 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

438 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

439 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

440 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

441 
(*ptr)= value; 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

442 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

443 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

444 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

445 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

446 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

447 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

448 
Uint64 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

449 
SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

450 
{ 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

451 
#ifdef nativeIncrementThenFetch64 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

452 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

453 
Uint64 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

454 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

455 
privateWaitLock(ptr); 
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

456 
(*ptr)+= 1; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

457 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

458 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

459 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

460 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

461 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

462 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

463 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

464 
Uint64 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

465 
SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

466 
{ 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

467 
#ifdef nativeDecrementThenFetch64 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

468 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

469 
Uint64 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

470 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

471 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

472 
(*ptr)= 1; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

473 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

474 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

475 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

476 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

477 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

478 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

479 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

480 
Uint64 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

481 
SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

482 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

483 
#ifdef nativeAddThenFetch64 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

484 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

485 
Uint64 tmp = 0; 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

486 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

487 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

488 
(*ptr)+= value; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

489 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

490 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

491 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

492 
return tmp; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

493 
#endif 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

494 
} 
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

495 

3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

496 
Uint64 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

497 
SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

498 
{ 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

499 
#ifdef nativeSubtractThenFetch64 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

500 
#else 
3212
759032c318d8
This is a cosmetic fix, I found a stupid typo
Bob Pendleton <bob@pendleton.com>
parents:
3202
diff
changeset

501 
Uint64 tmp = 0; 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

502 

3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

503 
privateWaitLock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

504 
(*ptr)= value; 
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

505 
tmp = *ptr; 
3261
72b542f34739
The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops.
Bob Pendleton <bob@pendleton.com>
parents:
3212
diff
changeset

506 
privateUnlock(ptr); 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

507 

3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

508 
return tmp; 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

509 
#endif 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

510 
} 
3199
3e1bf2b8bd81
This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form.
Bob Pendleton <bob@pendleton.com>
parents:
diff
changeset

511 
#endif 
3202
3aa519a5c676
I've made so many changes I don't dare continue until I check the current stuff in.
Bob Pendleton <bob@pendleton.com>
parents:
3199
diff
changeset

512 