feat: Support cdpSimpleQuicksort on CUDA SDK

Add the implicit function, __cudaRegisterVar. However, the relationship of dynamic parallelism
should be clarified.

Author: coldfunction

qcu-device/hw/misc/virtio-qcuda.c

@@ -67,7 +67,7 @@ CUcontext cudaContext;
 
 int cudaContext_count;
 
-#define cudaFunctionMaxNum 8
+#define cudaFunctionMaxNum 512
 uint32_t cudaFunctionNum;
 
 #define cudaEventMaxNum 32
@@ -254,6 +254,12 @@ static void qcu_cudaRegisterFatBinary(VirtioQCArg *arg)
 
 }
 
+static void qcu_cudaRegisterVar(VirtioQCArg *arg)
+{
+	ptrace("call cudaRegisterVar\n");
+}
+
+
 static void qcu_cudaUnregisterFatBinary(VirtioQCArg *arg)
 {
 	uint32_t i;
@@ -298,7 +304,7 @@ static void qcu_cudaRegisterFunction(VirtioQCArg *arg)
 	memcpy(devicesKernels[cudaFunctionNum].functionName, functionName, arg->pBSize);
 	devicesKernels[cudaFunctionNum].funcId = funcId;
 
-	ptrace("fatBin= %16p ,name= '%s'\n", fatBin, functionName);
+	ptrace("fatBin= %16p ,name= '%s', cudaFunctionNum = %d\n", fatBin, functionName, cudaFunctionNum);
 
 
 	int i = totalDevices;
@@ -743,6 +749,20 @@ static void qcu_cudaDeviceReset(VirtioQCArg *arg)
 	arg->cmd = err;
 }
 
+static void qcu_cudaDeviceSetLimit(VirtioQCArg *arg)
+{
+	cudaError_t err;
+	int device;
+
+	pfunc();
+
+	cudaError(err = cudaDeviceSetLimit(arg->pA, arg->pB));
+
+	arg->cmd = err;
+
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ///	Version Management
 ////////////////////////////////////////////////////////////////////////////////
@@ -1266,6 +1286,10 @@ static void virtio_qcuda_cmd_handle(VirtIODevice *vdev, VirtQueue *vq)
 				qcu_cudaUnregisterFatBinary(arg); 
 				break;
 
+			case VIRTQC_cudaRegisterVar:	
+				qcu_cudaRegisterVar(arg);
+			break;
+
 			case VIRTQC_cudaRegisterFunction:
 				qcu_cudaRegisterFunction(arg);
 				break;
@@ -1320,6 +1344,11 @@ static void virtio_qcuda_cmd_handle(VirtIODevice *vdev, VirtQueue *vq)
 				qcu_cudaDeviceReset(arg);
 				break;
 
+			case VIRTQC_cudaDeviceSetLimit:
+				qcu_cudaDeviceSetLimit(arg);
+			break;	
+
+
 			// Version Management (runtime API)
 			case VIRTQC_cudaDriverGetVersion:
 				qcu_cudaDriverGetVersion(arg);

qcu-driver/qcuda_common.h

@@ -36,6 +36,7 @@ enum
 	VIRTQC_cudaRegisterFatBinary = 200,
 	VIRTQC_cudaUnregisterFatBinary,
 	VIRTQC_cudaRegisterFunction,
+	VIRTQC_cudaRegisterVar,
 	VIRTQC_cudaLaunch,
 
 	// Memory Management (runtime API)
@@ -52,6 +53,7 @@ enum
 	VIRTQC_cudaSetDevice,
 	VIRTQC_cudaDeviceSynchronize,
 	VIRTQC_cudaDeviceReset,
+	VIRTQC_cudaDeviceSetLimit,
 
 	// Version Management (runtime API)
 	VIRTQC_cudaDriverGetVersion,

qcu-driver/qcuda_driver.c

@@ -357,6 +357,12 @@ void qcu_cudaRegisterFunction(VirtioQCArg *arg)
 	kfree_gpa(arg->pB, arg->pBSize);
 }
 
+void qcu_cudaRegisterVar(VirtioQCArg *arg)
+{
+	qcu_misc_send_cmd(arg);
+}
+
+
 void qcu_cudaLaunch(VirtioQCArg *arg)
 {	// pA: cuda kernel configuration
 	// pB: cuda kernel parameters
@@ -692,6 +698,13 @@ void qcu_cudaDeviceReset(VirtioQCArg *arg)
 	qcu_misc_send_cmd(arg);
 }
 
+void qcu_cudaDeviceSetLimit(VirtioQCArg *arg)
+{
+	pfunc();
+
+	qcu_misc_send_cmd(arg);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 ///	Version Management
 ////////////////////////////////////////////////////////////////////////////////
@@ -1109,6 +1122,10 @@ static long qcu_misc_ioctl(struct file *filp, unsigned int _cmd, unsigned long _
 			qcu_cudaRegisterFunction(arg);
 			break;
 
+		case VIRTQC_cudaRegisterVar:	
+			qcu_cudaRegisterVar(arg);
+			break;
+
 		case VIRTQC_cudaLaunch:
 			qcu_cudaLaunch(arg);
 			break;
@@ -1159,6 +1176,10 @@ static long qcu_misc_ioctl(struct file *filp, unsigned int _cmd, unsigned long _
 			qcu_cudaDeviceReset(arg);
 			break;
 
+		case VIRTQC_cudaDeviceSetLimit:
+			qcu_cudaDeviceSetLimit(arg);
+			break;			
+
 		//case VIRTQC_checkCudaCapabilities:
 		//	qcu_checkCudaCapabilities(arg);
 		//	break;

qcu-library/libcudart.c

@@ -301,6 +301,30 @@ void __cudaRegisterFunction(
 	time_end(t_RegFunc);
 }
 
+void __cudaRegisterVar(
+        void **fatCubinHandle,
+        char  *hostVar,
+        char  *deviceAddress,
+  const char  *deviceName,
+        int    ext,
+        int    size,
+        int    constant,
+        int    global
+)
+{
+	pfunc();
+
+    ptrace("fatCubinHandle= %p, value= %p\n", fatCubinHandle, *fatCubinHandle);
+	ptrace("hostVar= %s (%p)\n", hostVar, hostVar);
+	ptrace("deviceAddress= %s (%p)\n", deviceAddress, deviceAddress);
+	ptrace("deviceName= %s\n", deviceName);
+	ptrace("ext= %d, size = %d, constant = %d, global = %d\n", ext, size, constant, global);
+
+	VirtioQCArg arg;
+	send_cmd_to_device( VIRTQC_cudaRegisterVar, &arg);
+}
+
+
 cudaError_t cudaConfigureCall(
 		dim3 gridDim, 
 		dim3 blockDim, 
@@ -655,6 +679,23 @@ cudaError_t cudaDeviceReset(void)
 	return (cudaError_t)arg.cmd;
 }
 
+
+cudaError_t cudaDeviceSetLimit	(enum cudaLimit limit, size_t value )	
+{
+	VirtioQCArg arg;
+	pfunc();
+
+	memset(&arg, 0, sizeof(VirtioQCArg));
+
+	ptr( arg.pA, limit, 0);
+	ptr( arg.pB, value, 0);
+
+	send_cmd_to_device( VIRTQC_cudaDeviceSetLimit, &arg);
+
+	return (cudaError_t)arg.cmd;
+}
+
+
 ////////////////////////////////////////////////////////////////////////////////
 /// Version Management
 ////////////////////////////////////////////////////////////////////////////////