add fortran accessors to parallel task related fields in codelets

examples/native_fortran/nf_vector.f90

@@ -73,6 +73,12 @@ program nf_vector
         ! optionally set 'where' field to CPU only
         call fstarpu_codelet_set_where(cl_vec, FSTARPU_CPU)
 
+        ! set 'type' field to SEQ (for demonstration purpose)
+        call fstarpu_codelet_set_type(cl_vec, FSTARPU_SEQ)
+
+        ! set 'max_parallelism' field to 1 (for demonstration purpose)
+        call fstarpu_codelet_set_max_parallelism(cl_vec, 1)
+
         ! add a Read-only mode data buffer to the codelet
         call fstarpu_codelet_add_buffer(cl_vec, FSTARPU_R)
 

include/fstarpu_mod.f90

@@ -103,6 +103,10 @@ module fstarpu_mod
         type(c_ptr), bind(C) :: FSTARPU_NL_REGRESSION_BASED
         type(c_ptr), bind(C) :: FSTARPU_MULTIPLE_REGRESSION_BASED
 
+        type(c_ptr), bind(C) :: FSTARPU_SEQ
+        type(c_ptr), bind(C) :: FSTARPU_SPMD
+        type(c_ptr), bind(C) :: FSTARPU_FORKJOIN
+
         ! (some) portable iso_c_binding types
         type(c_ptr), bind(C) :: FSTARPU_SZ_C_DOUBLE
         type(c_ptr), bind(C) :: FSTARPU_SZ_C_FLOAT
@@ -713,6 +717,18 @@ module fstarpu_mod
                         type(c_ptr), value, intent(in) :: where ! C function expects an intptr_t
                 end subroutine fstarpu_codelet_set_where
 
+                subroutine fstarpu_codelet_set_type (cl, type_constant) bind(C)
+                        use iso_c_binding, only: c_ptr
+                        type(c_ptr), value, intent(in) :: cl
+                        type(c_ptr), value, intent(in) :: type_constant ! C function expects an intptr_t
+                end subroutine fstarpu_codelet_set_type
+
+                subroutine fstarpu_codelet_set_max_parallelism (cl, max_parallelism) bind(C)
+                        use iso_c_binding, only: c_ptr,c_int
+                        type(c_ptr), value, intent(in) :: cl
+                        integer(c_int), value, intent(in) :: max_parallelism
+                end subroutine fstarpu_codelet_set_max_parallelism
+
                 function fstarpu_perfmodel_allocate () bind(C)
                         use iso_c_binding, only: c_ptr
                         type(c_ptr) :: fstarpu_perfmodel_allocate
@@ -2475,6 +2491,13 @@ module fstarpu_mod
                         FSTARPU_MULTIPLE_REGRESSION_BASED = &
                                 fstarpu_get_constant(C_CHAR_"FSTARPU_MULTIPLE_REGRESSION_BASED"//C_NULL_CHAR)
 
+                        FSTARPU_SEQ = &
+                                fstarpu_get_constant(C_CHAR_"FSTARPU_SEQ"//C_NULL_CHAR)
+                        FSTARPU_SPMD = &
+                                fstarpu_get_constant(C_CHAR_"FSTARPU_SPMD"//C_NULL_CHAR)
+                        FSTARPU_FORKJOIN = &
+                                fstarpu_get_constant(C_CHAR_"FSTARPU_FORKJOIN"//C_NULL_CHAR)
+
                         ! Initialize size constants as 'c_ptr'
                         FSTARPU_SZ_C_DOUBLE        = sz_to_p(c_sizeof(FSTARPU_SZ_C_DOUBLE_dummy))
                         FSTARPU_SZ_C_FLOAT        = sz_to_p(c_sizeof(FSTARPU_SZ_C_FLOAT_dummy))

src/util/fstarpu.c

@@ -113,6 +113,10 @@ static const intptr_t fstarpu_regression_based	= STARPU_REGRESSION_BASED;
 static const intptr_t fstarpu_nl_regression_based	= STARPU_NL_REGRESSION_BASED;
 static const intptr_t fstarpu_multiple_regression_based	= STARPU_MULTIPLE_REGRESSION_BASED;
 
+static const intptr_t fstarpu_seq	= STARPU_SEQ;
+static const intptr_t fstarpu_spmd	= STARPU_SPMD;
+static const intptr_t fstarpu_forkjoin	= STARPU_FORKJOIN;
+
 intptr_t fstarpu_get_constant(char *s)
 {
 	if	(!strcmp(s, "FSTARPU_R"))	{ return fstarpu_r; }
@@ -206,6 +210,10 @@ intptr_t fstarpu_get_constant(char *s)
 	else if (!strcmp(s, "FSTARPU_NL_REGRESSION_BASED"))	{ return fstarpu_nl_regression_based; }
 	else if (!strcmp(s, "FSTARPU_MULTIPLE_REGRESSION_BASED"))	{ return fstarpu_multiple_regression_based; }
 
+	else if (!strcmp(s, "FSTARPU_SEQ"))	{ return fstarpu_seq; }
+	else if (!strcmp(s, "FSTARPU_SPMD"))	{ return fstarpu_spmd; }
+	else if (!strcmp(s, "FSTARPU_FORKJOIN"))	{ return fstarpu_forkjoin; }
+
 	else { _STARPU_ERROR("unknown constant"); }
 }
 
@@ -427,6 +435,24 @@ void fstarpu_codelet_set_where(struct starpu_codelet *cl, intptr_t where)
 	cl->where = (uint32_t)where;
 }
 
+void fstarpu_codelet_set_type(struct starpu_codelet *cl, intptr_t type_constant)
+{
+	STARPU_ASSERT(type_constant == STARPU_SEQ || type_constant == STARPU_SPMD || type_constant == STARPU_FORKJOIN);
+	cl->type = (int)type_constant;
+}
+
+void fstarpu_codelet_set_max_parallelism(struct starpu_codelet *cl, int max_parallelism)
+{
+	if (max_parallelism >= 1)
+	{
+		cl->max_parallelism = max_parallelism;
+	}
+	else
+	{
+		_STARPU_ERROR("fstarpu: invalid max_parallelism parameter");
+	}
+}
+
 STARPU_ATTRIBUTE_MALLOC
 struct starpu_perfmodel *fstarpu_perfmodel_allocate(void)
 {