Shared Persistent Heap Data Environment Manual
1.1.0
|
Shared Persistent Heap, logger/queue etc event entry status, update, and access functions. More...
Go to the source code of this file.
Classes | |
struct | sphLFEntryLayout_t |
Fields defining the entry header details word. More... | |
union | sphLFEntry_t |
Union of Entry details with 32-bit word for atomic update. More... | |
struct | SPHLFEntryHeader_t |
Instance of a Lock Free Entry Header. More... | |
struct | SPHLFEntryHandle_t |
Instance of a Lock Free event data Entry Handle. More... | |
Macros | |
#define | SPHENTRYGETSTRUCTPTR(__handle, __struct) SPHLFEntryGetStructPtr(__handle, sizeof(__struct), __alignof__(__struct)) |
Macro for using sizeof/__alignof__ parms with SPHLFEntryGetStructPtr function. | |
#define | SPHENTRYALLOCSTRUCT(__handle, __struct) SPHLFEntryAllocStruct(__handle, sizeof(__struct), __alignof__(__struct)) |
Macro for using sizeof/__alignof__ parms with SPHLFEntryAllocStruct function. | |
Typedefs | |
typedef unsigned long | longPtr_t |
unsigned int type, consistent with the size of a pointer and used for pointer calculations | |
typedef unsigned int | sphLFEntryID_t |
Aggregate type for handling sphLogEntryLayout_t. | |
typedef unsigned short | sphpid16_t |
Common type for PID/TID values stored in event entries. | |
Functions | |
static int | SPHLFEntryStrongComplete (SPHLFEntryHandle_t *handlespace) |
Marks the entry specified by the entry handle as complete. Also executes any memory barriers required by the platform to ensure that all previous stores to this entry by this thread are visible to other threads. More... | |
static int | SPHLFEntryWeakComplete (SPHLFEntryHandle_t *handlespace) |
Marks the entry specified by the entry handle as complete. No memory barriers are performance. On out-of-order machines there are no guarantee that all previous stores by this thread are visible to other threads. More... | |
static int | SPHLFEntryComplete (SPHLFEntryHandle_t *handlespace) |
Marks the entry specified by the entry handle as complete. Also executes write memory barries required by the platform to ensure that all previous stores by this thread to this entry are complete. More... | |
static int | SPHLFEntryIsComplete (SPHLFEntryHandle_t *handlespace) |
Return the status of the entry specified by the entry handle. More... | |
static int | SPHLFEntryIsTimestamped (SPHLFEntryHandle_t *handlespace) |
Return the status of the entry specified by the entry handle. More... | |
static sphtimer_t | SPHLFEntryTimeStamp (SPHLFEntryHandle_t *handlespace) |
Return the time stamp value for the entry specified by the entry handle. More... | |
static sphpid16_t | SPHLFEntryPID (SPHLFEntryHandle_t *handlespace) |
Return the process ID for the entry specified by the entry handle. More... | |
static sphpid16_t | SPHLFEntryTID (SPHLFEntryHandle_t *handlespace) |
Return the thread ID for the entry specified by the entry handle. More... | |
static SPHLFEntryHeader_t * | SPHLFEntryHeader (SPHLFEntryHandle_t *handlespace) |
Return the address for the entry header specified by the entry handle. More... | |
static int | SPHLFEntryCategory (SPHLFEntryHandle_t *handlespace) |
Return the entry category for the entry specified by the entry handle. More... | |
static int | SPHLFEntrySubcat (SPHLFEntryHandle_t *handlespace) |
Return the entry sub-category for the entry specified by the entry handle. More... | |
static void * | SPHLFEntryGetFreePtr (SPHLFEntryHandle_t *handle) |
Return the first free byte address for the entry specified by the entry handle. More... | |
static void * | SPHLFEntryGetStructPtr (SPHLFEntryHandle_t *handle, unsigned long __size, unsigned long __align) |
Return the correctly aligned pointer for a struct or array starting at the next free location within the entry. More... | |
static void * | SPHLFEntryAllocStruct (SPHLFEntryHandle_t *handle, unsigned long __size, unsigned long __align) |
Allocate space for struct starting at the next free location within the entry. More... | |
static int | SPHLFEntryAddString (SPHLFEntryHandle_t *handle, char *value) |
Insert a C string at the next free location within the entry. More... | |
static int | SPHLFEntryAddChar (SPHLFEntryHandle_t *handle, char value) |
Insert a character at the next free location within the entry. More... | |
static int | SPHLFEntryAddShort (SPHLFEntryHandle_t *handle, short int value) |
Insert a short int at the next free location within the entry. More... | |
static int | SPHLFEntryAddInt (SPHLFEntryHandle_t *handle, int value) |
Insert a int at the next free location within the entry. More... | |
static int | SPHLFEntryAddLong (SPHLFEntryHandle_t *handle, long value) |
Insert a long int at the next free location within the entry. More... | |
static int | SPHLFEntryAddPtr (SPHLFEntryHandle_t *handle, void *value) |
Insert a void* at the next free location within the entry. More... | |
static int | SPHLFEntryAddLongLong (SPHLFEntryHandle_t *handle, long long value) |
Insert a long long int at the next free location within the entry. More... | |
static int | SPHLFEntryAddFloat (SPHLFEntryHandle_t *handle, float value) |
Insert a float at the next free location within the entry. More... | |
static int | SPHLFEntryAddDouble (SPHLFEntryHandle_t *handle, double value) |
Insert a double at the next free location within the entry. More... | |
static char | SPHLFEntryGetNextChar (SPHLFEntryHandle_t *handle) |
Return the next char from the entry via the current next value pointer. The internal next value pointer is advanced to the next location. More... | |
static char * | SPHLFEntryGetNextString (SPHLFEntryHandle_t *handle) |
Return the pointer to the next C string from the logger entry via the current next value pointer. The internal next value pointer is advanced to the next location after the string NUL char. More... | |
static short int | SPHLFEntryGetNextShort (SPHLFEntryHandle_t *handle) |
Return the next short int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
static int | SPHLFEntryGetNextInt (SPHLFEntryHandle_t *handle) |
Return the next int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
static long | SPHLFEntryGetNextLong (SPHLFEntryHandle_t *handle) |
Return the next long int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
static void * | SPHLFEntryGetNextPtr (SPHLFEntryHandle_t *handle) |
Return the next void* from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
static long long | SPHLFEntryGetNextLongLong (SPHLFEntryHandle_t *handle) |
Return the next long long int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
static float | SPHLFEntryGetNextFloat (SPHLFEntryHandle_t *handle) |
Return the next float from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
static double | SPHLFEntryGetNextDouble (SPHLFEntryHandle_t *handle) |
Return the next double from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location. More... | |
Shared Persistent Heap, logger/queue etc event entry status, update, and access functions.
|
inlinestatic |
Insert a character at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a char value. |
|
inlinestatic |
Insert a double at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a double value. |
|
inlinestatic |
Insert a float at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a float value. |
|
inlinestatic |
Insert a int at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a int value. |
|
inlinestatic |
Insert a long int at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a long int value. |
|
inlinestatic |
Insert a long long int at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a long long int value. |
|
inlinestatic |
Insert a void* at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a void* (C pointer) value. |
|
inlinestatic |
Insert a short int at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | a short int value. |
|
inlinestatic |
Insert a C string at the next free location within the entry.
handle | Entry Handle for an allocated entry. |
value | pointer to a C string value. |
|
inlinestatic |
Allocate space for struct starting at the next free location within the entry.
Allocate space in the log entry for a multi-field structure or an array. The returned pointer can then be used to directly store data into struct fields or array entries. The SPHENTRYALLOCSTRUCT can be used to insure the correct usage sizeof and alignof to provide values for the __size and __align parameters.
handle | Entry Handle for an allocated entry. |
__size | of the struct/array to allocate. |
__align | alignment requirement of the struct/array space to allocated. |
|
inlinestatic |
Return the entry category for the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Marks the entry specified by the entry handle as complete. Also executes write memory barries required by the platform to ensure that all previous stores by this thread to this entry are complete.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the first free byte address for the entry specified by the entry handle.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next char from the entry via the current next value pointer. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next double from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next float from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next long int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next long long int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next void* from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the next short int from the entry via the current next value pointer. Leading bytes may be skipped to get the required alignment. The internal next value pointer is advanced to the next location.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the pointer to the next C string from the logger entry via the current next value pointer. The internal next value pointer is advanced to the next location after the string NUL char.
handle | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the correctly aligned pointer for a struct or array starting at the next free location within the entry.
The entries next pointer is adjusted for alignment and returned. The entries next pointer and remaining fields are updated for the next field following the struct/array.
handle | Entry Handle for an allocated entry. |
__size | of the struct/array to allocate. |
__align | alignment requirement of the struct/array space to allocated. |
|
inlinestatic |
Return the address for the entry header specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the status of the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the status of the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the process ID for the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Marks the entry specified by the entry handle as complete. Also executes any memory barriers required by the platform to ensure that all previous stores to this entry by this thread are visible to other threads.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the entry sub-category for the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the thread ID for the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Return the time stamp value for the entry specified by the entry handle.
handlespace | Entry Handle for an allocated entry. |
|
inlinestatic |
Marks the entry specified by the entry handle as complete. No memory barriers are performance. On out-of-order machines there are no guarantee that all previous stores by this thread are visible to other threads.
handlespace | Entry Handle for an allocated entry. |