Fixes a memory leak related to task dependencies (patch from Alex Duran)

[AndreyChurbanov]

Summary

Fixes a memory leak related to task dependencies as there was no call to free resources from implicit tasks

[Eugene.Zelenko]

Please run Clang-format over changed code.

[AndreyChurbanov]

Addressed Eugene's comment - passed new code through clang-format.

[Hahnfeld]

In D25504#568429, @Eugene.Zelenko wrote:

Please run Clang-format over changed code.

My last information is that the reformatting is still outstanding which means that clang-format will currently lead to inconsistencies.

runtime/src/kmp_taskdeps.cpp

130–151

For example these two functions will be heavily reformatted for no actual benefit

[AndreyChurbanov]

Adjusted output of clang-format to match the style of surrounded code - 4 space indent, function name at the start of line.

[tlwilmar]

LGTM.

Clang-format can wait, as the clang-formatting of entire code base is in the works.

[AndreyChurbanov]

committed r285283.

[pawosm01]

Segfault at the fery first line of kmp_dephash_free_entries() while trying to dereference a pointer passed as a parameter. The pointer to memory allocated by kmp_fast_allocate() became invalid after __kmp_free_fast_memory() was called.

runtime/src/kmp_runtime.c

5704

See comment below (line 5757)

5757

Calling this after __kmp_free_fast_memory( thread ); was called in line 5704 causes crash on sparselu_taskdep benchmark from kastors suite.

[Hahnfeld]

Accepting to allow closing - should have been fixed with rL287551

[Hahnfeld]

Hmm, doesn't work. Maybe @pawosm01 has to accept and close this...

runtime/src/kmp.h

 extern void __kmp_push_current_task_to_thread( kmp_info_t *this_thr,
                   kmp_team_t *team, int tid );
 extern void __kmp_pop_current_task_from_thread( kmp_info_t *this_thr );
 extern kmp_task_t* __kmp_task_alloc( ident_t *loc_ref, kmp_int32 gtid,
   kmp_tasking_flags_t *flags, size_t sizeof_kmp_task_t, size_t sizeof_shareds,
   kmp_routine_entry_t task_entry );
 extern void __kmp_init_implicit_task( ident_t *loc_ref, kmp_info_t *this_thr,
                   kmp_team_t *team, int tid, int set_curr_task );
+extern void __kmp_finish_implicit_task ( kmp_info_t *this_thr );
+extern void __kmp_free_implicit_task ( kmp_info_t *this_thr );
 
 int __kmp_execute_tasks_32(kmp_info_t *thread, kmp_int32 gtid, kmp_flag_32 *flag, int final_spin,
                            int *thread_finished,
 #if USE_ITT_BUILD
                            void * itt_sync_obj,
 #endif /* USE_ITT_BUILD */
                            kmp_int32 is_constrained);
 int __kmp_execute_tasks_64(kmp_info_t *thread, kmp_int32 gtid, kmp_flag_64 *flag, int final_spin,

 KMP_EXPORT void __kmpc_end_taskgroup( ident_t * loc, int gtid );
 
 KMP_EXPORT kmp_int32 __kmpc_omp_task_with_deps ( ident_t *loc_ref, kmp_int32 gtid, kmp_task_t * new_task,
                                                  kmp_int32 ndeps, kmp_depend_info_t *dep_list,
                                                  kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list );
 KMP_EXPORT void __kmpc_omp_wait_deps ( ident_t *loc_ref, kmp_int32 gtid, kmp_int32 ndeps, kmp_depend_info_t *dep_list,
                                           kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list );
 extern void __kmp_release_deps ( kmp_int32 gtid, kmp_taskdata_t *task );
+extern void __kmp_dephash_free_entries ( kmp_info_t *thread, kmp_dephash_t *h  );
+extern void __kmp_dephash_free ( kmp_info_t *thread, kmp_dephash_t *h  );
 
 extern kmp_int32 __kmp_omp_task( kmp_int32 gtid, kmp_task_t * new_task, bool serialize_immediate );
 
 KMP_EXPORT kmp_int32 __kmpc_cancel(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind);
 KMP_EXPORT kmp_int32 __kmpc_cancellationpoint(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind);
 KMP_EXPORT kmp_int32 __kmpc_cancel_barrier(ident_t* loc_ref, kmp_int32 gtid);
 KMP_EXPORT int __kmp_get_cancellation_status(int cancel_kind);
 

runtime/src/kmp_runtime.c

if ( ! is_root ) {
 
         // Decrement # of [worker] threads in the pool.
         KMP_DEBUG_ASSERT( __kmp_thread_pool_nth > 0 );
         --__kmp_thread_pool_nth;
     }; // if
 
     // Free the fast memory for tasking
     #if USE_FAST_MEMORY
         __kmp_free_fast_memory( thread );
     #endif /* USE_FAST_MEMORY */
 
     __kmp_suspend_uninitialize_thread( thread );
 
     KMP_DEBUG_ASSERT( __kmp_threads[ gtid ] == thread );
     TCW_SYNC_PTR(__kmp_threads[gtid], NULL);
 
     -- __kmp_all_nth;

 
 #if KMP_AFFINITY_SUPPORTED
     if ( thread->th.th_affin_mask != NULL ) {
         KMP_CPU_FREE( thread->th.th_affin_mask );
         thread->th.th_affin_mask = NULL;
     }; // if
 #endif /* KMP_AFFINITY_SUPPORTED */
 
+    __kmp_free_implicit_task( thread );
     __kmp_reap_team( thread->th.th_serial_team );
     thread->th.th_serial_team = NULL;
     __kmp_free( thread );
 
     KMP_MB();
 
 } // __kmp_reap_thread
 

 }
 
 void
 __kmp_run_after_invoked_task( int gtid, int tid, kmp_info_t *this_thr,
   kmp_team_t *team )
 {
     if( __kmp_env_consistency_check )
         __kmp_pop_parallel( gtid, team->t.t_ident );
+
+    __kmp_finish_implicit_task( this_thr );
 }
 
 int
 __kmp_invoke_task_func( int gtid )
 {
     int          rc;
     int          tid      = __kmp_tid_from_gtid( gtid );
     kmp_info_t  *this_thr = __kmp_threads[ gtid ];

runtime/src/kmp_taskdeps.cpp

__kmp_dephash_create ( kmp_info_t *thread, kmp_taskdata_t *current_task )
 
     size_t h_size;
 
     if ( current_task->td_flags.tasktype == TASK_IMPLICIT )
         h_size = KMP_DEPHASH_MASTER_SIZE;
     else
         h_size = KMP_DEPHASH_OTHER_SIZE;
 
-    kmp_int32 size = h_size * sizeof(kmp_dephash_entry_t) + sizeof(kmp_dephash_t);
+    kmp_int32 size = h_size * sizeof(kmp_dephash_entry_t *) + sizeof(kmp_dephash_t);
 
 #if USE_FAST_MEMORY
     h = (kmp_dephash_t *) __kmp_fast_allocate( thread, size );
 #else
     h = (kmp_dephash_t *) __kmp_thread_malloc( thread, size );
 #endif
     h->size = h_size;
 
 #ifdef KMP_DEBUG
     h->nelements = 0;
     h->nconflicts = 0;
 #endif
     h->buckets = (kmp_dephash_entry **)(h+1);
 
     for ( size_t i = 0; i < h_size; i++ )
         h->buckets[i] = 0;
 
     return h;
 }
 
-static void
-__kmp_dephash_free ( kmp_info_t *thread, kmp_dephash_t *h )
+void 
+__kmp_dephash_free_entries ( kmp_info_t *thread, kmp_dephash_t *h  )
 {
     for ( size_t i=0; i < h->size; i++ ) {
         if ( h->buckets[i] ) {
             kmp_dephash_entry_t *next;
             for ( kmp_dephash_entry_t *entry = h->buckets[i]; entry; entry = next ) {
                 next = entry->next_in_bucket;
                 __kmp_depnode_list_free(thread,entry->last_ins);
                 __kmp_node_deref(thread,entry->last_out);
 #if USE_FAST_MEMORY
                 __kmp_fast_free(thread,entry);
 #else
                 __kmp_thread_free(thread,entry);
 #endif
             }
-        }
-    }
+      h->buckets[i] = 0;
+        }
+
+void 
+__kmp_dephash_free ( kmp_info_t *thread, kmp_dephash_t *h )
+{
+    __kmp_dephash_free_entries(thread,h);
 #if USE_FAST_MEMORY
     __kmp_fast_free(thread,h);
 #else
     __kmp_thread_free(thread,h);
 #endif
 }
 
 static kmp_dephash_entry *
 __kmp_dephash_find ( kmp_info_t *thread, kmp_dephash_t *h, kmp_intptr_t addr )
 {
     kmp_int32 bucket = __kmp_dephash_hash(addr,h->size);
 
     kmp_dephash_entry_t *entry;
     for ( entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket )

runtime/src/kmp_tasking.c

#endif
     task->td_flags.team_serial = ( team->t.t_serialized ) ? 1 : 0;
 
     task->td_flags.started     = 1;
     task->td_flags.executing   = 1;
     task->td_flags.complete    = 0;
     task->td_flags.freed       = 0;
 
 #if OMP_40_ENABLED
-    task->td_dephash = NULL;
     task->td_depnode = NULL;
 #endif
 
     if (set_curr_task) {  // only do this initialization the first time a thread is created
         task->td_incomplete_child_tasks = 0;
         task->td_allocated_child_tasks  = 0; // Not used because do not need to deallocate implicit task
 #if OMP_40_ENABLED
         task->td_taskgroup = NULL;           // An implicit task does not have taskgroup
+        task->td_dephash = NULL;
 #endif
         __kmp_push_current_task_to_thread( this_thr, team, tid );
     } else {
         KMP_DEBUG_ASSERT(task->td_incomplete_child_tasks == 0);
         KMP_DEBUG_ASSERT(task->td_allocated_child_tasks  == 0);
     }
 
 #if OMPT_SUPPORT
     __kmp_task_init_ompt(task, tid, NULL);
 #endif
 
     KF_TRACE(10, ("__kmp_init_implicit_task(exit): T#:%d team=%p task=%p\n",
                   tid, team, task ) );
 }
 
+
+//----------------------------------------------------------------------------------------------------
+//// __kmp_finish_implicit_task: Release resources associated to implicit tasks at the end of parallel 
+//// regions. Some resources are kept for reuse in the next parallel region.
+////
+//// thread:  thread data structure corresponding to implicit task
+//
+void 
+__kmp_finish_implicit_task ( kmp_info_t *thread  )
+{
+     kmp_taskdata_t *task = thread->th.th_current_task;
+     if ( task->td_dephash ) __kmp_dephash_free_entries(thread,task->td_dephash);
+}
+
+
+//----------------------------------------------------------------------------------------------------
+//// __kmp_free_implicit_task: Release resources associated to implicit tasks when these are destroyed
+//// regions
+////
+//// thread:  thread data structure corresponding to implicit task
+//
+void 
+__kmp_free_implicit_task ( kmp_info_t *thread )
+{
+     kmp_taskdata_t *task = thread->th.th_current_task;
+     if ( task->td_dephash ) __kmp_dephash_free(thread,task->td_dephash);
+     task->td_dephash = NULL;
+}
+
 // Round up a size to a power of two specified by val
 // Used to insert padding between structures co-allocated using a single malloc() call
 static size_t
 __kmp_round_up_to_val( size_t size, size_t val ) {
     if ( size & ( val - 1 ) ) {
         size &= ~ ( val - 1 );
         if ( size <= KMP_SIZE_T_MAX - val ) {
             size += val;    // Round up if there is no overflow.