Rather use the proper english writing, prologue. Prolog is really essentially a language :)

ChangeLog

@@ -47,7 +47,7 @@ New features:
     _STARPU_PERFMODEL_VERSION should be updated. It is then possible
     to switch easily between differents versions of StarPU having
     different performance model formats.
-  * Tasks can now define a optional prolog callback which is executed
+  * Tasks can now define a optional prologue callback which is executed
     on the host just before the task is pushed. Tasks which depend on
     the task might already be executing.
 

examples/Makefile.am

@@ -182,7 +182,7 @@ examplebin_PROGRAMS +=				\
 	spmd/vector_scal_spmd			\
 	spmv/spmv				\
 	callback/callback			\
-	callback/prolog		\
+	callback/prologue			\
 	incrementer/incrementer			\
 	binary/binary				\
 	interface/complex			\

examples/callback/prolog.c

@@ -63,8 +63,8 @@ int main(int argc, char **argv)
 
 	struct starpu_task *task = starpu_task_create();
 	task->cl = &cl;
-	task->prolog_func = callback_func;
-	task->prolog_arg = NULL;
+	task->prologue_func = callback_func;
+	task->prologue_arg = NULL;
 	task->handles[0] = handle;
 
 	ret = starpu_task_submit(task);

include/starpu_task.h

@@ -126,8 +126,8 @@ struct starpu_task
 	void (*callback_func)(void *);
 	void *callback_arg;
 
-	void (*prolog_func)(void *);
-	void *prolog_arg;
+	void (*prologue_func)(void *);
+	void *prologue_arg;
 
 	unsigned use_tag;
 	starpu_tag_t tag_id;

include/starpu_task_util.h

@@ -43,8 +43,8 @@ void starpu_create_sync_task(starpu_tag_t sync_tag, unsigned ndeps, starpu_tag_t
 #define STARPU_HYPERVISOR_TAG	 (1<<28)
 #define STARPU_FLOPS	         (1<<29)
 #define STARPU_SCHED_CTX	 (1<<30)
-#define STARPU_PROLOG_CALLBACK   (1<<31)
-#define STARPU_PROLOG_CALLBACK_ARG (1<<32)
+#define STARPU_PROLOGUE_CALLBACK   (1<<31)
+#define STARPU_PROLOGUE_CALLBACK_ARG (1<<32)
 
 int starpu_insert_task(struct starpu_codelet *cl, ...);
 

src/core/sched_policy.c

@@ -314,8 +314,8 @@ static int _starpu_nworkers_able_to_execute_task(struct starpu_task *task, struc
 int _starpu_push_task(struct _starpu_job *j)
 {
 
-	if(j->task->prolog_func)
-		j->task->prolog_func(j->task->prolog_arg);
+	if(j->task->prologue_func)
+		j->task->prologue_func(j->task->prologue_arg);
 
 	struct starpu_task *task = j->task;
 	struct _starpu_sched_ctx *sched_ctx = _starpu_get_sched_ctx_struct(task->sched_ctx);

src/util/starpu_insert_task_utils.c

@@ -172,12 +172,12 @@ int _starpu_codelet_pack_args(void **arg_buffer, size_t arg_buffer_size, va_list
 		{
 			(void)va_arg(varg_list, void *);
 		}
-		else if (arg_type==STARPU_PROLOG_CALLBACK)
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK)
 		{
 			va_arg(varg_list, _starpu_callback_func_t);
 			va_arg(varg_list, void *);
 		}
-		else if (arg_type==STARPU_PROLOG_CALLBACK_ARG)
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG)
 		{
 			(void)va_arg(varg_list, void *);
 		}
@@ -237,10 +237,10 @@ int _starpu_insert_task_create_and_submit(void *arg_buffer, size_t arg_buffer_si
 
 	cl_arg_wrapper->callback_func = NULL;
 
-	struct insert_task_cb_wrapper *prolog_cl_arg_wrapper = (struct insert_task_cb_wrapper *) malloc(sizeof(struct insert_task_cb_wrapper));
-	STARPU_ASSERT(prolog_cl_arg_wrapper);
+	struct insert_task_cb_wrapper *prologue_cl_arg_wrapper = (struct insert_task_cb_wrapper *) malloc(sizeof(struct insert_task_cb_wrapper));
+	STARPU_ASSERT(prologue_cl_arg_wrapper);
 
-	prolog_cl_arg_wrapper->callback_func = NULL;
+	prologue_cl_arg_wrapper->callback_func = NULL;
 
 	while((arg_type = va_arg(varg_list, int)) != 0)
 	{
@@ -310,19 +310,19 @@ int _starpu_insert_task_create_and_submit(void *arg_buffer, size_t arg_buffer_si
 			void *callback_arg = va_arg(varg_list, void *);
 			cl_arg_wrapper->callback_arg = callback_arg;
 		}
-		else if (arg_type==STARPU_PROLOG_CALLBACK)
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK)
 		{
 			void (*callback_func)(void *);
 			void *callback_arg;
 			callback_func = va_arg(varg_list, _starpu_callback_func_t);
 			callback_arg = va_arg(varg_list, void *);
-			prolog_cl_arg_wrapper->callback_func = callback_func;
-			prolog_cl_arg_wrapper->callback_arg = callback_arg;
+			prologue_cl_arg_wrapper->callback_func = callback_func;
+			prologue_cl_arg_wrapper->callback_arg = callback_arg;
 		}
-		else if (arg_type==STARPU_PROLOG_CALLBACK_ARG)
+		else if (arg_type==STARPU_PROLOGUE_CALLBACK_ARG)
 		{
 			void *callback_arg = va_arg(varg_list, void *);
-			prolog_cl_arg_wrapper->callback_arg = callback_arg;
+			prologue_cl_arg_wrapper->callback_arg = callback_arg;
 		}
 		else if (arg_type==STARPU_PRIORITY)
 		{
@@ -374,8 +374,8 @@ int _starpu_insert_task_create_and_submit(void *arg_buffer, size_t arg_buffer_si
 	(*task)->callback_func = starpu_task_insert_callback_wrapper;
 	(*task)->callback_arg = cl_arg_wrapper;
 
-	(*task)->prolog_func = starpu_task_insert_callback_wrapper;
-	(*task)->prolog_arg = prolog_cl_arg_wrapper;
+	(*task)->prologue_func = starpu_task_insert_callback_wrapper;
+	(*task)->prologue_arg = prologue_cl_arg_wrapper;
 
 	int ret = starpu_task_submit(*task);
 
@@ -387,7 +387,7 @@ int _starpu_insert_task_create_and_submit(void *arg_buffer, size_t arg_buffer_si
 			(*task)->cl->name ? (*task)->cl->name :
 			((*task)->cl->model && (*task)->cl->model->symbol)?(*task)->cl->model->symbol:"none");
 		free(cl_arg_wrapper);
-		free(prolog_cl_arg_wrapper);
+		free(prologue_cl_arg_wrapper);
 	}
 
 	return ret;