How can I do this without using OMP TASK? - multithreading

Question

I have an array of 4 tasks called array. It is declared as following:
type(tcb),dimension(4)::arrray 
with:
type:: tcb !> new type task control block
procedure(my_interface),NOPASS,pointer:: f_ptr => null() !< the function pointer
type(variables)::variables !< the variables
integer :: state !< the task state
end type tcb
I have only 2 threads to execute these 4 tasks. I want to avoid using !$OMP TASK.
When I used the tasking construct, I got something like this:
type(tcb),dimension(4),intent(inout)::array !< the array of tasks
integer,intent(in)::ff !< the counter
type(tcb)::self !< self
type(variables),intent(inout)::var !< the variables
!OpenMP variables
integer::num_thread !< the rank of the thread
integer::nthreads !< the number of threads
integer:: OMP_GET_THREAD_NUM !< function to get the rank of the thread
integer::OMP_GET_NUM_THREADS !< function to get the number of threads
!=======================================================================================================================================================
!$OMP PARALLEL PRIVATE(num_thread,nthreads,ff) &
!$OMP SHARED(array)
num_thread=OMP_GET_THREAD_NUM() !< le rang du thread
nthreads=OMP_GET_NUM_THREADS() !< le nombre de threads
!$OMP MASTER
do ff=1,3
!$OMP TASK SHARED(array) IF ((num_thread .ne. 0) .and. (num_thread .ne. 1))
call array(ff)%f_ptr(self,var)
!$OMP END TASK
end if
end do
!$OMP TASKWAIT
!$OMP END MASTER
Do you have any idea ? I want that when a thread finishes running a task, it moves directly to the next available task. It shouldn't wait for the other thread to finish.
How can I do it without using the OMP Tasking ?
I want to schedule the tasks alone not with the help of OpenMP. Is it possible ?

Answer 1

Using OpenMP directives you have created a serial program. Here, I try to explain why. The task creation in your code is inside the MASTER region, in which the num_thread is always zero. From specification:
Thread number: A number that the OpenMP implementation assigns to an
OpenMP thread. For threads within the same team, zero identifies
the master thread and consecutive numbers identify the other threads
of this team.
Therefore the ((num_thread .ne. 0) .and. (num_thread .ne. 1)) expression is always false. Again from specification:
When an if clause is present on a task construct, and the if
clause expression evaluates to false, an undeferred task is generated,
and the encountering thread must suspend the current task region, for
which execution cannot be resumed until the generated task is
completed.
So, it means that you have a serial program. The master threads execution is suspend until a task is finished. Although it is not required (or specified) by the standard, in practice it means that your program will run on the master thread only, the other threads are just waiting. So, you have to remove the if clause and your program will be concurrent.
If you wish to run those tasks on 2 threads only, you have to use the num_threads(2) clause on parallel region to explicitly specify it.
EDIT: To answer your question, using tasks is a good choice, but if the number of tasks are known at compile time you can use sections as well
!$omp sections
!$omp section
! first job is here
!$omp section
! second job is here
...
!$omp end sections
ps: you mentioned 4 tasks, but your code only generates 3 of them..
ps2: end if is not needed.