开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
atomicbase.h
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：53k
源码类别：

Symbian

开发平台：

C/C++

atomicbase.h：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  37. /***********************************************************************
  38.  *  THIS CODE IS HIGHLY CRITICAL TO THE SERVER'S STABILITY!!!
  39.  *  DO NOT MAKE CHANGES TO THE ATOMIC OPERATORS OR TO THE
  40.  *  MUTEX CODE WITHOUT A SERVER TEAM CODE-REVIEW! (dev@helix-server)
  41.  */
  44. /****************************************************************************
  45.  *  $Id: atomicbase.h,v 1.23.2.2 2004/01/26 23:46:02 rggammon Exp $
  46.  *
  47.  *  atomicbase.h - Defines several atomic operations
  48.  * 
  49.  *  See server/common/util/pub/servatomic.h for broader platform support.
  50.  *  Also conditionally overrides InterlockedIncrement/Decrement
  51.  *  via USE_HX_ATOMIC_INTERLOCKED_INC_DEC.
  52.  *
  53.  *
  54.  ***********************************************************************
  55.  *
  56.  * Defines:
  57.  *
  58.  * void HXAtomicIncINT32(INT32* p)             -- Increment *p
  59.  * void HXAtomicDecINT32(INT32* p)             -- Decrement *p
  60.  * void HXAtomicAddINT32(INT32* p, INT32 n)    -- Increment *p by n 
  61.  * void HXAtomicSubINT32(INT32* p, INT32 n)    -- Decrement *p by n
  62.  * INT32 HXAtomicIncRetINT32(INT32* p)         -- Increment *p and return it
  63.  * INT32 HXAtomicDecRetINT32(INT32* p)         -- Decrement *p and return it
  64.  * INT32 HXAtomicAddRetINT32(INT32* p, INT32 n)-- Increment *p by n, return it
  65.  * INT32 HXAtomicSubRetINT32(INT32* p, INT32 n)-- Increment *p by n, return it
  66.  *
  67.  *
  68.  * There are also UINT32 versions:
  69.  *
  70.  * void HXAtomicIncUINT32(UINT32* p)
  71.  * void HXAtomicDecUINT32(UINT32* p)
  72.  * void HXAtomicAddUINT32(UINT32* p, UINT32 n)
  73.  * void HXAtomicSubUINT32(UINT32* p, UINT32 n)
  74.  * UINT32 HXAtomicIncRetUINT32(UINT32* p)
  75.  * UINT32 HXAtomicDecRetUINT32(UINT32* p)
  76.  * UINT32 HXAtomicAddRetUINT32(UINT32* p, UINT32 n)
  77.  * UINT32 HXAtomicSubRetUINT32(UINT32* p, UINT32 n)
  78.  *
  79.  ***********************************************************************
  80.  *
  81.  * TODO:
  82.  *   Add INT64 versions
  83.  *   Obsolete the 0x80000000-based Solaris implementation entirely.
  84.  *
  85.  ***********************************************************************/
  86. #ifndef _ATOMICBASE_H_
  87. #define _ATOMICBASE_H_
  90. /***********************************************************************
  91.  * Sun Solaris / SPARC (Native compiler)
  92.  *
  93.  * Implementation Notes:
  94.  * This uses inline assembly from server/common/util/platform/solaris/atomicops.il
  95.  * Note: Sparc/gcc is in include/atomicbase.h
  96.  */
  97. #if defined (_SOLARIS) && !defined (__GNUC__)
  99. #if defined(__cplusplus)
  100. extern "C" {
  101. #endif
  102.     //UINT32 _HXAtomicIncRetUINT32 (UINT32* pNum);
  103.     //UINT32 _HXAtomicDecRetUINT32 (UINT32* pNum);
  104.     UINT32 _HXAtomicAddRetUINT32 (UINT32* pNum, UINT32 ulNum);
  105.     UINT32 _HXAtomicSubRetUINT32 (UINT32* pNum, UINT32 ulNum);
  106. #if defined(__cplusplus)
  107. }
  108. #endif
  111. #define HXAtomicIncUINT32(p)      _HXAtomicAddRetUINT32((p),(UINT32)1)
  112. #define HXAtomicDecUINT32(p)      _HXAtomicSubRetUINT32((p),(UINT32)1)
  113. #define HXAtomicIncRetUINT32(p)   _HXAtomicAddRetUINT32((p),(UINT32)1)
  114. #define HXAtomicDecRetUINT32(p)   _HXAtomicSubRetUINT32((p),(UINT32)1)
  115. #define HXAtomicAddUINT32(p,n)    _HXAtomicAddRetUINT32((p),(n))
  116. #define HXAtomicSubUINT32(p,n)    _HXAtomicSubRetUINT32((p),(n))
  117. #define HXAtomicAddRetUINT32(p,n) _HXAtomicAddRetUINT32((p),(n))
  118. #define HXAtomicSubRetUINT32(p,n) _HXAtomicSubRetUINT32((p),(n))
  120. inline void HXAtomicIncINT32(INT32* p)              { HXAtomicIncUINT32((UINT32*)p); }
  121. inline void HXAtomicDecINT32(INT32* p)              { HXAtomicDecUINT32((UINT32*)p); }
  122. inline void HXAtomicAddINT32(INT32* p, INT32 n)     { HXAtomicAddUINT32((UINT32*)p, (UINT32)n); }
  123. inline void HXAtomicSubINT32(INT32* p, INT32 n)     { HXAtomicSubUINT32((UINT32*)p, (UINT32)n); }
  124. inline INT32 HXAtomicIncRetINT32(INT32* p)          { return HXAtomicIncRetUINT32((UINT32*)p); }
  125. inline INT32 HXAtomicDecRetINT32(INT32* p)          { return HXAtomicDecRetUINT32((UINT32*)p); }
  126. inline INT32 HXAtomicAddRetINT32(INT32* p, INT32 n) { return HXAtomicAddRetUINT32((UINT32*)p, (UINT32)n); }
  127. inline INT32 HXAtomicSubRetINT32(INT32* p, INT32 n) { return HXAtomicSubRetUINT32((UINT32*)p, (UINT32)n); }
  131. /***********************************************************************
  132.  * Sun Solaris / SPARC (gcc)
  133.  *
  134.  * Implementation Notes:
  135.  * The sparc method of pipelining and use of "delay slots" requires
  136.  * the nop's.  Be extra careful modifying these routines!
  137.  *
  138.  * This implementation sacrifices being able to store the value
  139.  * 0x800000000 in the INT32 value, which is a special "busy" marker value.
  140.  * Since these are intended for use primarily with AddRef/Release and
  141.  * resource usage counters, this should be acceptable for now.  If a counter
  142.  * is incremented to the point it would conflict with the flag, it is
  143.  * incremented one more to hop over it.  The same in reverse for decrement.
  144.  * This is far from ideal, however...  See the inline-assembly file
  145.  * server/common/util/platform/solaris/mutex_setbit.il for *much*
  146.  * better implementations using newer sparc assembly operators.
  147.  *
  148.  * Basic design of the flag-based implementation:
  149.  *   1. Load a register with 0x80000000
  150.  *   2. _atomically_ swap it with the INT32 (critical!)
  151.  *   3. Compare what we got with 0x80000000
  152.  *   4. Branch if equal to #2
  153.  *   5. Increment (or decrement) the result
  154.  *   6. Compare to 0x80000000
  155.  *   7. Branch if equal to #5
  156.  *   8. Save the new value to the INT32's location in memory
  157.  *   9. Return new INT32 result if required
  158.  *   
  159.  * This implementation primarily exists due to limitations in the ancient
  160.  * version of gcc we used to use on Solaris (2.7.2.3), and more modern
  161.  * gcc's can probably handle assembly more like what's used in Sun's
  162.  * Native compiler version.  
  163.  *
  164.  */
  165. #elif defined (__sparc__) && defined (__GNUC__)
  167. /* Increment by 1 */
  168. inline void
  169. HXAtomicIncUINT32(UINT32* pNum)
  170. {
  171.     __asm__ __volatile__(
  172. "1:      swap    [%0], %2;               ! Swap *pNum and %2n"
  173. "        nop;                            ! delay slot...n"
  174. "        cmp     %2, %1;                 ! Is someone else using pNum?n"
  175. "        be      1b;                     ! If so, retry...n"
  176. "        nop;                            ! delay slot...yawnn"
  177. "2:      inc     %2;                     ! Increment %2n"
  178. "        cmp     %2, %1;                 ! check for overflown"
  179. "        be      2b;                     ! if so, inc againn"
  180. "        nop;                            ! but this means a delay, sighn"
  181. "        st      %2, [%0];               ! Save new value into *pNumn"
  182.         : /* no output */
  183.         : "r" (pNum), "r" (0x80000000), "r" (0x80000000)
  184.         : "cc", "memory"
  185.         );
  186. }
  188. /* Decrement by 1 */
  189. inline void
  190. HXAtomicDecUINT32(UINT32* pNum)
  191. {
  192.     __asm__ __volatile__(
  193. "1:      swap    [%0], %2;               ! Swap *pNum and %2n"
  194. "        nop;                            ! delay slot...n"
  195. "        cmp     %2, %1;                 ! Is someone else using pNum?n"
  196. "        be      1b;                     ! If so, retry...n"
  197. "        nop;                            ! delay slot...yawnn"
  198. "2:      dec     %2;                     ! Increment %2n"
  199. "        cmp     %2, %1;                 ! check for overflown"
  200. "        be      2b;                     ! if so, dec againn"
  201. "        nop;                            ! but this means a delay, sighn"
  202. "        st      %2, [%0];               ! Save new value into *pNumn"
  203.         : /* no output */
  204.         : "r" (pNum), "r" (0x80000000), "r" (0x80000000)
  205.         : "cc", "memory"
  206.         );
  207. }
  209. /* Increment by 1 and return new value */
  210. inline UINT32
  211. HXAtomicIncRetUINT32(UINT32* pNum)
  212. {
  213.     volatile UINT32 ulRet;
  214.     __asm__ __volatile__(
  215. "        mov     %2, %0;                 ! Copy %2 to %0 n"
  216. "1:      swap    [%1], %0;               ! Swap *pNum and %0n"
  217. "        nop;                            ! delay slot...n"
  218. "        cmp     %0, %2;                 ! Is someone else using pNum?n"
  219. "        be      1b;                     ! If so, retry...n"
  220. "        nop;                            ! delay slot...yawnn"
  221. "2:      inc     %0;                     ! Increment %0n"
  222. "        cmp     %0, %2;                 ! check for overflown"
  223. "        be      2b;                     ! if so, inc againn"
  224. "        nop;                            ! but this means a delay, sighn"
  225. "        st      %0, [%1];               ! Save new value into *pNumn"
  226.         : "=r" (ulRet)
  227.         : "r" (pNum), "r" (0x80000000), "0" (ulRet)
  228.         : "cc", "memory"
  229.         );
  230.     return ulRet;
  231. }
  233. /* Decrement by 1 and return new value */
  234. inline UINT32
  235. HXAtomicDecRetUINT32(UINT32* pNum)
  236. {   volatile UINT32 ulRet;
  237.     __asm__ __volatile__(
  238. "        mov     %2, %0;                 ! Copy %2 to %0 n"
  239. "1:      swap    [%1], %0;               ! Swap *pNum and %0n"
  240. "        nop;                            ! delay slot...n"
  241. "        cmp     %0, %2;                 ! Is someone else using pNum?n"
  242. "        be      1b;                     ! If so, retry...n"
  243. "        nop;                            ! delay slot...yawnn"
  244. "2:      dec     %0;                     ! Decrement %0n"
  245. "        cmp     %0, %2;                 ! check for overflown"
  246. "        be      2b;                     ! if so, dec againn"
  247. "        nop;                            ! but this means a delay, sighn"
  248. "        st      %0, [%1];               ! Save new value into *pNumn"
  249.         : "=r" (ulRet)
  250.         : "r" (pNum), "r" (0x80000000), "0" (ulRet)
  251.         : "cc", "memory"
  252.         );
  253.     return ulRet;
  254. }
  256. /* Add n */
  257. inline void
  258. HXAtomicAddUINT32(UINT32* pNum, UINT32 ulNum)
  259. {
  260.     __asm__ __volatile__(
  261. "1:      swap    [%0], %2;               ! Swap *pNum and %2n"
  262. "        nop;                            ! delay slot...n"
  263. "        cmp     %2, %1;                 ! Is someone else using pNum?n"
  264. "        be      1b;                     ! If so, retry...n"
  265. "        nop;                            ! delay slot...yawnn"
  266. "        add     %2, %3, %2;             ! Add ulNum to %2n"
  267. "        cmp     %2, %1;                 ! check for overflown"
  268. "        bne     2f;                     ! if not, skip to the endn"
  269. "        nop;                            ! but this means a delay, sighn"
  270. "        inc     %2;                     ! skip marker valuen"
  271. "2:      st      %2, [%0];               ! Save new value into *pNumn"
  272.         : /* no output */
  273.         : "r" (pNum), "r" (0x80000000), "r" (0x80000000), "r" (ulNum)
  274.         : "cc", "memory"
  275.         );
  276. }
  278. /* Subtract n */
  279. inline void
  280. HXAtomicSubUINT32(UINT32* pNum, UINT32 ulNum)
  281. {
  282.     __asm__ __volatile__(
  283. "1:      swap    [%0], %2;               ! Swap *pNum and %2n"
  284. "        nop;                            ! delay slot...n"
  285. "        cmp     %2, %1;                 ! Is someone else using pNum?n"
  286. "        be      1b;                     ! If so, retry...n"
  287. "        nop;                            ! delay slot...yawnn"
  288. "        sub     %2, %3, %2;             ! Subtract ulNum to %2n"
  289. "        cmp     %2, %1;                 ! check for overflown"
  290. "        bne     2f;                     ! if not, skip to the endn"
  291. "        nop;                            ! but this means a delay, sighn"
  292. "        inc     %2;                     ! skip marker valuen"
  293. "2:      st      %2, [%0];               ! Save new value into *pNumn"
  294.         : /* no output */
  295.         : "r" (pNum), "r" (0x80000000), "r" (0x80000000), "r" (ulNum)
  296.         : "cc", "memory"
  297.         );
  298. }
  300. /* Add n and return new value */
  301. inline UINT32
  302. HXAtomicAddRetUINT32(UINT32* pNum, UINT32 ulNum)
  303. {
  304.     volatile UINT32 ulRet; 
  305.     __asm__ __volatile__(
  306. "        mov     %2, %0                  ! Copy %2 to %0 n"
  307. "1:      swap    [%1], %0;               ! Swap *pNum and %0n"
  308. "        nop;                            ! delay slot...n"
  309. "        cmp     %0, %2;                 ! Is someone else using pNum?n"
  310. "        be      1b;                     ! If so, retry...n"
  311. "        nop;                            ! delay slot...yawnn"
  312. "        add     %0, %3, %0;             ! Add ulNum to %0n"
  313. "        cmp     %0, %2;                 ! check for overflown"
  314. "        bne     2f;                     ! if not, skip to the endn"
  315. "        nop;                            ! but this means a delay, sighn"
  316. "        inc     %0;                     ! skip marker valuen"
  317. "2:      st      %0, [%1];               ! Save new value into *pNumn"
  318.         : "=r" (ulRet)
  319.         : "r" (pNum), "r" (0x80000000), "r" (ulNum), "0" (ulRet)
  320.         : "cc", "memory"
  321.         );
  322.         return ulRet;
  323. }
  325. /* Subtract n and return new value */
  326. inline UINT32
  327. HXAtomicSubRetUINT32(UINT32* pNum, UINT32 ulNum)
  328. {   volatile UINT32 ulRet;
  329.     __asm__ __volatile__(
  330. "        mov     %2, %0                  ! Copy %2 to %0 n"
  331. "1:      swap    [%1], %0;               ! Swap *pNum and %0n"
  332. "        nop;                            ! delay slot...n"
  333. "        cmp     %0, %2;                 ! Is someone else using pNum?n"
  334. "        be      1b;                     ! If so, retry...n"
  335. "        nop;                            ! delay slot...yawnn"
  336. "        sub     %0, %3, %0;             ! Sub ulNum from %0n"
  337. "        cmp     %0, %2;                 ! check for overflown"
  338. "        bne     2f;                     ! if not, skip to the endn"
  339. "        nop;                            ! but this means a delay, sighn"
  340. "        dec     %0;                     ! skip marker valuen"
  341. "2:      st      %0, [%1];               ! Save new value into *pNumn"
  342.         : "=r" (ulRet)
  343.         : "r" (pNum), "r" (0x80000000), "r" (ulNum), "0" (ulRet)
  344.         : "cc", "memory"
  345.         );
  346.         return ulRet;
  347. }
  349. inline void HXAtomicIncINT32(INT32* p)              { HXAtomicIncUINT32((UINT32*)p); }
  350. inline void HXAtomicDecINT32(INT32* p)              { HXAtomicDecUINT32((UINT32*)p); }
  351. inline void HXAtomicAddINT32(INT32* p, INT32 n)     { HXAtomicAddUINT32((UINT32*)p, (UINT32)n); }
  352. inline void HXAtomicSubINT32(INT32* p, INT32 n)     { HXAtomicSubUINT32((UINT32*)p, (UINT32)n); }
  353. inline INT32 HXAtomicIncRetINT32(INT32* p)          { return HXAtomicIncRetUINT32((UINT32*)p); }
  354. inline INT32 HXAtomicDecRetINT32(INT32* p)          { return HXAtomicDecRetUINT32((UINT32*)p); }
  355. inline INT32 HXAtomicAddRetINT32(INT32* p, INT32 n) { return HXAtomicAddRetUINT32((UINT32*)p, (UINT32)n); }
  356. inline INT32 HXAtomicSubRetINT32(INT32* p, INT32 n) { return HXAtomicSubRetUINT32((UINT32*)p, (UINT32)n); }
  360. /***********************************************************************
  361.  * Windows / x86 (Visual C/C++)
  362.  *
  363.  * Implementation Notes:
  364.  *   'xadd' is only available in the 486 series and later, not the 386.
  365.  *   There is no 'xsub' counterpart, you have to negate the operand
  366.  *   and use 'xadd'.  Note the use of the 'lock' prefix to ensure
  367.  *   certain operations occur atomically.
  368.  */
  369. #elif defined (_M_IX86) /* && _M_IX86 > 300 XXX wschildbach: disabled until the build system delivers the correct value */
  371. /* Increment by 1 */
  372. static __inline void
  373. HXAtomicIncUINT32(UINT32* pNum)
  374. {
  375.         // register usage summary:
  376.         //   eax - pointer to the value we're modifying
  377.     _asm
  378.     {
  379.              mov  eax, pNum              ; Load the pointer into a register
  380.         lock inc  dword ptr [eax]        ; Atomically increment *pNum
  381.     }
  382. }
  384. /* Decrement by 1 */
  385. static __inline void
  386. HXAtomicDecUINT32(UINT32* pNum)
  387. {
  388.         // register usage summary:
  389.         //   eax - pointer to the value we're modifying
  390.     _asm
  391.     {
  392.              mov  eax,  pNum             ; Load the pointer into a register
  393.         lock dec  dword ptr [eax]        ; Atomically decrement *pNum
  394.     }
  395. }
  397. /* Increment by 1 and return new value */
  398. static __inline UINT32
  399. HXAtomicIncRetUINT32(UINT32* pNum)
  400. {
  401.     volatile UINT32 ulRet;     
  402.         // register usage summary:
  403.         //   eax - pointer to the value we're modifying
  404.         //   ebx - work register
  405.     _asm
  406.     {
  407.              mov  eax, pNum              ; Load the pointer into a register
  408.              mov  ebx, 0x1               ; Load increment amount into a register
  409.         lock xadd dword ptr [eax], ebx   ; Increment *pNum; ebx gets old value
  410.              inc  ebx                    ; Increment old value
  411.              mov  ulRet, ebx             ; Set the return value
  412.     }
  413.     return ulRet;
  414. }
  416. /* Decrement by 1 and return new value */
  417. static __inline UINT32
  418. HXAtomicDecRetUINT32(UINT32* pNum)
  419. {   
  420.     volatile UINT32 ulRet;
  421.         // register usage summary:
  422.         //   eax - pointer to the value we're modifying
  423.         //   ebx - work register
  424.         // note: we increment by 0xffffffff to decrement by 1
  425.     _asm
  426.     {
  427.              mov  eax, pNum              ; Load the pointer into a register
  428.              mov  ebx, 0xffffffff        ; Load decrement amount into a register
  429.         lock xadd dword ptr [eax], ebx   ; Decrement *pNum; ebx gets old value
  430.              dec  ebx                    ; decrement old value
  431.              mov  ulRet, ebx             ; Set the return value
  432.     }
  433.     return ulRet;
  434. }
  436. /* Add n */
  437. static __inline void
  438. HXAtomicAddUINT32(UINT32* pNum, UINT32 ulNum)
  439. {
  440.         // register usage summary:
  441.         //   eax - pointer to the value we're modifying
  442.         //   ebx - work register
  443.     _asm
  444.     {
  445.              mov  eax, pNum              ; Load the pointer into a register
  446.              mov  ebx, ulNum             ; Load increment amount into a register
  447.         lock add  dword ptr [eax], ebx   ; Increment *pNum by ulNum
  448.     }
  449. }
  451. /* Subtract n */
  452. static __inline void
  453. HXAtomicSubUINT32(UINT32* pNum, UINT32 ulNum)
  454. {
  455.         // register usage summary:
  456.         //   eax - pointer to the value we're modifying
  457.         //   ebx - work register
  458.     _asm
  459.     {
  460.              mov  eax, pNum              ; Load the pointer into a register
  461.              mov  ebx, ulNum             ; Load increment amount into a register
  462.         lock sub  dword ptr [eax], ebx   ; Atomically decrement *pNum by ulNum
  463.     }
  464. }
  466. /* Add n and return new value */
  467. static __inline UINT32
  468. HXAtomicAddRetUINT32(UINT32* pNum, UINT32 ulNum)
  469. {
  470.     volatile UINT32 ulRet;
  471.         // register usage summary:
  472.         //   eax - pointer to the value we're modifying
  473.         //   ebx - work register
  474.         //   ecx - work register #2
  475.     _asm
  476.     {
  477.              mov  eax, pNum              ; Load the pointer into a register
  478.              mov  ebx, ulNum             ; Load increment amount into a register
  479.              mov  ecx, ebx               ; copy ebx into ecx
  480.         lock xadd dword ptr [eax], ecx   ; Increment *pNum; ecx gets old value
  481.              add  ecx, ebx               ; Add ulNum to it
  482.              mov  ulRet, ecx             ; save result in ulRet
  483.     }
  484.     return ulRet;
  485. }
  487. /* Subtract n and return new value */
  488. static __inline UINT32
  489. HXAtomicSubRetUINT32(UINT32* pNum, UINT32 ulNum) 
  490. {   
  491.     volatile UINT32 ulRet;
  492.         // register usage summary:
  493.         //   eax - pointer to the value we're modifying
  494.         //   ebx - work register
  495.         //   ecx - work register #2
  496.     _asm
  497.     {
  498.              mov  eax, pNum              ; Load the pointer into a register
  499.              mov  ebx, ulNum             ; Load increment amount into a register
  500.              mov  ecx, 0x0               ; zero out ecx
  501.              sub  ecx, ebx               ; compute -(ulNum), saving in ecx
  502.         lock xadd dword ptr [eax], ecx   ; Decrement *pNum; ecx gets old value
  503.              sub  ecx, ebx               ; subtract ulNum from it
  504.              mov  ulRet, ecx             ; save result in ulRet
  505.     }
  506.     return ulRet;
  507. }
  509. static __inline void HXAtomicIncINT32(INT32* p)              { HXAtomicIncUINT32((UINT32*)p); }
  510. static __inline void HXAtomicDecINT32(INT32* p)              { HXAtomicDecUINT32((UINT32*)p); }
  511. static __inline void HXAtomicAddINT32(INT32* p, INT32 n)     { HXAtomicAddUINT32((UINT32*)p, (UINT32)n); }
  512. static __inline void HXAtomicSubINT32(INT32* p, INT32 n)     { HXAtomicSubUINT32((UINT32*)p, (UINT32)n); }
  513. static __inline INT32 HXAtomicIncRetINT32(INT32* p)          { return HXAtomicIncRetUINT32((UINT32*)p); }
  514. static __inline INT32 HXAtomicDecRetINT32(INT32* p)          { return HXAtomicDecRetUINT32((UINT32*)p); }
  515. static __inline INT32 HXAtomicAddRetINT32(INT32* p, INT32 n) { return HXAtomicAddRetUINT32((UINT32*)p, (UINT32)n); }
  516. static __inline INT32 HXAtomicSubRetINT32(INT32* p, INT32 n) { return HXAtomicSubRetUINT32((UINT32*)p, (UINT32)n); }
  520. /***********************************************************************
  521.  * Intel x86 (gcc) / Unix  -- i486 and higher
  522.  *
  523.  * Implementation Notes:
  524.  *   'xadd' is only available in the 486 series and later, not the 386.
  525.  *   There is no 'xsub' counterpart, you have to negate the operand
  526.  *   and use 'xadd'.  Note the use of the 'lock' prefix to ensure
  527.  *   certain operations occur atomically.
  528.  *
  529.  *   OpenBSD is excluded since the standard assembler on x86 systems
  530.  *   can't handle the xadd instruction.
  531.  *
  532.  */
  533. #elif defined(__GNUC__) && !defined(_OPENBSD) && 
  534.       (__GNUC__>2 || (__GNUC__==2 && __GNUC_MINOR__>=95)) && 
  535.       ( defined (__i486__) || defined (__i586__) || defined (__i686__) || 
  536.         defined (__pentium__) || defined (__pentiumpro__))
  538. /* Increment by 1 */
  539. static __inline__ void
  540. HXAtomicIncUINT32(UINT32* pNum)
  541. {
  542.     __asm__ __volatile__(
  543.         "lock incl (%0);"                // atomically add 1 to *pNum
  544.         : /* no output */
  545.         : "r" (pNum)
  546.         : "cc", "memory"
  547.         );
  548. }
  550. /* Decrement by 1 */
  551. static __inline__ void
  552. HXAtomicDecUINT32(UINT32* pNum)
  553. {
  554.     __asm__ __volatile__(
  555.         "lock decl (%0);"                // atomically add -1 to *pNum
  556.         : /* no output */
  557.         : "r" (pNum)
  558.         : "cc", "memory"
  559.         );
  560. }
  562. /* Increment by 1 and return new value */
  563. static __inline__ UINT32
  564. HXAtomicIncRetUINT32(UINT32* pNum)
  565. {
  566.     volatile UINT32 ulRet;
  567.     __asm__ __volatile__(
  568.         "lock xaddl %0, (%1);"           // atomically add 1 to *pNum
  569.         "     inc   %0;"                 // old value in %0, increment it
  570.         : "=r" (ulRet)
  571.         : "r" (pNum), "0" (0x1)
  572.         : "cc", "memory"
  573.         );
  574.     return ulRet;
  575. }
  577. /* Decrement by 1 and return new value */
  578. static __inline__ UINT32
  579. HXAtomicDecRetUINT32(UINT32* pNum)
  580. {   
  581.     volatile UINT32 ulRet;
  582.     __asm__ __volatile__(
  583.         "lock xaddl %0, (%1);"           // atomically add -1 to *pNum
  584.         "     dec   %0;"                 // old value in %0, decrement it
  585.         : "=r" (ulRet)
  586.         : "r" (pNum), "0" (-1)
  587.         : "cc", "memory"
  588.         );
  589.     return ulRet;
  590. }
  592. /* Add n */
  593. static __inline__ void
  594. HXAtomicAddUINT32(UINT32* pNum, UINT32 ulNum)
  595. {
  596.     __asm__ __volatile__(
  597.         "lock addl %1, (%0);"            // atomically add ulNum to *pNum
  598.         : /* no output */
  599.         : "r" (pNum), "r" (ulNum)
  600.         : "cc", "memory"
  601.         );
  602. }
  604. /* Subtract n */
  605. static __inline__ void
  606. HXAtomicSubUINT32(UINT32* pNum, UINT32 ulNum)
  607. {
  608.     __asm__ __volatile__(
  609.         "lock subl %1, (%0);"            // atomically add ulNum to *pNum
  610.         : /* no output */
  611.         : "r" (pNum), "r" (ulNum)
  612.         : "cc", "memory"
  613.         );
  614. }
  616. /* Add n and return new value */
  617. static __inline__ UINT32
  618. HXAtomicAddRetUINT32(UINT32* pNum, UINT32 ulNum)
  619. {
  620.     volatile UINT32 ulRet;
  621.     __asm__ __volatile__(
  622.         "     mov   %2, %0;"             // copy ulNum into %0
  623.         "lock xaddl %0, (%1);"           // atomically add ulNum to *pNum
  624.         "     add   %2, %0;"             // old value in %0, add ulNum
  625.         : "=r" (ulRet)
  626.         : "r" (pNum), "r" (ulNum), "0" (0)
  627.         : "cc", "memory"
  628.         );
  629.     return ulRet;
  630. }
  632. /* Subtract n and return new value */
  633. static __inline__ UINT32
  634. HXAtomicSubRetUINT32(UINT32* pNum, UINT32 ulNum) 
  635. {   
  636.     volatile UINT32 ulRet;
  637.     __asm__ __volatile__(
  638.         "     sub   %2, %0;"             // negate ulNum, saving in %0
  639.         "lock xaddl %0, (%1);"           // atomically add -(ulNum) to *pNum
  640.         "     sub   %2, %0;"             // old value in %0, subtract ulNum
  641.         : "=r" (ulRet)
  642.         : "r" (pNum), "r" (ulNum), "0" (0)
  643.         : "cc", "memory"
  644.         );
  645.     return ulRet;
  646. }
  649. static __inline__ void HXAtomicIncINT32(INT32* p)              { HXAtomicIncUINT32((UINT32*)p); }
  650. static __inline__ void HXAtomicDecINT32(INT32* p)              { HXAtomicDecUINT32((UINT32*)p); }
  651. static __inline__ void HXAtomicAddINT32(INT32* p, INT32 n)     { HXAtomicAddUINT32((UINT32*)p, (UINT32)n); }
  652. static __inline__ void HXAtomicSubINT32(INT32* p, INT32 n)     { HXAtomicSubUINT32((UINT32*)p, (UINT32)n); }
  653. static __inline__ INT32 HXAtomicIncRetINT32(INT32* p)          { return HXAtomicIncRetUINT32((UINT32*)p); }
  654. static __inline__ INT32 HXAtomicDecRetINT32(INT32* p)          { return HXAtomicDecRetUINT32((UINT32*)p); }
  655. static __inline__ INT32 HXAtomicAddRetINT32(INT32* p, INT32 n) { return HXAtomicAddRetUINT32((UINT32*)p, (UINT32)n); }
  656. static __inline__ INT32 HXAtomicSubRetINT32(INT32* p, INT32 n) { return HXAtomicSubRetUINT32((UINT32*)p, (UINT32)n); }
  660. /***********************************************************************
  661.  * HP-UX / IA64 (Native compiler)
  662.  *
  663.  * Implementation Notes:
  664.  *      A work-in-progress...
  665.  */
  666. #elif defined(_HPUX) && defined(_IA64)
  668. #if defined(__cplusplus)
  669. extern "C" {
  670. #endif
  671.     UINT32 _HXAtomicIncRetUINT32 (UINT32* pNum);
  672.     UINT32 _HXAtomicDecRetUINT32 (UINT32* pNum);
  673.     UINT32 _HXAtomicAddRetUINT32 (UINT32* pNum, UINT32 ulNum);
  674.     UINT32 _HXAtomicSubRetUINT32 (UINT32* pNum, UINT32 ulNum);
  675. #if defined(__cplusplus)
  676. }
  677. #endif
  679. #define HXAtomicIncINT32(p)       _HXAtomicIncRetUINT32((UINT32*)(p))
  680. #define HXAtomicDecINT32(p)       _HXAtomicDecRetUINT32((UINT32*)(p))
  681. #define HXAtomicIncRetINT32(p)    _HXAtomicIncRetUINT32((UINT32*)(p))
  682. #define HXAtomicDecRetINT32(p)    _HXAtomicDecRetUINT32((UINT32*)(p))
  683. #define HXAtomicAddINT32(p,n)     _HXAtomicAddRetUINT32((UINT32*)(p),(INT32)(n))
  684. #define HXAtomicSubINT32(p,n)     _HXAtomicSubRetUINT32((UINT32*)(p),(INT32)(n))
  685. #define HXAtomicAddRetINT32(p,n)  _HXAtomicAddRetUINT32((UINT32*)(p),(INT32)(n))
  686. #define HXAtomicSubRetINT32(p,n)  _HXAtomicSubRetUINT32((UINT32*)(p),(INT32)(n))
  688. #define HXAtomicIncUINT32(p)      _HXAtomicIncRetUINT32((p))
  689. #define HXAtomicDecUINT32(p)      _HXAtomicDecRetUINT32((p))
  690. #define HXAtomicIncRetUINT32(p)   _HXAtomicIncRetUINT32((p))
  691. #define HXAtomicDecRetUINT32(p)   _HXAtomicDecRetUINT32((p))
  692. #define HXAtomicAddUINT32(p,n)    _HXAtomicAddRetUINT32((p),(n))
  693. #define HXAtomicSubUINT32(p,n)    _HXAtomicSubRetUINT32((p),(n))
  694. #define HXAtomicAddRetUINT32(p,n) _HXAtomicAddRetUINT32((p),(n))
  695. #define HXAtomicSubRetUINT32(p,n) _HXAtomicSubRetUINT32((p),(n))
  699. /***********************************************************************
  700.  * Tru64 (OSF1) / Alpha (Native compiler)
  701.  *
  702.  * Implementation Notes:
  703.  *
  704.  * The Alpha CPU provides instructions to load-lock a value,
  705.  * modify it, and attempt to write it back.  If the value has
  706.  * been modified by someone else since the load-lock occured,
  707.  * the write will fail and you can check the status code to
  708.  * know whether you need to retry or not.
  709.  *
  710.  */
  711. #elif defined (__alpha)
  713. #include <c_asm.h>
  715. /* Increment by 1 and return new value */
  716. inline INT32
  717. HXAtomicIncRetINT32(INT32* pNum)
  718. {
  719.     return asm (
  720.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  721.         "        addl    %t0, 1, %t0;"      // Increment value
  722.         "        or      %t0, %zero, %v0;"  // set new value for return.
  723.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  724.         "        beq     %t0, 10b;"         // Retry if sequence failed
  725.         , pNum);
  726. }
  728. /* Decrement by 1 and return new value */
  729. inline INT32
  730. HXAtomicDecRetINT32(INT32* pNum)
  731. {
  732.     return asm (
  733.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  734.         "        subl    %t0, 1, %t0;"      // Decrement value
  735.         "        or      %t0, %zero, %v0;"  // set new value for return.
  736.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  737.         "        beq     %t0, 10b;"         // Retry if sequence failed
  738.         , pNum);
  739. }
  741. /* Add n and return new value */
  742. inline INT32
  743. HXAtomicAddRetINT32(INT32* pNum, INT32 n)
  744. {
  745.     return asm (
  746.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  747.         "        addl    %t0, %a1, %t0;"    // Add n to value
  748.         "        or      %t0, %zero, %v0;"  // set new value for return.
  749.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  750.         "        beq     %t0, 10b;"         // Retry if sequence failed
  751.         , pNum, n);
  752. }
  754. /* Subtract n and return new value */
  755. inline INT32
  756. HXAtomicSubRetINT32(INT32* pNum, INT32 n)
  757. {
  758.     return asm (
  759.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  760.         "        subl    %t0, %a1, %t0;"    // Subtract n from value
  761.         "        or      %t0, %zero, %v0;"  // set new value for return.
  762.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  763.         "        beq     %t0, 10b;"         // Retry if sequence failed
  764.         , pNum, n);
  765. }
  767. /* Increment by 1 and return new value */
  768. inline UINT32
  769. HXAtomicIncRetUINT32(UINT32* pNum)
  770. {
  771.     return asm (
  772.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  773.         "        addl    %t0, 1, %t0;"      // Increment value
  774.         "        or      %t0, %zero, %v0;"  // set new value for return.
  775.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  776.         "        beq     %t0, 10b;"         // Retry if sequence failed
  777.         , pNum);
  778. }
  780. /* Decrement by 1 and return new value */
  781. inline UINT32
  782. HXAtomicDecRetUINT32(UINT32* pNum)
  783. {
  784.     return asm (
  785.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  786.         "        subl    %t0, 1, %t0;"      // Decrement value
  787.         "        or      %t0, %zero, %v0;"  // set new value for return.
  788.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  789.         "        beq     %t0, 10b;"         // Retry if sequence failed
  790.         , pNum);
  791. }
  793. /* Add n and return new value */
  794. inline UINT32
  795. HXAtomicAddRetUINT32(UINT32* pNum, UINT32 n)
  796. {
  797.     return asm (
  798.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  799.         "        addl    %t0, %a1, %t0;"    // Add n to value
  800.         "        or      %t0, %zero, %v0;"  // set new value for return.
  801.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  802.         "        beq     %t0, 10b;"         // Retry if sequence failed
  803.         , pNum, n);
  804. }
  806. /* Subtract n and return new value */
  807. inline UINT32
  808. HXAtomicSubRetUINT32(UINT32* pNum, UINT32 n)
  809. {
  810.     return asm (
  811.         "10:     ldl_l   %t0, (%a0);"       // Load-lock value into a register
  812.         "        subl    %t0, %a1, %t0;"    // Subtract n from value
  813.         "        or      %t0, %zero, %v0;"  // set new value for return.
  814.         "        stl_c   %t0, (%a0);"       // Save new value into *pNum
  815.         "        beq     %t0, 10b;"         // Retry if sequence failed
  816.         , pNum, n);
  817. }
  819. #define HXAtomicIncINT32(p)    HXAtomicIncRetINT32((p))
  820. #define HXAtomicDecINT32(p)    HXAtomicDecRetINT32((p))
  821. #define HXAtomicAddINT32(p,n)  HXAtomicAddRetINT32((p),(n))
  822. #define HXAtomicSubINT32(p,n)  HXAtomicSubRetINT32((p),(n))
  824. #define HXAtomicIncUINT32(p)   HXAtomicIncRetUINT32((p))
  825. #define HXAtomicDecUINT32(p)   HXAtomicDecRetUINT32((p))
  826. #define HXAtomicAddUINT32(p,n) HXAtomicAddRetUINT32((p),(n))
  827. #define HXAtomicSubUINT32(p,n) HXAtomicSubRetUINT32((p),(n))
  831. /***********************************************************************
  832.  * AIX / PowerPC (Native compiler)
  833.  *
  834.  * Implementation Notes:
  835.  *
  836.  * XXXDC: The xlc compiler is able to do inline asm for C but when I do
  837.  * it for C++ it crashes, so for now I have resorted to putting
  838.  * the asm in a seperate assembler routine.  The way you inline with
  839.  * xlc/xlC is difficult to use, requiring the use of "#pragma mc_func".
  840.  */
  841. #elif defined (_AIX)
  843. //defined in common/util/platform/aix/atomicops.s
  844. #if defined(__cplusplus)
  845. extern "C" {
  846. #endif
  847.     INT32 _HXAtomicAddRetINT32   (INT32*  pNum, INT32  lNum);
  848.     INT32 _HXAtomicSubRetINT32   (INT32*  pNum, INT32  lNum);
  849.     UINT32 _HXAtomicAddRetUINT32 (UINT32* pNum, UINT32 ulNum);
  850.     UINT32 _HXAtomicSubRetUINT32 (UINT32* pNum, UINT32 ulNum);
  851. #if defined(__cplusplus)
  852. }
  853. #endif
  855. #define HXAtomicIncINT32(p)       _HXAtomicAddRetINT32((p),(INT32)1)
  856. #define HXAtomicDecINT32(p)       _HXAtomicSubRetINT32((p),(INT32)1)
  857. #define HXAtomicIncRetINT32(p)    _HXAtomicAddRetINT32((p),(INT32)1)
  858. #define HXAtomicDecRetINT32(p)    _HXAtomicSubRetINT32((p),(INT32)1)
  859. #define HXAtomicAddINT32(p,n)     _HXAtomicAddRetINT32((p),(n))
  860. #define HXAtomicSubINT32(p,n)     _HXAtomicSubRetINT32((p),(n))
  861. #define HXAtomicAddRetINT32(p,n)  _HXAtomicAddRetINT32((p),(n))
  862. #define HXAtomicSubRetINT32(p,n)  _HXAtomicSubRetINT32((p),(n))
  864. #define HXAtomicIncUINT32(p)      _HXAtomicAddRetUINT32((p),(UINT32)1)
  865. #define HXAtomicDecUINT32(p)      _HXAtomicSubRetUINT32((p),(UINT32)1)
  866. #define HXAtomicIncRetUINT32(p)   _HXAtomicAddRetUINT32((p),(UINT32)1)
  867. #define HXAtomicDecRetUINT32(p)   _HXAtomicSubRetUINT32((p),(UINT32)1)
  868. #define HXAtomicAddUINT32(p,n)    _HXAtomicAddRetUINT32((p),(n))
  869. #define HXAtomicSubUINT32(p,n)    _HXAtomicSubRetUINT32((p),(n))
  870. #define HXAtomicAddRetUINT32(p,n) _HXAtomicAddRetUINT32((p),(n))
  871. #define HXAtomicSubRetUINT32(p,n) _HXAtomicSubRetUINT32((p),(n))
  874. /***********************************************************************
  875.  * MAC / PowerPC (CW)
  876.  *
  877.  * Implementation Notes:
  878.  *
  879.  * This will need to be rewritten, probably, once we move away from CW to PB.
  880.  *
  881.  * Note: This is an imcompletely-defined platform, be aware that
  882.  * not all standard HXAtomic operators are defined!
  883.  *
  884.  */
  885. #elif defined(_MACINTOSH) && defined(__MWERKS__)
  887. inline UINT32
  888. HXAtomicIncRetUINT32(register UINT32* pNum)
  889. {
  890.     register UINT32 zeroOffset = 0;
  891.     register UINT32 temp;
  893.     asm
  894.     {
  895. again:
  896.     lwarx temp, zeroOffset, pNum
  897.     addi temp, temp, 1
  898.     stwcx. temp, zeroOffset, pNum
  899.     bne- again
  900.     }
  902.     return temp;
  903. }
  905. inline UINT32
  906. HXAtomicDecRetUINT32(register UINT32* pNum)
  907. {
  908.     register UINT32 zeroOffset = 0;
  909.     register UINT32 temp;
  911.     asm
  912.     {
  913. again:
  914.     lwarx temp, zeroOffset, pNum
  915.     subi temp, temp, 1
  916.     stwcx. temp, zeroOffset, pNum
  917.     bne- again
  918.     }
  920.     return temp;
  921. }
  924. /***********************************************************************
  925.  * MAC / PowerPC (PB)
  926.  *
  927.  * Implementation Notes:
  928.  *
  929.  * Use the atomic operations exposed by DriverSynchronization.h
  930.  *
  931.  * Note: This is an imcompletely-defined platform, be aware that
  932.  * not all standard HXAtomic operators are defined!
  933.  *
  934.  */
  935. #elif defined(_MACINTOSH) || defined(_MAC_UNIX)
  937. inline UINT32
  938. HXAtomicIncRetUINT32(UINT32* pNum)
  939. {
  940.     return (UINT32)(IncrementAtomic((SInt32*)pNum) + 1);
  941. }
  943. inline UINT32
  944. HXAtomicDecRetUINT32(UINT32* pNum)
  945. {
  946.     return (UINT32)(DecrementAtomic((SInt32*)pNum) - 1);
  947. }
  949. /***********************************************************************
  950.  * Linux / PowerPC
  951.  *
  952.  * Implementation Notes:
  953.  *
  954.  * Use PowerPC load exclusive and store exclusive instructions
  955.  *
  956.  */
  957. #elif defined(_LINUX) && defined(__powerpc__)
  959. inline UINT32
  960. HXAtomicIncRetUINT32(UINT32* pNum)
  961. {
  962.     volatile UINT32 result;
  964. __asm__ __volatile__ (
  965. "1:      lwarx  %0, 0, %2;n"
  966. "        addi   %0, %0, 1;n"
  967. "        stwcx. %0, 0, %2;n"
  968. "        bne- 1b;"
  969.          : "=r" (result) 
  970.          : "0" (result), "r" (pNum)
  971.          : "cc", "memory"
  972.  );
  974. return result;
  975. }
  977. inline UINT32
  978. HXAtomicDecRetUINT32(UINT32* pNum)
  979. {
  980.     volatile UINT32 result;
  982. __asm__ __volatile__ (
  983. "1:      lwarx   %0, 0, %2;n"
  984. "        subi   %0, %0, 1;n"
  985. "        stwcx. %0, 0, %2;n"
  986. "        bne- 1b;"
  987.          : "=r" (result) 
  988.          :  "0" (result), "r" (pNum)
  989.          : "cc", "memory"
  990.          );
  992. return result;
  993. }
  995. /***********************************************************************
  996.  * Generic
  997.  *
  998.  * Implementation Notes:
  999.  *
  1000.  * This should work on any platform with a HXMutex-style mutex.
  1001.  * It allocates a pool of mutexes and hashes the int pointers
  1002.  * to one of the mutexes.  Since the mutexes are held for
  1003.  * such a short time, only long enough to increment an int,
  1004.  * collisions should be extremely rare and this should work fine,
  1005.  * although it is probably less fast than the extra-high-performance
  1006.  * atomic operators provided above.  You need to link in atomic.cpp
  1007.  * to get HXAtomic::m_pLocks defined.
  1008.  *
  1009.  * Basic design of the mutex-based lock-pool implementation:
  1010.  *   At startup, allocate an array of N mutexes (where N is a power of 2).
  1011.  *   When a method is called, hash the int pointer to one of the locks.
  1012.  *   Lock this mutex.
  1013.  *   Modify the value.
  1014.  *   Unlock this mutex.
  1015.  *
  1016.  *
  1017.  * Platform-specific notes:
  1018.  *   Any platforms that use this should be documented here!
  1019.  *   Why are you using the generic operators for this platform?
  1020.  *
  1021.  * HP-UX / HP-PA:
  1022.  *   This is used on the HP-PA processor since it doesn't provide the
  1023.  *   necessary assembler operators to implement proper atomic updates
  1024.  *   of ints.  HP's mutex primitive seems pretty fast however, resulting
  1025.  *   in a workable solution.
  1026.  *
  1027.  * OpenBSD:
  1028.  *   The standard assembler on x86 can't handle the gcc/asm operators
  1029.  *   defined above, so we're using the lock-pool approach for now.
  1030.  *   This approach also makes it possible to support non-x86 OpenBSD
  1031.  *   builds more easily (someday).
  1032.  *
  1033.  */
  1034. #elif defined(_HPUX) || defined(_OPENBSD)
  1036. #include "microsleep.h"
  1037. #include "hxcom.h"
  1038. #include "hxmutexlock.h"
  1040. class HXAtomic
  1041. {
  1042. public:
  1043.     HXAtomic();
  1044.     ~HXAtomic();
  1045.     void InitLockPool();
  1047.     /* Users of the HXAtomic routines should *NEVER* call these directly.
  1048.      * They should *ALWAYS* use the HXAtomicAddRetINT32-style macros instead.
  1049.      */
  1050.     INT32  _AddRetINT32  (INT32*  pNum, INT32  nNum);
  1051.     UINT32 _AddRetUINT32 (UINT32* pNum, UINT32 ulNum);
  1052.     INT32  _SubRetINT32  (INT32*  pNum, INT32  nNum);
  1053.     UINT32 _SubRetUINT32 (UINT32* pNum, UINT32 ulNum);
  1055. private:
  1056.     void Lock   (HX_MUTEX pLock);
  1057.     void Unlock (HX_MUTEX pLock);
  1059.     HX_MUTEX* m_pLocks;
  1060. };
  1062. extern HXAtomic g_AtomicOps; //in common/util/atomicops.cpp
  1064. #define HXAtomicIncINT32(p)       g_AtomicOps._AddRetINT32((p),(INT32)1)
  1065. #define HXAtomicDecINT32(p)       g_AtomicOps._SubRetINT32((p),(INT32)1)
  1066. #define HXAtomicIncRetINT32(p)    g_AtomicOps._AddRetINT32((p),(INT32)1)
  1067. #define HXAtomicDecRetINT32(p)    g_AtomicOps._SubRetINT32((p),(INT32)1)
  1069. #define HXAtomicAddRetINT32(p,n)  g_AtomicOps._AddRetINT32((p),(n))
  1070. #define HXAtomicSubRetINT32(p,n)  g_AtomicOps._SubRetINT32((p),(n))
  1071. #define HXAtomicAddINT32(p,n)     g_AtomicOps._AddRetINT32((p),(n))
  1072. #define HXAtomicSubINT32(p,n)     g_AtomicOps._SubRetINT32((p),(n))
  1074. #define HXAtomicIncUINT32(p)      g_AtomicOps._AddRetUINT32((p),(UINT32)1)
  1075. #define HXAtomicDecUINT32(p)      g_AtomicOps._SubRetUINT32((p),(UINT32)1)
  1076. #define HXAtomicIncRetUINT32(p)   g_AtomicOps._AddRetUINT32((p),(UINT32)1)
  1077. #define HXAtomicDecRetUINT32(p)   g_AtomicOps._SubRetUINT32((p),(UINT32)1)
  1079. #define HXAtomicAddRetUINT32(p,n) g_AtomicOps._AddRetUINT32((p),(n))
  1080. #define HXAtomicSubRetUINT32(p,n) g_AtomicOps._SubRetUINT32((p),(n))
  1081. #define HXAtomicAddUINT32(p,n)    g_AtomicOps._AddRetUINT32((p),(n))
  1082. #define HXAtomicSubUINT32(p,n)    g_AtomicOps._SubRetUINT32((p),(n))
  1086. /***********************************************************************
  1087.  * SYMBIAN
  1088.  *
  1089.  * Implementation Notes:
  1090.  *
  1091.  * Note: This is an imcompletely-defined platform, be aware that
  1092.  * not all standard HXAtomic operators are defined!
  1093.  *
  1094.  */
  1095. #elif defined(_SYMBIAN)
  1097. /* Increment by 1 and return new value */
  1098. inline INT32
  1099. HXAtomicIncRetINT32(INT32* pNum)
  1100. {
  1101.     return User::LockedInc(*((TInt*)pNum)) + 1;
  1102. }
  1104. /* Decrement by 1 and return new value */
  1105. inline INT32
  1106. HXAtomicDecRetINT32(INT32* pNum)
  1107. {
  1108.     return User::LockedDec(*((TInt*)pNum)) - 1;
  1109. }
  1111. /* Increment by 1 and return new value */
  1112. inline UINT32
  1113. HXAtomicIncRetUINT32(UINT32* pNum)
  1114. {
  1115.     return ((UINT32)User::LockedInc(*((TInt*)pNum))) + 1;
  1116. }
  1118. /* Decrement by 1 and return new value */
  1119. inline UINT32
  1120. HXAtomicDecRetUINT32(UINT32* pNum)
  1121. {
  1122.     return ((UINT32)User::LockedDec(*((TInt*)pNum))) - 1;
  1123. }
  1125. #define HXAtomicIncINT32(p)    HXAtomicIncRetINT32((p))
  1126. #define HXAtomicDecINT32(p)    HXAtomicDecRetINT32((p))
  1127. #define HXAtomicIncUINT32(p)   HXAtomicIncRetUINT32((p))
  1128. #define HXAtomicDecUINT32(p)   HXAtomicDecRetUINT32((p))
  1130. #if 0
  1132. /* 
  1133.  * Add and subtract operations are not implemented
  1134.  * at this time because there isn't an easy way to
  1135.  * do it using the facilities provided by Symbian.
  1136.  * Assembly will likely be needed.
  1137.  */
  1139. /* Add n and return new value */
  1140. inline INT32
  1141. HXAtomicAddRetINT32(INT32* pNum, INT32 n)
  1142. {
  1144. }
  1146. /* Subtract n and return new value */
  1147. inline INT32
  1148. HXAtomicSubRetINT32(INT32* pNum, INT32 n)
  1149. {
  1151. }
  1153. /* Add n and return new value */
  1154. inline UINT32
  1155. HXAtomicAddRetUINT32(UINT32* pNum, UINT32 n)
  1156. {
  1158. }
  1160. /* Subtract n and return new value */
  1161. inline UINT32
  1162. HXAtomicSubRetUINT32(UINT32* pNum, UINT32 n)
  1163. {
  1165. }
  1167. #define HXAtomicAddINT32(p,n)  HXAtomicAddRetINT32((p),(n))
  1168. #define HXAtomicSubINT32(p,n)  HXAtomicSubRetINT32((p),(n))
  1170. #define HXAtomicAddUINT32(p,n) HXAtomicAddRetUINT32((p),(n))
  1171. #define HXAtomicSubUINT32(p,n) HXAtomicSubRetUINT32((p),(n))
  1173. #endif
  1175. /***********************************************************************
  1176.  * Linux / ARM (gcc)
  1177.  *
  1178.  * Implementation Notes:
  1179.  *
  1180.  * This implementation sacrifices being able to store the value
  1181.  * 0x800000000 in the INT32 value, which is a special "busy" marker value.
  1182.  * Since these are intended for use primarily with AddRef/Release and
  1183.  * resource usage counters, this should be acceptable for now.  If a counter
  1184.  * is incremented to the point it would conflict with the flag, it is
  1185.  * incremented one more to hop over it.  The same in reverse for decrement.
  1186.  *
  1187.  * Basic design of the flag-based implementation:
  1188.  *   1. Load a register with 0x80000000
  1189.  *   2. _atomically_ swap it with the INT32 (critical!)
  1190.  *   3. Compare what we got with 0x80000000
  1191.  *   4. Branch if equal to #2
  1192.  *   5. Increment (or decrement) the result
  1193.  *   6. Compare to 0x80000000
  1194.  *   7. Increment (or decrement) again if equal
  1195.  *   8. Save the new value to the INT32's location in memory
  1196.  *   9. Return new INT32 result if required
  1197.  *   
  1198.  */
  1199. #elif defined (_ARM) && defined (__GNUC__)
  1201. /* Increment by 1 */
  1202. inline void
  1203. HXAtomicIncUINT32(UINT32* pNum)
  1204. {
  1205.     UINT32 ulTmp;
  1206.     __asm__ __volatile__(
  1207. "        mov   %0, #0x80000000;n"      /* Set ulTmp to 0x800000000    */
  1208. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulTmp        */
  1209. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1210. "        beq   1;n"                    /* If so, retry...             */
  1211. "        add   %0, %0, #1;n"           /* Increment ulTmp             */
  1212. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1213. "        addeq %0, %0, #1;n"           /* if so, increment again      */
  1214. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1215.         : /* no output */
  1216.         : "r" (ulTmp), "r" (pNum)
  1217.         : "cc", "memory"
  1218.         );
  1219. }
  1221. /* Decrement by 1 */
  1222. inline void
  1223. HXAtomicDecUINT32(UINT32* pNum)
  1224. {
  1225.     UINT32 ulTmp;
  1226.     __asm__ __volatile__(
  1227. "        mov   %0, #0x80000000;n"      /* Set ulTmp to 0x800000000    */
  1228. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulTmp        */
  1229. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1230. "        beq   1;n"                    /* If so, retry...             */
  1231. "        sub   %0, %0, #1;n"           /* Decrement ulTmp             */
  1232. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1233. "        subeq %0, %0, #1;n"           /* if so, decrement again      */
  1234. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1235.         : /* no output */
  1236.         :  "r" (ulTmp), "r" (pNum)
  1237.         : "cc", "memory"
  1238.         );
  1239. }
  1241. /* Increment by 1 and return new value */
  1242. inline UINT32
  1243. HXAtomicIncRetUINT32(UINT32* pNum)
  1244. {
  1245.     volatile UINT32 ulRet;
  1246.     __asm__ __volatile__(
  1247. "        mov   %0, #0x80000000;n"      /* Set ulRet to 0x80000000     */
  1248. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulRet        */
  1249. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1250. "        beq   1;n"                    /* If so, retry...             */
  1251. "        add   %0, %0, #1;n"           /* Increment ulRet             */
  1252. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1253. "        addeq %0, %0, #1;n"         /* if so, increment again      */
  1254. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1255.         : "=&r" (ulRet)
  1256.         : "r" (pNum)
  1257.         : "cc", "memory"
  1258.         );
  1259.     return ulRet;
  1260. }
  1262. /* Decrement by 1 and return new value */
  1263. inline UINT32
  1264. HXAtomicDecRetUINT32(UINT32* pNum)
  1265. {
  1266.     volatile UINT32 ulRet;
  1267.     __asm__ __volatile__(
  1268. "        mov   %0, #0x80000000;n"      /* Set ulRet to 0x80000000     */
  1269. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulRet        */
  1270. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1271. "        beq   1;n"                    /* If so, retry...             */
  1272. "        sub   %0, %0, #1;n"           /* Decrement ulRet             */
  1273. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1274. "        subeq %0, %0, #1;n"         /* if so, decrement again      */
  1275. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1276.         : "=&r" (ulRet)
  1277.         : "r" (pNum)
  1278.         : "cc", "memory"
  1279.         );
  1280.     return ulRet;
  1281. }
  1283. /* Add n */
  1284. inline void
  1285. HXAtomicAddUINT32(UINT32* pNum, UINT32 ulNum)
  1286. {
  1287.     UINT32 ulTmp;
  1288.     __asm__ __volatile__(
  1289. "        mov   %0, #0x80000000;n"      /* Set ulTmp to 0x800000000    */
  1290. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulTmp        */
  1291. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1292. "        beq   1;n"                    /* If so, retry...             */
  1293. "        add   %0, %0, %2;n"           /* Add ulNum to ulTmp          */
  1294. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1295. "        addeq %0, %0, #1;n"           /* if so, increment again      */
  1296. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1297.         : /* no output */
  1298.         : "r" (ulTmp), "r" (pNum), "r" (ulNum)
  1299.         : "cc", "memory"
  1300.         );
  1301. }
  1303. /* Subtract n */
  1304. inline void
  1305. HXAtomicSubUINT32(UINT32* pNum, UINT32 ulNum)
  1306. {
  1307.     UINT32 ulTmp;
  1308.     __asm__ __volatile__(
  1309. "        mov   %0, #0x80000000;n"      /* Set ulTmp to 0x800000000    */
  1310. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulTmp        */
  1311. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1312. "        beq   1;n"                    /* If so, retry...             */
  1313. "        sub   %0, %0, %2;n"           /* Subtract ulNum from ulTmp   */
  1314. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1315. "        subeq %0, %0, #1;n"           /* if so, decrement again      */
  1316. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1317.         : /* no output */
  1318.         : "r" (ulTmp), "r" (pNum), "r" (ulNum)
  1319.         : "cc", "memory"
  1320.         );
  1321. }
  1323. /* Add n and return new value */
  1324. inline UINT32
  1325. HXAtomicAddRetUINT32(UINT32* pNum, UINT32 ulNum)
  1326. {
  1327.     volatile UINT32 ulRet;
  1328.     __asm__ __volatile__(
  1329. "        mov   %0, #0x80000000;n"      /* Set ulRet to 0x80000000     */
  1330. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulRet        */
  1331. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1332. "        beq   1;n"                    /* If so, retry...             */
  1333. "        add   %0, %0, %2;n"           /* Add ulNum to ulRet          */
  1334. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1335. "        addeq %0, %0, #1;n"         /* if so, increment again      */
  1336. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1337.         : "=&r" (ulRet)
  1338.         : "r" (pNum) , "r" (ulNum)
  1339.         : "cc", "memory"
  1340.         );
  1341.     return ulRet;
  1342. }
  1344. /* Subtract n and return new value */
  1345. inline UINT32
  1346. HXAtomicSubRetUINT32(UINT32* pNum, UINT32 ulNum)
  1347. {   
  1348.     volatile UINT32 ulRet;
  1349.     __asm__ __volatile__(
  1350. "        mov   %0, #0x80000000;n"      /* Set ulRet to 0x80000000     */
  1351. "1:      swp   %0, %0, [%1];n"         /* Swap *pNum and ulRet        */
  1352. "        cmp   %0, #0x80000000;n"      /* Is someone else using pNum? */
  1353. "        beq   1;n"                    /* If so, retry...             */
  1354. "        sub   %0, %0, %2;n"           /* Subtract ulNum from ulRet   */
  1355. "        cmp   %0, #0x80000000;n"      /* check for overflow          */
  1356. "        subeq %0, %0, #1;n"         /* if so, decrement again      */
  1357. "        str   %0, [%1];n"             /* Save new value into *pNum   */
  1358.         : "=&r" (ulRet)
  1359.         : "r" (pNum), "r" (ulNum)
  1360.         : "cc", "memory"
  1361.         );
  1362.     return ulRet;
  1363. }
  1365. inline void HXAtomicIncINT32(INT32* p)              { HXAtomicIncUINT32((UINT32*)p); }
  1366. inline void HXAtomicDecINT32(INT32* p)              { HXAtomicDecUINT32((UINT32*)p); }
  1367. inline void HXAtomicAddINT32(INT32* p, INT32 n)     { HXAtomicAddUINT32((UINT32*)p, (UINT32)n); }
  1368. inline void HXAtomicSubINT32(INT32* p, INT32 n)     { HXAtomicSubUINT32((UINT32*)p, (UINT32)n); }
  1369. inline INT32 HXAtomicIncRetINT32(INT32* p)          { return HXAtomicIncRetUINT32((UINT32*)p); }
  1370. inline INT32 HXAtomicDecRetINT32(INT32* p)          { return HXAtomicDecRetUINT32((UINT32*)p); }
  1371. inline INT32 HXAtomicAddRetINT32(INT32* p, INT32 n) { return HXAtomicAddRetUINT32((UINT32*)p, (UINT32)n); }
  1372. inline INT32 HXAtomicSubRetINT32(INT32* p, INT32 n) { return HXAtomicSubRetUINT32((UINT32*)p, (UINT32)n); }
  1374. /***********************************************************************
  1375.  * Add new platforms above here
  1376.  */
  1377. #else
  1379. //
  1380. // Unsupported platform
  1381. //
  1383. #  ifndef HELIX_CONFIG_DISABLE_ATOMIC_OPERATORS
  1384. // Defining HELIX_CONFIG_DISABLE_ATOMIC_OPERATORS will use the ++ and --
  1385. // operators in place of atomic operators in some places in the code. These
  1386. // operators are not thread-safe, and should only be used in the intermediary
  1387. // stages of porting.
  1388. #    error "You need to create atomic dec/inc opers for your platform or #define HELIX_CONFIG_DISABLE_ATOMIC_OPERATORS"
  1389. #  endif
  1390. #endif
  1394. /*************************************************************************/
  1396. /*
  1397.  * Conditional override of InterlockedIncrement/Decrement
  1398.  *
  1399.  * Place this in your Umakefil/.pcf file to turn off atomic
  1400.  * InterlockedIncrement/Decrement on a per-module basis,
  1401.  * or place it in your umake profile for system-wide scope.
  1402.  * If this is defined you'll still have access to the underlying
  1403.  * HXAtomicxxx operators (if they exist for your platform),
  1404.  * just that the specific InterlockedIncrement/InterlockedDecrement
  1405.  * macros won't be defined to use them.
  1406.  */
  1407. #if !defined (HELIX_CONFIG_DISABLE_ATOMIC_OPERATORS)
  1409. #undef InterlockedIncrement
  1410. #undef InterlockedDecrement
  1412. // Since many classes (incorrectly) implement their refcount using LONG32
  1413. // rather than the proper ULONG32, we have to use the typecast for things
  1414. // to build on many platforms.
  1415. #define InterlockedIncrement(p) HXAtomicIncRetUINT32((UINT32*)(p))
  1416. #define InterlockedDecrement(p) HXAtomicDecRetUINT32((UINT32*)(p))
  1418. #define HAVE_INTERLOCKED_INCREMENT //so hxcom.h doesn't redefine these to ++/--
  1420. #endif /* !defined(HELIX_CONFIG_DISABLE_ATOMIC_OPERATORS) */
  1422. #endif /* _ATOMICBASE_H_ */