miopenFindConvolutionForwardAlgorithm segfault

[AdemSchen]

Hello! We have been struggling a lot with the miopenFindConvolutionForwardAlgorithm function. Every time we call it we get segfault. We have allocated memory for the buffers using OpenCL. We can not seem to find the problem. We are novice programmers in OpenCL and might be allocating memory incorrectly, or doing something else wrong. We have included our code below. All help is much appreciated!

#include <iostream>
#include <cstdio>

#include "activ_driver.hpp"
#include "bn_driver.hpp"
#include "conv_driver.hpp"
#include "driver.hpp"
#include "gemm_driver.hpp"
#include "lrn_driver.hpp"
#include "pool_driver.hpp"
#include "softmax_driver.hpp"
#include "rnn_driver.hpp"
#include "miopen/config.h"
#include <miopen/miopen.h>
#include <miopen/tensor.hpp>
#include <miopen/env.hpp>
#include <miopen/convolution.hpp>

#include <CL/cl.h>
#include <CL/cl.hpp>
#include <CL/cl_ext.h>
#include <CL/cl_gl.h>
#include <CL/cl_gl_ext.h>
#include <CL/cl_platform.h>
#include <CL/opencl.h>

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <float.h>
#include <fstream>
#include <memory>
using namespace std;

#define MEM_FLAG		CL_MEM_ALLOC_HOST_PTR 

int main() 
{
	/* _______DECLARATIONS_______ */

	int status = 0;		// Error codes
	int n = 1;	  	// Mini-Batch size (how many images)
	int c = 1; 		// Nr of channels (eg RGB is 3, grayscale is 1)
	int stride = 1;
	int padding = 1;
	int dilation = 1;
	size_t WorkSpaceSize = 0;
	int requestAlgoCount = 1;
	int returnedAlgoCount = 0;
	bool ExhaustiveSearch = 0;

	/* _______CREATING THE ENVIRONMENT_______ */
	miopenHandle_t Network;
	status = miopenCreate(&Network); 
	if (status!=0)
	{
		printf("Error in miopencreate. Error code %d",status);
		return 0;
	}

	/* _______CREATING THE INPUT TENSOR_______ */
	miopenTensorDescriptor_t InputTensorDesc;
	status = miopenCreateTensorDescriptor(&InputTensorDesc);	
	if (status!=0)
	{
		printf("Error in miopenCreateTensorDescriptor. Error code %d",status);
		return 0;
	}

	status = miopenSet4dTensorDescriptor(	InputTensorDesc,
						miopenFloat,
						n, //batch size
						c, //nr of channels
						10, //data height img.rows
						10); //data width img.cols
	if (status!=0)
	{
		printf("Error in miopenSet4dTensorDescriptor. Error code %d",status);
		return 0;
	}

	/* _________CREATING THE OUTPUT TENSOR______________ */
	miopenTensorDescriptor_t OutputTensorDesc;
	status = miopenCreateTensorDescriptor(&OutputTensorDesc);	
	if (status!=0)
	{
		printf("Error in miopencreate. Error code %d",status);
		return 0;
	}

	status = miopenSet4dTensorDescriptor(	OutputTensorDesc,
						miopenFloat,
						n,
						c, //nr of channels
						10, //data height img.rows
						10); //data width img.cols

	if (status!=0)
	{
		printf("Error in miopenSet4dTensorDescriptor. Error code %d",status);
		return 0;
	}

	/* _______________KERNEL CREATION_____________________________ */	
	miopenTensorDescriptor_t KernelDescriptor;
	status = miopenCreateTensorDescriptor(&KernelDescriptor);	
	if (status!=0)
	{
		printf("Error in miopencreate. Error code %d",status);
		return 0;
	}

	status = miopenSet4dTensorDescriptor(	KernelDescriptor,
						miopenFloat,
						n,
						c, // nr of channels
						3, // filter height 
						3); // filter width
	if (status!=0)
	{
		printf("Error in miopenSet4dTensorDescriptor. Error code %d",status);
		return 0;
	}

	/* _________CREATING THE CONVOLUTION DESCRIPTOR______________ */
	miopenConvolutionDescriptor_t ConvDesc;
	status = miopenCreateConvolutionDescriptor(&ConvDesc);

	if (status!=0)
	{
		printf("Error in miopenCreateConvolutionDescriptor. Error code %d",status);
		return 0;
	}

	status = miopenInitConvolutionDescriptor(	ConvDesc,
							miopenConvolution,
							padding, //h
							padding, //w
							stride,	 //h
							stride,	 //w
							dilation, //h
							dilation); //w
	if (status!=0)
	{
		printf("Error in miopenCreateConvolutionDescriptor. Error code %d",status);
		return 0;
	}

	/* _________CONVOLUTION GET WORKSPACE SIZE______________ */
	miopenConvolutionDescriptor_t const const_ConvDesc = ConvDesc;
	miopenTensorDescriptor_t const const_KernelDescriptor = KernelDescriptor;
	miopenTensorDescriptor_t const const_InputTensorDesc = InputTensorDesc;
	miopenTensorDescriptor_t const const_OutputTensorDesc = OutputTensorDesc;

	status = miopenConvolutionForwardGetWorkSpaceSize(	Network,
								const_KernelDescriptor,
								const_InputTensorDesc,
								const_ConvDesc,
								const_OutputTensorDesc,
								&WorkSpaceSize );
	if (status!=0)
	{
		printf("Error in miopenConvolutionForwardGetWorkSpaceSize. Err code %d",status);
		return 0;
	}
	cout << "WorkSpaceSize = " << WorkSpaceSize << " bytes\n";

	/* _______OPENCL ALLOCATING MEMORY_______ */
	cl_platform_id platform;		// PLATFORM-TYPE
	clGetPlatformIDs(1, &platform, NULL);	// ADRESS TO PLATFORM
	cl_device_id device;			// DEVICE-TYPE
	clGetDeviceIDs(platform, CL_DEVICE_TYPE_GPU, 1, &device, NULL);	// ADRESS TO DEVICE
	cl_context context = clCreateContext(NULL, 1, &device, NULL, NULL, NULL); // CONTEXT
	
	// QUEUES
	cl_command_queue queue = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, NULL); 
	cl_command_queue queue2 = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, NULL); 
	cl_command_queue queue3 = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, NULL);
	cl_command_queue queue4 = clCreateCommandQueue(context, device, CL_QUEUE_PROFILING_ENABLE, NULL);

	// DECLARATIONS	
	char buf[4096]; 				// CHARBUFFER FOR DEVICE NAME
	cl_int errorcode;				// FOR ERRORCODES
	int buffSize = 1024*3600; 			// MEMORY TO ALLOCATE FOR WORKSPACE
	int imageSize = 1024*sizeof(int); 		// MEMORY TO ALLOCATE FOR THE IMAGE
	int outimageSize = 1024*sizeof(int); 		// MEMORY TO ALLOCATE FOR THE OUTIMAGE
	int kernelWeightsSize = 1024*sizeof(int); 	// MEMORY TO ALLOCATE FOR THE OUTIMAGE

	// ALLOCATE OBJECTS ON GPU
	cl_mem buff = clCreateBuffer(context, MEM_FLAG, buffSize, NULL, NULL); 
	cl_mem image = clCreateBuffer(context, MEM_FLAG, imageSize, NULL, NULL); 
	cl_mem outimage = clCreateBuffer(context, MEM_FLAG, outimageSize, NULL, NULL); 
	cl_mem kernelweights = clCreateBuffer(context, MEM_FLAG, kernelWeightsSize, NULL, NULL);

	// QUERIE DEVICE NAME
	errorcode = clGetDeviceInfo(device, CL_DEVICE_NAME, sizeof(buf), buf, NULL); 
  	if (errorcode != CL_SUCCESS) 
	{
		printf("Error getting cl Device Info");
		exit(-1);
	}
	printf("Device Name : %s\n", buf);

	// GET POINTER TO MEMORY IN GPU
	void *WorkSpace = clEnqueueMapBuffer(queue, buff, CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, buffSize, 0, NULL, NULL, &errorcode);
  	if (errorcode != CL_SUCCESS) 
	{
		printf("Error getting cl Device Info");
		exit(-1);
	}
	cout << "WorkSpace adress = " << WorkSpace << endl;
	cout << "Memeory allocated = " << buffSize << endl;

	int *imageDummy = (int*)clEnqueueMapBuffer(queue2, image, CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, imageSize, 0, NULL, NULL, &errorcode);
  	if (errorcode != CL_SUCCESS) 
	{
		printf("Error getting cl Device Info");
		exit(-1);
	}

	cout << "imageDummy adress = " << imageDummy << endl;
	cout << "Memeory allocated = " << imageSize << endl;

	// CREATING DUMMY IMAGE
	for (int i = 0; i < 100; i++) 
	{
		imageDummy[i] = 1;
	}

	// TESTING IF IMAGE IS ON GPU
	for (int i = 0; i < 100; i++) 
	{
		cout << imageDummy[i] << "  ";
	}
	cout << "\n\n\n";

	
	// GET POINTER TO MEMORY IN GPU
	
	void *outimagePtr = clEnqueueMapBuffer(queue3, outimage, CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, outimageSize, 0, NULL, NULL, &errorcode);
  	if (errorcode != CL_SUCCESS) 
	{
		printf("Error getting cl Device Info");
		exit(-1);
	}

	cout << "outimagePtr adress = " << outimagePtr << endl;
	cout << "Memeory allocated = " << outimageSize << endl;
	

	void *kernelWeightsPtr = clEnqueueMapBuffer(queue4, kernelweights, CL_TRUE, CL_MAP_WRITE | CL_MAP_READ, 0, kernelWeightsSize, 0, NULL, NULL, &errorcode);
  	if (errorcode != CL_SUCCESS) 
	{
		printf("Error getting cl Device Info");
		exit(-1);
	}


	/* _________CONVOLUTION FIND FORWARD ALGORITM______________ */
	miopenConvAlgoPerf_t PrefConvAlg;
	status = miopenFindConvolutionForwardAlgorithm(	Network,
							const_InputTensorDesc,
							imageDummy, 		//Data tensor
							const_KernelDescriptor,
							kernelWeightsPtr,		//Weights tensor
							const_ConvDesc,
							const_OutputTensorDesc,
							outimagePtr,		//Data tensor,
							requestAlgoCount,	//request algorithm count
							&returnedAlgoCount,	//returned Alg Count
							&PrefConvAlg,		//Pointer to union of best algo returned
							WorkSpace,		//Ptr to workspace required for the search
							WorkSpaceSize,		//size in bytes of the memory needed for find
							ExhaustiveSearch	//A boolean to toggle a full search of all algo and config
							);

	cout << "Find Algorithm finished\n";
	if (status!=0)
	{
		printf("Error in miopenFindConvolutionForwardAlgorithm. Error code %d /n",status);
		return 0;
	} 

	/* _________UNMAP THE POINTERs & CLEANING______________ */			
	clEnqueueUnmapMemObject(queue, buff, WorkSpace, 0, NULL, NULL);
	clEnqueueUnmapMemObject(queue2, image, imageDummy, 0, NULL, NULL);
	clEnqueueUnmapMemObject(queue3, outimage, outimagePtr, 0, NULL, NULL);
	clEnqueueUnmapMemObject(queue4, kernelweights, kernelWeightsPtr, 0, NULL, NULL);

	clReleaseMemObject(buff);
	clReleaseMemObject(image);
	clReleaseMemObject(outimage);
	clReleaseMemObject(kernelweights);
	clReleaseCommandQueue(queue);
	clReleaseCommandQueue(queue2);
	clReleaseCommandQueue(queue3);
	clReleaseCommandQueue(queue4);
	clReleaseContext(context);

	miopenDestroyConvolutionDescriptor(ConvDesc);
	miopenDestroyTensorDescriptor(InputTensorDesc);
	miopenDestroyTensorDescriptor(KernelDescriptor);
	miopenDestroyTensorDescriptor(OutputTensorDesc);
	miopenDestroy(Network);
	


    return 0;
}

[AdemSchen]

We soulved the Seg fault(it was opencl issues) but got a warning and wondering if it's critical issue ?

MIOpen(OpenCL): Warning [FindRecordUnsafe] File is unreadable: /opt/rocm/miopen/share/miopen/db/gfx801_6.cd.pdb.txt

[dagamayank]

@AdemSchen Looks like you are running on a system which we do not support. gfx801_6 gives that hint. You are using one of the APUs on which is ROCm is not supported and hence, MIOpen is also not supported.