Mercurial > sdl-ios-xcode
changeset 5003:3a95a2b93eb3
Updated the atomic API for better use cases
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Sat, 15 Jan 2011 12:41:59 -0800 |
| parents | c5b9486688ce |
| children | 0c72ae7b7cb2 |
| files | Android.mk VisualC/SDL/SDL_VS2005.vcproj VisualC/SDL/SDL_VS2008.vcproj VisualC/SDL/SDL_VS2010.vcxproj Xcode-iPhoneOS/SDL/SDLiPhoneOS.xcodeproj/project.pbxproj Xcode/SDL/SDL.xcodeproj/project.pbxproj configure.in include/SDL_atomic.h src/atomic/SDL_atomic.c src/atomic/SDL_spinlock.c src/atomic/dummy/SDL_atomic.c src/atomic/linux/SDL_atomic.c src/atomic/macosx/SDL_atomic.c src/atomic/qnx/SDL_atomic.c src/atomic/win32/SDL_atomic.c test/testatomic.c |
| diffstat | 16 files changed, 488 insertions(+), 2758 deletions(-) [+] |
line wrap: on
line diff
--- a/Android.mk Sat Jan 15 12:34:43 2011 -0800 +++ b/Android.mk Sat Jan 15 12:41:59 2011 -0800 @@ -16,6 +16,8 @@ $(subst $(LOCAL_PATH)/,, \ $(wildcard $(LOCAL_PATH)/src/*.c) \ $(wildcard $(LOCAL_PATH)/src/audio/*.c) \ + $(LOCAL_PATH)/src/atomic/SDL_atomic.c \ + $(LOCAL_PATH)/src/atomic/SDL_spinlock.c.arm \ $(wildcard $(LOCAL_PATH)/src/cpuinfo/*.c) \ $(wildcard $(LOCAL_PATH)/src/events/*.c) \ $(wildcard $(LOCAL_PATH)/src/file/*.c) \ @@ -31,7 +33,6 @@ $(wildcard $(LOCAL_PATH)/src/video/android/*.c) \ $(wildcard $(LOCAL_PATH)/src/joystick/android/*.c) \ $(wildcard $(LOCAL_PATH)/src/haptic/dummy/*.c) \ - $(wildcard $(LOCAL_PATH)/src/atomic/dummy/*.c) \ $(wildcard $(LOCAL_PATH)/src/thread/pthread/*.c) \ $(wildcard $(LOCAL_PATH)/src/timer/unix/*.c) \ $(wildcard $(LOCAL_PATH)/src/loadso/dlopen/*.c))
--- a/VisualC/SDL/SDL_VS2005.vcproj Sat Jan 15 12:34:43 2011 -0800 +++ b/VisualC/SDL/SDL_VS2005.vcproj Sat Jan 15 12:41:59 2011 -0800 @@ -644,7 +644,11 @@ > </File> <File - RelativePath="..\..\src\atomic\win32\SDL_atomic.c" + RelativePath="..\..\src\atomic\SDL_atomic.c" + > + </File> + <File + RelativePath="..\..\src\atomic\SDL_spinlock.c" > </File> <File
--- a/VisualC/SDL/SDL_VS2008.vcproj Sat Jan 15 12:34:43 2011 -0800 +++ b/VisualC/SDL/SDL_VS2008.vcproj Sat Jan 15 12:41:59 2011 -0800 @@ -631,7 +631,11 @@ > </File> <File - RelativePath="..\..\src\atomic\win32\SDL_atomic.c" + RelativePath="..\..\src\atomic\SDL_atomic.c" + > + </File> + <File + RelativePath="..\..\src\atomic\SDL_spinlock.c" > </File> <File
--- a/VisualC/SDL/SDL_VS2010.vcxproj Sat Jan 15 12:34:43 2011 -0800 +++ b/VisualC/SDL/SDL_VS2010.vcxproj Sat Jan 15 12:41:59 2011 -0800 @@ -365,7 +365,8 @@ <ClCompile Include="..\..\src\SDL.c" /> <ClCompile Include="..\..\src\video\SDL_alphamult.c" /> <ClCompile Include="..\..\src\SDL_assert.c" /> - <ClCompile Include="..\..\src\atomic\win32\SDL_atomic.c" /> + <ClCompile Include="..\..\src\atomic\SDL_atomic.c" /> + <ClCompile Include="..\..\src\atomic\SDL_spinlock.c" /> <ClCompile Include="..\..\src\audio\SDL_audio.c" /> <ClCompile Include="..\..\src\audio\SDL_audiocvt.c" /> <ClCompile Include="..\..\src\audio\SDL_audiodev.c" /> @@ -457,4 +458,4 @@ <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" /> <ImportGroup Label="ExtensionTargets"> </ImportGroup> -</Project> \ No newline at end of file +</Project>
--- a/Xcode-iPhoneOS/SDL/SDLiPhoneOS.xcodeproj/project.pbxproj Sat Jan 15 12:34:43 2011 -0800 +++ b/Xcode-iPhoneOS/SDL/SDLiPhoneOS.xcodeproj/project.pbxproj Sat Jan 15 12:41:59 2011 -0800 @@ -93,7 +93,6 @@ 04B2ECEC1025CE4800F9BC5F /* SDL_atomic.h in Headers */ = {isa = PBXBuildFile; fileRef = 04B2ECE61025CE4800F9BC5F /* SDL_atomic.h */; settings = {ATTRIBUTES = (Public, ); }; }; 04B2ECED1025CE4800F9BC5F /* SDL_power.h in Headers */ = {isa = PBXBuildFile; fileRef = 04B2ECE71025CE4800F9BC5F /* SDL_power.h */; settings = {ATTRIBUTES = (Public, ); }; }; 04B2ECEE1025CE4800F9BC5F /* SDL_revision.h in Headers */ = {isa = PBXBuildFile; fileRef = 04B2ECE81025CE4800F9BC5F /* SDL_revision.h */; settings = {ATTRIBUTES = (Public, ); }; }; - 04B2ECFF1025CEB900F9BC5F /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = 04B2ECF11025CEB900F9BC5F /* SDL_atomic.c */; }; 04B2ED081025CF9E00F9BC5F /* SDL_config.h in Headers */ = {isa = PBXBuildFile; fileRef = 04B2ED061025CF9E00F9BC5F /* SDL_config.h */; settings = {ATTRIBUTES = (Public, ); }; }; 04BA9D6311EF474A00B60E01 /* SDL_gesture_c.h in Headers */ = {isa = PBXBuildFile; fileRef = 04BA9D5F11EF474A00B60E01 /* SDL_gesture_c.h */; }; 04BA9D6411EF474A00B60E01 /* SDL_gesture.c in Sources */ = {isa = PBXBuildFile; fileRef = 04BA9D6011EF474A00B60E01 /* SDL_gesture.c */; }; @@ -104,6 +103,11 @@ 04EC8B521025D12900431D42 /* SDL_config_iphoneos.h in Headers */ = {isa = PBXBuildFile; fileRef = 04EC8B501025D12900431D42 /* SDL_config_iphoneos.h */; }; 04F2AF541104ABC300D6DDF7 /* SDL_assert.h in Headers */ = {isa = PBXBuildFile; fileRef = 04F2AF531104ABC300D6DDF7 /* SDL_assert.h */; }; 04F2AF561104ABD200D6DDF7 /* SDL_assert.c in Sources */ = {isa = PBXBuildFile; fileRef = 04F2AF551104ABD200D6DDF7 /* SDL_assert.c */; }; + 04FFAB8B12E23B8D00BA343D /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = 04FFAB8912E23B8D00BA343D /* SDL_atomic.c */; }; + 04FFAB8C12E23B8D00BA343D /* SDL_spinlock.c in Sources */ = {isa = PBXBuildFile; fileRef = 04FFAB8A12E23B8D00BA343D /* SDL_spinlock.c */; }; + 04FFAB9612E23BDC00BA343D /* SDL_blendmode.h in Headers */ = {isa = PBXBuildFile; fileRef = 04FFAB9312E23BDC00BA343D /* SDL_blendmode.h */; }; + 04FFAB9712E23BDC00BA343D /* SDL_scalemode.h in Headers */ = {isa = PBXBuildFile; fileRef = 04FFAB9412E23BDC00BA343D /* SDL_scalemode.h */; }; + 04FFAB9812E23BDC00BA343D /* SDL_shape.h in Headers */ = {isa = PBXBuildFile; fileRef = 04FFAB9512E23BDC00BA343D /* SDL_shape.h */; }; 56ED04E1118A8EE200A56AA6 /* SDL_power.c in Sources */ = {isa = PBXBuildFile; fileRef = 56ED04E0118A8EE200A56AA6 /* SDL_power.c */; }; 56ED04E3118A8EFD00A56AA6 /* SDL_syspower.m in Sources */ = {isa = PBXBuildFile; fileRef = 56ED04E2118A8EFD00A56AA6 /* SDL_syspower.m */; }; FD24846D0E5655AE0021E198 /* SDL_uikitkeyboard.h in Headers */ = {isa = PBXBuildFile; fileRef = FD24846B0E5655AE0021E198 /* SDL_uikitkeyboard.h */; }; @@ -350,7 +354,6 @@ 04B2ECE61025CE4800F9BC5F /* SDL_atomic.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_atomic.h; path = ../../include/SDL_atomic.h; sourceTree = SOURCE_ROOT; }; 04B2ECE71025CE4800F9BC5F /* SDL_power.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_power.h; path = ../../include/SDL_power.h; sourceTree = SOURCE_ROOT; }; 04B2ECE81025CE4800F9BC5F /* SDL_revision.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_revision.h; path = ../../include/SDL_revision.h; sourceTree = SOURCE_ROOT; }; - 04B2ECF11025CEB900F9BC5F /* SDL_atomic.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_atomic.c; sourceTree = "<group>"; }; 04B2ED061025CF9E00F9BC5F /* SDL_config.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_config.h; path = ../../include/SDL_config.h; sourceTree = SOURCE_ROOT; }; 04BA9D5F11EF474A00B60E01 /* SDL_gesture_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_gesture_c.h; sourceTree = "<group>"; }; 04BA9D6011EF474A00B60E01 /* SDL_gesture.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_gesture.c; sourceTree = "<group>"; }; @@ -361,6 +364,11 @@ 04EC8B501025D12900431D42 /* SDL_config_iphoneos.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_config_iphoneos.h; path = ../../include/SDL_config_iphoneos.h; sourceTree = SOURCE_ROOT; }; 04F2AF531104ABC300D6DDF7 /* SDL_assert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_assert.h; path = ../../include/SDL_assert.h; sourceTree = SOURCE_ROOT; }; 04F2AF551104ABD200D6DDF7 /* SDL_assert.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = SDL_assert.c; path = ../../src/SDL_assert.c; sourceTree = SOURCE_ROOT; }; + 04FFAB8912E23B8D00BA343D /* SDL_atomic.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_atomic.c; sourceTree = "<group>"; }; + 04FFAB8A12E23B8D00BA343D /* SDL_spinlock.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_spinlock.c; sourceTree = "<group>"; }; + 04FFAB9312E23BDC00BA343D /* SDL_blendmode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_blendmode.h; path = ../../include/SDL_blendmode.h; sourceTree = SOURCE_ROOT; }; + 04FFAB9412E23BDC00BA343D /* SDL_scalemode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_scalemode.h; path = ../../include/SDL_scalemode.h; sourceTree = SOURCE_ROOT; }; + 04FFAB9512E23BDC00BA343D /* SDL_shape.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_shape.h; path = ../../include/SDL_shape.h; sourceTree = SOURCE_ROOT; }; 56ED04E0118A8EE200A56AA6 /* SDL_power.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = SDL_power.c; path = ../../src/power/SDL_power.c; sourceTree = SOURCE_ROOT; }; 56ED04E2118A8EFD00A56AA6 /* SDL_syspower.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = SDL_syspower.m; path = ../../src/power/uikit/SDL_syspower.m; sourceTree = SOURCE_ROOT; }; FD0BBFEF0E3933DD00D833B1 /* SDL_uikitview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_uikitview.h; sourceTree = "<group>"; }; @@ -690,20 +698,13 @@ 04B2ECEF1025CEB900F9BC5F /* atomic */ = { isa = PBXGroup; children = ( - 04B2ECF01025CEB900F9BC5F /* dummy */, + 04FFAB8912E23B8D00BA343D /* SDL_atomic.c */, + 04FFAB8A12E23B8D00BA343D /* SDL_spinlock.c */, ); name = atomic; path = ../../src/atomic; sourceTree = SOURCE_ROOT; }; - 04B2ECF01025CEB900F9BC5F /* dummy */ = { - isa = PBXGroup; - children = ( - 04B2ECF11025CEB900F9BC5F /* SDL_atomic.c */, - ); - path = dummy; - sourceTree = "<group>"; - }; 19C28FACFE9D520D11CA2CBB /* Products */ = { isa = PBXGroup; children = ( @@ -848,6 +849,9 @@ FD99B8BC0DD52E5C00FB1D6B /* Public Headers */ = { isa = PBXGroup; children = ( + 04FFAB9312E23BDC00BA343D /* SDL_blendmode.h */, + 04FFAB9412E23BDC00BA343D /* SDL_scalemode.h */, + 04FFAB9512E23BDC00BA343D /* SDL_shape.h */, FD99B8CC0DD52EB400FB1D6B /* begin_code.h */, FD99B8CD0DD52EB400FB1D6B /* close_code.h */, FD99B8F50DD52EB400FB1D6B /* SDL.h */, @@ -1213,6 +1217,9 @@ 04BA9D6511EF474A00B60E01 /* SDL_touch_c.h in Headers */, 04BA9D7D11EF497E00B60E01 /* SDL_gesture.h in Headers */, 04BA9D7E11EF497E00B60E01 /* SDL_touch.h in Headers */, + 04FFAB9612E23BDC00BA343D /* SDL_blendmode.h in Headers */, + 04FFAB9712E23BDC00BA343D /* SDL_scalemode.h in Headers */, + 04FFAB9812E23BDC00BA343D /* SDL_shape.h in Headers */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -1262,7 +1269,14 @@ isa = PBXProject; buildConfigurationList = C01FCF4E08A954540054247B /* Build configuration list for PBXProject "SDLiPhoneOS" */; compatibilityVersion = "Xcode 3.1"; + developmentRegion = English; hasScannedForEncodings = 1; + knownRegions = ( + English, + Japanese, + French, + German, + ); mainGroup = 29B97314FDCFA39411CA2CEA /* CustomTemplate */; projectDirPath = ""; projectRoot = ../..; @@ -1443,7 +1457,6 @@ 046387440F0B5B7D0041FD65 /* SDL_drawline.c in Sources */, 046387450F0B5B7D0041FD65 /* SDL_drawpoint.c in Sources */, 046387460F0B5B7D0041FD65 /* SDL_fillrect.c in Sources */, - 04B2ECFF1025CEB900F9BC5F /* SDL_atomic.c in Sources */, 043DD76F10FD8A0000DED673 /* SDL_alphamult.c in Sources */, 043DD77110FD8A0000DED673 /* SDL_blendfillrect.c in Sources */, 043DD77210FD8A0000DED673 /* SDL_drawrect.c in Sources */, @@ -1455,6 +1468,8 @@ 0420497111E6F03D007E7EC9 /* SDL_clipboardevents.c in Sources */, 04BA9D6411EF474A00B60E01 /* SDL_gesture.c in Sources */, 04BA9D6611EF474A00B60E01 /* SDL_touch.c in Sources */, + 04FFAB8B12E23B8D00BA343D /* SDL_atomic.c in Sources */, + 04FFAB8C12E23B8D00BA343D /* SDL_spinlock.c in Sources */, ); runOnlyForDeploymentPostprocessing = 0; };
--- a/Xcode/SDL/SDL.xcodeproj/project.pbxproj Sat Jan 15 12:34:43 2011 -0800 +++ b/Xcode/SDL/SDL.xcodeproj/project.pbxproj Sat Jan 15 12:41:59 2011 -0800 @@ -150,8 +150,6 @@ 00CFA68F106B44CE00758660 /* SDL_rect.h in Headers */ = {isa = PBXBuildFile; fileRef = 00CFA67F106B44CE00758660 /* SDL_rect.h */; }; 00CFA690106B44CE00758660 /* SDL_scancode.h in Headers */ = {isa = PBXBuildFile; fileRef = 00CFA680106B44CE00758660 /* SDL_scancode.h */; }; 00CFA691106B44CE00758660 /* SDL_surface.h in Headers */ = {isa = PBXBuildFile; fileRef = 00CFA681106B44CE00758660 /* SDL_surface.h */; }; - 00CFA6A8106B467B00758660 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = 00CFA6A1106B467B00758660 /* SDL_atomic.c */; }; - 00CFA6AD106B467B00758660 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = 00CFA6A1106B467B00758660 /* SDL_atomic.c */; }; 00CFA6B6106B46E500758660 /* SDL_audio_c.h in Headers */ = {isa = PBXBuildFile; fileRef = 00CFA6B0106B46E500758660 /* SDL_audio_c.h */; }; 00CFA6B7106B46E500758660 /* SDL_audiodev_c.h in Headers */ = {isa = PBXBuildFile; fileRef = 00CFA6B1106B46E500758660 /* SDL_audiodev_c.h */; }; 00CFA6B8106B46E500758660 /* SDL_audiomem.h in Headers */ = {isa = PBXBuildFile; fileRef = 00CFA6B2106B46E500758660 /* SDL_audiomem.h */; }; @@ -480,6 +478,10 @@ 04F2AF671104AC0800D6DDF7 /* SDL_assert.c in Sources */ = {isa = PBXBuildFile; fileRef = 04F2AF651104AC0800D6DDF7 /* SDL_assert.c */; }; 04F2AF691104AC4500D6DDF7 /* SDL_assert.h in Headers */ = {isa = PBXBuildFile; fileRef = 04F2AF681104AC4500D6DDF7 /* SDL_assert.h */; settings = {ATTRIBUTES = (Public, ); }; }; 04F2AF6A1104AC4500D6DDF7 /* SDL_assert.h in Headers */ = {isa = PBXBuildFile; fileRef = 04F2AF681104AC4500D6DDF7 /* SDL_assert.h */; }; + 04FB7D4C12E2350700A522C6 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = 04FB7D4A12E2350700A522C6 /* SDL_atomic.c */; }; + 04FB7D4D12E2350700A522C6 /* SDL_spinlock.c in Sources */ = {isa = PBXBuildFile; fileRef = 04FB7D4B12E2350700A522C6 /* SDL_spinlock.c */; }; + 04FB7D4E12E2350700A522C6 /* SDL_atomic.c in Sources */ = {isa = PBXBuildFile; fileRef = 04FB7D4A12E2350700A522C6 /* SDL_atomic.c */; }; + 04FB7D4F12E2350700A522C6 /* SDL_spinlock.c in Sources */ = {isa = PBXBuildFile; fileRef = 04FB7D4B12E2350700A522C6 /* SDL_spinlock.c */; }; 4537737D1207C4CE002F0F45 /* SDL_shape_internals.h in Headers */ = {isa = PBXBuildFile; fileRef = 4537737B1207C4CE002F0F45 /* SDL_shape_internals.h */; }; 4537737E1207C4CE002F0F45 /* SDL_shape.c in Sources */ = {isa = PBXBuildFile; fileRef = 4537737C1207C4CE002F0F45 /* SDL_shape.c */; }; 453773821207C518002F0F45 /* SDL_shape.h in Headers */ = {isa = PBXBuildFile; fileRef = 453773811207C518002F0F45 /* SDL_shape.h */; }; @@ -656,7 +658,6 @@ 00CFA67F106B44CE00758660 /* SDL_rect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_rect.h; path = ../../include/SDL_rect.h; sourceTree = SOURCE_ROOT; }; 00CFA680106B44CE00758660 /* SDL_scancode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_scancode.h; path = ../../include/SDL_scancode.h; sourceTree = SOURCE_ROOT; }; 00CFA681106B44CE00758660 /* SDL_surface.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_surface.h; path = ../../include/SDL_surface.h; sourceTree = SOURCE_ROOT; }; - 00CFA6A1106B467B00758660 /* SDL_atomic.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_atomic.c; sourceTree = "<group>"; }; 00CFA6B0106B46E500758660 /* SDL_audio_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_audio_c.h; sourceTree = "<group>"; }; 00CFA6B1106B46E500758660 /* SDL_audiodev_c.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_audiodev_c.h; sourceTree = "<group>"; }; 00CFA6B2106B46E500758660 /* SDL_audiomem.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SDL_audiomem.h; sourceTree = "<group>"; }; @@ -861,6 +862,8 @@ 04DEA57811E600A600386CAC /* SDL_cocoaclipboard.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = SDL_cocoaclipboard.m; sourceTree = "<group>"; }; 04F2AF651104AC0800D6DDF7 /* SDL_assert.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = SDL_assert.c; path = ../../src/SDL_assert.c; sourceTree = SOURCE_ROOT; }; 04F2AF681104AC4500D6DDF7 /* SDL_assert.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SDL_assert.h; path = ../../include/SDL_assert.h; sourceTree = SOURCE_ROOT; }; + 04FB7D4A12E2350700A522C6 /* SDL_atomic.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_atomic.c; sourceTree = "<group>"; }; + 04FB7D4B12E2350700A522C6 /* SDL_spinlock.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = SDL_spinlock.c; sourceTree = "<group>"; }; 083E489D006D88D97F000001 /* SDL_joystick.c */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.c; path = SDL_joystick.c; sourceTree = "<group>"; }; 0C5AF5E501191D2B7F000001 /* begin_code.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = begin_code.h; path = ../../include/begin_code.h; sourceTree = SOURCE_ROOT; }; 0C5AF5E601191D2B7F000001 /* close_code.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = close_code.h; path = ../../include/close_code.h; sourceTree = SOURCE_ROOT; }; @@ -1073,20 +1076,13 @@ 00CFA69B106B467B00758660 /* atomic */ = { isa = PBXGroup; children = ( - 00CFA6A0106B467B00758660 /* macosx */, + 04FB7D4A12E2350700A522C6 /* SDL_atomic.c */, + 04FB7D4B12E2350700A522C6 /* SDL_spinlock.c */, ); name = atomic; path = ../../src/atomic; sourceTree = SOURCE_ROOT; }; - 00CFA6A0106B467B00758660 /* macosx */ = { - isa = PBXGroup; - children = ( - 00CFA6A1106B467B00758660 /* SDL_atomic.c */, - ); - path = macosx; - sourceTree = "<group>"; - }; 00CFA6DF106B48D800758660 /* haptic */ = { isa = PBXGroup; children = ( @@ -2273,7 +2269,6 @@ 002F32E509CA0BF600EBEB88 /* SDL_dummyaudio.c in Sources */, 046B91EC0A11B53500FB151C /* SDL_sysloadso.c in Sources */, 046B92130A11B8AD00FB151C /* SDL_dlcompat.c in Sources */, - 00CFA6A8106B467B00758660 /* SDL_atomic.c in Sources */, 00CFA6B9106B46E500758660 /* SDL_audiotypecvt.c in Sources */, 00CFA6CD106B480800758660 /* SDL_windowevents.c in Sources */, 00CFA6EC106B48D800758660 /* SDL_syshaptic.c in Sources */, @@ -2357,6 +2352,8 @@ 4537738A1207C5A2002F0F45 /* SDL_cocoashape.m in Sources */, 453773921207C6E9002F0F45 /* SDL_x11shape.c in Sources */, 046B9B6812D02EE600159CFE /* SDL_x11touch.c in Sources */, + 04FB7D4C12E2350700A522C6 /* SDL_atomic.c in Sources */, + 04FB7D4D12E2350700A522C6 /* SDL_spinlock.c in Sources */, ); runOnlyForDeploymentPostprocessing = 0; }; @@ -2399,7 +2396,6 @@ 002F32E709CA0BF600EBEB88 /* SDL_dummyaudio.c in Sources */, 046B91ED0A11B53500FB151C /* SDL_sysloadso.c in Sources */, 046B92140A11B8AD00FB151C /* SDL_dlcompat.c in Sources */, - 00CFA6AD106B467B00758660 /* SDL_atomic.c in Sources */, 00CFA6BF106B46E500758660 /* SDL_audiotypecvt.c in Sources */, 00CFA6D3106B480800758660 /* SDL_windowevents.c in Sources */, 00CFA6F3106B48D800758660 /* SDL_syshaptic.c in Sources */, @@ -2477,6 +2473,8 @@ 04DEA57C11E600A600386CAC /* SDL_cocoaclipboard.m in Sources */, 0420496411E6EFD3007E7EC9 /* SDL_clipboardevents.c in Sources */, 046B9B6A12D02EE600159CFE /* SDL_x11touch.c in Sources */, + 04FB7D4E12E2350700A522C6 /* SDL_atomic.c in Sources */, + 04FB7D4F12E2350700A522C6 /* SDL_spinlock.c in Sources */, ); runOnlyForDeploymentPostprocessing = 0; };
--- a/configure.in Sat Jan 15 12:34:43 2011 -0800 +++ b/configure.in Sat Jan 15 12:41:59 2011 -0800 @@ -288,6 +288,7 @@ # Standard C sources SOURCES="$SOURCES $srcdir/src/*.c" SOURCES="$SOURCES $srcdir/src/audio/*.c" +SOURCES="$SOURCES $srcdir/src/atomic/*.c" SOURCES="$SOURCES $srcdir/src/cpuinfo/*.c" SOURCES="$SOURCES $srcdir/src/events/*.c" SOURCES="$SOURCES $srcdir/src/file/*.c" @@ -2303,16 +2304,6 @@ ;; esac fi - # Set up files for the atomic operations library - if test x$enable_atomic = xyes; then - case $ARCH in - linux) - AC_DEFINE(SDL_ATOMIC_LINUX) - SOURCES="$SOURCES $srcdir/src/atomic/linux/*.c" - have_atomic=yes - ;; - esac - fi # Set up files for the joystick library if test x$enable_joystick = xyes; then case $ARCH in @@ -2395,12 +2386,6 @@ SOURCES="$SOURCES $srcdir/src/timer/unix/*.c" have_timers=yes fi - # Setup files for the atomic operations - if test x$enable_atomic = xyes; then - AC_DEFINE(SDL_ATOMIC_QNX) - SOURCES="$SOURCES $srcdir/src/atomic/qnx/*.c" - have_atomic=yes - fi # Set up dummy files for the joystick for now if test x$enable_joystick = xyes; then AC_DEFINE(SDL_JOYSTICK_DUMMY) @@ -2460,12 +2445,6 @@ fi have_audio=yes fi - # Set up files for the atomic operations library - if test x$enable_atomic = xyes; then - AC_DEFINE(SDL_ATOMIC_WIN32) - SOURCES="$SOURCES $srcdir/src/atomic/win32/*.c" - have_atomic=yes - fi # Set up dummy files for the joystick for now if test x$enable_joystick = xyes; then AC_DEFINE(SDL_JOYSTICK_DUMMY) @@ -2555,12 +2534,6 @@ fi have_audio=yes fi - # Set up files for the atomic operations library - if test x$enable_atomic = xyes; then - AC_DEFINE(SDL_ATOMIC_WIN32) - SOURCES="$SOURCES $srcdir/src/atomic/win32/*.c" - have_atomic=yes - fi # Set up files for the joystick library if test x$enable_joystick = xyes; then if test x$have_dinput = xyes; then @@ -2715,12 +2688,6 @@ SOURCES="$SOURCES $srcdir/src/audio/macosx/*.c" have_audio=yes fi - # Set up files for the atomic operations library - if test x$enable_atomic = xyes; then - AC_DEFINE(SDL_ATOMIC_MACOSX) - SOURCES="$SOURCES $srcdir/src/atomic/macosx/*.c" - have_atomic=yes - fi # Set up files for the joystick library if test x$enable_joystick = xyes; then AC_DEFINE(SDL_JOYSTICK_IOKIT) @@ -2826,12 +2793,6 @@ fi SOURCES="$SOURCES $srcdir/src/loadso/dummy/*.c" fi -if test x$have_atomic != xyes; then - if test x$enable_atomic = xyes; then - AC_DEFINE(SDL_ATOMIC_DISABLED) - fi - SOURCES="$SOURCES $srcdir/src/atomic/dummy/*.c" -fi if test x$SDLMAIN_SOURCES = x; then SDLMAIN_SOURCES="$srcdir/src/main/dummy/*.c" fi
--- a/include/SDL_atomic.h Sat Jan 15 12:34:43 2011 -0800 +++ b/include/SDL_atomic.h Sat Jan 15 12:41:59 2011 -0800 @@ -18,24 +18,34 @@ Sam Lantinga slouken@libsdl.org - - Contributed by Bob Pendleton, bob@pendleton.com */ /** - * \file SDL_atomic.h - * - * Atomic operations. - * - * These operations may, or may not, actually be implemented using - * processor specific atomic operations. When possible they are - * implemented as true processor specific atomic operations. When that - * is not possible the are implemented using locks that *do* use the - * available atomic operations. - * - * At the very minimum spin locks must be implemented. Without spin - * locks it is not possible (AFAICT) to emulate the rest of the atomic - * operations. + * \file SDL_atomic.h + * + * Atomic operations. + * + * IMPORTANT: + * If you are not an expert in concurrent lockless programming, you should + * only be using the atomic lock and reference counting functions in this + * file. In all other cases you should be protecting your data structures + * with full mutexes. + * + * The list of "safe" functions to use are: + * SDL_AtomicLock() + * SDL_AtomicUnlock() + * SDL_AtomicIncRef() + * SDL_AtomicDecRef() + * + * Seriously, here be dragons! + * + * These operations may, or may not, actually be implemented using + * processor specific atomic operations. When possible they are + * implemented as true processor specific atomic operations. When that + * is not possible the are implemented using locks that *do* use the + * available atomic operations. + * + * All of the atomic operations that modify memory are full memory barriers. */ #ifndef _SDL_atomic_h_ @@ -53,154 +63,138 @@ /* *INDENT-ON* */ #endif -/* Function prototypes */ - /** - * \name SDL AtomicLock - * - * The spin lock functions and type are required and can not be - * emulated because they are used in the emulation code. + * \name SDL AtomicLock + * + * The atomic locks are efficient spinlocks using CPU instructions, + * but are vulnerable to starvation and can spin forever if a thread + * holding a lock has been terminated. For this reason you should + * minimize the code executed inside an atomic lock and never do + * expensive things like API or system calls while holding them. + * + * The atomic locks are not safe to lock recursively. + * + * Porting Note: + * The spin lock functions and type are required and can not be + * emulated because they are used in the atomic emulation code. */ /*@{*/ -typedef volatile Uint32 SDL_SpinLock; +typedef int SDL_SpinLock; /** - * \brief Lock a spin lock by setting it to a none zero value. - * - * \param lock Points to the lock. + * \brief Try to lock a spin lock by setting it to a non-zero value. + * + * \param lock Points to the lock. + * + * \return SDL_TRUE if the lock succeeded, SDL_FALSE if the lock is already held. + */ +extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTryLock(SDL_SpinLock *lock); + +/** + * \brief Lock a spin lock by setting it to a non-zero value. + * + * \param lock Points to the lock. */ extern DECLSPEC void SDLCALL SDL_AtomicLock(SDL_SpinLock *lock); /** - * \brief Unlock a spin lock by setting it to 0. Always returns immediately + * \brief Unlock a spin lock by setting it to 0. Always returns immediately * - * \param lock Points to the lock. + * \param lock Points to the lock. */ extern DECLSPEC void SDLCALL SDL_AtomicUnlock(SDL_SpinLock *lock); /*@}*//*SDL AtomicLock*/ -/** - * \name 32 bit atomic operations - */ -/*@{*/ +/* Platform specific optimized versions of the atomic functions */ +/* None yet... */ /** - * \brief Check to see if \c *ptr == 0 and set it to 1. - * - * \return SDL_True if the value pointed to by \c ptr was zero and - * SDL_False if it was not zero - * - * \param ptr Points to the value to be tested and set. + * \brief A type representing an atomic integer value. It is a struct + * so people don't accidentally use numeric operations on it. */ -extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet32(volatile Uint32 * ptr); +#ifndef SDL_atomic_t_defined +typedef struct { int value; } SDL_atomic_t; +#endif /** - * \brief Set the value pointed to by \c ptr to be zero. - * - * \param ptr Address of the value to be set to zero + * \brief Set an atomic variable to a value. + * + * \return The previous value of the atomic variable. */ -extern DECLSPEC void SDLCALL SDL_AtomicClear32(volatile Uint32 * ptr); +#ifndef SDL_AtomicSet +extern DECLSPEC int SDLCALL SDL_AtomicSet(SDL_atomic_t *a, int value); +#endif /** - * \brief Fetch the current value of \c *ptr and then increment that - * value in place. - * - * \return The value before it was incremented. - * - * \param ptr Address of the value to fetch and increment + * \brief Get the value of an atomic variable */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr); +#ifndef SDL_AtomicGet +extern DECLSPEC int SDLCALL SDL_AtomicGet(SDL_atomic_t *a); +#endif /** - * \brief Fetch \c *ptr and then decrement the value in place. - * - * \return The value before it was decremented. - * - * \param ptr Address of the value to fetch and decrement + * \brief Add to an atomic variable. + * + * \return The previous value of the atomic variable. */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr); +#ifndef SDL_AtomicAdd +extern DECLSPEC int SDLCALL SDL_AtomicAdd(SDL_atomic_t *a, int value); +#endif /** - * \brief Fetch the current value at \c ptr and then add \c value to \c *ptr. - * - * \return \c *ptr before the addition took place. - * - * \param ptr The address of data we are changing. - * \param value The value to add to \c *ptr. + * \brief Increment an atomic variable used as a reference count. */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value); +#ifndef SDL_AtomicIncRef +extern DECLSPEC void SDLCALL SDL_AtomicIncRef(SDL_atomic_t *a); +#endif /** - * \brief Fetch \c *ptr and then subtract \c value from it. - * - * \return \c *ptr before the subtraction took place. - * - * \param ptr The address of the data being changed. - * \param value The value to subtract from \c *ptr. + * \brief Decrement an atomic variable used as a reference count. + * + * \return SDL_TRUE if the variable has reached zero after decrementing, + * SDL_FALSE otherwise */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value); +#ifndef SDL_AtomicDecRef +extern DECLSPEC SDL_bool SDLCALL SDL_AtomicDecRef(SDL_atomic_t *a); +#endif /** - * \brief Add one to the data pointed to by \c ptr and return that value. - * - * \return The incremented value. - * - * \param ptr The address of the data to increment. - */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr); - -/** - * \brief Subtract one from data pointed to by \c ptr and return the new value. - * - * \return The decremented value. - * - * \param ptr The address of the data to decrement. - */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr); + * \brief Set an atomic variable to a new value if it is currently an old value. + * + * \return The previous value of the atomic variable + * + * \note If you don't know what this function is for, you shouldn't use it! +*/ +#ifndef SDL_AtomicCAS +extern DECLSPEC int SDLCALL SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval); +#endif /** - * \brief Add \c value to the data pointed to by \c ptr and return result. - * - * \return The sum of \c *ptr and \c value. - * - * \param ptr The address of the data to be modified. - * \param value The value to be added. + * \brief Set a pointer to a value atomically. */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value); +#ifndef SDL_AtomicSetPtr +extern DECLSPEC void SDLCALL SDL_AtomicSetPtr(void** a, void* value); +#endif /** - * \brief Subtract \c value from the data pointed to by \c ptr and return the result. - * - * \return The difference between \c *ptr and \c value. - * - * \param ptr The address of the data to be modified. - * \param value The value to be subtracted. + * \brief Get the value of a pointer atomically. */ -extern DECLSPEC Uint32 SDLCALL SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value); - -/*@}*//*32 bit atomic operations*/ +#ifndef SDL_AtomicGetPtr +extern DECLSPEC void* SDLCALL SDL_AtomicGetPtr(void** a); +#endif /** - * \name 64 bit atomic operations - */ -/*@{*/ -#ifdef SDL_HAS_64BIT_TYPE - -extern DECLSPEC SDL_bool SDLCALL SDL_AtomicTestThenSet64(volatile Uint64 * ptr); -extern DECLSPEC void SDLCALL SDL_AtomicClear64(volatile Uint64 * ptr); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value); -extern DECLSPEC Uint64 SDLCALL SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value); -#endif /* SDL_HAS_64BIT_TYPE */ - -/*@}*//*64 bit atomic operations*/ + * \brief Set a pointer to a new value if it is currently an old value. + * + * \return The previous value of the pointer + * + * \note If you don't know what this function is for, you shouldn't use it! +*/ +#ifndef SDL_AtomicCASPtr +extern DECLSPEC void* SDLCALL SDL_AtomicCASPtr(void **a, void *oldval, void *newval); +#endif /* Ends C function definitions when using C++ */ #ifdef __cplusplus
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/atomic/SDL_atomic.c Sat Jan 15 12:41:59 2011 -0800 @@ -0,0 +1,179 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2010 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_stdinc.h" + +#include "SDL_atomic.h" + +/* + If any of the operations are not provided then we must emulate some + of them. That means we need a nice implementation of spin locks + that avoids the "one big lock" problem. We use a vector of spin + locks and pick which one to use based on the address of the operand + of the function. + + To generate the index of the lock we first shift by 3 bits to get + rid on the zero bits that result from 32 and 64 bit allignment of + data. We then mask off all but 5 bits and use those 5 bits as an + index into the table. + + Picking the lock this way insures that accesses to the same data at + the same time will go to the same lock. OTOH, accesses to different + data have only a 1/32 chance of hitting the same lock. That should + pretty much eliminate the chances of several atomic operations on + different data from waiting on the same "big lock". If it isn't + then the table of locks can be expanded to a new size so long as + the new size is a power of two. + + Contributed by Bob Pendleton, bob@pendleton.com +*/ + +static SDL_SpinLock locks[32]; + +static __inline__ void +enterLock(void *a) +{ + uintptr_t index = ((((uintptr_t)a) >> 3) & 0x1f); + + SDL_AtomicLock(&locks[index]); +} + +static __inline__ void +leaveLock(void *a) +{ + uintptr_t index = ((((uintptr_t)a) >> 3) & 0x1f); + + SDL_AtomicUnlock(&locks[index]); +} + +#ifndef SDL_AtomicSet +int +SDL_AtomicSet(SDL_atomic_t *a, int value) +{ + int oldvalue; + + enterLock(a); + oldvalue = a->value; + a->value = value; + leaveLock(a); + + return oldvalue; +} +#endif + +#ifndef SDL_AtomicGet +int +SDL_AtomicGet(SDL_atomic_t *a) +{ + /* Assuming integral reads on this platform, we're safe here since the + functions that set the variable have the necessary memory barriers. + */ + return a->value; +} +#endif + +#ifndef SDL_AtomicAdd +int +SDL_AtomicAdd(SDL_atomic_t *a, int value) +{ + int oldvalue; + + enterLock(a); + oldvalue = a->value; + a->value += value; + leaveLock(a); + + return oldvalue; +} +#endif + +#ifndef SDL_AtomicIncRef +void +SDL_AtomicIncRef(SDL_atomic_t *a) +{ + SDL_AtomicAdd(a, 1); +} +#endif + +#ifndef SDL_AtomicDecRef +SDL_bool +SDL_AtomicDecRef(SDL_atomic_t *a) +{ + return SDL_AtomicAdd(a, -1) == 1; +} +#endif + +#ifndef SDL_AtomicCAS +int +SDL_AtomicCAS(SDL_atomic_t *a, int oldval, int newval) +{ + int prevval; + + enterLock(a); + prevval = a->value; + if (prevval == oldval) { + a->value = newval; + } + leaveLock(a); + + return prevval; +} +#endif + +#ifndef SDL_AtomicSetPtr +void +SDL_AtomicSetPtr(void** a, void* value) +{ + void *prevval; + do { + prevval = *a; + } while (SDL_AtomicCASPtr(a, prevval, value) != prevval); +} +#endif + +#ifndef SDL_AtomicGetPtr +void* +SDL_AtomicGetPtr(void** a) +{ + /* Assuming integral reads on this platform, we're safe here since the + functions that set the pointer have the necessary memory barriers. + */ + return *a; +} +#endif + +#ifndef SDL_AtomicCASPtr +void* SDL_AtomicCASPtr(void **a, void *oldval, void *newval) +{ + void *prevval; + + enterLock(a); + prevval = *a; + if (*a == oldval) { + *a = newval; + } + leaveLock(a); + + return prevval; +} +#endif + +/* vi: set ts=4 sw=4 expandtab: */
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/atomic/SDL_spinlock.c Sat Jan 15 12:41:59 2011 -0800 @@ -0,0 +1,99 @@ +/* + SDL - Simple DirectMedia Layer + Copyright (C) 1997-2010 Sam Lantinga + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + Sam Lantinga + slouken@libsdl.org +*/ +#include "SDL_stdinc.h" + +#include "SDL_atomic.h" +#include "SDL_timer.h" + +#if defined(__WIN32__) +#define WIN32_LEAN_AND_MEAN +#include <windows.h> + +#elif defined(__MACOSX__) +#include <libkern/OSAtomic.h> + +#endif + + +/* This function is where all the magic happens... */ +SDL_bool +SDL_AtomicTryLock(SDL_SpinLock *lock) +{ +#if defined(__WIN32__) + return (InterlockedExchange(lock, 1) == 0); + +#elif defined(__MACOSX__) + return OSAtomicCompareAndSwap32Barrier(0, 1, lock); + +#elif defined(__GNUC__) +#if defined(__arm__) +#ifdef __ARM_ARCH_5__ + int result; + __asm__ __volatile__ ( + "swp %0, %1, [%2]\n" + : "=&r,&r" (result) : "r,0" (1), "r,r" (lock) : "memory"); + return (result == 0); +#else + int result; + __asm__ __volatile__ ( + "ldrex %0, [%2]\nteq %0, #0\nstrexeq %0, %1, [%2]" + : "=&r" (result) : "r" (1), "r" (lock) : "cc", "memory"); + return (result == 0); +#endif +#else + return (__sync_lock_test_and_set(lock, 1) == 0); +#endif + +#else + /* Need CPU instructions for spinlock here! */ + __need_spinlock_implementation__ +#endif +} + +void +SDL_AtomicLock(SDL_SpinLock *lock) +{ + /* FIXME: Should we have an eventual timeout? */ + while (!SDL_AtomicTryLock(lock)) { + SDL_Delay(0); + } +} + +void +SDL_AtomicUnlock(SDL_SpinLock *lock) +{ +#if defined(__WIN32__) + *lock = 0; + +#elif defined(__MACOSX__) + *lock = 0; + +#elif defined(__GNUC__) && !defined(__arm__) + __sync_lock_release(lock); + +#else + /* Assuming memory barrier in lock and integral assignment operation */ + *lock = 0; +#endif +} + +/* vi: set ts=4 sw=4 expandtab: */
--- a/src/atomic/dummy/SDL_atomic.c Sat Jan 15 12:34:43 2011 -0800 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,469 +0,0 @@ -/* - SDL - Simple DirectMedia Layer - Copyright (C) 1997-2010 Sam Lantinga - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Sam Lantinga - slouken@libsdl.org - - Contributed by Bob Pendleton, bob@pendleton.com -*/ - -#include "SDL_stdinc.h" -#include "SDL_atomic.h" - -#include "SDL_error.h" - -/* - This file provides 32, and 64 bit atomic operations. If the - operations are provided by the native hardware and operating system - they are used. If they are not then the operations are emulated - using the SDL spin lock operations. If spin lock can not be - implemented then these functions must fail. -*/ - -/* - DUMMY VERSION. - - This version of the code assumes there is no support for atomic - operations. Therefore, every function sets the SDL error - message. Oddly enough, if you only have one thread then this - version actuallys works. -*/ - -/* - Native spinlock routines. Because this is the dummy implementation - these will always call SDL_SetError() and do nothing. -*/ - -void -SDL_AtomicLock(SDL_SpinLock *lock) -{ - SDL_SetError("SDL_atomic.c: is not implemented on this platform"); -} - -void -SDL_AtomicUnlock(SDL_SpinLock *lock) -{ - SDL_SetError("SDL_atomic.c: is not implemented on this platform"); -} - -/* - Note that platform specific versions can be built from this version - by changing the #undefs to #defines and adding platform specific - code. -*/ - -#undef nativeTestThenSet32 -#undef nativeClear32 -#undef nativeFetchThenIncrement32 -#undef nativeFetchThenDecrement32 -#undef nativeFetchThenAdd32 -#undef nativeFetchThenSubtract32 -#undef nativeIncrementThenFetch32 -#undef nativeDecrementThenFetch32 -#undef nativeAddThenFetch32 -#undef nativeSubtractThenFetch32 - -#undef nativeTestThenSet64 -#undef nativeClear64 -#undef nativeFetchThenIncrement64 -#undef nativeFetchThenDecrement64 -#undef nativeFetchThenAdd64 -#undef nativeFetchThenSubtract64 -#undef nativeIncrementThenFetch64 -#undef nativeDecrementThenFetch64 -#undef nativeAddThenFetch64 -#undef nativeSubtractThenFetch64 - -/* - If any of the operations are not provided then we must emulate some - of them. That means we need a nice implementation of spin locks - that avoids the "one big lock" problem. We use a vector of spin - locks and pick which one to use based on the address of the operand - of the function. - - To generate the index of the lock we first shift by 3 bits to get - rid on the zero bits that result from 32 and 64 bit allignment of - data. We then mask off all but 5 bits and use those 5 bits as an - index into the table. - - Picking the lock this way insures that accesses to the same data at - the same time will go to the same lock. OTOH, accesses to different - data have only a 1/32 chance of hitting the same lock. That should - pretty much eliminate the chances of several atomic operations on - different data from waiting on the same "big lock". If it isn't - then the table of locks can be expanded to a new size so long as - the new size is a power of two. -*/ - -static SDL_SpinLock locks[32] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -}; - -static __inline__ void -privateWaitLock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicLock(&locks[index]); -} - -static __inline__ void -privateUnlock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicUnlock(&locks[index]); -} - -/* 32 bit atomic operations */ - -SDL_bool -SDL_AtomicTestThenSet32(volatile Uint32 * ptr) -{ -#ifdef nativeTestThenSet32 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear32(volatile Uint32 * ptr) -{ -#ifdef nativeClear32 -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint32 -SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenIncrement32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenDecrement32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenAdd32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenSubtract32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeIncrementThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeDecrementThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeAddThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeSubtractThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -/* 64 bit atomic operations */ -#ifdef SDL_HAS_64BIT_TYPE - -SDL_bool -SDL_AtomicTestThenSet64(volatile Uint64 * ptr) -{ -#ifdef nativeTestThenSet64 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear64(volatile Uint64 * ptr) -{ -#ifdef nativeClear64 -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint64 -SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenIncrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenDecrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenAdd64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenSubtract64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeIncrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeDecrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeAddThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeSubtractThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} -#endif -
--- a/src/atomic/linux/SDL_atomic.c Sat Jan 15 12:34:43 2011 -0800 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,510 +0,0 @@ -/* - SDL - Simple DirectMedia Layer - Copyright (C) 1997-2010 Sam Lantinga - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Sam Lantinga - slouken@libsdl.org - - Contributed by Bob Pendleton, bob@pendleton.com -*/ - -#include "SDL_stdinc.h" -#include "SDL_atomic.h" - -#include "SDL_error.h" - -/* - This file provides 32, and 64 bit atomic operations. If the - operations are provided by the native hardware and operating system - they are used. If they are not then the operations are emulated - using the SDL spin lock operations. If spin lock can not be - implemented then these functions must fail. -*/ - -/* - LINUX/GCC VERSION. - - This version of the code assumes support of the atomic builtins as - documented at gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html This - code should work on any modern x86 or other processor supported by - GCC. - - Some processors will only support some of these operations so - #ifdefs will have to be added as incompatibilities are discovered -*/ - -/* - Native spinlock routines. -*/ - -void -SDL_AtomicLock(SDL_SpinLock *lock) -{ - while (0 != __sync_lock_test_and_set(lock, 1)) - { - } -} - -void -SDL_AtomicUnlock(SDL_SpinLock *lock) -{ - __sync_lock_test_and_set(lock, 0); -} - -/* - Note that platform specific versions can be built from this version - by changing the #undefs to #defines and adding platform specific - code. -*/ - -#define nativeTestThenSet32 -#define nativeClear32 -#define nativeFetchThenIncrement32 -#define nativeFetchThenDecrement32 -#define nativeFetchThenAdd32 -#define nativeFetchThenSubtract32 -#define nativeIncrementThenFetch32 -#define nativeDecrementThenFetch32 -#define nativeAddThenFetch32 -#define nativeSubtractThenFetch32 - -#ifdef SDL_HAS_64BIT_TYPE - #ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 - #define nativeTestThenSet64 - #define nativeClear64 - #define nativeFetchThenIncrement64 - #define nativeFetchThenDecrement64 - #define nativeFetchThenAdd64 - #define nativeFetchThenSubtract64 - #define nativeIncrementThenFetch64 - #define nativeDecrementThenFetch64 - #define nativeAddThenFetch64 - #define nativeSubtractThenFetch64 - #else - #undef nativeTestThenSet64 - #undef nativeClear64 - #undef nativeFetchThenIncrement64 - #undef nativeFetchThenDecrement64 - #undef nativeFetchThenAdd64 - #undef nativeFetchThenSubtract64 - #undef nativeIncrementThenFetch64 - #undef nativeDecrementThenFetch64 - #undef nativeAddThenFetch64 - #undef nativeSubtractThenFetch64 - #endif /* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 */ -#endif /* SDL_HAS_64BIT_TYPE */ - -/* - If any of the operations are not provided then we must emulate some - of them. That means we need a nice implementation of spin locks - that avoids the "one big lock" problem. We use a vector of spin - locks and pick which one to use based on the address of the operand - of the function. - - To generate the index of the lock we first shift by 3 bits to get - rid on the zero bits that result from 32 and 64 bit allignment of - data. We then mask off all but 5 bits and use those 5 bits as an - index into the table. - - Picking the lock this way insures that accesses to the same data at - the same time will go to the same lock. OTOH, accesses to different - data have only a 1/32 chance of hitting the same lock. That should - pretty much eliminate the chances of several atomic operations on - different data from waiting on the same "big lock". If it isn't - then the table of locks can be expanded to a new size so long as - the new size is a power of two. -*/ - -static SDL_SpinLock locks[32] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -}; - -static __inline__ void -privateWaitLock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicLock(&locks[index]); -} - -static __inline__ void -privateUnlock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicUnlock(&locks[index]); -} - -/* 32 bit atomic operations */ - -SDL_bool -SDL_AtomicTestThenSet32(volatile Uint32 * ptr) -{ -#ifdef nativeTestThenSet32 - return 0 == __sync_lock_test_and_set(ptr, 1); -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear32(volatile Uint32 * ptr) -{ -#ifdef nativeClear32 - __sync_lock_test_and_set(ptr, 0); - return; -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint32 -SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenIncrement32 - return __sync_fetch_and_add(ptr, 1); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenDecrement32 - return __sync_fetch_and_sub(ptr, 1); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenAdd32 - return __sync_fetch_and_add(ptr, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenSubtract32 - return __sync_fetch_and_sub(ptr, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeIncrementThenFetch32 - return __sync_add_and_fetch(ptr, 1); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeDecrementThenFetch32 - return __sync_sub_and_fetch(ptr, 1); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeAddThenFetch32 - return __sync_add_and_fetch(ptr, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeSubtractThenFetch32 - return __sync_sub_and_fetch(ptr, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -/* 64 bit atomic operations */ -#ifdef SDL_HAS_64BIT_TYPE - -SDL_bool -SDL_AtomicTestThenSet64(volatile Uint64 * ptr) -{ -#ifdef nativeTestThenSet64 - return 0 == __sync_lock_test_and_set(ptr, 1); -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear64(volatile Uint64 * ptr) -{ -#ifdef nativeClear64 - __sync_lock_test_and_set(ptr, 0); - return; -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint64 -SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenIncrement64 - return __sync_fetch_and_add(ptr, 1); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenDecrement64 - return __sync_fetch_and_sub(ptr, 1); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenAdd64 - return __sync_fetch_and_add(ptr, value); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenSubtract64 - return __sync_fetch_and_sub(ptr, value); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeIncrementThenFetch64 - return __sync_add_and_fetch(ptr, 1); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeDecrementThenFetch64 - return __sync_sub_and_fetch(ptr, 1); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeAddThenFetch64 - return __sync_add_and_fetch(ptr, value); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeSubtractThenFetch64 - return __sync_sub_and_fetch(ptr, value); -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -#endif /* SDL_HAS_64BIT_TYPE */
--- a/src/atomic/macosx/SDL_atomic.c Sat Jan 15 12:34:43 2011 -0800 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,469 +0,0 @@ -/* - SDL - Simple DirectMedia Layer - Copyright (C) 1997-2010 Sam Lantinga - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Sam Lantinga - slouken@libsdl.org - - Contributed by Bob Pendleton, bob@pendleton.com -*/ - -#include "SDL_stdinc.h" -#include "SDL_atomic.h" - -#include "SDL_error.h" - -/* - This file provides 32, and 64 bit atomic operations. If the - operations are provided by the native hardware and operating system - they are used. If they are not then the operations are emulated - using the SDL spin lock operations. If spin lock can not be - implemented then these functions must fail. -*/ - -/* - DUMMY VERSION. - - This version of the code assumes there is no support for atomic - operations. Therefore, every function sets the SDL error - message. Oddly enough, if you only have one thread then this - version actuallys works. -*/ - -/* - Native spinlock routines. Because this is the dummy implementation - these will always call SDL_SetError() and do nothing. -*/ - -void -SDL_AtomicLock(SDL_SpinLock *lock) -{ - SDL_SetError("SDL_atomic.c: is not implemented on this platform"); -} - -void -SDL_AtomicUnlock(SDL_SpinLock *lock) -{ - SDL_SetError("SDL_atomic.c: is not implemented on this platform"); -} - -/* - Note that platform specific versions can be built from this version - by changing the #undefs to #defines and adding platform specific - code. -*/ - -#undef nativeTestThenSet32 -#undef nativeClear32 -#undef nativeFetchThenIncrement32 -#undef nativeFetchThenDecrement32 -#undef nativeFetchThenAdd32 -#undef nativeFetchThenSubtract32 -#undef nativeIncrementThenFetch32 -#undef nativeDecrementThenFetch32 -#undef nativeAddThenFetch32 -#undef nativeSubtractThenFetch32 - -#undef nativeTestThenSet64 -#undef nativeClear64 -#undef nativeFetchThenIncrement64 -#undef nativeFetchThenDecrement64 -#undef nativeFetchThenAdd64 -#undef nativeFetchThenSubtract64 -#undef nativeIncrementThenFetch64 -#undef nativeDecrementThenFetch64 -#undef nativeAddThenFetch64 -#undef nativeSubtractThenFetch64 - -/* - If any of the operations are not provided then we must emulate some - of them. That means we need a nice implementation of spin locks - that avoids the "one big lock" problem. We use a vector of spin - locks and pick which one to use based on the address of the operand - of the function. - - To generate the index of the lock we first shift by 3 bits to get - rid on the zero bits that result from 32 and 64 bit allignment of - data. We then mask off all but 5 bits and use those 5 bits as an - index into the table. - - Picking the lock this way insures that accesses to the same data at - the same time will go to the same lock. OTOH, accesses to different - data have only a 1/32 chance of hitting the same lock. That should - pretty much eliminate the chances of several atomic operations on - different data from waiting on the same "big lock". If it isn't - then the table of locks can be expanded to a new size so long as - the new size is a power of two. -*/ - -static SDL_SpinLock locks[32] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -}; - -static __inline__ void -privateWaitLock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicLock(&locks[index]); -} - -static __inline__ void -privateUnlock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicUnlock(&locks[index]); -} - -/* 32 bit atomic operations */ - -SDL_bool -SDL_AtomicTestThenSet32(volatile Uint32 * ptr) -{ -#ifdef nativeTestThenSet32 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear32(volatile Uint32 * ptr) -{ -#ifdef nativeClear32 -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint32 -SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenIncrement32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenDecrement32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenAdd32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenSubtract32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeIncrementThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeDecrementThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeAddThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeSubtractThenFetch32 -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -/* 64 bit atomic operations */ -#ifdef SDL_HAS_64BIT_TYPE - -SDL_bool -SDL_AtomicTestThenSet64(volatile Uint64 * ptr) -{ -#ifdef nativeTestThenSet64 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear64(volatile Uint64 * ptr) -{ -#ifdef nativeClear64 -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint64 -SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenIncrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenDecrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenAdd64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenSubtract64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeIncrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeDecrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeAddThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeSubtractThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} -#endif -
--- a/src/atomic/qnx/SDL_atomic.c Sat Jan 15 12:34:43 2011 -0800 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,505 +0,0 @@ -/* - SDL - Simple DirectMedia Layer - Copyright (C) 1997-2010 Sam Lantinga - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Sam Lantinga - slouken@libsdl.org - - QNX native atomic operations - Copyright (C) 2009 Mike Gorchak - (mike@malva.ua, lestat@i.com.ua) -*/ - -#include "SDL_stdinc.h" -#include "SDL_atomic.h" -#include "SDL_error.h" - -#include <atomic.h> - -/* SMP Exchange for PPC platform */ -#ifdef __PPC__ -#include <ppc/smpxchg.h> -#endif /* __PPC__ */ - -/* SMP Exchange for ARM platform */ -#ifdef __ARM__ -#include <arm/smpxchg.h> -#endif /* __ARM__ */ - -/* SMP Exchange for MIPS platform */ -#if defined (__MIPSEB__) || defined(__MIPSEL__) -#include <mips/smpxchg.h> -#endif /* __MIPSEB__ || __MIPSEL__ */ - -/* SMP Exchange for SH platform */ -#ifdef __SH__ -#include <sh/smpxchg.h> -#endif /* __SH__ */ - -/* SMP Exchange for x86 platform */ -#ifdef __X86__ -#include <x86/smpxchg.h> -#endif /* __X86__ */ - -/* - This file provides 32, and 64 bit atomic operations. If the - operations are provided by the native hardware and operating system - they are used. If they are not then the operations are emulated - using the SDL spin lock operations. If spin lock can not be - implemented then these functions must fail. -*/ - -void -SDL_AtomicLock(SDL_SpinLock *lock) -{ - unsigned volatile* l = (unsigned volatile*)lock; - Uint32 oldval = 0; - Uint32 newval = 1; - - oldval = _smp_xchg(l, newval); - while(1 == oldval) - { - oldval = _smp_xchg(l, newval); - } -} - -void -SDL_AtomicUnlock(SDL_SpinLock *lock) -{ - unsigned volatile* l = (unsigned volatile*)lock; - Uint32 newval = 0; - - _smp_xchg(l, newval); -} - -/* - QNX 6.4.1 supports only 32 bit atomic access -*/ - -#undef nativeTestThenSet32 -#define nativeClear32 -#define nativeFetchThenIncrement32 -#define nativeFetchThenDecrement32 -#define nativeFetchThenAdd32 -#define nativeFetchThenSubtract32 -#define nativeIncrementThenFetch32 -#define nativeDecrementThenFetch32 -#define nativeAddThenFetch32 -#define nativeSubtractThenFetch32 - -#undef nativeTestThenSet64 -#undef nativeClear64 -#undef nativeFetchThenIncrement64 -#undef nativeFetchThenDecrement64 -#undef nativeFetchThenAdd64 -#undef nativeFetchThenSubtract64 -#undef nativeIncrementThenFetch64 -#undef nativeDecrementThenFetch64 -#undef nativeAddThenFetch64 -#undef nativeSubtractThenFetch64 - -/* - If any of the operations are not provided then we must emulate some - of them. That means we need a nice implementation of spin locks - that avoids the "one big lock" problem. We use a vector of spin - locks and pick which one to use based on the address of the operand - of the function. - - To generate the index of the lock we first shift by 3 bits to get - rid on the zero bits that result from 32 and 64 bit allignment of - data. We then mask off all but 5 bits and use those 5 bits as an - index into the table. - - Picking the lock this way insures that accesses to the same data at - the same time will go to the same lock. OTOH, accesses to different - data have only a 1/32 chance of hitting the same lock. That should - pretty much eliminate the chances of several atomic operations on - different data from waiting on the same "big lock". If it isn't - then the table of locks can be expanded to a new size so long as - the new size is a power of two. -*/ - -static SDL_SpinLock locks[32] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -}; - -static __inline__ void -privateWaitLock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif /* SIZEOF_VOIDP */ - - SDL_AtomicLock(&locks[index]); -} - -static __inline__ void -privateUnlock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif /* SIZEOF_VOIDP */ - - SDL_AtomicUnlock(&locks[index]); -} - -/* 32 bit atomic operations */ - -SDL_bool -SDL_AtomicTestThenSet32(volatile Uint32 * ptr) -{ -#ifdef nativeTestThenSet32 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif /* nativeTestThenSet32 */ -} - -void -SDL_AtomicClear32(volatile Uint32 * ptr) -{ -#ifdef nativeClear32 - atomic_clr(ptr, 0xFFFFFFFF); -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif /* nativeClear32 */ -} - -Uint32 -SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenIncrement32 - return atomic_add_value(ptr, 0x00000001); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenIncrement32 */ -} - -Uint32 -SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenDecrement32 - return atomic_sub_value(ptr, 0x00000001); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenDecrement32 */ -} - -Uint32 -SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenAdd32 - return atomic_add_value(ptr, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenAdd32 */ -} - -Uint32 -SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenSubtract32 - return atomic_sub_value(ptr, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenSubtract32 */ -} - -Uint32 -SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeIncrementThenFetch32 - atomic_add(ptr, 0x00000001); - return atomic_add_value(ptr, 0x00000000); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeIncrementThenFetch32 */ -} - -Uint32 -SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeDecrementThenFetch32 - atomic_sub(ptr, 0x00000001); - return atomic_sub_value(ptr, 0x00000000); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeDecrementThenFetch32 */ -} - -Uint32 -SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeAddThenFetch32 - atomic_add(ptr, value); - return atomic_add_value(ptr, 0x00000000); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeAddThenFetch32 */ -} - -Uint32 -SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeSubtractThenFetch32 - atomic_sub(ptr, value); - return atomic_sub_value(ptr, 0x00000000); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeSubtractThenFetch32 */ -} - -/* 64 bit atomic operations */ -#ifdef SDL_HAS_64BIT_TYPE - -SDL_bool -SDL_AtomicTestThenSet64(volatile Uint64 * ptr) -{ -#ifdef nativeTestThenSet64 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif /* nativeTestThenSet64 */ -} - -void -SDL_AtomicClear64(volatile Uint64 * ptr) -{ -#ifdef nativeClear64 -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif /* nativeClear64 */ -} - -Uint64 -SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenIncrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenIncrement64 */ -} - -Uint64 -SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenDecrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenDecrement64 */ -} - -Uint64 -SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenAdd64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenAdd64 */ -} - -Uint64 -SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenSubtract64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif /* nativeFetchThenSubtract64 */ -} - -Uint64 -SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeIncrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeIncrementThenFetch64 */ -} - -Uint64 -SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeDecrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeDecrementThenFetch64 */ -} - -Uint64 -SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeAddThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeAddThenFetch64 */ -} - -Uint64 -SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeSubtractThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif /* nativeSubtractThenFetch64 */ -} - -#endif /* SDL_HAS_64BIT_TYPE */
--- a/src/atomic/win32/SDL_atomic.c Sat Jan 15 12:34:43 2011 -0800 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,512 +0,0 @@ -/* - SDL - Simple DirectMedia Layer - Copyright (C) 1997-2010 Sam Lantinga - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - - Sam Lantinga - slouken@libsdl.org - - Contributed by Bob Pendleton, bob@pendleton.com -*/ - -#include "SDL_stdinc.h" -#include "SDL_atomic.h" - -#define WIN32_LEAN_AND_MEAN -#include <windows.h> - -#include "SDL_error.h" - -/* - This file provides 32, and 64 bit atomic operations. If the - operations are provided by the native hardware and operating system - they are used. If they are not then the operations are emulated - using the SDL spin lock operations. If spin lock can not be - implemented then these functions must fail. -*/ - -/* - WIN32 VERSION. - - This makes use of native Windows atomic operations. -*/ - -/* - Native spinlock routines. Because this is the dummy implementation - these will always call SDL_SetError() and do nothing. -*/ - -void -SDL_AtomicLock(SDL_SpinLock *lock) -{ - long volatile * l = (long volatile *)lock; - Uint32 old = 0; - Uint32 new = 1; - - old = InterlockedExchange(l, new); - while(1 == old) - { - old = InterlockedExchange(l, new); - } -} - -void -SDL_AtomicUnlock(SDL_SpinLock *lock) -{ - long volatile * l = (long volatile *)lock; - Uint32 new = 0; - - InterlockedExchange(l, new); -} - -/* - Note that platform specific versions can be built from this version - by changing the #undefs to #defines and adding platform specific - code. -*/ - -#define nativeTestThenSet32 -#define nativeClear32 -#define nativeFetchThenIncrement32 -#define nativeFetchThenDecrement32 -#define nativeFetchThenAdd32 -#define nativeFetchThenSubtract32 -#define nativeIncrementThenFetch32 -#define nativeDecrementThenFetch32 -#define nativeAddThenFetch32 -#define nativeSubtractThenFetch32 - -#undef nativeTestThenSet64 -#undef nativeClear64 -#undef nativeFetchThenIncrement64 -#undef nativeFetchThenDecrement64 -#undef nativeFetchThenAdd64 -#undef nativeFetchThenSubtract64 -#undef nativeIncrementThenFetch64 -#undef nativeDecrementThenFetch64 -#undef nativeAddThenFetch64 -#undef nativeSubtractThenFetch64 - -/* - If any of the operations are not provided then we must emulate some - of them. That means we need a nice implementation of spin locks - that avoids the "one big lock" problem. We use a vector of spin - locks and pick which one to use based on the address of the operand - of the function. - - To generate the index of the lock we first shift by 3 bits to get - rid on the zero bits that result from 32 and 64 bit allignment of - data. We then mask off all but 5 bits and use those 5 bits as an - index into the table. - - Picking the lock this way insures that accesses to the same data at - the same time will go to the same lock. OTOH, accesses to different - data have only a 1/32 chance of hitting the same lock. That should - pretty much eliminate the chances of several atomic operations on - different data from waiting on the same "big lock". If it isn't - then the table of locks can be expanded to a new size so long as - the new size is a power of two. -*/ - -static SDL_SpinLock locks[32] = { - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, -}; - -static __inline__ void -privateWaitLock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicLock(&locks[index]); -} - -static __inline__ void -privateUnlock(volatile void *ptr) -{ -#if SIZEOF_VOIDP == 4 - Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); -#elif SIZEOF_VOIDP == 8 - Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); -#endif - - SDL_AtomicUnlock(&locks[index]); -} - -/* 32 bit atomic operations */ - -SDL_bool -SDL_AtomicTestThenSet32(volatile Uint32 * ptr) -{ -#ifdef nativeTestThenSet32 - long volatile * p = (long volatile *)ptr; - Uint32 new = 1; - - return 0 == InterlockedExchange(p, new); -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear32(volatile Uint32 * ptr) -{ -#ifdef nativeClear32 - long volatile * p = (long volatile *)ptr; - Uint32 new = 0; - - InterlockedExchange(p, new); -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint32 -SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenIncrement32 - long volatile * p = (long volatile *)ptr; - - return InterlockedExchangeAdd(p, 1); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) -{ -#ifdef nativeFetchThenDecrement32 - long volatile * p = (long volatile *)ptr; - - return InterlockedExchangeAdd(p, -1); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenAdd32 - long volatile * p = (long volatile *)ptr; - - return InterlockedExchangeAdd(p, value); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeFetchThenSubtract32 - long volatile * p = (long volatile *)ptr; - - return InterlockedExchangeAdd(p, (0 - value)); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeIncrementThenFetch32 - long volatile * p = (LONG volatile *)ptr; - - return InterlockedIncrement(p); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) -{ -#ifdef nativeDecrementThenFetch32 - long volatile * p = (LONG volatile *)ptr; - - return InterlockedDecrement(p); -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeAddThenFetch32 - long volatile * p = (long volatile *)ptr; - - return InterlockedExchangeAdd(p, value) + value; -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint32 -SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) -{ -#ifdef nativeSubtractThenFetch32 - long volatile * p = (long volatile *)ptr; - - return InterlockedExchangeAdd(p, (0 - value)) - value; -#else - Uint32 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -/* 64 bit atomic operations */ -#ifdef SDL_HAS_64BIT_TYPE - -SDL_bool -SDL_AtomicTestThenSet64(volatile Uint64 * ptr) -{ -#ifdef nativeTestThenSet64 -#else - SDL_bool result = SDL_FALSE; - - privateWaitLock(ptr); - result = (*ptr == 0); - if (result) - { - *ptr = 1; - } - privateUnlock(ptr); - - return result; -#endif -} - -void -SDL_AtomicClear64(volatile Uint64 * ptr) -{ -#ifdef nativeClear64 -#else - privateWaitLock(ptr); - *ptr = 0; - privateUnlock(ptr); - - return; -#endif -} - -Uint64 -SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenIncrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) -{ -#ifdef nativeFetchThenDecrement64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr) -= 1; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenAdd64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)+= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeFetchThenSubtract64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - tmp = *ptr; - (*ptr)-= value; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeIncrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) -{ -#ifdef nativeDecrementThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= 1; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeAddThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)+= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} - -Uint64 -SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) -{ -#ifdef nativeSubtractThenFetch64 -#else - Uint64 tmp = 0; - - privateWaitLock(ptr); - (*ptr)-= value; - tmp = *ptr; - privateUnlock(ptr); - - return tmp; -#endif -} -#endif -
--- a/test/testatomic.c Sat Jan 15 12:34:43 2011 -0800 +++ b/test/testatomic.c Sat Jan 15 12:41:59 2011 -0800 @@ -1,18 +1,6 @@ #include <stdio.h> #include "SDL.h" -/* Make sure we have good macros for printing 32 and 64 bit values */ -#ifndef PRIu32 -#define PRIu32 "u" -#endif -#ifndef PRIu64 -#ifdef __WIN32__ -#define PRIu64 "I64u" -#else -#define PRIu64 "llu" -#endif -#endif - /* Absolutely basic tests just to see if we get the expected value after calling each function. @@ -21,109 +9,60 @@ char * tf(SDL_bool tf) { - static char *t = "true"; - static char *f = "false"; + static char *t = "TRUE"; + static char *f = "FALSE"; - if (tf) - { - return t; - } + if (tf) + { + return t; + } - return f; + return f; } int main(int argc, char *argv[]) { - - volatile Uint32 val32 = 0; - Uint32 ret32 = 0; - - volatile Uint64 val64 = 0; - Uint64 ret64 = 0; - - SDL_SpinLock lock = 0; + int value; + SDL_SpinLock lock = 0; - SDL_bool tfret = SDL_FALSE; - - printf("\nspin lock---------------------------------------\n\n"); + SDL_bool tfret = SDL_FALSE; - SDL_AtomicLock(&lock); - printf("AtomicLock lock=%d\n", lock); - SDL_AtomicUnlock(&lock); - printf("AtomicUnlock lock=%d\n", lock); - - printf("\n32 bit -----------------------------------------\n\n"); + printf("\nspin lock---------------------------------------\n\n"); - val32 = 0; - tfret = SDL_AtomicTestThenSet32(&val32); - printf("TestThenSet32 tfret=%s val=%"PRIu32"\n", tf(tfret), val32); - tfret = SDL_AtomicTestThenSet32(&val32); - printf("TestThenSet32 tfret=%s val=%"PRIu32"\n", tf(tfret), val32); + SDL_AtomicLock(&lock); + printf("AtomicLock lock=%d\n", lock); + SDL_AtomicUnlock(&lock); + printf("AtomicUnlock lock=%d\n", lock); - SDL_AtomicClear32(&val32); - printf("Clear32 val=%"PRIu32"\n", val32); - - ret32 = SDL_AtomicFetchThenIncrement32(&val32); - printf("FetchThenIncrement32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); + printf("\natomic -----------------------------------------\n\n"); - ret32 = SDL_AtomicFetchThenDecrement32(&val32); - printf("FetchThenDecrement32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); - - ret32 = SDL_AtomicFetchThenAdd32(&val32, 10); - printf("FetchThenAdd32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); - - ret32 = SDL_AtomicFetchThenSubtract32(&val32, 10); - printf("FetchThenSubtract32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); - - ret32 = SDL_AtomicIncrementThenFetch32(&val32); - printf("IncrementThenFetch32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); + SDL_atomic_t v; + + SDL_AtomicSet(&v, 0); + tfret = SDL_AtomicSet(&v, 10) == 0; + printf("AtomicSet(10) tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); + tfret = SDL_AtomicAdd(&v, 10) == 10; + printf("AtomicAdd(10) tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); - ret32 = SDL_AtomicDecrementThenFetch32(&val32); - printf("DecrementThenFetch32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); - - ret32 = SDL_AtomicAddThenFetch32(&val32, 10); - printf("AddThenFetch32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); - - ret32 = SDL_AtomicSubtractThenFetch32(&val32, 10); - printf("SubtractThenFetch32 ret=%"PRIu32" val=%"PRIu32"\n", ret32, val32); - -#ifdef SDL_HAS_64BIT_TYPE - printf("\n64 bit -----------------------------------------\n\n"); - - val64 = 0; - tfret = SDL_AtomicTestThenSet64(&val64); - printf("TestThenSet64 tfret=%s val=%"PRIu64"\n", tf(tfret), val64); - tfret = SDL_AtomicTestThenSet64(&val64); - printf("TestThenSet64 tfret=%s val=%"PRIu64"\n", tf(tfret), val64); - - SDL_AtomicClear64(&val64); - printf("Clear64 val=%"PRIu64"\n", val64); - - ret64 = SDL_AtomicFetchThenIncrement64(&val64); - printf("FetchThenIncrement64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); + SDL_AtomicSet(&v, 0); + SDL_AtomicIncRef(&v); + tfret = (SDL_AtomicGet(&v) == 1); + printf("AtomicIncRef() tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); + SDL_AtomicIncRef(&v); + tfret = (SDL_AtomicGet(&v) == 2); + printf("AtomicIncRef() tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); + tfret = (SDL_AtomicDecRef(&v) == SDL_FALSE); + printf("AtomicDecRef() tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); + tfret = (SDL_AtomicDecRef(&v) == SDL_TRUE); + printf("AtomicDecRef() tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); - ret64 = SDL_AtomicFetchThenDecrement64(&val64); - printf("FetchThenDecrement64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); - - ret64 = SDL_AtomicFetchThenAdd64(&val64, 10); - printf("FetchThenAdd64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); - - ret64 = SDL_AtomicFetchThenSubtract64(&val64, 10); - printf("FetchThenSubtract64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); - - ret64 = SDL_AtomicIncrementThenFetch64(&val64); - printf("IncrementThenFetch64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); + SDL_AtomicSet(&v, 10); + tfret = (SDL_AtomicCAS(&v, 0, 20) != 0); + printf("AtomicCAS() tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); + value = SDL_AtomicGet(&v); + tfret = (SDL_AtomicCAS(&v, value, 20) == value); + printf("AtomicCAS() tfret=%s val=%"PRIu32"\n", tf(tfret), SDL_AtomicGet(&v)); - ret64 = SDL_AtomicDecrementThenFetch64(&val64); - printf("DecrementThenFetch64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); - - ret64 = SDL_AtomicAddThenFetch64(&val64, 10); - printf("AddThenFetch64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); - - ret64 = SDL_AtomicSubtractThenFetch64(&val64, 10); - printf("SubtractThenFetch64 ret=%"PRIu64" val=%"PRIu64"\n", ret64, val64); -#endif - - return 0; - } + return 0; +}