Label -> TaskId

noabauma · noabauma · commit 220d84412860 · 2025-07-23T11:39:41.000+02:00
diff --git a/examples/abcTasks/cpp/abcTasks.hpp b/examples/abcTasks/cpp/abcTasks.hpp
@@ -27,9 +27,9 @@ void abcTasks(taskr::Runtime &taskr)
   taskr.setTaskCallbackHandler(HiCR::tasking::Task::callback_t::onTaskFinish, [&taskr](taskr::Task *task) { delete task; });
 
   // Creating the execution units (functions that the tasks will run)
-  auto taskAfc = taskr::Function([](taskr::Task *task) { printf("Task A %ld\n", task->getLabel()); });
-  auto taskBfc = taskr::Function([](taskr::Task *task) { printf("Task B %ld\n", task->getLabel()); });
-  auto taskCfc = taskr::Function([](taskr::Task *task) { printf("Task C %ld\n", task->getLabel()); });
+  auto taskAfc = taskr::Function([](taskr::Task *task) { printf("Task A %ld\n", task->getTaskId()); });
+  auto taskBfc = taskr::Function([](taskr::Task *task) { printf("Task B %ld\n", task->getTaskId()); });
+  auto taskCfc = taskr::Function([](taskr::Task *task) { printf("Task C %ld\n", task->getTaskId()); });
 
   // Initializing taskr
   taskr.initialize();
@@ -38,17 +38,17 @@ void abcTasks(taskr::Runtime &taskr)
   for (size_t r = 0; r < REPETITIONS; r++)
   {
     // Calculating the base task id for this repetition
-    auto repetitionLabel = r * ITERATIONS * 3;
+    auto repetitionTaskId = r * ITERATIONS * 3;
 
     // Our connection with the previous iteration is the last task C, null in the first iteration
     taskr::Task *prevTaskC = nullptr;
 
     // Each run consists of several iterations of ABC
     for (size_t i = 0; i < ITERATIONS; i++)
     {
-      auto taskA = new taskr::Task(repetitionLabel + i * 3 + 0, &taskAfc);
-      auto taskB = new taskr::Task(repetitionLabel + i * 3 + 1, &taskBfc);
-      auto taskC = new taskr::Task(repetitionLabel + i * 3 + 2, &taskCfc);
+      auto taskA = new taskr::Task(repetitionTaskId + i * 3 + 0, &taskAfc);
+      auto taskB = new taskr::Task(repetitionTaskId + i * 3 + 1, &taskBfc);
+      auto taskC = new taskr::Task(repetitionTaskId + i * 3 + 2, &taskCfc);
 
       // Creating dependencies
       if (i > 0) taskA->addDependency(prevTaskC);
diff --git a/examples/abcTasks/python/abcTasks.py b/examples/abcTasks/python/abcTasks.py
@@ -6,9 +6,9 @@
 def abcTasks(runtime):
 
    # Create the taskr Tasks
-  taskAfc = taskr.Function(lambda task : print(f"Task A {task.getLabel()}"))
-  taskBfc = taskr.Function(lambda task : print(f"Task B {task.getLabel()}"))
-  taskCfc = taskr.Function(lambda task : print(f"Task C {task.getLabel()}"))
+  taskAfc = taskr.Function(lambda task : print(f"Task A {task.getTaskId()}"))
+  taskBfc = taskr.Function(lambda task : print(f"Task B {task.getTaskId()}"))
+  taskCfc = taskr.Function(lambda task : print(f"Task C {task.getTaskId()}"))
 
   # Initializing taskr
   runtime.initialize()
@@ -19,13 +19,13 @@ def abcTasks(runtime):
   # Creating the execution units (functions that the tasks will run)
   for r in range(REPETITIONS):
     # Calculating the base task id for this repetition
-    repetitionLabel = r * ITERATIONS * 3
+    repetitionTaskId = r * ITERATIONS * 3
 
     for i in range(ITERATIONS):
 
-      taskA = taskr.Task(repetitionLabel + i * 3 + 0, taskAfc)
-      taskB = taskr.Task(repetitionLabel + i * 3 + 1, taskBfc)
-      taskC = taskr.Task(repetitionLabel + i * 3 + 2, taskCfc)
+      taskA = taskr.Task(repetitionTaskId + i * 3 + 0, taskAfc)
+      taskB = taskr.Task(repetitionTaskId + i * 3 + 1, taskBfc)
+      taskC = taskr.Task(repetitionTaskId + i * 3 + 2, taskCfc)
 
       # Creating dependencies
       if i > 0: taskA.addDependency(prevTaskC)
diff --git a/examples/jacobi3d/source/nosv.cpp b/examples/jacobi3d/source/nosv.cpp
@@ -176,7 +176,7 @@ int main(int argc, char *argv[])
     [&g](taskr::Task *task) { g->calculateLocalResidual(task, ((Task *)task)->i, ((Task *)task)->j, ((Task *)task)->k, ((Task *)task)->iteration); });
 
   // Task map
-  std::map<taskr::label_t, std::shared_ptr<taskr::Task>> _taskMap;
+  std::map<taskr::taskId_t, std::shared_ptr<taskr::Task>> _taskMap;
 
   // printf("Instance %lu: Executing...\n", myInstanceId);
 
diff --git a/examples/jacobi3d/source/pthreads.cpp b/examples/jacobi3d/source/pthreads.cpp
@@ -165,7 +165,7 @@ int main(int argc, char *argv[])
     [&g](taskr::Task *task) { g->calculateLocalResidual(task, ((Task *)task)->i, ((Task *)task)->j, ((Task *)task)->k, ((Task *)task)->iteration); });
 
   // Task map
-  std::map<taskr::label_t, std::shared_ptr<taskr::Task>> _taskMap;
+  std::map<taskr::taskId_t, std::shared_ptr<taskr::Task>> _taskMap;
 
   // printf("Instance %lu: Executing...\n", myInstanceId);
 
diff --git a/examples/jacobi3d/source/task.hpp b/examples/jacobi3d/source/task.hpp
@@ -54,17 +54,17 @@ class Task final : public taskr::Task
     const auto                   hashResult = hasher(buffer);
 
     // find if this hash already exists in the hashmap if not: add it
-    size_t tasklabel;
+    size_t taskId;
     auto   it = taskid_hashmap.find(hashResult);
 
     if (it == taskid_hashmap.end())
     {
-      tasklabel = taskid_hashmap.size();
+      taskId = taskid_hashmap.size();
 
-      taskid_hashmap[hashResult] = tasklabel;
+      taskid_hashmap[hashResult] = taskId;
     }
-    else { tasklabel = it->second; }
+    else { taskId = it->second; }
 
-    return tasklabel;
+    return taskId;
   }
 };
diff --git a/examples/matmul/python/matmul.py b/examples/matmul/python/matmul.py
@@ -60,8 +60,8 @@ def matmul_numpy(task):
         B[i, j] = 1.0/(i + 1)
         C[i, j] = 1.0/(j + 1)
 
-    B += task.getLabel()+1
-    C += task.getLabel()+1
+    B += task.getTaskId()+1
+    C += task.getTaskId()+1
     
     A = B @ C
 
diff --git a/examples/multiJob/cpp/job1.cpp b/examples/multiJob/cpp/job1.cpp
@@ -26,9 +26,9 @@ void job1(taskr::Runtime &taskr)
   std::vector<taskr::Task *> tasks(3 * ITERATIONS);
 
   // Creating the execution units (functions that the tasks will run)
-  auto taskAfc = taskr::Function([&](taskr::Task *task) { printf("Job 1 - Task A %lu\n", task->getLabel()); });
-  auto taskBfc = taskr::Function([&](taskr::Task *task) { printf("Job 1 - Task B %lu\n", task->getLabel()); });
-  auto taskCfc = taskr::Function([&](taskr::Task *task) { printf("Job 1 - Task C %lu\n", task->getLabel()); });
+  auto taskAfc = taskr::Function([&](taskr::Task *task) { printf("Job 1 - Task A %lu\n", task->getTaskId()); });
+  auto taskBfc = taskr::Function([&](taskr::Task *task) { printf("Job 1 - Task B %lu\n", task->getTaskId()); });
+  auto taskCfc = taskr::Function([&](taskr::Task *task) { printf("Job 1 - Task C %lu\n", task->getTaskId()); });
 
   // Now creating tasks
   for (size_t i = 0; i < ITERATIONS; i++)
diff --git a/examples/multiJob/cpp/job2.cpp b/examples/multiJob/cpp/job2.cpp
@@ -26,9 +26,9 @@ void job2(taskr::Runtime &taskr)
   std::vector<taskr::Task *> tasks(3 * ITERATIONS);
 
   // Creating the execution units (functions that the tasks will run)
-  auto taskAfc = taskr::Function([&](taskr::Task *task) { printf("Job 2 - Task A %lu\n", task->getLabel()); });
-  auto taskBfc = taskr::Function([&](taskr::Task *task) { printf("Job 2 - Task B %lu\n", task->getLabel()); });
-  auto taskCfc = taskr::Function([&](taskr::Task *task) { printf("Job 2 - Task C %lu\n", task->getLabel()); });
+  auto taskAfc = taskr::Function([&](taskr::Task *task) { printf("Job 2 - Task A %lu\n", task->getTaskId()); });
+  auto taskBfc = taskr::Function([&](taskr::Task *task) { printf("Job 2 - Task B %lu\n", task->getTaskId()); });
+  auto taskCfc = taskr::Function([&](taskr::Task *task) { printf("Job 2 - Task C %lu\n", task->getTaskId()); });
 
   // Now creating tasks
   for (size_t i = 0; i < ITERATIONS; i++)
diff --git a/examples/multiJob/python/job1.py b/examples/multiJob/python/job1.py
@@ -23,9 +23,9 @@ def job1(runtime):
   tasks = [None] * (3 * ITERATIONS)
 
   # Creating the execution units (functions that the tasks will run)
-  taskAfc = taskr.Function(lambda task : print(f"Job 1 - Task A {task.getLabel()}"))
-  taskBfc = taskr.Function(lambda task : print(f"Job 1 - Task B {task.getLabel()}"))
-  taskCfc = taskr.Function(lambda task : print(f"Job 1 - Task C {task.getLabel()}"))
+  taskAfc = taskr.Function(lambda task : print(f"Job 1 - Task A {task.getTaskId()}"))
+  taskBfc = taskr.Function(lambda task : print(f"Job 1 - Task B {task.getTaskId()}"))
+  taskCfc = taskr.Function(lambda task : print(f"Job 1 - Task C {task.getTaskId()}"))
 
   # Now creating tasks
   for i in range(ITERATIONS):
diff --git a/examples/multiJob/python/job2.py b/examples/multiJob/python/job2.py
@@ -23,9 +23,9 @@ def job2(runtime):
   tasks = [None] * (3 * ITERATIONS)
 
   # Creating the execution units (functions that the tasks will run)
-  taskAfc = taskr.Function(lambda task : print(f"Job 1 - Task A {task.getLabel()}"))
-  taskBfc = taskr.Function(lambda task : print(f"Job 1 - Task B {task.getLabel()}"))
-  taskCfc = taskr.Function(lambda task : print(f"Job 1 - Task C {task.getLabel()}"))
+  taskAfc = taskr.Function(lambda task : print(f"Job 1 - Task A {task.getTaskId()}"))
+  taskBfc = taskr.Function(lambda task : print(f"Job 1 - Task B {task.getTaskId()}"))
+  taskCfc = taskr.Function(lambda task : print(f"Job 1 - Task C {task.getTaskId()}"))
 
   # Now creating tasks
   for i in range(ITERATIONS):
diff --git a/examples/pendingOperation/cpp/pendingOperation.hpp b/examples/pendingOperation/cpp/pendingOperation.hpp
@@ -23,7 +23,7 @@
 void heavyTask(taskr::Task *currentTask)
 {
   // Printing starting message
-  printf("Task %lu -- Starting 1 second-long operation.\n", currentTask->getLabel());
+  printf("Task %lu -- Starting 1 second-long operation.\n", currentTask->getTaskId());
 
   // Getting initial time
   auto t0 = std::chrono::high_resolution_clock::now();
@@ -50,7 +50,7 @@ void heavyTask(taskr::Task *currentTask)
   currentTask->suspend();
 
   // Printing finished message
-  printf("Task %lu - operation finished\n", currentTask->getLabel());
+  printf("Task %lu - operation finished\n", currentTask->getTaskId());
 }
 
 void pendingOperation(taskr::Runtime &taskr)
diff --git a/examples/pendingOperation/python/pendingOperation.py b/examples/pendingOperation/python/pendingOperation.py
@@ -19,7 +19,7 @@
 
 def heavyTask(currentTask):
   # Printing starting message
-  print(f"Task {currentTask.getLabel()} -- Starting 1 second-long operation.")
+  print(f"Task {currentTask.getTaskId()} -- Starting 1 second-long operation.")
 
   # Getting initial time
   t0 = time.time()
@@ -46,7 +46,7 @@ def operation():
   currentTask.suspend()
 
   # Printing finished message
-  print(f"Task {currentTask.getLabel()} - operation finished")
+  print(f"Task {currentTask.getTaskId()} - operation finished")
 
 
 def pendingOperation(runtime):
diff --git a/examples/simple/cpp/simple.hpp b/examples/simple/cpp/simple.hpp
@@ -26,7 +26,7 @@ void simple(taskr::Runtime *taskr)
   // Initializing taskr
   taskr->initialize();
 
-  auto fc = [](taskr::Task *task) { printf("Hello, I am task %ld\n", task->getLabel()); };
+  auto fc = [](taskr::Task *task) { printf("Hello, I am task %ld\n", task->getTaskId()); };
 
   // Create the taskr Tasks
   auto taskfc = taskr::Function(fc);
diff --git a/examples/simple/python/simple.py b/examples/simple/python/simple.py
@@ -22,7 +22,7 @@ def simple(runtime):
   runtime.initialize()
 
   # Create tasks
-  fc = lambda task : print(f"Hello, I am task {task.getLabel()}")
+  fc = lambda task : print(f"Hello, I am task {task.getTaskId()}")
   taskfc = taskr.Function(fc)
 
   # Adding to tasks to taskr
diff --git a/examples/sleepsort/python/main.py b/examples/sleepsort/python/main.py
@@ -35,7 +35,7 @@ def fc(task):
         nonlocal sorted_array
         nonlocal shuffled_array
 
-        id = task.getLabel()
+        id = task.getTaskId()
 
         value = shuffled_array[id]
 
diff --git a/examples/workerSpecific/cpp/workerSpecific.hpp b/examples/workerSpecific/cpp/workerSpecific.hpp
@@ -21,17 +21,17 @@
 
 void workFc(taskr::Task *currentTask)
 {
-  auto taskLabel    = currentTask->getLabel();
+  auto taskId    = currentTask->getTaskId();
   int  currentCPUId = sched_getcpu();
 
   ////// First launched on even cpus
 
-  printf("Task %lu first run running on CPU %d\n", taskLabel, currentCPUId);
+  printf("Task %lu first run running on CPU %d\n", taskId, currentCPUId);
 
   // Sanity check
-  if (int(2 * taskLabel) != currentCPUId)
+  if (int(2 * taskId) != currentCPUId)
   {
-    fprintf(stderr, "Task label (%lu) does not coincide with the current CPU id! (%d)\n", taskLabel, currentCPUId);
+    fprintf(stderr, "Task ID (%lu) does not coincide with the current CPU id! (%d)\n", taskId, currentCPUId);
     std::abort();
   }
 
@@ -44,12 +44,12 @@ void workFc(taskr::Task *currentTask)
   ///// Now launched in odd cpus
 
   currentCPUId = sched_getcpu();
-  printf("Task %lu second run running on CPU %d\n", taskLabel, currentCPUId);
+  printf("Task %lu second run running on CPU %d\n", taskId, currentCPUId);
 
   // Sanity check
-  if (int(2 * taskLabel) + 1 != currentCPUId)
+  if (int(2 * taskId) + 1 != currentCPUId)
   {
-    fprintf(stderr, "Task label (%lu) + 1 does not coincide with the current CPU id! (%d)\n", taskLabel, currentCPUId);
+    fprintf(stderr, "Task ID (%lu) + 1 does not coincide with the current CPU id! (%d)\n", taskId, currentCPUId);
     std::abort();
   }
 }
diff --git a/examples/workerSpecific/python/workerSpecific.py b/examples/workerSpecific/python/workerSpecific.py
@@ -24,16 +24,16 @@
 import taskr
 
 def workFc(currentTask):
-  taskLabel = currentTask.getLabel()
+  taskId = currentTask.getTaskId()
   currentCPUId = libc.sched_getcpu()
 
   #### First launched on even cpus
 
-  print(f"Task {taskLabel} first run running on CPU {currentCPUId}")
+  print(f"Task {taskId} first run running on CPU {currentCPUId}")
 
   # Sanity check
-  if int(2 * taskLabel) != currentCPUId:
-    sys.stderr.write(f"Task label ({taskLabel}) does not coincide with the current CPU id! ({currentCPUId})")
+  if int(2 * taskId) != currentCPUId:
+    sys.stderr.write(f"Task ID ({taskId}) does not coincide with the current CPU id! ({currentCPUId})")
     sys.exit(1)
 
   # Changing to odd cpus
@@ -45,11 +45,11 @@ def workFc(currentTask):
   #### Now launched in odd cpus
 
   currentCPUId = libc.sched_getcpu()
-  print(f"Task {taskLabel} second run running on CPU {currentCPUId}")
+  print(f"Task {taskId} second run running on CPU {currentCPUId}")
 
   # Sanity check
-  if int(2 * taskLabel) + 1 != currentCPUId:
-    sys.stderr.write(f"Task label ({taskLabel}) + 1 does not coincide with the current CPU id! ({currentCPUId})")
+  if int(2 * taskId) + 1 != currentCPUId:
+    sys.stderr.write(f"Task ID ({taskId}) + 1 does not coincide with the current CPU id! ({currentCPUId})")
     sys.exit(1)
 
 
diff --git a/include/pytaskr/pytaskr.cpp b/include/pytaskr/pytaskr.cpp
@@ -56,9 +56,9 @@ PYBIND11_MODULE(taskr, m)
   // TaskR's Task class
   py::class_<Task>(m, "Task")
     .def(py::init<Function *, const workerId_t>(), py::arg("fc"), py::arg("workerAffinity") = -1)
-    .def(py::init<const label_t, Function *, const workerId_t>(), py::arg("ID"), py::arg("taskfc"), py::arg("workerAffinity") = -1)
-    .def("getLabel", &Task::getLabel)
-    .def("setLabel", &Task::setLabel)
+    .def(py::init<const taskId_t, Function *, const workerId_t>(), py::arg("taskId"), py::arg("taskfc"), py::arg("workerAffinity") = -1)
+    .def("getTaskId", &Task::getTaskId)
+    .def("setTaskId", &Task::setTaskId)
     .def("getWorkerAffinity", &Task::getWorkerAffinity)
     .def("setWorkerAffinity", &Task::setWorkerAffinity)
     .def("addDependency", &Task::addDependency)
@@ -91,8 +91,8 @@ PYBIND11_MODULE(taskr, m)
          py::call_guard<py::gil_scoped_release>(),
          "cv waitFor with condition")
     .def("waitFor", py::overload_cast<Task *, Mutex &, size_t>(&ConditionVariable::waitFor), py::call_guard<py::gil_scoped_release>(), "cv waitFor")
-    .def("notifyOne", &ConditionVariable::notifyOne) // Not sure if I need to release the GIL here as this function also uses the intern mutex lock
-    .def("notifyAll", &ConditionVariable::notifyAll) // Same here
+    .def("notifyOne", &ConditionVariable::notifyOne)
+    .def("notifyAll", &ConditionVariable::notifyAll)
     .def("getWaitingTaskCount", &ConditionVariable::getWaitingTaskCount);
 }
 
diff --git a/include/taskr/common.hpp b/include/taskr/common.hpp
@@ -49,9 +49,9 @@ namespace taskr
 {
 
 /**
- * A unique identifier (label) for an object
+ * A unique identifier for an object (task)
  */
-typedef HiCR::tasking::uniqueId_t label_t;
+typedef HiCR::tasking::uniqueId_t taskId_t;
 
 /**
  * Type for a locally-unique worker identifier
diff --git a/include/taskr/runtime.hpp b/include/taskr/runtime.hpp
@@ -409,10 +409,10 @@ class Runtime
   }
 
   /**
-   * This function informs TaskR that a certain task (with a given unique label) has finished
+   * This function informs TaskR that a certain task (with a given unique ID) has finished
    * If this task the last remaining dependency for a given task, now the task may be scheduled for execution.
    * 
-   * @param[in] task Label of the task to report as finished
+   * @param[in] task The task to report as finished
    */
   __INLINE__ void setFinishedTask(taskr::Task *const task)
   {
diff --git a/include/taskr/task.hpp b/include/taskr/task.hpp
diff --git a/include/taskr/taskImpl.hpp b/include/taskr/taskImpl.hpp

Original file line number	Diff line number	Diff line change
`@@ -54,17 +54,17 @@ class Task final : public taskr::Task`
`54`	`54`	`const auto hashResult = hasher(buffer);`
`55`	`55`
`56`	`56`	`// find if this hash already exists in the hashmap if not: add it`
`57`		`- size_t tasklabel;`
	`57`	`+ size_t taskId;`
`58`	`58`	`auto it = taskid_hashmap.find(hashResult);`
`59`	`59`
`60`	`60`	`if (it == taskid_hashmap.end())`
`61`	`61`	`{`
`62`		`- tasklabel = taskid_hashmap.size();`
	`62`	`+ taskId = taskid_hashmap.size();`
`63`	`63`
`64`		`- taskid_hashmap[hashResult] = tasklabel;`
	`64`	`+ taskid_hashmap[hashResult] = taskId;`
`65`	`65`	`}`
`66`		`- else { tasklabel = it->second; }`
	`66`	`+ else { taskId = it->second; }`
`67`	`67`
`68`		`- return tasklabel;`
	`68`	`+ return taskId;`
`69`	`69`	`}`
`70`	`70`	`};`