arno
/
hashcat
mirror of https://github.com/hashcat/hashcat.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Update HIP includes to work with Linux on HIP 5.1.20531+

Browse Source
pull/3260/head
Jens Steube 2 years ago
parent 4b4f9b61b9
commit cf352e4f8b
2 changed files with 172 additions and 109 deletions
Show Stats Download Patch File Download Diff File

277
include/ext_hip.h
Unescape View File

@ -10,7 +10,7 @@
// Therefore, we need to take certain items, such as hipDeviceptr_t from driver specific paths like amd_driver_types.h // Therefore, we need to take certain items, such as hipDeviceptr_t from driver specific paths like amd_driver_types.h
// We just need to keep this in mind in case we need to update these constants from future SDK versions // We just need to keep this in mind in case we need to update these constants from future SDK versions
// start: amd_driver_types.h // start: driver_types.h
typedef void* hipDeviceptr_t; typedef void* hipDeviceptr_t;
@ -26,9 +26,9 @@ typedef enum hipFunction_attribute {
HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES, HIP_FUNC_ATTRIBUTE_MAX_DYNAMIC_SHARED_SIZE_BYTES,
HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT, HIP_FUNC_ATTRIBUTE_PREFERRED_SHARED_MEMORY_CARVEOUT,
HIP_FUNC_ATTRIBUTE_MAX HIP_FUNC_ATTRIBUTE_MAX
}hipFunction_attribute; } hipFunction_attribute;
// stop: amd_driver_types.h // stop: driver_types.h
// start: hip_runtime_api.h // start: hip_runtime_api.h
@ -101,6 +101,7 @@ typedef enum __HIP_NODISCARD hipError_t {
hipErrorInvalidHandle = 400, hipErrorInvalidHandle = 400,
// Deprecated // Deprecated
hipErrorInvalidResourceHandle = 400, ///< Resource handle (hipEvent_t or hipStream_t) invalid. hipErrorInvalidResourceHandle = 400, ///< Resource handle (hipEvent_t or hipStream_t) invalid.
hipErrorIllegalState = 401, ///< Resource required is not in a valid state to perform operation.
hipErrorNotFound = 500, hipErrorNotFound = 500,
hipErrorNotReady = 600, ///< Indicates that asynchronous operations enqueued earlier are not hipErrorNotReady = 600, ///< Indicates that asynchronous operations enqueued earlier are not
///< ready. This is not actually an error, but is used to distinguish ///< ready. This is not actually an error, but is used to distinguish
@ -149,6 +150,10 @@ typedef enum __HIP_NODISCARD hipError_t {
///< the hipStreamCaptureModeRelaxed argument to ///< the hipStreamCaptureModeRelaxed argument to
///< hipStreamBeginCapture was passed to ///< hipStreamBeginCapture was passed to
///< hipStreamEndCapture in a different thread. ///< hipStreamEndCapture in a different thread.
hipErrorGraphExecUpdateFailure = 910, ///< This error indicates that the graph update
///< not performed because it included changes which
///< violated constraintsspecific to instantiated graph
///< update.
hipErrorUnknown = 999, //< Unknown error. hipErrorUnknown = 999, //< Unknown error.
// HSA Runtime Error Codes start here. // HSA Runtime Error Codes start here.
hipErrorRuntimeMemory = 1052, ///< HSA runtime memory call returned error. Typically not seen hipErrorRuntimeMemory = 1052, ///< HSA runtime memory call returned error. Typically not seen
@ -161,112 +166,170 @@ typedef enum __HIP_NODISCARD hipError_t {
#undef __HIP_NODISCARD #undef __HIP_NODISCARD
typedef enum hipDeviceAttribute_t { typedef enum hipDeviceAttribute_t {
hipDeviceAttributeMaxThreadsPerBlock, ///< Maximum number of threads per block. hipDeviceAttributeCudaCompatibleBegin = 0,
hipDeviceAttributeMaxBlockDimX, ///< Maximum x-dimension of a block.
hipDeviceAttributeMaxBlockDimY, ///< Maximum y-dimension of a block. hipDeviceAttributeEccEnabled = hipDeviceAttributeCudaCompatibleBegin, ///< Whether ECC support is enabled.
hipDeviceAttributeMaxBlockDimZ, ///< Maximum z-dimension of a block. hipDeviceAttributeAccessPolicyMaxWindowSize, ///< Cuda only. The maximum size of the window policy in bytes.
hipDeviceAttributeMaxGridDimX, ///< Maximum x-dimension of a grid. hipDeviceAttributeAsyncEngineCount, ///< Cuda only. Asynchronous engines number.
hipDeviceAttributeMaxGridDimY, ///< Maximum y-dimension of a grid. hipDeviceAttributeCanMapHostMemory, ///< Whether host memory can be mapped into device address space
hipDeviceAttributeMaxGridDimZ, ///< Maximum z-dimension of a grid. hipDeviceAttributeCanUseHostPointerForRegisteredMem,///< Cuda only. Device can access host registered memory
hipDeviceAttributeMaxSharedMemoryPerBlock, ///< Maximum shared memory available per block in ///< at the same virtual address as the CPU
///< bytes. hipDeviceAttributeClockRate, ///< Peak clock frequency in kilohertz.
hipDeviceAttributeTotalConstantMemory, ///< Constant memory size in bytes. hipDeviceAttributeComputeMode, ///< Compute mode that device is currently in.
hipDeviceAttributeWarpSize, ///< Warp size in threads. hipDeviceAttributeComputePreemptionSupported, ///< Cuda only. Device supports Compute Preemption.
hipDeviceAttributeMaxRegistersPerBlock, ///< Maximum number of 32-bit registers available to a hipDeviceAttributeConcurrentKernels, ///< Device can possibly execute multiple kernels concurrently.
///< thread block. This number is shared by all thread hipDeviceAttributeConcurrentManagedAccess, ///< Device can coherently access managed memory concurrently with the CPU
///< blocks simultaneously resident on a hipDeviceAttributeCooperativeLaunch, ///< Support cooperative launch
///< multiprocessor. hipDeviceAttributeCooperativeMultiDeviceLaunch, ///< Support cooperative launch on multiple devices
hipDeviceAttributeClockRate, ///< Peak clock frequency in kilohertz. hipDeviceAttributeDeviceOverlap, ///< Cuda only. Device can concurrently copy memory and execute a kernel.
hipDeviceAttributeMemoryClockRate, ///< Peak memory clock frequency in kilohertz. ///< Deprecated. Use instead asyncEngineCount.
hipDeviceAttributeMemoryBusWidth, ///< Global memory bus width in bits. hipDeviceAttributeDirectManagedMemAccessFromHost, ///< Host can directly access managed memory on
hipDeviceAttributeMultiprocessorCount, ///< Number of multiprocessors on the device. ///< the device without migration
hipDeviceAttributeComputeMode, ///< Compute mode that device is currently in. hipDeviceAttributeGlobalL1CacheSupported, ///< Cuda only. Device supports caching globals in L1
hipDeviceAttributeL2CacheSize, ///< Size of L2 cache in bytes. 0 if the device doesn't have L2 hipDeviceAttributeHostNativeAtomicSupported, ///< Cuda only. Link between the device and the host supports native atomic operations
///< cache. hipDeviceAttributeIntegrated, ///< Device is integrated GPU
hipDeviceAttributeMaxThreadsPerMultiProcessor, ///< Maximum resident threads per hipDeviceAttributeIsMultiGpuBoard, ///< Multiple GPU devices.
///< multiprocessor. hipDeviceAttributeKernelExecTimeout, ///< Run time limit for kernels executed on the device
hipDeviceAttributeComputeCapabilityMajor, ///< Major compute capability version number. hipDeviceAttributeL2CacheSize, ///< Size of L2 cache in bytes. 0 if the device doesn't have L2 cache.
hipDeviceAttributeComputeCapabilityMinor, ///< Minor compute capability version number. hipDeviceAttributeLocalL1CacheSupported, ///< caching locals in L1 is supported
hipDeviceAttributeConcurrentKernels, ///< Device can possibly execute multiple kernels hipDeviceAttributeLuid, ///< Cuda only. 8-byte locally unique identifier in 8 bytes. Undefined on TCC and non-Windows platforms
///< concurrently. hipDeviceAttributeLuidDeviceNodeMask, ///< Cuda only. Luid device node mask. Undefined on TCC and non-Windows platforms
hipDeviceAttributePciBusId, ///< PCI Bus ID. hipDeviceAttributeComputeCapabilityMajor, ///< Major compute capability version number.
hipDeviceAttributePciDeviceId, ///< PCI Device ID. hipDeviceAttributeManagedMemory, ///< Device supports allocating managed memory on this system
hipDeviceAttributeMaxSharedMemoryPerMultiprocessor, ///< Maximum Shared Memory Per hipDeviceAttributeMaxBlocksPerMultiProcessor, ///< Cuda only. Max block size per multiprocessor
///< Multiprocessor. hipDeviceAttributeMaxBlockDimX, ///< Max block size in width.
hipDeviceAttributeIsMultiGpuBoard, ///< Multiple GPU devices. hipDeviceAttributeMaxBlockDimY, ///< Max block size in height.
hipDeviceAttributeIntegrated, ///< iGPU hipDeviceAttributeMaxBlockDimZ, ///< Max block size in depth.
hipDeviceAttributeCooperativeLaunch, ///< Support cooperative launch hipDeviceAttributeMaxGridDimX, ///< Max grid size in width.
hipDeviceAttributeCooperativeMultiDeviceLaunch, ///< Support cooperative launch on multiple devices hipDeviceAttributeMaxGridDimY, ///< Max grid size in height.
hipDeviceAttributeMaxTexture1DWidth, ///< Maximum number of elements in 1D images hipDeviceAttributeMaxGridDimZ, ///< Max grid size in depth.
hipDeviceAttributeMaxTexture2DWidth, ///< Maximum dimension width of 2D images in image elements hipDeviceAttributeMaxSurface1D, ///< Maximum size of 1D surface.
hipDeviceAttributeMaxTexture2DHeight, ///< Maximum dimension height of 2D images in image elements hipDeviceAttributeMaxSurface1DLayered, ///< Cuda only. Maximum dimensions of 1D layered surface.
hipDeviceAttributeMaxTexture3DWidth, ///< Maximum dimension width of 3D images in image elements hipDeviceAttributeMaxSurface2D, ///< Maximum dimension (width, height) of 2D surface.
hipDeviceAttributeMaxTexture3DHeight, ///< Maximum dimensions height of 3D images in image elements hipDeviceAttributeMaxSurface2DLayered, ///< Cuda only. Maximum dimensions of 2D layered surface.
hipDeviceAttributeMaxTexture3DDepth, ///< Maximum dimensions depth of 3D images in image elements hipDeviceAttributeMaxSurface3D, ///< Maximum dimension (width, height, depth) of 3D surface.
hipDeviceAttributeMaxSurfaceCubemap, ///< Cuda only. Maximum dimensions of Cubemap surface.
hipDeviceAttributeHdpMemFlushCntl, ///< Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register hipDeviceAttributeMaxSurfaceCubemapLayered, ///< Cuda only. Maximum dimension of Cubemap layered surface.
hipDeviceAttributeHdpRegFlushCntl, ///< Address of the HDP_REG_COHERENCY_FLUSH_CNTL register hipDeviceAttributeMaxTexture1DWidth, ///< Maximum size of 1D texture.
hipDeviceAttributeMaxTexture1DLayered, ///< Cuda only. Maximum dimensions of 1D layered texture.
hipDeviceAttributeMaxPitch, ///< Maximum pitch in bytes allowed by memory copies hipDeviceAttributeMaxTexture1DLinear, ///< Maximum number of elements allocatable in a 1D linear texture.
hipDeviceAttributeTextureAlignment, ///<Alignment requirement for textures ///< Use cudaDeviceGetTexture1DLinearMaxWidth() instead on Cuda.
hipDeviceAttributeTexturePitchAlignment, ///<Pitch alignment requirement for 2D texture references bound to pitched memory; hipDeviceAttributeMaxTexture1DMipmap, ///< Cuda only. Maximum size of 1D mipmapped texture.
hipDeviceAttributeKernelExecTimeout, ///<Run time limit for kernels executed on the device hipDeviceAttributeMaxTexture2DWidth, ///< Maximum dimension width of 2D texture.
hipDeviceAttributeCanMapHostMemory, ///<Device can map host memory into device address space hipDeviceAttributeMaxTexture2DHeight, ///< Maximum dimension hight of 2D texture.
hipDeviceAttributeEccEnabled, ///<Device has ECC support enabled hipDeviceAttributeMaxTexture2DGather, ///< Cuda only. Maximum dimensions of 2D texture if gather operations performed.
hipDeviceAttributeMaxTexture2DLayered, ///< Cuda only. Maximum dimensions of 2D layered texture.
hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc, ///< Supports cooperative launch on multiple hipDeviceAttributeMaxTexture2DLinear, ///< Cuda only. Maximum dimensions (width, height, pitch) of 2D textures bound to pitched memory.
///devices with unmatched functions hipDeviceAttributeMaxTexture2DMipmap, ///< Cuda only. Maximum dimensions of 2D mipmapped texture.
hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim, ///< Supports cooperative launch on multiple hipDeviceAttributeMaxTexture3DWidth, ///< Maximum dimension width of 3D texture.
///devices with unmatched grid dimensions hipDeviceAttributeMaxTexture3DHeight, ///< Maximum dimension height of 3D texture.
hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim, ///< Supports cooperative launch on multiple hipDeviceAttributeMaxTexture3DDepth, ///< Maximum dimension depth of 3D texture.
///devices with unmatched block dimensions hipDeviceAttributeMaxTexture3DAlt, ///< Cuda only. Maximum dimensions of alternate 3D texture.
hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem, ///< Supports cooperative launch on multiple hipDeviceAttributeMaxTextureCubemap, ///< Cuda only. Maximum dimensions of Cubemap texture
///devices with unmatched shared memories hipDeviceAttributeMaxTextureCubemapLayered, ///< Cuda only. Maximum dimensions of Cubemap layered texture.
hipDeviceAttributeAsicRevision, ///< Revision of the GPU in this device hipDeviceAttributeMaxThreadsDim, ///< Maximum dimension of a block
hipDeviceAttributeManagedMemory, ///< Device supports allocating managed memory on this system hipDeviceAttributeMaxThreadsPerBlock, ///< Maximum number of threads per block.
hipDeviceAttributeDirectManagedMemAccessFromHost, ///< Host can directly access managed memory on hipDeviceAttributeMaxThreadsPerMultiProcessor, ///< Maximum resident threads per multiprocessor.
/// the device without migration hipDeviceAttributeMaxPitch, ///< Maximum pitch in bytes allowed by memory copies
hipDeviceAttributeConcurrentManagedAccess, ///< Device can coherently access managed memory hipDeviceAttributeMemoryBusWidth, ///< Global memory bus width in bits.
/// concurrently with the CPU hipDeviceAttributeMemoryClockRate, ///< Peak memory clock frequency in kilohertz.
hipDeviceAttributePageableMemoryAccess, ///< Device supports coherently accessing pageable memory hipDeviceAttributeComputeCapabilityMinor, ///< Minor compute capability version number.
/// without calling hipHostRegister on it hipDeviceAttributeMultiGpuBoardGroupID, ///< Cuda only. Unique ID of device group on the same multi-GPU board
hipDeviceAttributePageableMemoryAccessUsesHostPageTables, ///< Device accesses pageable memory via hipDeviceAttributeMultiprocessorCount, ///< Number of multiprocessors on the device.
/// the host's page tables hipDeviceAttributeName, ///< Device name.
hipDeviceAttributeCanUseStreamWaitValue ///< '1' if Device supports hipStreamWaitValue32() and hipDeviceAttributePageableMemoryAccess, ///< Device supports coherently accessing pageable memory
///< hipStreamWaitValue64() , '0' otherwise. ///< without calling hipHostRegister on it
hipDeviceAttributePageableMemoryAccessUsesHostPageTables, ///< Device accesses pageable memory via the host's page tables
hipDeviceAttributePciBusId, ///< PCI Bus ID.
hipDeviceAttributePciDeviceId, ///< PCI Device ID.
hipDeviceAttributePciDomainID, ///< PCI Domain ID.
hipDeviceAttributePersistingL2CacheMaxSize, ///< Cuda11 only. Maximum l2 persisting lines capacity in bytes
hipDeviceAttributeMaxRegistersPerBlock, ///< 32-bit registers available to a thread block. This number is shared
///< by all thread blocks simultaneously resident on a multiprocessor.
hipDeviceAttributeMaxRegistersPerMultiprocessor, ///< 32-bit registers available per block.
hipDeviceAttributeReservedSharedMemPerBlock, ///< Cuda11 only. Shared memory reserved by CUDA driver per block.
hipDeviceAttributeMaxSharedMemoryPerBlock, ///< Maximum shared memory available per block in bytes.
hipDeviceAttributeSharedMemPerBlockOptin, ///< Cuda only. Maximum shared memory per block usable by special opt in.
hipDeviceAttributeSharedMemPerMultiprocessor, ///< Cuda only. Shared memory available per multiprocessor.
hipDeviceAttributeSingleToDoublePrecisionPerfRatio, ///< Cuda only. Performance ratio of single precision to double precision.
hipDeviceAttributeStreamPrioritiesSupported, ///< Cuda only. Whether to support stream priorities.
hipDeviceAttributeSurfaceAlignment, ///< Cuda only. Alignment requirement for surfaces
hipDeviceAttributeTccDriver, ///< Cuda only. Whether device is a Tesla device using TCC driver
hipDeviceAttributeTextureAlignment, ///< Alignment requirement for textures
hipDeviceAttributeTexturePitchAlignment, ///< Pitch alignment requirement for 2D texture references bound to pitched memory;
hipDeviceAttributeTotalConstantMemory, ///< Constant memory size in bytes.
hipDeviceAttributeTotalGlobalMem, ///< Global memory available on devicice.
hipDeviceAttributeUnifiedAddressing, ///< Cuda only. An unified address space shared with the host.
hipDeviceAttributeUuid, ///< Cuda only. Unique ID in 16 byte.
hipDeviceAttributeWarpSize, ///< Warp size in threads.
hipDeviceAttributeCudaCompatibleEnd = 9999,
hipDeviceAttributeAmdSpecificBegin = 10000,
hipDeviceAttributeClockInstructionRate = hipDeviceAttributeAmdSpecificBegin, ///< Frequency in khz of the timer used by the device-side "clock*"
hipDeviceAttributeArch, ///< Device architecture
hipDeviceAttributeMaxSharedMemoryPerMultiprocessor, ///< Maximum Shared Memory PerMultiprocessor.
hipDeviceAttributeGcnArch, ///< Device gcn architecture
hipDeviceAttributeGcnArchName, ///< Device gcnArch name in 256 bytes
hipDeviceAttributeHdpMemFlushCntl, ///< Address of the HDP_MEM_COHERENCY_FLUSH_CNTL register
hipDeviceAttributeHdpRegFlushCntl, ///< Address of the HDP_REG_COHERENCY_FLUSH_CNTL register
hipDeviceAttributeCooperativeMultiDeviceUnmatchedFunc, ///< Supports cooperative launch on multiple
///< devices with unmatched functions
hipDeviceAttributeCooperativeMultiDeviceUnmatchedGridDim, ///< Supports cooperative launch on multiple
///< devices with unmatched grid dimensions
hipDeviceAttributeCooperativeMultiDeviceUnmatchedBlockDim, ///< Supports cooperative launch on multiple
///< devices with unmatched block dimensions
hipDeviceAttributeCooperativeMultiDeviceUnmatchedSharedMem, ///< Supports cooperative launch on multiple
///< devices with unmatched shared memories
hipDeviceAttributeIsLargeBar, ///< Whether it is LargeBar
hipDeviceAttributeAsicRevision, ///< Revision of the GPU in this device
hipDeviceAttributeCanUseStreamWaitValue, ///< '1' if Device supports hipStreamWaitValue32() and
///< hipStreamWaitValue64(), '0' otherwise.
hipDeviceAttributeImageSupport, ///< '1' if Device supports image, '0' otherwise.
hipDeviceAttributePhysicalMultiProcessorCount, ///< All available physical compute
///< units for the device
hipDeviceAttributeAmdSpecificEnd = 19999,
hipDeviceAttributeVendorSpecificBegin = 20000,
// Extended attributes for vendors
} hipDeviceAttribute_t; } hipDeviceAttribute_t;
//! Flags that can be used with hipStreamCreateWithFlags //Flags that can be used with hipStreamCreateWithFlags.
#define hipStreamDefault \ /** Default stream creation flags. These are used with hipStreamCreate().*/
0x00 ///< Default stream creation flags. These are used with hipStreamCreate(). #define hipStreamDefault 0x00
#define hipStreamNonBlocking 0x01 ///< Stream does not implicitly synchronize with null stream
/** Stream does not implicitly synchronize with null stream.*/
#define hipStreamNonBlocking 0x01
//! Flags that can be used with hipEventCreateWithFlags:
#define hipEventDefault 0x0 ///< Default flags //Flags that can be used with hipEventCreateWithFlags.
#define hipEventBlockingSync \ /** Default flags.*/
0x1 ///< Waiting will yield CPU. Power-friendly and usage-friendly but may increase latency. #define hipEventDefault 0x0
#define hipEventDisableTiming \
0x2 ///< Disable event's capability to record timing information. May improve performance. /** Waiting will yield CPU. Power-friendly and usage-friendly but may increase latency.*/
#define hipEventInterprocess 0x4 ///< Event can support IPC. @warning - not supported in HIP. #define hipEventBlockingSync 0x1
#define hipEventReleaseToDevice \
0x40000000 /// < Use a device-scope release when recording this event. This flag is useful to /** Disable event's capability to record timing information. May improve performance.*/
/// obtain more precise timings of commands between events. The flag is a no-op on #define hipEventDisableTiming 0x2
/// CUDA platforms.
#define hipEventReleaseToSystem \ /** Event can support IPC. Warnig: It is not supported in HIP.*/
0x80000000 /// < Use a system-scope release when recording this event. This flag is #define hipEventInterprocess 0x4
/// useful to make non-coherent host memory visible to the host. The flag is a
/// no-op on CUDA platforms. /** Use a device-scope release when recording this event. This flag is useful to obtain more
* precise timings of commands between events. The flag is a no-op on CUDA platforms.*/
#define hipEventReleaseToDevice 0x40000000
#define hipDeviceScheduleAuto 0x0 ///< Automatically select between Spin and Yield
#define hipDeviceScheduleSpin \ /** Use a system-scope release when recording this event. This flag is useful to make
0x1 ///< Dedicate a CPU core to spin-wait. Provides lowest latency, but burns a CPU core and * non-coherent host memory visible to the host. The flag is a no-op on CUDA platforms.*/
///< may consume more power. #define hipEventReleaseToSystem 0x80000000
#define hipDeviceScheduleYield \
0x2 ///< Yield the CPU to the operating system when waiting. May increase latency, but lowers #define hipDeviceScheduleAuto 0x0
///< power and is friendlier to other threads in the system.
/** Dedicate a CPU core to spin-wait. Provides lowest latency, but burns a CPU core and may
* consume more power.*/
#define hipDeviceScheduleSpin 0x1
/** Yield the CPU to the operating system when waiting. May increase latency, but lowers power
* and is friendlier to other threads in the system.*/
#define hipDeviceScheduleYield 0x2
#define hipDeviceScheduleBlockingSync 0x4 #define hipDeviceScheduleBlockingSync 0x4
#define hipDeviceScheduleMask 0x7 #define hipDeviceScheduleMask 0x7
#define hipDeviceMapHost 0x8 #define hipDeviceMapHost 0x8

4
include/ext_hiprtc.h
Unescape View File

@ -6,7 +6,7 @@
#ifndef _EXT_HIPRTC_H #ifndef _EXT_HIPRTC_H
#define _EXT_HIPRTC_H #define _EXT_HIPRTC_H
// start: amd_detail/hiprtc.h // start: hiprtc.h
typedef enum hiprtcResult { typedef enum hiprtcResult {
HIPRTC_SUCCESS = 0, HIPRTC_SUCCESS = 0,
@ -25,7 +25,7 @@ typedef enum hiprtcResult {
typedef struct _hiprtcProgram* hiprtcProgram; typedef struct _hiprtcProgram* hiprtcProgram;
// stop: amd_detail/hiprtc.h // stop: hiprtc.h
#ifdef _WIN32 #ifdef _WIN32
#define HIPRTCAPI __stdcall #define HIPRTCAPI __stdcall

Write Preview
Loading…
Cancel
Save