plank_Atomic.h

/*
 -------------------------------------------------------------------------------
 This file is part of the Plink, Plonk, Plank libraries
  by Martin Robinson
 
 http://code.google.com/p/pl-nk/
 
 Copyright University of the West of England, Bristol 2011-14
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:
 
 * Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
 * Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
 * Neither the name of University of the West of England, Bristol nor 
   the names of its contributors may be used to endorse or promote products
   derived from this software without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 DISCLAIMED. IN NO EVENT SHALL UNIVERSITY OF THE WEST OF ENGLAND, BRISTOL BE 
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
 GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 
 OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
 
 This software makes use of third party libraries. For more information see:
 doc/license.txt included in the distribution.
 -------------------------------------------------------------------------------
 */

#ifndef PLANK_ATOMIC_H
#define PLANK_ATOMIC_H

PLANK_BEGIN_C_LINKAGE

static void pl_AtomicMemoryBarrier();

//------------------------------------------------------------------------------

typedef struct PlankAtomicI* PlankAtomicIRef;

PlankAtomicIRef pl_AtomicI_CreateAndInit();

PlankAtomicIRef pl_AtomicI_Create();

static inline PlankResult pl_AtomicI_Init (PlankAtomicIRef p);

static inline PlankResult pl_AtomicI_DeInit (PlankAtomicIRef p);

PlankResult pl_AtomicI_Destroy (PlankAtomicIRef p);

static PlankI pl_AtomicI_Get (PlankAtomicIRef p);

static PlankI pl_AtomicI_GetUnchecked (PlankAtomicIRef p);

PlankUI pl_AtomicI_GetExtra (PlankAtomicIRef p);

PlankUI pl_AtomicI_GetExtraUnchecked (PlankAtomicIRef p);

static PlankI pl_AtomicI_Swap (PlankAtomicIRef p, PlankI newValue);

static void pl_AtomicI_SwapOther (PlankAtomicIRef p1, PlankAtomicIRef p2);

static void pl_AtomicI_Set (PlankAtomicIRef p, PlankI newValue);

void pl_AtomicI_SetUnchecked (PlankAtomicIRef p, PlankI newValue);


static PlankI pl_AtomicI_Add (PlankAtomicIRef p, PlankI operand);

static PlankI pl_AtomicI_Subtract (PlankAtomicIRef p, PlankI operand);

static PlankI pl_AtomicI_Increment (PlankAtomicIRef p);

static PlankI pl_AtomicI_Decrement (PlankAtomicIRef p);

static PlankB pl_AtomicI_CompareAndSwap (PlankAtomicIRef p, PlankI oldValue, PlankI newValue);

//------------------------------------------------------------------------------

typedef struct PlankAtomicL* PlankAtomicLRef;

PlankAtomicLRef pl_AtomicL_CreateAndInit();

PlankAtomicLRef pl_AtomicL_Create();

static inline PlankResult pl_AtomicL_Init (PlankAtomicLRef p);

static inline PlankResult pl_AtomicL_DeInit (PlankAtomicLRef p);

PlankResult pl_AtomicL_Destroy (PlankAtomicLRef p);

static PlankL pl_AtomicL_Get (PlankAtomicLRef p);

static PlankL pl_AtomicL_GetUnchecked (PlankAtomicLRef p);

PlankUL pl_AtomicL_GetExtra (PlankAtomicLRef p);

PlankUL pl_AtomicL_GetExtraUnchecked (PlankAtomicLRef p);

static PlankL pl_AtomicL_Swap (PlankAtomicLRef p, PlankL newValue);

static void pl_AtomicL_SwapOther (PlankAtomicLRef p1, PlankAtomicLRef p2);

static void pl_AtomicL_Set (PlankAtomicLRef p, PlankL newValue);

void pl_AtomicL_SetUnchecked (PlankAtomicLRef p, PlankL newValue);

static PlankL pl_AtomicL_Add (PlankAtomicLRef p, PlankL operand);

static PlankL pl_AtomicL_Subtract (PlankAtomicLRef p, PlankL operand);

static PlankL pl_AtomicL_Increment (PlankAtomicLRef p);

static PlankL pl_AtomicL_Decrement (PlankAtomicLRef p);

static PlankB pl_AtomicL_CompareAndSwap (PlankAtomicLRef p, PlankL oldValue, PlankL newValue);

//------------------------------------------------------------------------------

typedef struct PlankAtomicLL* PlankAtomicLLRef;

PlankAtomicLLRef pl_AtomicLL_CreateAndInit();

PlankAtomicLLRef pl_AtomicLL_Create();

static PlankResult pl_AtomicLL_Init (PlankAtomicLLRef p);

static PlankResult pl_AtomicLL_DeInit (PlankAtomicLLRef p);

PlankResult pl_AtomicLL_Destroy (PlankAtomicLLRef p);

static PlankLL pl_AtomicLL_Get (PlankAtomicLLRef p);

static PlankLL pl_AtomicLL_GetUnchecked (PlankAtomicLLRef p);

PlankULL pl_AtomicLL_GetExtra (PlankAtomicLLRef p);

PlankULL pl_AtomicLL_GetExtraUnchecked (PlankAtomicLLRef p);

static PlankLL pl_AtomicLL_Swap (PlankAtomicLLRef p, PlankLL newValue);

static void pl_AtomicLL_SwapOther (PlankAtomicLLRef p1, PlankAtomicLLRef p2);

static void pl_AtomicLL_Set (PlankAtomicLLRef p, PlankLL newValue);

void pl_AtomicLL_SetUnchecked (PlankAtomicLLRef p, PlankLL newValue);

static PlankLL pl_AtomicLL_Add (PlankAtomicLLRef p, PlankLL operand);

static PlankLL pl_AtomicLL_Subtract (PlankAtomicLLRef p, PlankLL operand);

static PlankLL pl_AtomicLL_Increment (PlankAtomicLLRef p);

static PlankLL pl_AtomicLL_Decrement (PlankAtomicLLRef p);

//#if !PLANK_NOATOMIC64BIT || DOXYGEN
//static
//#endif
static PlankB pl_AtomicLL_CompareAndSwap (PlankAtomicLLRef p, PlankLL oldValue, PlankLL newValue);

//------------------------------------------------------------------------------

typedef struct PlankAtomicF* PlankAtomicFRef;

PlankAtomicFRef pl_AtomicF_CreateAndInit();

PlankAtomicFRef pl_AtomicF_Create();

static inline PlankResult pl_AtomicF_Init (PlankAtomicFRef p);

static inline PlankResult pl_AtomicF_DeInit (PlankAtomicFRef p);

PlankResult pl_AtomicF_Destroy (PlankAtomicFRef p);

static PlankF pl_AtomicF_Get (PlankAtomicFRef p);

static PlankF pl_AtomicF_GetUnchecked (PlankAtomicFRef p);

PlankUI pl_AtomicF_GetExtra (PlankAtomicFRef p);

PlankUI pl_AtomicF_GetExtraUnchecked (PlankAtomicFRef p);

static PlankF pl_AtomicF_Swap (PlankAtomicFRef p, PlankF newValue);

static void pl_AtomicF_SwapOther (PlankAtomicFRef p1, PlankAtomicFRef p2);

static void pl_AtomicF_Set (PlankAtomicFRef p, PlankF newValue);

void pl_AtomicF_SetUnchecked (PlankAtomicFRef p, PlankF newValue);

static PlankF pl_AtomicF_Add (PlankAtomicFRef p, PlankF operand);

static PlankF pl_AtomicF_Subtract (PlankAtomicFRef p, PlankF operand);

static PlankF pl_AtomicF_Increment (PlankAtomicFRef p);

static PlankF pl_AtomicF_Decrement (PlankAtomicFRef p);

static PlankB pl_AtomicF_CompareAndSwap (PlankAtomicFRef p, PlankF oldValue, PlankF newValue);

//------------------------------------------------------------------------------

typedef struct PlankAtomicD* PlankAtomicDRef;

PlankAtomicDRef pl_AtomicD_CreateAndInit();

PlankAtomicDRef pl_AtomicD_Create();

static PlankResult pl_AtomicD_Init (PlankAtomicDRef p);

static PlankResult pl_AtomicD_DeInit (PlankAtomicDRef p);

PlankResult pl_AtomicD_Destroy (PlankAtomicDRef p);

static PlankD pl_AtomicD_Get (PlankAtomicDRef p);

static PlankD pl_AtomicD_GetUnchecked (PlankAtomicDRef p);

PlankULL pl_AtomicD_GetExtra (PlankAtomicDRef p);

PlankULL pl_AtomicD_GetExtraUnchecked (PlankAtomicDRef p);

static PlankD pl_AtomicD_Swap (PlankAtomicDRef p, PlankD newValue);

static void pl_AtomicD_SwapOther (PlankAtomicDRef p1, PlankAtomicDRef p2);

static void pl_AtomicD_Set (PlankAtomicDRef p, PlankD newValue);

void pl_AtomicD_SetUnchecked (PlankAtomicDRef p, PlankD newValue);

static PlankD pl_AtomicD_Add (PlankAtomicDRef p, PlankD operand);

static PlankD pl_AtomicD_Subtract (PlankAtomicDRef p, PlankD operand);

static PlankD pl_AtomicD_Increment (PlankAtomicDRef p);

static PlankD pl_AtomicD_Decrement (PlankAtomicDRef p);

static PlankB pl_AtomicD_CompareAndSwap (PlankAtomicDRef p, PlankD oldValue, PlankD newValue);

//------------------------------------------------------------------------------

typedef struct PlankAtomicP* PlankAtomicPRef;

PlankAtomicPRef pl_AtomicP_CreateAndInit();

PlankAtomicPRef pl_AtomicP_Create();

static inline PlankResult pl_AtomicP_Init (PlankAtomicPRef p);

static inline PlankResult pl_AtomicP_DeInit (PlankAtomicPRef p);

PlankResult pl_AtomicP_Destroy (PlankAtomicPRef p);

static PlankP pl_AtomicP_Get (PlankAtomicPRef p);

static PlankP pl_AtomicP_GetUnchecked (PlankAtomicPRef p);

PlankUL pl_AtomicP_GetExtra (PlankAtomicPRef p);

PlankUL pl_AtomicP_GetExtraUnchecked (PlankAtomicPRef p);

static PlankP pl_AtomicP_Swap (PlankAtomicPRef p, PlankP newPtr);

static void pl_AtomicP_SwapOther (PlankAtomicPRef p1, PlankAtomicPRef p2);

static void pl_AtomicP_Set (PlankAtomicPRef p, PlankP newPtr);

void pl_AtomicP_SetUnchecked (PlankAtomicPRef p, PlankP newPtr);

static PlankP pl_AtomicP_Add (PlankAtomicPRef p, PlankL operand);

static PlankP pl_AtomicP_Subtract (PlankAtomicPRef p, PlankL operand);

static PlankP pl_AtomicP_Increment (PlankAtomicPRef p);

static PlankP pl_AtomicP_Decrement (PlankAtomicPRef p);

static PlankB pl_AtomicP_CompareAndSwap (PlankAtomicPRef p, PlankP oldPtr, PlankP newPtr);

//------------------------------------------------------------------------------

typedef struct PlankAtomicPX* PlankAtomicPXRef;

static PlankAtomicPXRef pl_AtomicPX_CreateAndInit();

static PlankAtomicPXRef pl_AtomicPX_Create();

static PlankResult pl_AtomicPX_Init (PlankAtomicPXRef p);

static PlankResult pl_AtomicPX_DeInit (PlankAtomicPXRef p);

static PlankResult pl_AtomicPX_Destroy (PlankAtomicPXRef p);

static PlankP pl_AtomicPX_Get (PlankAtomicPXRef p);

static PlankP pl_AtomicPX_GetUnchecked (PlankAtomicPXRef p);

static PlankUL pl_AtomicPX_GetExtra (PlankAtomicPXRef p);

static PlankUL pl_AtomicPX_GetExtraUnchecked (PlankAtomicPXRef p);

static PlankP pl_AtomicPX_SwapAll (PlankAtomicPXRef p, PlankP newPtr, PlankUL newExtra, PlankUL* oldExtra);

static PlankP pl_AtomicPX_Swap (PlankAtomicPXRef p, PlankP newPtr);

static void pl_AtomicPX_SwapOther (PlankAtomicPXRef p1, PlankAtomicPXRef p2);

static void pl_AtomicPX_SetAll (PlankAtomicPXRef p, PlankP newPtr, PlankUL newExtra);

static inline void pl_AtomicPX_SetAllUnchecked (PlankAtomicPXRef p, PlankP newPtr, PlankUL newExtra);

static void pl_AtomicPX_Set (PlankAtomicPXRef p, PlankP newPtr);

static PlankP pl_AtomicPX_Add (PlankAtomicPXRef p, PlankL operand);

static PlankP pl_AtomicPX_Subtract (PlankAtomicPXRef p, PlankL operand);

static PlankP pl_AtomicPX_Increment (PlankAtomicPXRef p);

static PlankP pl_AtomicPX_Decrement (PlankAtomicPXRef p);

static PlankB pl_AtomicPX_CompareAndSwap (PlankAtomicPXRef p, PlankP oldPtr, PlankUL oldExtra, PlankP newPtr, PlankUL newExtra);

static PlankB pl_AtomicPX_CompareAndSwapP (PlankAtomicPXRef p, PlankP oldPtr, PlankP newPtr);


//------------------------------------------------------------------------------

PLANK_END_C_LINKAGE

#define PLANK_INLINING_FUNCTIONS 1
#include "plank_AtomicInline.h"
#undef PLANK_INLINING_FUNCTIONS

#endif // PLANK_ATOMIC_H