nvscisync.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019, NVIDIA CORPORATION. All rights reserved.
 *
 * NVIDIA Corporation and its licensors retain all intellectual property
 * and proprietary rights in and to this software, related documentation
 * and any modifications thereto.  Any use, reproduction, disclosure or
 * distribution of this software and related documentation without an express
 * license agreement from NVIDIA Corporation is strictly prohibited.
 */
#ifndef INCLUDED_NVSCISYNC_H
#define INCLUDED_NVSCISYNC_H

#if defined(__cplusplus)
#include <cstdlib>
#else
#include <stdlib.h>
#include <stdbool.h>
#endif

#include <nvscierror.h>
#include <nvsciipc.h>

#if defined (__cplusplus)
extern "C"
{
#endif

static const uint32_t NvSciSyncMajorVersion = 1U;
static const uint32_t NvSciSyncMinorVersion = 0U;

typedef struct NvSciSyncModuleRec* NvSciSyncModule;

typedef struct NvSciSyncCpuWaitContextRec* NvSciSyncCpuWaitContext;

typedef struct {
    uint64_t payload[6];
} NvSciSyncFence;

static const NvSciSyncFence NvSciSyncFenceInitializer = {{0U}};

typedef struct {
    uint64_t payload[7];
} NvSciSyncFenceIpcExportDescriptor;

typedef struct {
    uint64_t payload[128];
} NvSciSyncObjIpcExportDescriptor;

typedef struct NvSciSyncObjRec* NvSciSyncObj;

typedef struct NvSciSyncAttrListRec* NvSciSyncAttrList;

typedef enum {
    NvSciSyncAccessPerm_WaitOnly,
    NvSciSyncAccessPerm_SignalOnly,
    NvSciSyncAccessPerm_WaitSignal,
} NvSciSyncAccessPerm;

typedef enum {
    NvSciSyncAttrKey_LowerBound,
    NvSciSyncAttrKey_NeedCpuAccess,
    NvSciSyncAttrKey_RequiredPerm,
    NvSciSyncAttrKey_ActualPerm,
    NvSciSyncAttrKey_WaiterContextInsensitiveFenceExports,
    NvSciSyncAttrKey_UpperBound,
} NvSciSyncAttrKey;

typedef struct {
    NvSciSyncAttrKey attrKey;
    const void* value;
    size_t len;
} NvSciSyncAttrKeyValuePair;

NvSciError NvSciSyncModuleOpen(
    NvSciSyncModule* newModule);

void NvSciSyncModuleClose(
    NvSciSyncModule module);

NvSciError NvSciSyncCpuWaitContextAlloc(
    NvSciSyncModule module,
    NvSciSyncCpuWaitContext* newContext);

void NvSciSyncCpuWaitContextFree(
    NvSciSyncCpuWaitContext context);

NvSciError NvSciSyncAttrListCreate(
    NvSciSyncModule module,
    NvSciSyncAttrList* attrList);

void NvSciSyncAttrListFree(
    NvSciSyncAttrList attrList);

NvSciError NvSciSyncAttrListIsReconciled(
    NvSciSyncAttrList attrList,
    bool* isReconciled);

NvSciError NvSciSyncAttrListValidateReconciled(
    NvSciSyncAttrList reconciledAttrList,
    const NvSciSyncAttrList inputUnreconciledAttrListArray[],
    size_t inputUnreconciledAttrListCount,
    bool* isReconciledListValid);

NvSciError NvSciSyncAttrListSetAttrs(
    NvSciSyncAttrList attrList,
    const NvSciSyncAttrKeyValuePair* pairArray,
    size_t pairCount);

NvSciError NvSciSyncAttrListGetAttrs(
    NvSciSyncAttrList attrList,
    NvSciSyncAttrKeyValuePair* pairArray,
    size_t pairCount);

size_t NvSciSyncAttrListGetSlotCount(
    NvSciSyncAttrList attrList);

NvSciError NvSciSyncAttrListAppendUnreconciled(
    const NvSciSyncAttrList inputUnreconciledAttrListArray[],
    size_t inputUnreconciledAttrListCount,
    NvSciSyncAttrList* newUnreconciledAttrList);

NvSciError NvSciSyncAttrListClone(
    NvSciSyncAttrList origAttrList,
    NvSciSyncAttrList* newAttrList);

NvSciError NvSciSyncAttrListSlotGetAttrs(
    NvSciSyncAttrList attrList,
    size_t slotIndex,
    NvSciSyncAttrKeyValuePair* pairArray,
    size_t pairCount);

NvSciError NvSciSyncAttrListReconcile(
    const NvSciSyncAttrList inputArray[],
    size_t inputCount,
    NvSciSyncAttrList* newReconciledList,
    NvSciSyncAttrList* newConflictList);

NvSciError NvSciSyncAttrListDebugDump(
    NvSciSyncAttrList attrList,
    void** buf,
    size_t* len);

NvSciError NvSciSyncAttrListIpcExportUnreconciled(
    const NvSciSyncAttrList unreconciledAttrListArray[],
    size_t unreconciledAttrListCount,
    NvSciIpcEndpoint ipcEndpoint,
    void** descBuf,
    size_t* descLen);

NvSciError NvSciSyncAttrListIpcExportReconciled(
    const NvSciSyncAttrList reconciledAttrList,
    NvSciIpcEndpoint ipcEndpoint,
    void** descBuf,
    size_t* descLen);

NvSciError NvSciSyncAttrListIpcImportUnreconciled(
    NvSciSyncModule module,
    NvSciIpcEndpoint ipcEndpoint,
    const void* descBuf,
    size_t descLen,
    NvSciSyncAttrList* importedUnreconciledAttrList);

NvSciError NvSciSyncAttrListIpcImportReconciled(
    NvSciSyncModule module,
    NvSciIpcEndpoint ipcEndpoint,
    const void* descBuf,
    size_t descLen,
    const NvSciSyncAttrList inputUnreconciledAttrListArray[],
    size_t inputUnreconciledAttrListCount,
    NvSciSyncAttrList* importedReconciledAttrList);

void NvSciSyncAttrListFreeDesc(
    void* descBuf);

void NvSciSyncFenceClear(
    NvSciSyncFence* syncFence);

NvSciError NvSciSyncFenceDup(
    const NvSciSyncFence* srcSyncFence,
    NvSciSyncFence* dstSyncFence);

NvSciError NvSciSyncObjAlloc(
    NvSciSyncAttrList reconciledList,
    NvSciSyncObj* syncObj);

NvSciError NvSciSyncObjDup(
    NvSciSyncObj syncObj,
    NvSciSyncObj* dupObj);

NvSciError NvSciSyncObjGetAttrList(
    NvSciSyncObj syncObj,
    NvSciSyncAttrList* syncAttrList);

void NvSciSyncObjFree(
    NvSciSyncObj syncObj);

NvSciError NvSciSyncObjIpcExport(
    NvSciSyncObj syncObj,
    NvSciSyncAccessPerm permissions,
    NvSciIpcEndpoint ipcEndpoint,
    NvSciSyncObjIpcExportDescriptor* desc);

NvSciError NvSciSyncObjIpcImport(
    NvSciIpcEndpoint ipcEndpoint,
    const NvSciSyncObjIpcExportDescriptor* desc,
    NvSciSyncAttrList inputAttrList,
    NvSciSyncAccessPerm permissions,
    int64_t timeoutUs,
    NvSciSyncObj* syncObj);

NvSciError NvSciSyncIpcExportFence(
    const NvSciSyncFence* syncFence,
    NvSciIpcEndpoint ipcEndpoint,
    NvSciSyncFenceIpcExportDescriptor* desc);

NvSciError NvSciSyncIpcImportFence(
    NvSciSyncObj syncObj,
    const NvSciSyncFenceIpcExportDescriptor* desc,
    NvSciSyncFence* syncFence);

NvSciError NvSciSyncObjGenerateFence(
    NvSciSyncObj syncObj,
    NvSciSyncFence* syncFence);

NvSciError NvSciSyncObjSignal(
    NvSciSyncObj syncObj);

NvSciError NvSciSyncFenceWait(
    const NvSciSyncFence* syncFence,
    NvSciSyncCpuWaitContext context,
    int64_t timeoutUs);

NvSciError NvSciSyncAttrListGetAttr(
    NvSciSyncAttrList attrList,
    NvSciSyncAttrKey key,
    const void** value,
    size_t* len);

NvSciError NvSciSyncAttrListReconcileAndObjAlloc(
    const NvSciSyncAttrList inputArray[],
    size_t inputCount,
    NvSciSyncObj* syncObj,
    NvSciSyncAttrList* newConflictList);

NvSciError NvSciSyncIpcExportAttrListAndObj(
    NvSciSyncObj syncObj,
    NvSciSyncAccessPerm permissions,
    NvSciIpcEndpoint ipcEndpoint,
    void** attrListAndObjDesc,
    size_t* attrListAndObjDescSize);

void NvSciSyncAttrListAndObjFreeDesc(
    void* attrListAndObjDescBuf);

NvSciError NvSciSyncIpcImportAttrListAndObj(
    NvSciSyncModule module,
    NvSciIpcEndpoint ipcEndpoint,
    const void* attrListAndObjDesc,
    size_t attrListAndObjDescSize,
    NvSciSyncAttrList const attrList[],
    size_t attrListCount,
    NvSciSyncAccessPerm minPermissions,
    int64_t timeoutUs,
    NvSciSyncObj* syncObj);

#if defined(__cplusplus)
}
#endif // __cplusplus

#endif // INCLUDED_NVSCISYNC_H