bosilca
commented
1 year ago - A correct execution of a correct implementation should not depend on the number of compute resource used. Once the DAG of tasks is built, there are clear way of keeping the result consistent, and I'm pretty sure we follow them. I run your core with the current master version (changing the number of core to -1 to enable parsec detection) and I get correct results.
Hello from task 0 and outputs 100 Hello from task 2, reads 100 , and outputs 200 Hello from task 1, reads 100 , and outputs 100 Hello from task 3, reads 200 , and outputs 600 Hello from task 4, reads 600 , and outputs 2400 Hello from task 5, reads 2400 , and outputs 12000
Passed the computation
The order of the output is scrambled, but that's OK for as long as the values are correct (which they seem to be).
- Once a task is taken in consideration by the runtime, it can be started right away if all inputs are available, or be delayed until they become available. If I correctly understand your question, parsec does not need to build the entire graph of tasks before starting to execute them. In fact it depends the order in which you construct the graph and when you start the runtime. To give an example if I build a parsec context, then insert tasks and then start the context, then I first build the DAG and only then I will start executing it. At the contrary if I build a parsec context, then start it and then add tasks, then tasks will start execution (or at least be considered as ready) as soon as all their input are available.
QingleiCao
cheng-hsiang-chiu
devreal
Dear PaRSEC developers,
Recently, I am using PaRSEC for a mini project and have some questions regarding dynamic task discovery(DTD) paradigm. I use DTD to do some simple works. Assume there is an array of six integers called results. The operations on the array is shown in the following figure,
Task 0 does some computations and writes the value to results[0]. Task 1 reads results[0], does some computations and writes the value to results[1]. Task 2 reads results[1], does some computations and writes the value to results[2]. Task 3 to task 5 follow the same operations. That is, except task 0, all tasks(task 1 to task 5) first read results[index-1] and write to results[index], where index is 1 to 5. The task dependencies are: task 0->task 1->task 2->task 3->task 4->task 5
To implement the above work, I write the following code to create six tasks,
for (int index=0; index<6; ++index){ if(index==0){ parsec_dtd_insert_task( dtd_tp, task_0, 0, PARSEC_DEC_CPU, "task_0", sizeof(int), &index, PARSEC_VALUE, sizeof(int), &results[0], PARSEC_OUTPUT|PARSEC_REF, PARSEC_DTD_ARG_END ); } else{ parsec_dtd_insert_task( dtd_tp, tasks, 0, PARSEC_DEC_CPU, "tasks", sizeof(int), &index, PARSEC_VALUE, sizeof(int), &reslts[index-1], PARSEC_INPUT|PARSEC_REF, sizeof(int*), &results[index], PARSEC_OUTPUT|PARSEC_REF, PARSEC_DTD_ARG_END ); } }
The whole implementation is the attached dtd.txt file.
The following are my questions: Q1. My implementation(dtd.txt) gives me correct results as the sequential implementation(lines 135:143 in dtd.txt) with one core. However, if I specify more core counts, I got wrong results sometimes. How could I fix it? The work runs on a single machine not on a distributed environment.
Q2. When inserting tasks using parsec_dtd_insert_task, PaRSEC will dynamically discover the tasks and figure out the dependencies based on the operation types(e.g. INPUT and OUTPUT). Once a task is created and inserted in parsec taskpool, does PaRSEC runtime immediately schedules the task? For example, in my example, deos PaRSEC immediately schedule task 0 because task 0 has no dependency and then schedule task 1 after task 0 is finished? Or does PaRSEC runtime build a DAG of the six tasks(task 0->task 1->task 2->task 3->task 4->task 5) first and then schedule the tasks?
Thank you so much. dtd.txt