public void CopyAlgorithmDescriptor(AlgorithmDescriptor dest)
{
res = CudaDNNNativeMethods.cudnnCopyAlgorithmDescriptor(_desc, dest.Desc);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCopyAlgorithmDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
public void SetFusedOpsVariantParamPackAttribute(cudnnFusedOpsVariantParamLabel paramLabel, IntPtr param)
{
res = CudaDNNNativeMethods.cudnnSetFusedOpsVariantParamPackAttribute(_pack, paramLabel, param);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetFusedOpsVariantParamPackAttribute", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
///
/// </summary>
public void GetCTCLossDescriptorEx(ref cudnnDataType compType, ref cudnnLossNormalizationMode normMode, ref cudnnNanPropagation gradMode)
{
res = CudaDNNNativeMethods.cudnnGetCTCLossDescriptorEx(_desc, ref compType, ref normMode, ref gradMode);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetCTCLossDescriptorEx", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
public void SetAlgorithmPerformance(int index, AlgorithmDescriptor algoDesc, cudnnStatus status, float time, SizeT memory)
{
res = CudaDNNNativeMethods.cudnnSetAlgorithmPerformance(_perfs[index], algoDesc.Desc, status, time, memory);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetAlgorithmPerformance", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function sets the stream to be used by the cudnn library to execute its routines.
/// </summary>
/// <param name="stream">the stream to be used by the library.</param>
public void SetStream(CudaStream stream)
{
res = CudaDNNNativeMethods.cudnnSetStream(_handle, stream.Stream);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetStream", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function initializes a previously created CTC Loss descriptor object.
/// </summary>
/// <param name="dataType">Math precision.</param>
public void SetCTCLossDescriptor(cudnnDataType dataType)
{
res = CudaDNNNativeMethods.cudnnSetCTCLossDescriptor(_desc, dataType);
Debug.Write("");//Line(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetCTCLossDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// </summary>
public CudaDNNContext()
{
_handle = new cudnnHandle();
res = CudaDNNNativeMethods.cudnnCreate(ref _handle);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCreate", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// </summary>
public FusedOpsVariantParamPack(cudnnFusedOps ops)
{
_pack = new cudnnFusedOpsVariantParamPack();
res = CudaDNNNativeMethods.cudnnCreateFusedOpsVariantParamPack(ref _pack, ops);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCreateFusedOpsVariantParamPack", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// </summary>
public TensorDescriptor()
{
_desc = new cudnnTensorDescriptor();
res = CudaDNNNativeMethods.cudnnCreateTensorDescriptor(ref _desc);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCreateTensorDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// </summary>
public PersistentRNNPlan(RNNDescriptor rnnDesc, int minibatch, cudnnDataType dataType)
{
_desc = new cudnnPersistentRNNPlan();
res = CudaDNNNativeMethods.cudnnCreatePersistentRNNPlan(rnnDesc.Desc, minibatch, dataType, ref _desc);
Debug.Write("");//Line(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCreatePersistentRNNPlan", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// </summary>
public AlgorithmPerformances(int count)
{
_perfs = new cudnnAlgorithmPerformance[count];
res = CudaDNNNativeMethods.cudnnCreateAlgorithmPerformance(_perfs, count);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCreateAlgorithmPerformance", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function queries the parameters of the previouly initialized activation descriptor object.
/// </summary>
/// <param name="mode">Enumerant to specify the activation mode.</param>
/// <param name="reluNanOpt">Nan propagation option for the relu.</param>
/// <param name="reluCeiling">The ceiling for the clipped relu.</param>
public void GetActivationDescriptor(ref cudnnActivationMode mode,
ref cudnnNanPropagation reluNanOpt,
ref double reluCeiling)
{
res = CudaDNNNativeMethods.cudnnGetActivationDescriptor(_desc, ref mode, ref reluNanOpt, ref reluCeiling);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetActivationDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function provides the output dimensions of a tensor after Nd pooling has been applied
/// </summary>
/// <param name="inputTensorDesc">Handle to the previously initialized input tensor descriptor.</param>
/// <param name="nbDims">Number of dimensions in which pooling is to be applied.</param>
/// <param name="outputTensorDimA">Array of nbDims output dimensions</param>
public void GetPoolingNdForwardOutputDim(TensorDescriptor inputTensorDesc,
int nbDims,
int[] outputTensorDimA)
{
res = CudaDNNNativeMethods.cudnnGetPoolingNdForwardOutputDim(_desc, inputTensorDesc.Desc, nbDims, outputTensorDimA);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetPoolingNdForwardOutputDim", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// </summary>
public LRNDescriptor(CudaDNNContext context)
{
_handle = context.Handle;
_desc = new cudnnLRNDescriptor();
res = CudaDNNNativeMethods.cudnnCreateLRNDescriptor(ref _desc);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnCreateLRNDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function computes the gradient of a grid generation operation.
/// </summary>
/// <param name="dgrid">Data pointer to GPU memory contains the input differential data.</param>
/// <param name="dtheta">Data pointer to GPU memory contains the output differential data.</param>
/// <returns></returns>
public void SpatialTfGridGeneratorBackward(
CudaDeviceVariable <float> dgrid,
CudaDeviceVariable <float> dtheta)
{
res = CudaDNNNativeMethods.cudnnSpatialTfGridGeneratorBackward(_handle, _desc, dtheta.DevicePointer, dgrid.DevicePointer);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSpatialTfGridGeneratorBackward", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
///<summary>
/// This function initializes then previously created activation descriptor object.
/// </summary>
/// <param name="mode">Enumerant to specify the activation mode.</param>
/// <param name="reluNanOpt">Nan propagation option for the relu.</param>
/// <param name="coef">floating point number to specify the clipping threashold when the activation
/// mode is set to CUDNN_ACTIVATION_CLIPPED_RELU or to specify the alpha
/// coefficient when the activation mode is set to CUDNN_ACTIVATION_ELU.</param>
public void SetActivationDescriptor(cudnnActivationMode mode,
cudnnNanPropagation reluNanOpt,
double coef)
{
res = CudaDNNNativeMethods.cudnnSetActivationDescriptor(_desc, mode, reluNanOpt, coef);
Debug.Write("");//Line(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetActivationDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
public cudnnAlgorithm GetAlgorithmDescriptor()
{
cudnnAlgorithm algo = new cudnnAlgorithm();
res = CudaDNNNativeMethods.cudnnGetAlgorithmDescriptor(_desc, ref algo);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetAlgorithmDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
return(algo);
}
public void GetAlgorithmPerformance(int index, ref AlgorithmDescriptor algoDesc, ref cudnnStatus status, ref float time, ref SizeT memory)
{
cudnnAlgorithmDescriptor descTemp = new cudnnAlgorithmDescriptor();
res = CudaDNNNativeMethods.cudnnGetAlgorithmPerformance(_perfs[index], ref descTemp, ref status, ref time, ref memory);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetAlgorithmPerformance", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
algoDesc = new AlgorithmDescriptor(descTemp);
}
public void SetFilterNdDescriptor(cudnnDataType dataType, // image data type
int nbDims,
int[] filterDimA
)
{
res = CudaDNNNativeMethods.cudnnSetFilterNdDescriptor(_desc, dataType, nbDims, filterDimA);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetFilterNdDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// Retrieves the values stored in a previously initialized tensor transform descriptor.
/// </summary>
public void GetTensorTransformDescriptor(uint nbDims,
cudnnTensorFormat destFormat, int[] padBeforeA,
int[] padAfterA, uint[] foldA,
cudnnFoldingDirection direction)
{
res = CudaDNNNativeMethods.cudnnGetTensorTransformDescriptor(_desc, nbDims, ref destFormat, padBeforeA, padAfterA, foldA, ref direction);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetTensorTransformDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
public SizeT InitTransformDest(TensorDescriptor srcDesc, TensorDescriptor destDesc)
{
SizeT destSizeInBytes = new SizeT();
res = CudaDNNNativeMethods.cudnnInitTransformDest(_desc, srcDesc.Desc, destDesc.Desc, ref destSizeInBytes);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnInitTransformDest", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
return(destSizeInBytes);
}
public SizeT GetAlgorithmSpaceSize(CudaDNNContext ctx)
{
SizeT size = new SizeT();
res = CudaDNNNativeMethods.cudnnGetAlgorithmSpaceSize(ctx.Handle, _desc, ref size);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetAlgorithmSpaceSize", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
return(size);
}
/* Set all data points of a tensor to a given value : srcDest = alpha * srcDest */
public void ScaleTensor(TensorDescriptor srcDestDesc,
CudaDeviceVariable <double> srcDestData,
double alpha
)
{
res = CudaDNNNativeMethods.cudnnScaleTensor(_handle, srcDestDesc.Desc, srcDestData.DevicePointer, ref alpha);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnScaleTensor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
///
/// </summary>
public cudnnDataType GetCTCLossDescriptor()
{
cudnnDataType dataType = new cudnnDataType();
res = CudaDNNNativeMethods.cudnnGetCTCLossDescriptor(_desc, ref dataType);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetCTCLossDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
return(dataType);
}
/// <summary>
///
/// </summary>
/// <param name="opTensorOp"></param>
/// <param name="opTensorCompType"></param>
/// <param name="opTensorNanOpt"></param>
public void GetOpTensorDescriptor(
ref cudnnOpTensorOp opTensorOp,
ref cudnnDataType opTensorCompType,
ref cudnnNanPropagation opTensorNanOpt)
{
res = CudaDNNNativeMethods.cudnnGetOpTensorDescriptor(_desc, ref opTensorOp, ref opTensorCompType, ref opTensorNanOpt);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetOpTensorDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function returns the size of the tensor in memory in respect to the given descriptor.
/// This function can be used to know the amount of GPU memory to be allocated to hold that tensor.
/// </summary>
/// <returns>Size in bytes needed to hold the tensor in GPU memory.</returns>
public SizeT GetTensorSizeInBytes()
{
SizeT retVal = 0;
res = CudaDNNNativeMethods.cudnnGetTensorSizeInBytes(_desc, ref retVal);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetTensorSizeInBytes", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
return(retVal);
}
public void SetSeqDataDescriptor(cudnnDataType dataType, int nbDims,
int[] dimA, cudnnSeqDataAxis[] axes,
int[] seqLengthArray, float paddingFill)
{
res = CudaDNNNativeMethods.cudnnSetSeqDataDescriptor(_desc, dataType, nbDims,
dimA, axes,
seqLengthArray.Length, seqLengthArray, ref paddingFill);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnSetSeqDataDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
public void GetSeqDataDescriptor(ref cudnnDataType dataType, ref int nbDims,
int[] dimA, cudnnSeqDataAxis[] axes,
ref SizeT seqLengthArraySize, int[] seqLengthArray, IntPtr paddingFill)
{
res = CudaDNNNativeMethods.cudnnGetSeqDataDescriptor(_desc, ref dataType, ref nbDims,
dimA.Length, dimA, axes,
ref seqLengthArraySize, dimA.Length, seqLengthArray, paddingFill);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetSeqDataDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
/// <summary>
/// This function provides the output dimensions of a tensor after 2d pooling has been applied
/// </summary>
/// <param name="inputTensorDesc">Handle to the previously initialized input tensor descriptor.</param>
/// <param name="n">Number of images in the output</param>
/// <param name="c">Number of channels in the output</param>
/// <param name="h">Height of images in the output</param>
/// <param name="w">Width of images in the output</param>
public void GetPooling2dForwardOutputDim(TensorDescriptor inputTensorDesc,
ref int n,
ref int c,
ref int h,
ref int w)
{
res = CudaDNNNativeMethods.cudnnGetPooling2dForwardOutputDim(_desc, inputTensorDesc.Desc, ref n, ref c, ref h, ref w);
Debug.Write(""); //Line(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetPooling2dForwardOutputDim", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
// Retrieve the settings currently stored in an LRN layer descriptor
// Any of the provided pointers can be NULL (no corresponding value will be returned)
public void GetLRNDescriptor(ref uint lrnN,
ref double lrnAlpha,
ref double lrnBeta,
ref double lrnK
)
{
res = CudaDNNNativeMethods.cudnnGetLRNDescriptor(_desc, ref lrnN, ref lrnAlpha, ref lrnBeta, ref lrnK);
Debug.WriteLine(String.Format("{0:G}, {1}: {2}", DateTime.Now, "cudnnGetLRNDescriptor", res));
if (res != cudnnStatus.Success)
{
throw new CudaDNNException(res);
}
}
