stm.h

Go to the documentation of this file.

 
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA CORPORATION & AFFILIATES assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA CORPORATION & AFFILIATES. No third party distribution is allowed unless
// expressly authorized by NVIDIA. Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA CORPORATION & AFFILIATES products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA CORPORATION & AFFILIATES.
//
// SPDX-FileCopyrightText: Copyright (c) 2018-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.
//
 
#ifndef STM_H_
#define STM_H_
 
#if __GNUC__ >= 4
#define STM_API __attribute__((visibility("default")))
#endif
 
#include <stdint.h>
#include "stm_error.h"
#include <cuda_runtime.h>
#include <stdbool.h>
#include <nvscisync.h>
 
#ifdef VIBRANTE
#if VIBRANTE_PDK_DECIMAL < 6000400
#include <nvmedia_dla.h>
#endif
#if VIBRANTE_PDK_DECIMAL >= 6000000
#include <cupva_host_wrapper.h>
#if VIBRANTE_PDK_DECIMAL >= 6000400
#include <cudla.h>
#if VIBRANTE_PDK_DECIMAL >= 6000500
#include <VulkanSC/vulkan/vulkan_sc.h>
#if VIBRANTE_PDK_DECIMAL >= 6000600
#include <nvmedia_6x/nvmedia_ldc.h>
#include <nvmedia_6x/nvmedia_2d.h>
#endif
#endif
#endif
#endif
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef struct
{
    uint32_t epochIterations;
    uint16_t scheduleId;
} stmRunnableInfo_t;
 
typedef void (*stmRunnable_t)(void* userdata);
 
typedef void (*stmCudaSubmitter_t)(void* userdata, cudaStream_t stream);
 
STM_API void stmClientInit(const char* clientName);
 
STM_API void stmClientInitWithDiscriminator(const char* clientName, int32_t discriminator);
 
STM_API stmErrorCode_t stmRegisterCpuRunnable(stmRunnable_t func, const char* const runnableId, void* userdata);
 
STM_API stmErrorCode_t stmRegisterCudaSubmitter(stmCudaSubmitter_t func, const char* const runnableId, void* userdata);
 
STM_API stmErrorCode_t stmRegisterCudaResource(const char* resourceName, cudaStream_t stream);
 
#ifdef VIBRANTE
 
#if VIBRANTE_PDK_DECIMAL >= 6000500
STM_API stmErrorCode_t stmRegisterVulkanResource(const char* resourceName, VkQueue queue, VkDevice device, VkPhysicalDevice physicalDevice, VkInstance instance);
 
typedef void (*stmVulkanSubmitter_t)(void* userdata, VkQueue queue);
 
STM_API stmErrorCode_t stmRegisterVulkanSubmitter(stmVulkanSubmitter_t func, const char* const runnableId, void* userdata);
#endif
 
#if VIBRANTE_PDK_DECIMAL < 6000400
typedef void (*stmDlaSubmitter_t)(void* userdata, NvMediaDla* dla);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000200
typedef void (*stmCuDlaSubmitter_t)(void* userdata, cudaStream_t cudla);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000600
typedef void (*stmLdcSubmitter_t)(void* userdata, NvMediaLdc* ldc, NvSciSyncFence ldcPrefenceList[], size_t ldcPrefenceCount, NvSciSyncObj ldcPostfencesyncObj, NvSciSyncFence* ldcPostfence);
 
typedef void (*stmNv2DSubmitter_t)(void* userdata, NvMedia2D* nv2D, NvSciSyncFence nv2DPrefenceList[], size_t nv2DPrefenceCount, NvSciSyncObj nv2DPostfencesyncObj, NvSciSyncFence* nv2DPostfence);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000400
typedef void (*stmCuDlaStandaloneSubmitter_t)(void* userdata, cudlaDevHandle cudla);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000000
typedef void (*stmVpuSubmitter_t)(void* userdata, cupvaStream_t vpu);
#endif
 
#if VIBRANTE_PDK_DECIMAL < 6000400
STM_API stmErrorCode_t stmRegisterDlaResource(const char* resourceName, NvMediaDla* dla);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000200
STM_API stmErrorCode_t stmRegisterCuDlaResource(const char* resourceName, cudaStream_t cudla);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000600
STM_API stmErrorCode_t stmRegisterLdcResource(const char* resourceName, NvMediaLdc* ldc);
 
STM_API stmErrorCode_t stmRegisterNv2DResource(const char* resourceName, NvMedia2D* nv2D);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000400
STM_API stmErrorCode_t stmRegisterCuDlaStandaloneResource(const char* resourceName, cudlaDevHandle cudla);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000000
STM_API stmErrorCode_t stmRegisterVpuResource(const char* resourceName, cupvaStream_t vpu);
#endif
 
#if VIBRANTE_PDK_DECIMAL < 6000400
STM_API stmErrorCode_t stmRegisterDlaSubmitter(stmDlaSubmitter_t func, const char* const runnableId, void* userdata);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000200
STM_API stmErrorCode_t stmRegisterCuDlaSubmitter(stmCuDlaSubmitter_t func, const char* const runnableId, void* userdata);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000600
STM_API stmErrorCode_t stmRegisterLdcSubmitter(stmLdcSubmitter_t func, const char* const runnableId, void* userdata);
 
STM_API stmErrorCode_t stmRegisterNv2DSubmitter(stmNv2DSubmitter_t func, const char* const runnableId, void* userdata);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000400
STM_API stmErrorCode_t stmRegisterCuDlaStandaloneSubmitter(stmCuDlaStandaloneSubmitter_t func, const char* const runnableId, void* userdata);
#endif
 
#if VIBRANTE_PDK_DECIMAL >= 6000000
STM_API stmErrorCode_t stmRegisterVpuSubmitter(stmVpuSubmitter_t func, const char* const runnableId, void* userdata);
#endif
 
#endif
 
typedef void (*stmScheduleSwitchCallback_t)(uint16_t startScheduleId, uint16_t hyperepochId, void* userdata);
 
STM_API stmErrorCode_t stmRegisterCallBack(stmScheduleSwitchCallback_t func, void* userdata);
 
STM_API stmErrorCode_t stmEnterScheduler(void);
 
STM_API stmErrorCode_t stmGetRuntimeInfo(stmRunnableInfo_t* info);
 
STM_API stmErrorCode_t stmExitScheduler(void);
 
STM_API void stmClientExit(void);
 
#ifdef __cplusplus
}
#endif
 
#endif