What is wrong with my implementation to execute tasks using lock routines? - multithreading

Question

I implemented a code that takes an array of function pointers called tasks_ready_master. It contains 20 elements. Each element points to a subroutine (task) and to an integer representing the state of the task.
In order to execute the tasks, I only need to:
call tasks_ready_master(index_element)%f_ptr(self,var)
var represents all the variables needed in the computation.
Since I have 20 tasks, I want to use OpenMP to parallelize this code.
For example:
If we have 4 threads then we will consider 1 master, 1 application master(controls the states of the tasks) and 2 workers executing the tasks. The master should assign the tasks to a free worker.
So I don't want to have the executions in this order (it can be but I shouldn't impose it) : worker 1 (first task) / worker 2 (second task) / worker 1 (third task) / worker 2 (fourth task) / .. /
I want to use the lock routines in order to let the first worker not wait for the second one if he finishes his execution.
We can have the executions in this order (for exemple): worker 1 (first task) / worker 2 (second task) / worker 2 (third task) / worker 2 (fourth task) / worker 1 (fifth task) / .. /
The idea is not to wait for the other worker to finish his execution.
To do that, at each execution, the worker needs to erase (remove) the element(task) from the array. I should imperatively use the lock routines and avoid the OMP_BARRIER.
Here is my implementation:
!Thread Application Master (numero 1)
if (num_thread==1) then
do ff=5,20 ! 16 tasks
if (associated(tasklist_GRAD(ff)%f_ptr) .eqv. .true.) then
tasks_ready_master(ff) = tasklist_GRAD(ff)
tasks_ready_master(ff)%state=STATE_READY
end if
end do
end if
!$OMP BARRIER !!I used this OMP_BARRIER because I had a segmentation fault
if ((num_thread .ne. 0) .and. (num_thread .ne. 1)) then
do ff=1,nthreads-2
if (num_thread==ff+1) then
if (tasks_ready_master(ff+4)%state==STATE_READY) then
tasks_ready_master(ff+4)%state=STATE_RUNNING
free_workers_list(ff)=1
call tasks_ready_master(ff+4)%f_ptr(self,var)
tasks_ready_master(ff+4)%state=STATE_INACTIVE
free_workers_list(ff)=0
call erase(5,s,tasks_ready_master)
end if
end if
end do
do l=nthreads+3,20
call omp_set_lock(lock)
do ff=1,nthreads-2
if (num_thread==ff+1) then
if (free_workers_list(ff)==1) then
call omp_unset_lock(lock)
else
s=size(tasks_ready_master)
if (tasks_ready_master(ff+4)%state==STATE_READY) then
free_workers_list(ff)=1
call tasks_ready_master(5)%f_ptr(self,var)
tasks_ready_master(5)%state=STATE_INACTIVE
free_workers_list(ff)=0
call erase(5,s,tasks_ready_master)
end if
call omp_unset_lock(lock)
end if
end if
end do
end do
end if
For the declaration and initialization part, I did:
INTEGER ::ff,l
type(tcb)::self
type(variables)::var
integer::s
!OpenMP variables
integer::num_thread,nthreads
integer:: OMP_GET_THREAD_NUM, OMP_GET_NUM_THREADS
type(tcb),dimension(20)::tasklist_GRAD,tasks_ready_master
integer::STATUS=0
integer,allocatable,dimension(:)::free_workers_list !liste contenant les nums des threads workers
!Variables pour gestion des threads
INTEGER(KIND=omp_lock_kind), SAVE :: lock
CALL omp_init_lock (lock)
!=======================================================================================================================================================
!$OMP PARALLEL PRIVATE(num_thread,nthreads,ff) &
!$OMP SHARED(tasklist_GRAD,tasks_ready_master,free_workers_list,s)
num_thread=OMP_GET_THREAD_NUM() ! le rang du thread
nthreads=OMP_GET_NUM_THREADS() ! le nombre de threads
For the assignment of the tasks to the array:
!attribution des taches aux listes (20 tasks)
tasklist_GRAD(1)%f_ptr => u_prime_1 !1
tasklist_GRAD(2)%f_ptr => u_prime_droite_1 !2
tasklist_GRAD(3)%f_ptr => u_prime_gauche_1 !3
tasklist_GRAD(4)%f_ptr => u_grad_x_1 !4
tasklist_GRAD(5)%f_ptr => u_prime_2 !5
tasklist_GRAD(6)%f_ptr => taux_ !6
tasklist_GRAD(7)%f_ptr => u_prime_gauche_2 !7
tasklist_GRAD(8)%f_ptr => u_prime_droite_2 !8
tasklist_GRAD(9)%f_ptr => ax_droite_1 !9
tasklist_GRAD(10)%f_ptr => ax_gauche_1 !10
tasklist_GRAD(11)%f_ptr => ux_droite_1 !11
tasklist_GRAD(12)%f_ptr => ux_gauche_1 !12
tasklist_GRAD(13)%f_ptr => u_grad_x_2 !13
tasklist_GRAD(14)%f_ptr => u_prime_gauche_3 !14
tasklist_GRAD(15)%f_ptr => u_prime_droite_3 !15
tasklist_GRAD(16)%f_ptr => ax_droite_2 !16
tasklist_GRAD(17)%f_ptr => ax_gauche_2 !17
tasklist_GRAD(18)%f_ptr => ux_droite_2 !1
tasklist_GRAD(19)%f_ptr => ux_gauche_2 !19
tasklist_GRAD(20)%f_ptr => u_grad_x_3 !20
do ff=1,20
tasklist_GRAD(1)%state=STATE_WAITING
end do
tasklist_GRAD(1)%variables%ww_t => ww
tasklist_GRAD(1)%variables%pas_t => pas
tasklist_GRAD(1)%variables%cpt_t => cpt
tasklist_GRAD(1)%variables%nb_element_t => nb_element
tasklist_GRAD(1)%variables%cpt1_t => cpt1
tasklist_GRAD(1)%variables%dt_t => dt
tasklist_GRAD(1)%variables%dx_t => dx
tasklist_GRAD(1)%variables%p_element_t => p_element
tasklist_GRAD(1)%variables%u_prime_t => u_prime
tasklist_GRAD(1)%variables%u_prime_moins_t => u_prime_moins
tasklist_GRAD(1)%variables%u_prime_plus_t => u_prime_plus
tasklist_GRAD(1)%variables%taux_t => taux
tasklist_GRAD(1)%variables%grad_x_u_t => grad_x_u
tasklist_GRAD(1)%variables%grad_t_u_t => grad_t_u
tasklist_GRAD(1)%variables%grad_x_f_t => grad_x_f
tasklist_GRAD(1)%variables%grad_t_f_t => grad_t_f
tasklist_GRAD(1)%variables%ax_plus_t => ax_plus
tasklist_GRAD(1)%variables%ax_moins_t => ax_moins
tasklist_GRAD(1)%variables%ux_plus_t => ux_plus
tasklist_GRAD(1)%variables%ux_moins_t => ux_moins
tasklist_GRAD(1)%variables%sm_t => sm
tasklist_GRAD(1)%variables%flux_t => flux
tasklist_GRAD(1)%variables%tab0_t => tab0
tasklist_GRAD(1)%variables%tab_t => tab
You can find the whole code on: https://gitlab-sds.insa-cvl.fr/houeslat/stage_hecese/-/blob/master/OpenMP/hecese_OMP/app_management_test.f90.
I am facing a problem since the execution time increased and I feel that I'm executing the tasks not in parallel.