sphdirectpcqueue.h

Go to the documentation of this file.

/*
 * Copyright (c) 2015 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 SRC_SPHDIRECTPCQUEUE_H_
#define SRC_SPHDIRECTPCQUEUE_H_
#include <stdint.h>

#include "sastype.h"
#include "sasatom.h"
#include "sphlfentry.h"
#include "sphsinglepcqueue.h"


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

typedef void* SPHLFEntryDirect_t;

static inline int
SPHLFEntryDirectComplete (SPHLFEntryDirect_t directHandle,
                          sphLFEntryID_t entry_template,
                          int catcode, int subcode)
{
    int rc = 1;
    SPHLFEntryHeader_t  *entryPtr = (SPHLFEntryHeader_t*)directHandle;
    sphLFEntry_t        entrytemp;

    sas_read_barrier();
    /* the template should have allocated and len already set.  */
    entrytemp.idUnit = entry_template;
    entrytemp.detail.valid = 1;
    entrytemp.detail.category = catcode;
    entrytemp.detail.subcat = subcode;

    entryPtr->entryID.idUnit = entrytemp.idUnit;

    return (rc);
}

static inline void*
SPHLFEntryDirectGetFreePtr (SPHLFEntryDirect_t directHandle)
{
        char    *ptr    = (char*)directHandle + sizeof (sphLFEntry_t);

        return ((void*)ptr);
}

static inline void*
SPHLFEntryDirectGetPtrAligned (SPHLFEntryDirect_t directHandle,
                size_t alignval)
{
        uintptr_t       ptr             = (uintptr_t)directHandle;
        uintptr_t       adjust  = alignval - 1;
        uintptr_t       mask    = ~adjust;

        ptr = ((ptr + sizeof (sphLFEntry_t) + adjust) & mask);

        return ((void*)ptr);
}

static inline void*
SPHLFEntryDirectIncAndAlign (void *directptr, size_t incval, size_t alignval)
{
        uintptr_t       ptr             = (uintptr_t)directptr;
        uintptr_t       adjust  = alignval - 1;
        uintptr_t       mask    = ~adjust;

        ptr = ((ptr + incval + adjust) & mask);
        return ((void*)ptr);
}

static inline int
SPHLFEntryDirectIsComplete (SPHLFEntryDirect_t directHandle)
{
    SPHLFEntryHeader_t  *entryPtr = (SPHLFEntryHeader_t*)directHandle;

    return (entryPtr->entryID.detail.valid == 1);
}

static inline int
SPHLFEntryDirectIsTimestamped (SPHLFEntryDirect_t directHandle)
{
    SPHLFEntryHeader_t  *entryPtr = (SPHLFEntryHeader_t*)directHandle;

    return ((entryPtr->entryID.detail.valid == 1)
          &&(entryPtr->entryID.detail.timestamped == 1));
}

static inline int
SPHLFEntryDirectCategory (SPHLFEntryDirect_t directHandle)
{
    SPHLFEntryHeader_t  *entryPtr = (SPHLFEntryHeader_t*)directHandle;
    int result = -1;
#if 0
    printf ("SPHLFEntryCategory(%p) entry=%p id=%x\n",
                handlespace, entryPtr, entryPtr->entryID.idUnit);
#endif
    if (entryPtr->entryID.detail.valid == 1)
        result = entryPtr->entryID.detail.category;

    return (result);
}

static inline int
SPHLFEntryDirectSubcat (SPHLFEntryDirect_t directHandle)
{
    SPHLFEntryHeader_t  *entryPtr = (SPHLFEntryHeader_t*)directHandle;
    int result = -1;
#if 0
    printf ("SPHLFEntrySubcat(%p) entry=%p id=%x\n",
                handlespace, entryPtr, entryPtr->entryID.idUnit);
#endif
    if (entryPtr->entryID.detail.valid == 1)
        result = entryPtr->entryID.detail.subcat;

    return (result);
}

extern __C__ sphLFEntryID_t
SPHSinglePCQueueGetEntryTemplate (SPHSinglePCQueue_t queue);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueAllocStrideDirect (SPHSinglePCQueue_t queue);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueAllocStrideDirectSpin (SPHSinglePCQueue_t queue);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueAllocStrideDirectSpinPause (SPHSinglePCQueue_t queue);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueGetNextCompleteDirectSpin (SPHSinglePCQueue_t queue);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueGetNextCompleteDirectSpinPause (SPHSinglePCQueue_t queue);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueGetNextCompleteDirect (SPHSinglePCQueue_t queue);

extern __C__ int
SPHSinglePCQueueFreeNextEntryDirect (SPHSinglePCQueue_t queue,
                                     SPHLFEntryDirect_t next_entry);

extern __C__ SPHLFEntryDirect_t
SPHSinglePCQueueGetNextEntryDirect (SPHSinglePCQueue_t queue);

extern __C__ int
SPHSinglePCQueueEntryIsCompleteDirect (SPHLFEntryDirect_t directHandle);

#endif /* SRC_SPHDIRECTPCQUEUE_H_ */