Category

Development Platform
Home > SourceCode/Document > Communication-Mobile > Symbian > View Code
atomicbase.h
Package: 142_61_thumb_advanced.rar　[view]
Upload User: dangjiwu
Upload Date: 2013-07-19
Package Size: 42019k
Code Size: 54k
Category:

Symbian

Development Platform:

Visual C++

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