libomptarget/include/omptargetplugin.h - llvm-project/openmp - Git at Google

 //===-- omptargetplugin.h - Target dependent OpenMP Plugin API --*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines an interface between target independent OpenMP offload
 // runtime library libomptarget and target dependent plugin.
 //
 //===----------------------------------------------------------------------===//

 #ifndef _OMPTARGETPLUGIN_H_
 #define _OMPTARGETPLUGIN_H_

 #include <omptarget.h>

 #ifdef __cplusplus
 extern "C" {
 #endif

 // Return the number of available devices of the type supported by the
 // target RTL.
 int32_t __tgt_rtl_number_of_devices(void);

 // Return an integer different from zero if the provided device image can be
 // supported by the runtime. The functionality is similar to comparing the
 // result of __tgt__rtl__load__binary to NULL. However, this is meant to be a
 // lightweight query to determine if the RTL is suitable for an image without
 // having to load the library, which can be expensive.
 int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *Image);

 // Return an integer other than zero if the data can be exchaned from SrcDevId
 // to DstDevId. If it is data exchangable, the device plugin should provide
 // function to move data from source device to destination device directly.
 int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId);

 // Initialize the requires flags for the device.
 int64_t __tgt_rtl_init_requires(int64_t RequiresFlags);

 // Initialize the specified device. In case of success return 0; otherwise
 // return an error code.
 int32_t __tgt_rtl_init_device(int32_t ID);

 // Pass an executable image section described by image to the specified
 // device and prepare an address table of target entities. In case of error,
 // return NULL. Otherwise, return a pointer to the built address table.
 // Individual entries in the table may also be NULL, when the corresponding
 // offload region is not supported on the target device.
 __tgt_target_table *__tgt_rtl_load_binary(int32_t ID,
                                           __tgt_device_image *Image);

 // Allocate data on the particular target device, of the specified size.
 // HostPtr is a address of the host data the allocated target data
 // will be associated with (HostPtr may be NULL if it is not known at
 // allocation time, like for example it would be for target data that
 // is allocated by omp_target_alloc() API). Return address of the
 // allocated data on the target that will be used by libomptarget.so to
 // initialize the target data mapping structures. These addresses are
 // used to generate a table of target variables to pass to
 // __tgt_rtl_run_region(). The __tgt_rtl_data_alloc() returns NULL in
 // case an error occurred on the target device.
 void *__tgt_rtl_data_alloc(int32_t ID, int64_t Size, void *HostPtr);

 // Pass the data content to the target device using the target address. In case
 // of success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_submit(int32_t ID, void *TargetPtr, void *HostPtr,
                               int64_t Size);

 int32_t __tgt_rtl_data_submit_async(int32_t ID, void *TargetPtr, void *HostPtr,
                                     int64_t Size,
                                     __tgt_async_info *AsyncInfoPtr);

 // Retrieve the data content from the target device using its address. In case
 // of success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_retrieve(int32_t ID, void *HostPtr, void *TargetPtr,
                                 int64_t Size);

 // Asynchronous version of __tgt_rtl_data_retrieve
 int32_t __tgt_rtl_data_retrieve_async(int32_t ID, void *HostPtr,
                                       void *TargetPtr, int64_t Size,
                                       __tgt_async_info *AsyncInfoPtr);

 // Copy the data content from one target device to another target device using
 // its address. This operation does not need to copy data back to host and then
 // from host to another device. In case of success, return zero. Otherwise,
 // return an error code.
 int32_t __tgt_rtl_data_exchange(int32_t SrcID, void *SrcPtr, int32_t DstID,
                                 void *DstPtr, int64_t Size);

 // Asynchronous version of __tgt_rtl_data_exchange
 int32_t __tgt_rtl_data_exchange_async(int32_t SrcID, void *SrcPtr,
                                       int32_t DesID, void *DstPtr, int64_t Size,
                                       __tgt_async_info *AsyncInfoPtr);

 // De-allocate the data referenced by target ptr on the device. In case of
 // success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_data_delete(int32_t ID, void *TargetPtr);

 // Transfer control to the offloaded entry Entry on the target device.
 // Args and Offsets are arrays of NumArgs size of target addresses and
 // offsets. An offset should be added to the target address before passing it
 // to the outlined function on device side. If AsyncInfoPtr is nullptr, it is
 // synchronous; otherwise it is asynchronous. However, AsyncInfoPtr may be
 // ignored on some platforms, like x86_64. In that case, it is synchronous. In
 // case of success, return zero. Otherwise, return an error code.
 int32_t __tgt_rtl_run_target_region(int32_t ID, void *Entry, void **Args,
                                     ptrdiff_t *Offsets, int32_t NumArgs);

 // Asynchronous version of __tgt_rtl_run_target_region
 int32_t __tgt_rtl_run_target_region_async(int32_t ID, void *Entry, void **Args,
                                           ptrdiff_t *Offsets, int32_t NumArgs,
                                           __tgt_async_info *AsyncInfoPtr);

 // Similar to __tgt_rtl_run_target_region, but additionally specify the
 // number of teams to be created and a number of threads in each team. If
 // AsyncInfoPtr is nullptr, it is synchronous; otherwise it is asynchronous.
 // However, AsyncInfoPtr may be ignored on some platforms, like x86_64. In that
 // case, it is synchronous.
 int32_t __tgt_rtl_run_target_team_region(int32_t ID, void *Entry, void **Args,
                                          ptrdiff_t *Offsets, int32_t NumArgs,
                                          int32_t NumTeams, int32_t ThreadLimit,
                                          uint64_t loop_tripcount);

 // Asynchronous version of __tgt_rtl_run_target_team_region
 int32_t __tgt_rtl_run_target_team_region_async(
     int32_t ID, void *Entry, void **Args, ptrdiff_t *Offsets, int32_t NumArgs,
     int32_t NumTeams, int32_t ThreadLimit, uint64_t loop_tripcount,
     __tgt_async_info *AsyncInfoPtr);

 // Device synchronization. In case of success, return zero. Otherwise, return an
 // error code.
 int32_t __tgt_rtl_synchronize(int32_t ID, __tgt_async_info *AsyncInfoPtr);

 #ifdef __cplusplus
 }
 #endif

 #endif // _OMPTARGETPLUGIN_H_
	//===-- omptargetplugin.h - Target dependent OpenMP Plugin API --- C++ --===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//
	//
	// This file defines an interface between target independent OpenMP offload
	// runtime library libomptarget and target dependent plugin.
	//
	//===----------------------------------------------------------------------===//

	#ifndef _OMPTARGETPLUGIN_H_
	#define _OMPTARGETPLUGIN_H_

	#include <omptarget.h>

	#ifdef __cplusplus
	extern "C" {
	#endif

	// Return the number of available devices of the type supported by the
	// target RTL.
	int32_t __tgt_rtl_number_of_devices(void);

	// Return an integer different from zero if the provided device image can be
	// supported by the runtime. The functionality is similar to comparing the
	// result of __tgt__rtl__load__binary to NULL. However, this is meant to be a
	// lightweight query to determine if the RTL is suitable for an image without
	// having to load the library, which can be expensive.
	int32_t __tgt_rtl_is_valid_binary(__tgt_device_image *Image);

	// Return an integer other than zero if the data can be exchaned from SrcDevId
	// to DstDevId. If it is data exchangable, the device plugin should provide
	// function to move data from source device to destination device directly.
	int32_t __tgt_rtl_is_data_exchangable(int32_t SrcDevId, int32_t DstDevId);

	// Initialize the requires flags for the device.
	int64_t __tgt_rtl_init_requires(int64_t RequiresFlags);

	// Initialize the specified device. In case of success return 0; otherwise
	// return an error code.
	int32_t __tgt_rtl_init_device(int32_t ID);

	// Pass an executable image section described by image to the specified
	// device and prepare an address table of target entities. In case of error,
	// return NULL. Otherwise, return a pointer to the built address table.
	// Individual entries in the table may also be NULL, when the corresponding
	// offload region is not supported on the target device.
	__tgt_target_table *__tgt_rtl_load_binary(int32_t ID,
	__tgt_device_image *Image);

	// Allocate data on the particular target device, of the specified size.
	// HostPtr is a address of the host data the allocated target data
	// will be associated with (HostPtr may be NULL if it is not known at
	// allocation time, like for example it would be for target data that
	// is allocated by omp_target_alloc() API). Return address of the
	// allocated data on the target that will be used by libomptarget.so to
	// initialize the target data mapping structures. These addresses are
	// used to generate a table of target variables to pass to
	// __tgt_rtl_run_region(). The __tgt_rtl_data_alloc() returns NULL in
	// case an error occurred on the target device.
	void __tgt_rtl_data_alloc(int32_t ID, int64_t Size, void HostPtr);

	// Pass the data content to the target device using the target address. In case
	// of success, return zero. Otherwise, return an error code.
	int32_t __tgt_rtl_data_submit(int32_t ID, void TargetPtr, void HostPtr,
	int64_t Size);

	int32_t __tgt_rtl_data_submit_async(int32_t ID, void TargetPtr, void HostPtr,
	int64_t Size,
	__tgt_async_info *AsyncInfoPtr);

	// Retrieve the data content from the target device using its address. In case
	// of success, return zero. Otherwise, return an error code.
	int32_t __tgt_rtl_data_retrieve(int32_t ID, void HostPtr, void TargetPtr,
	int64_t Size);

	// Asynchronous version of __tgt_rtl_data_retrieve
	int32_t __tgt_rtl_data_retrieve_async(int32_t ID, void *HostPtr,
	void *TargetPtr, int64_t Size,
	__tgt_async_info *AsyncInfoPtr);

	// Copy the data content from one target device to another target device using
	// its address. This operation does not need to copy data back to host and then
	// from host to another device. In case of success, return zero. Otherwise,
	// return an error code.
	int32_t __tgt_rtl_data_exchange(int32_t SrcID, void *SrcPtr, int32_t DstID,
	void *DstPtr, int64_t Size);

	// Asynchronous version of __tgt_rtl_data_exchange
	int32_t __tgt_rtl_data_exchange_async(int32_t SrcID, void *SrcPtr,
	int32_t DesID, void *DstPtr, int64_t Size,
	__tgt_async_info *AsyncInfoPtr);

	// De-allocate the data referenced by target ptr on the device. In case of
	// success, return zero. Otherwise, return an error code.
	int32_t __tgt_rtl_data_delete(int32_t ID, void *TargetPtr);

	// Transfer control to the offloaded entry Entry on the target device.
	// Args and Offsets are arrays of NumArgs size of target addresses and
	// offsets. An offset should be added to the target address before passing it
	// to the outlined function on device side. If AsyncInfoPtr is nullptr, it is
	// synchronous; otherwise it is asynchronous. However, AsyncInfoPtr may be
	// ignored on some platforms, like x86_64. In that case, it is synchronous. In
	// case of success, return zero. Otherwise, return an error code.
	int32_t __tgt_rtl_run_target_region(int32_t ID, void Entry, void *Args,
	ptrdiff_t *Offsets, int32_t NumArgs);

	// Asynchronous version of __tgt_rtl_run_target_region
	int32_t __tgt_rtl_run_target_region_async(int32_t ID, void Entry, void *Args,
	ptrdiff_t *Offsets, int32_t NumArgs,
	__tgt_async_info *AsyncInfoPtr);

	// Similar to __tgt_rtl_run_target_region, but additionally specify the
	// number of teams to be created and a number of threads in each team. If
	// AsyncInfoPtr is nullptr, it is synchronous; otherwise it is asynchronous.
	// However, AsyncInfoPtr may be ignored on some platforms, like x86_64. In that
	// case, it is synchronous.
	int32_t __tgt_rtl_run_target_team_region(int32_t ID, void Entry, void *Args,
	ptrdiff_t *Offsets, int32_t NumArgs,
	int32_t NumTeams, int32_t ThreadLimit,
	uint64_t loop_tripcount);

	// Asynchronous version of __tgt_rtl_run_target_team_region
	int32_t __tgt_rtl_run_target_team_region_async(
	int32_t ID, void Entry, void Args, ptrdiff_t Offsets, int32_t NumArgs,
	int32_t NumTeams, int32_t ThreadLimit, uint64_t loop_tripcount,
	__tgt_async_info *AsyncInfoPtr);

	// Device synchronization. In case of success, return zero. Otherwise, return an
	// error code.
	int32_t __tgt_rtl_synchronize(int32_t ID, __tgt_async_info *AsyncInfoPtr);

	#ifdef __cplusplus
	}
	#endif

	#endif // _OMPTARGETPLUGIN_H_