julia: Add data dependency features with examples.

julia/examples/Makefile.am

@@ -97,4 +97,6 @@ STARPU_JULIA_EXAMPLES		+= callback/callback
 callback_callback_SOURCES	=	callback/callback.c
 SHELL_TESTS			+=	callback/callback.sh
 
-SHELL_TESTS			+=	dependency/sequential_consistency.sh
+SHELL_TESTS			+=	dependency/tag_dep.sh
+SHELL_TESTS			+=	dependency/task_dep.sh
+SHELL_TESTS			+=	dependency/end_dep.sh

julia/examples/dependency/end_dep.jl

@@ -0,0 +1,104 @@
+# StarPU --- Runtime system for heterogeneous multicore architectures.
+#
+# Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+#
+# StarPU is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version.
+#
+# StarPU is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU Lesser General Public License in COPYING.LGPL for more details.
+#
+using StarPU
+
+@target STARPU_CPU
+@codelet function codeletA() :: Nothing
+    # print("[Task A] Value = ", val[]);
+    # do nothing
+end
+
+@target STARPU_CPU
+@codelet function codeletB(val ::Ref{Int32}) :: Nothing
+    # println("[Task B] Value = ", val[]);
+    val[] = val[] *2
+end
+
+function callbackB(task)
+    sleep(1)
+    starpu_task_end_dep_release(task)
+end
+
+@target STARPU_CPU
+@codelet function codeletC(val ::Ref{Int32}) :: Nothing
+    # println("[Task C] Value = ", val[]);
+    val[] = val[] *2
+end
+
+function callbackC(task)
+    starpu_task_end_dep_release(task)
+end
+
+
+function main()
+    value = Ref(Int32(12))
+
+    @starpu_block let
+        perfmodel = starpu_perfmodel(
+            perf_type = starpu_perfmodel_type(STARPU_HISTORY_BASED),
+            symbol = "history_perf"
+        )
+
+        clA = starpu_codelet(
+            cpu_func = CPU_CODELETS["codeletA"],
+            perfmodel = perfmodel
+        )
+        clB = starpu_codelet(
+            cpu_func = CPU_CODELETS["codeletB"],
+            modes = [STARPU_RW],
+            perfmodel = perfmodel
+        )
+        clC = starpu_codelet(
+            cpu_func = CPU_CODELETS["codeletC"],
+            modes = [STARPU_RW],
+            perfmodel = perfmodel
+        )
+
+        handle = starpu_data_register(value)
+
+	starpu_data_set_sequential_consistency_flag(handle, 0)
+
+        taskA = starpu_task(cl = clA, detach=0)
+        taskB = starpu_task(cl = clB, handles = [handle], callback=callbackB, callback_arg=taskA)
+	taskC = starpu_task(cl = clC, handles = [handle], callback=callbackC, callback_arg=taskA)
+
+	starpu_task_end_dep_add(taskA, 2)
+        starpu_task_declare_deps(taskC, taskB)
+
+        starpu_task_submit(taskA)
+        starpu_task_submit(taskB)
+        starpu_task_submit(taskC)
+        starpu_task_wait(taskA)
+
+        starpu_data_acquire_on_node(handle, STARPU_MAIN_RAM, STARPU_R);
+	# Waiting for taskA should have also waited for taskB and taskC
+        if value[] != 48
+            error("Incorrect value $(value[]) (expected 48)")
+        end
+	starpu_data_release_on_node(handle, STARPU_MAIN_RAM);
+    end
+
+
+    println("Value = ", value[])
+end
+
+# Disable garbage collector because of random segfault/hang when using mutex.
+# This issue should be solved with Julia release 1.5.
+GC.enable(false)
+starpu_init()
+main()
+starpu_shutdown()
+GC.enable(true)

julia/examples/dependency/end_dep.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# StarPU --- Runtime system for heterogeneous multicore architectures.
+#
+# Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+#
+# StarPU is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version.
+#
+# StarPU is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU Lesser General Public License in COPYING.LGPL for more details.
+#
+
+$(dirname $0)/../execute.sh dependency/end_dep.jl

julia/examples/dependency/sequential_consistency.sh

@@ -15,4 +15,4 @@
 # See the GNU Lesser General Public License in COPYING.LGPL for more details.
 #
 
-$(dirname $0)/../execute.sh dependency/sequential_consistency.jl
+$(dirname $0)/../execute.sh dependency/tag_dep.jl

julia/examples/dependency/task_dep.jl

@@ -0,0 +1,88 @@
+# StarPU --- Runtime system for heterogeneous multicore architectures.
+#
+# Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+#
+# StarPU is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version.
+#
+# StarPU is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU Lesser General Public License in COPYING.LGPL for more details.
+#
+using StarPU
+
+@target STARPU_CPU
+@codelet function codeletA(val ::Ref{Int32}) :: Nothing
+    # print("[Task A] Value = ", val[]);
+    val[] = val[] * 2
+end
+
+@target STARPU_CPU
+@codelet function codeletB(val ::Ref{Int32}) :: Nothing
+    # println("[Task B] Value = ", val[]);
+    val[] = val[] +1
+end
+
+@target STARPU_CPU
+@codelet function codeletC(val ::Ref{Int32}) :: Nothing
+    # println("[Task C] Value = ", val[]);
+    val[] = val[] *2
+end
+
+function main()
+    value = Ref(Int32(12))
+
+    @starpu_block let
+        perfmodel = starpu_perfmodel(
+            perf_type = starpu_perfmodel_type(STARPU_HISTORY_BASED),
+            symbol = "history_perf"
+        )
+
+        clA = starpu_codelet(
+            cpu_func = CPU_CODELETS["codeletA"],
+            modes = [STARPU_RW],
+            perfmodel = perfmodel
+        )
+        clB = starpu_codelet(
+            cpu_func = CPU_CODELETS["codeletB"],
+            modes = [STARPU_RW],
+            perfmodel = perfmodel
+        )
+        clC = starpu_codelet(
+            cpu_func = CPU_CODELETS["codeletC"],
+            modes = [STARPU_RW],
+            perfmodel = perfmodel
+        )
+
+        starpu_data_set_default_sequential_consistency_flag(0)
+
+        handle = starpu_data_register(value)
+
+        taskA = starpu_task(cl = clA, handles = [handle])
+        taskB = starpu_task(cl = clB, handles = [handle])
+        taskC = starpu_task(cl = clC, handles = [handle])
+
+        starpu_task_declare_deps(taskA, taskB)
+        starpu_task_declare_deps(taskC, taskA, taskB)
+
+        starpu_task_submit(taskA)
+        starpu_task_submit(taskB)
+        starpu_task_submit(taskC)
+
+        starpu_task_wait_for_all()
+    end
+
+    if value[] != 52
+        error("Incorrect value $(value[]) (expected 52)")
+    end
+
+    println("Value = ", value[])
+end
+
+starpu_init()
+main()
+starpu_shutdown()

julia/examples/dependency/task_dep.sh

@@ -0,0 +1,18 @@
+#!/bin/bash
+# StarPU --- Runtime system for heterogeneous multicore architectures.
+#
+# Copyright (C) 2020       Université de Bordeaux, CNRS (LaBRI UMR 5800), Inria
+#
+# StarPU is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 2.1 of the License, or (at
+# your option) any later version.
+#
+# StarPU is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+# See the GNU Lesser General Public License in COPYING.LGPL for more details.
+#
+
+$(dirname $0)/../execute.sh dependency/task_dep.jl

julia/src/StarPU.jl

@@ -43,33 +43,47 @@ include("task.jl")
 include("task_dep.jl")
 include("init.jl")
 
+# macro
+export @starpu_filter
+export @starpu_block
+export @starpu_async_cl
+export @starpu_sync_tasks
+
+# enum / define
 export STARPU_CPU
+export STARPU_CUDA
+export STARPU_OPENCL
+export STARPU_MAIN_RAM
+export StarpuDataFilterFunc
+export STARPU_MATRIX_FILTER_VERTICAL_BLOCK, STARPU_MATRIX_FILTER_BLOCK
+export STARPU_PERFMODEL_INVALID, STARPU_PER_ARCH, STARPU_COMMON
+export STARPU_HISTORY_BASED, STARPU_REGRESSION_BASED
+export STARPU_NL_REGRESSION_BASED, STARPU_MULTIPLE_REGRESSION_BASED
+export starpu_tag_t
+export STARPU_NONE,STARPU_R,STARPU_W,STARPU_RW, STARPU_SCRATCH
+export STARPU_REDUX,STARPU_COMMUTE, STARPU_SSEND, STARPU_LOCALITY
+export STARPU_ACCESS_MODE_MAX
+
+# functions
 export starpu_init
 export starpu_shutdown
 export starpu_memory_pin
 export starpu_memory_unpin
 export starpu_data_access_mode
+export starpu_data_acquire_on_node
+export starpu_data_release_on_node
 export starpu_data_unregister
 export starpu_data_register
 export starpu_data_get_sub_data
-export StarpuDataFilterFunc
-export STARPU_MATRIX_FILTER_VERTICAL_BLOCK, STARPU_MATRIX_FILTER_BLOCK
-export StarpuDataFilter
 export starpu_data_partition
 export starpu_data_unpartition
 export starpu_data_map_filters
-export @starpu_sync_tasks
 export starpu_task_wait_for_all
-export @starpu_async_cl
 export starpu_task_submit
-export @starpu_block
-export StarpuPerfmodel
-export @starpu_filter
-export STARPU_PERFMODEL_INVALID, STARPU_PER_ARCH, STARPU_COMMON
-export STARPU_HISTORY_BASED, STARPU_REGRESSION_BASED
-export STARPU_NL_REGRESSION_BASED, STARPU_MULTIPLE_REGRESSION_BASED
-export starpu_tag_t
+export starpu_task_end_dep_add
+export starpu_task_end_dep_release
 export starpu_task_declare_deps
+export starpu_task_declare_end_deps
 export starpu_task_wait_for_n_submitted
 export starpu_task_destroy
 export starpu_tag_wait
@@ -78,12 +92,14 @@ export starpu_iteration_pop
 export starpu_iteration_push
 export starpu_tag_declare_deps
 export starpu_task
-export STARPU_NONE,STARPU_R,STARPU_W,STARPU_RW, STARPU_SCRATCH
-export STARPU_REDUX,STARPU_COMMUTE, STARPU_SSEND, STARPU_LOCALITY
-export STARPU_ACCESS_MODE_MAX
+export starpu_task_wait
 export starpu_codelet
 export starpu_perfmodel
 export starpu_perfmodel_type
 export starpu_translate_headers
+export starpu_data_get_default_sequential_consistency_flag
+export starpu_data_set_default_sequential_consistency_flag
+export starpu_data_get_sequential_consistency_flag
+export starpu_data_set_sequential_consistency_flag
 
 end

julia/src/data.jl

@@ -144,6 +144,22 @@ function starpu_data_map_filters(handle :: StarpuDataHandle, filter_1 :: starpu_
     starpu_data_map_filters(handle.object, 2, pointer_from_objref(filter_1), pointer_from_objref(filter_2))
 end
 
+function starpu_data_get_sequential_consistency_flag(handle :: StarpuDataHandle)
+    return starpu_data_get_sequential_consistency_flag(handle.object)
+end
+
+function starpu_data_set_sequential_consistency_flag(handle :: StarpuDataHandle, flag :: Int)
+    starpu_data_set_sequential_consistency_flag(handle.object, flag)
+end
+
+function starpu_data_acquire_on_node(handle :: StarpuDataHandle, node :: Int, mode)
+    starpu_data_acquire_on_node(handle.object, node, mode)
+end
+
+function starpu_data_release_on_node(handle :: StarpuDataHandle, node :: Int)
+    starpu_data_release_on_node(handle.object, node)
+end
+
 function repl(x::Symbol)
     return x
 end

julia/src/task.jl

@@ -92,7 +92,7 @@ task_list = Vector{jl_starpu_task}()
         """
 function starpu_task(; cl :: Union{Cvoid, jl_starpu_codelet} = nothing, handles :: Vector{StarpuDataHandle} = StarpuDataHandle[], cl_arg = (),
                      callback :: Union{Cvoid, Function} = nothing, callback_arg = nothing, tag :: Union{Cvoid, starpu_tag_t} = nothing,
-                     sequential_consistency = true)
+                     sequential_consistency = true, detach = 1)
     if (cl == nothing)
         error("\"cl\" field can't be empty when creating a StarpuTask")
     end
@@ -126,6 +126,7 @@ function starpu_task(; cl :: Union{Cvoid, jl_starpu_codelet} = nothing, handles
     output.c_task.cl = pointer_from_objref(cl.c_codelet)
     output.c_task.synchronous = false
     output.c_task.sequential_consistency = sequential_consistency
+    output.c_task.detach = detach
 
     ## TODO: check num handles equals num codelet buffers
     for i in 1:length(handles)
@@ -255,6 +256,14 @@ macro starpu_async_cl(expr, modes, cl_arg=(), color ::UInt32=0x00000000)
     end
 end
 
+function starpu_task_wait(task :: jl_starpu_task)
+    @threadcall(@starpufunc(:starpu_task_wait),
+                Cint, (Ptr{Cvoid},), Ref(task.c_task))
+
+    # starpu_task_wait(Ref(task.c_task))
+end
+
+
 """
     Blocks until every submitted task has finished.
 """

julia/src/task_dep.jl

@@ -29,6 +29,20 @@ end
 """
 function starpu_task_declare_deps(task :: jl_starpu_task, dep :: jl_starpu_task, other_deps :: jl_starpu_task...)
 
-    task_array = [dep.c_task, map((t -> t.c_task), other_deps)...]
-    starpu_task_declare_deps_array(task.c_task, length(task_array), pointer(task_array))
+    task_array = [pointer_from_objref(dep.c_task), map((t -> pointer_from_objref(t.c_task)), other_deps)...]
+    starpu_task_declare_deps_array(pointer_from_objref(task.c_task), length(task_array), task_array)
+end
+
+function starpu_task_end_dep_add(task :: jl_starpu_task, nb_deps :: Int)
+    starpu_task_end_dep_add(Ref(task.c_task), nb_deps)
+end
+
+function starpu_task_end_dep_release(task :: jl_starpu_task)
+    starpu_task_end_dep_release(Ref(task.c_task))
+end
+
+function starpu_task_declare_end_deps(task :: jl_starpu_task, dep :: jl_starpu_task, other_deps :: jl_starpu_task...)
+
+    task_array = [pointer_from_objref(dep.c_task), map((t -> pointer_from_objref(t.c_task)), other_deps)...]
+    starpu_task_declare_end_deps_array(pointer_from_objref(task.c_task), length(task_array), pointer(task_array))
 end

julia/src/translate_headers.jl

@@ -42,24 +42,34 @@ function starpu_translate_headers()
                                "starpu_perfmodel_type",
                                "starpu_data_handle_t",
                                "starpu_init",
+                               "starpu_data_acquire_on_node",
+                               "starpu_data_release_on_node",
                                "starpu_data_unregister",
                                "starpu_data_partition",
                                "starpu_data_unpartition",
                                "starpu_data_get_sub_data",
                                "starpu_data_map_filters",
+                               "starpu_data_get_default_sequential_consistency_flag",
+                               "starpu_data_set_default_sequential_consistency_flag",
+                               "starpu_data_get_sequential_consistency_flag",
+                               "starpu_data_set_sequential_consistency_flag",
                                "starpu_matrix_data_register",
                                "starpu_block_data_register",
                                "starpu_vector_data_register",
                                "starpu_variable_data_register",
                                "starpu_memory_pin",
                                "starpu_memory_unpin",
+                               "starpu_task_end_dep_add",
+                               "starpu_task_end_dep_release",
                                "starpu_task_init",
                                "starpu_task_destroy",
                                "starpu_task_submit",
+                               "starpu_task_wait",
                                "starpu_task_wait_for_n_submitted",
                                "starpu_tag_wait",
                                "starpu_tag_declare_deps_array",
                                "starpu_tag_notify_from_apps",
+                               "starpu_task_declare_end_deps_array",
                                "starpu_task_declare_deps_array",
                                "starpu_iteration_push",
                                "starpu_iteration_pop",