Add driver-related functions to the API;

* Add starpu_driver_init(), starpu_driver_run_once() and starpu_driver_deinit().
* Reorganize the CUDA driver, by slicing the _starpu_cuda_worker() function into three pieces (this will be done for other drivers, too).

include/starpu.h

@@ -203,6 +203,10 @@ int starpu_worker_get_devid(int id);
 
 int starpu_run_driver(struct starpu_driver *);
 void starpu_set_end_of_submissions(void);
+
+int starpu_driver_init(struct starpu_driver *d);
+int starpu_driver_run_once(struct starpu_driver *d);
+int starpu_driver_deinit(struct starpu_driver *d);
 #ifdef __cplusplus
 }
 #endif

src/core/workers.c

@@ -999,3 +999,66 @@ starpu_run_driver(struct starpu_driver *d)
 		return -EINVAL;
 	}
 }
+
+#ifdef STARPU_USE_CUDA
+extern int _starpu_cuda_driver_init(struct starpu_driver *);
+extern int _starpu_cuda_driver_run_once(struct starpu_driver *);
+extern int _starpu_cuda_driver_deinit(struct starpu_driver *);
+#endif
+
+int
+starpu_driver_init(struct starpu_driver *d)
+{
+	STARPU_ASSERT(d);
+
+	switch (d->type)
+	{
+#ifdef STARPU_USE_CUDA
+	case STARPU_CUDA_WORKER:
+		return _starpu_cuda_driver_init(d);
+#endif
+	case STARPU_CPU_WORKER:    /* Not supported yet */
+	case STARPU_OPENCL_WORKER: /* Not supported yet */
+	case STARPU_GORDON_WORKER: /* Not supported yet */
+	default:
+		return -EINVAL;
+	}
+}
+
+int
+starpu_driver_run_once(struct starpu_driver *d)
+{
+	STARPU_ASSERT(d);
+
+	switch (d->type)
+	{
+#ifdef STARPU_USE_CUDA
+	case STARPU_CUDA_WORKER:
+		return _starpu_cuda_driver_run_once(d);
+#endif
+	case STARPU_CPU_WORKER:    /* Not supported yet */
+	case STARPU_OPENCL_WORKER: /* Not supported yet */
+	case STARPU_GORDON_WORKER: /* Not supported yet */
+	default:
+		return -EINVAL;
+	}
+}
+
+int
+starpu_driver_deinit(struct starpu_driver *d)
+{
+	STARPU_ASSERT(d);
+
+	switch (d->type)
+	{
+#ifdef STARPU_USE_CUDA
+	case STARPU_CUDA_WORKER:
+		return _starpu_cuda_driver_deinit(d);
+#endif
+	case STARPU_CPU_WORKER:    /* Not supported yet */
+	case STARPU_OPENCL_WORKER: /* Not supported yet */
+	case STARPU_GORDON_WORKER: /* Not supported yet */
+	default:
+		return -EINVAL;
+	}
+}

src/drivers/cuda/driver_cuda.c

@@ -272,13 +272,25 @@ static int execute_job_on_cuda(struct _starpu_job *j, struct _starpu_worker *arg
 	return 0;
 }
 
-void *_starpu_cuda_worker(void *arg)
+static struct _starpu_worker*
+_starpu_get_worker_from_driver(struct starpu_driver *d)
 {
-	struct _starpu_worker* args = arg;
+	int workers[d->id.cuda_id + 1];
+	int nworkers;
+	nworkers = starpu_worker_get_ids_by_type(STARPU_CUDA_WORKER, workers, d->id.cuda_id+1);
+	if (nworkers >= 0 && (unsigned) nworkers < d->id.cuda_id)
+		return NULL; // No device was found.
+	
+	return _starpu_get_worker_struct(workers[d->id.cuda_id]);
+}
+
+/* XXX Should this be merged with _starpu_init_cuda ? */
+int _starpu_cuda_driver_init(struct starpu_driver *d)
+{
+	struct _starpu_worker* args = _starpu_get_worker_from_driver(d);
+	STARPU_ASSERT(args);
 
 	int devid = args->devid;
-	int workerid = args->workerid;
-	unsigned memnode = args->memory_node;
 
 #ifdef STARPU_USE_FXT
 	_starpu_fxt_register_thread(args->bindid);
@@ -287,7 +299,7 @@ void *_starpu_cuda_worker(void *arg)
 
 	_starpu_bind_thread_on_cpu(args->config, args->bindid);
 
-	_starpu_set_local_memory_node_key(&memnode);
+	_starpu_set_local_memory_node_key(&args->memory_node);
 
 	_starpu_set_local_worker_key(args);
 
@@ -324,68 +336,81 @@ void *_starpu_cuda_worker(void *arg)
 	_STARPU_PTHREAD_COND_SIGNAL(&args->ready_cond);
 	_STARPU_PTHREAD_MUTEX_UNLOCK(&args->mutex);
 
-	struct _starpu_job * j;
-	struct starpu_task *task;
-	int res;
+	return 0;
+}
 
-	while (_starpu_machine_is_running())
-	{
-		_STARPU_TRACE_START_PROGRESS(memnode);
-		_starpu_datawizard_progress(memnode, 1);
-		_STARPU_TRACE_END_PROGRESS(memnode);
+int _starpu_cuda_driver_run_once(struct starpu_driver *d)
+{
+	struct _starpu_worker* args = _starpu_get_worker_from_driver(d);
+	STARPU_ASSERT(args);
 
-		_STARPU_PTHREAD_MUTEX_LOCK(args->sched_mutex);
+	unsigned memnode = args->memory_node;
+	int workerid = args->workerid;
 
-		task = _starpu_pop_task(args);
+	_STARPU_TRACE_START_PROGRESS(memnode);
+	_starpu_datawizard_progress(memnode, 1);
+	_STARPU_TRACE_END_PROGRESS(memnode);
 
-                if (task == NULL)
-		{
-			if (_starpu_worker_can_block(memnode))
-				_starpu_block_worker(workerid, args->sched_cond, args->sched_mutex);
+	_STARPU_PTHREAD_MUTEX_LOCK(args->sched_mutex);
 
-			_STARPU_PTHREAD_MUTEX_UNLOCK(args->sched_mutex);
+	struct starpu_task *task = _starpu_pop_task(args);
+	struct _starpu_job *j = NULL;
 
-			continue;
-		};
+	if (task == NULL)
+	{
+		if (_starpu_worker_can_block(memnode))
+			_starpu_block_worker(workerid, args->sched_cond, args->sched_mutex);
 
 		_STARPU_PTHREAD_MUTEX_UNLOCK(args->sched_mutex);
 
-		STARPU_ASSERT(task);
-		j = _starpu_get_job_associated_to_task(task);
+		return 0;
+	}
 
-		/* can CUDA do that task ? */
-		if (!_STARPU_CUDA_MAY_PERFORM(j))
-		{
-			/* this is neither a cuda or a cublas task */
-			_starpu_push_task(j);
-			continue;
-		}
+	_STARPU_PTHREAD_MUTEX_UNLOCK(args->sched_mutex);
 
-		_starpu_set_current_task(task);
-		args->current_task = j->task;
+	STARPU_ASSERT(task);
+	j = _starpu_get_job_associated_to_task(task);
+
+	/* can CUDA do that task ? */
+	if (!_STARPU_CUDA_MAY_PERFORM(j))
+	{
+		/* this is neither a cuda or a cublas task */
+		_starpu_push_task(j);
+		return 0;
+	}
+
+	_starpu_set_current_task(task);
+	args->current_task = j->task;
 
-		res = execute_job_on_cuda(j, args);
+	int res = execute_job_on_cuda(j, args);
 
-		_starpu_set_current_task(NULL);
-		args->current_task = NULL;
+	_starpu_set_current_task(NULL);
+	args->current_task = NULL;
 
-		if (res)
+	if (res)
+	{
+		switch (res)
 		{
-			switch (res)
-			{
-				case -EAGAIN:
-					_STARPU_DISP("ouch, put the codelet %p back ... \n", j);
-					_starpu_push_task(j);
-					STARPU_ABORT();
-					continue;
-				default:
-					STARPU_ASSERT(0);
-			}
+			case -EAGAIN:
+				_STARPU_DISP("ouch, put the codelet %p back ... \n", j);
+				_starpu_push_task(j);
+				STARPU_ABORT();
+			default:
+				STARPU_ABORT();
 		}
-
-		_starpu_handle_job_termination(j);
 	}
 
+	_starpu_handle_job_termination(j);
+
+	return 0;
+}
+
+int _starpu_cuda_driver_deinit(struct starpu_driver *d)
+{
+	struct _starpu_worker* args = _starpu_get_worker_from_driver(d);
+	STARPU_ASSERT(args);
+	unsigned memnode = args->memory_node;
+
 	_STARPU_TRACE_WORKER_DEINIT_START
 
 	_starpu_handle_all_pending_node_data_requests(memnode);
@@ -399,6 +424,22 @@ void *_starpu_cuda_worker(void *arg)
 
 	_STARPU_TRACE_WORKER_DEINIT_END(_STARPU_FUT_CUDA_KEY);
 
+	return 0;
+}
+
+void *_starpu_cuda_worker(void *arg)
+{
+	struct _starpu_worker* args = arg;
+	struct starpu_driver d = {
+		.type       = STARPU_CUDA_WORKER,
+		.id.cuda_id = args->devid
+	};
+
+	_starpu_cuda_driver_init(&d);
+	while (_starpu_machine_is_running())
+		_starpu_cuda_driver_run_once(&d);
+	_starpu_cuda_driver_deinit(&d);
+
 	return NULL;
 }