sphlflogger.h

Go to the documentation of this file.

/*
 * Copyright (c) 2010-2014 IBM Corporation.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation, Steven Munroe - initial API and implementation
 */

#ifndef __SPH_LOCK_FREE_LOGGER_H
#define __SPH_LOCK_FREE_LOGGER_H

#include "sastype.h"
#include "sphtimer.h"


typedef void *SPHLFLogger_t; 

#ifdef __cplusplus
#define __C__ "C"
#else
#define __C__
#endif

typedef unsigned long longPtr_t;

typedef struct {
        unsigned int    valid : 1;
        unsigned int    timestamped : 1;
        unsigned int    __reserved : 2;
        unsigned int    category : 12;
        unsigned int    subcat : 8;
        unsigned int    len : 8;
        } sphLogEntryLayout_t;

typedef unsigned int sphLogEntryID_t;

typedef union {
        sphLogEntryID_t         idUnit;
        sphLogEntryLayout_t     detail;
        } sphLogEntry_t;


typedef unsigned short sphpid16_t;

typedef struct {
        sphLogEntry_t   entryID;
        sphpid16_t      PID;
        sphpid16_t      TID;
        sphtimer_t      timeStamp;
        } SPHLFLogHeader_t;


typedef struct {
        SPHLFLogHeader_t        *entry;
        char                    *next;
        unsigned short int      total_size;
        unsigned short int      remaining;
        } SPHLFLoggerHandle_t;

typedef struct {
        SPHLFLogger_t           logger;
        longPtr_t               current;
        longPtr_t               free;
        longPtr_t               start_log;
        longPtr_t               end_log;
        unsigned int            options;
        } SPHLFLogIterator_t;

#define SPHLFLOGGER_CIRCULAR (1)

#define SPHLFLOGGER_CIRCULAR_WRAPED (1<<1)

#define SPHLFLOGGER_CIRCULAR_NOTFIRST (1<<2)

#define SPHLFLOGGER_CACHE_PREFETCH0 (1<<3)

#define SPHLFLOGGER_CACHE_PREFETCH1 (1<<4)

#define SPHLFLOGGER_CIRCULAR_RESETMASK (SPHLFLOGGER_CIRCULAR | \
                SPHLFLOGGER_CACHE_PREFETCH0 | \
                SPHLFLOGGER_CACHE_PREFETCH1)

extern __C__ SPHLFLogger_t 
SPHLFLoggerInit (void *buf_seg , block_size_t buf_size);

extern __C__ SPHLFLogger_t 
SPHLFLoggerInitWithStride (void* buf_seg,  block_size_t buf_size,
                           unsigned short entry_stride,
                           unsigned int options);

extern __C__ SPHLFLogger_t 
SPHLFLoggerCreate (block_size_t buf_size);

extern __C__ SPHLFLogger_t
SPHLFCircularLoggerCreate (block_size_t buf_size,
                           unsigned short stride);

extern __C__ void *
SPHLFLoggerAllocRaw (SPHLFLogger_t log, 
                     block_size_t alloc_size);

extern __C__ SPHLFLoggerHandle_t *
SPHLFLoggerAllocTimeStamped (SPHLFLogger_t log,
                             int catcode, int subcode,
                             block_size_t alloc_size,
                             SPHLFLoggerHandle_t *handlespace);

extern __C__ SPHLFLoggerHandle_t *
SPHLFLoggerAllocStrideTimeStamped (SPHLFLogger_t log,
                                   int catcode, int subcode,
                                   SPHLFLoggerHandle_t *handlespace);

extern __C__ SPHLFLoggerHandle_t *
SPHLFLoggerAllocTimeStampedNoLock (SPHLFLogger_t log,
                             int catcode, int subcode,
                             block_size_t alloc_size,
                             SPHLFLoggerHandle_t *handlespace);

extern __C__ SPHLFLoggerHandle_t *
SPHLFLoggerAllocStrideTimeStampedNoLock (SPHLFLogger_t log,
                                   int catcode, int subcode,
                                   SPHLFLoggerHandle_t *handlespace);

extern __C__ int
SPHLFLoggerEntryComplete (SPHLFLoggerHandle_t *entryhandle);

extern __C__ int
SPHLFLoggerEntryIsComplete (SPHLFLoggerHandle_t *entryhandle);

extern __C__ int
SPHLFLoggerEntryIsTimestamped (SPHLFLoggerHandle_t *entryhandle);

extern __C__ SPHLFLoggerHandle_t *
SPHLFLoggerIteratorNext (SPHLFLogIterator_t *iterator,
                         SPHLFLoggerHandle_t *handlespace);

extern __C__ SPHLFLogIterator_t *
SPHLFLoggerCreateIterator(SPHLFLogger_t log,
                          SPHLFLogIterator_t *iteratorSpace);

extern __C__ int
SPHLFLoggerEmpty (SPHLFLogger_t log);

extern __C__ int
SPHLFLoggerWrapped (SPHLFLogger_t log);

extern __C__ block_size_t
SPHLFLoggerFreeSpace (SPHLFLogger_t log);

extern __C__ int
SPHLFLoggerFull (SPHLFLogger_t log);

extern __C__ int
SPHLFLoggerResetIfFullSync (SPHLFLogger_t log);

extern __C__ int
SPHLFLoggerResetAsync (SPHLFLogger_t log);

extern __C__ int
SPHLFLoggerPrefetch (SPHLFLogger_t log);

extern __C__ int
SPHLFLoggerSetCachePrefetch (SPHLFLogger_t log, int prefetch);

extern __C__ int 
SPHLFLoggerDestroy (SPHLFLogger_t log);

#endif /* __SPH_LOCK_FREE_LOGGER_H */