Merge pull request #12183 from ronawho/fence-unordered-ops-task-end

Automatically fence unordered operations at task termination

[reviewed by @gbtitus and @mppf]

Unordered operations must be fenced before operations are guaranteed to be
completed. Previously, the only way to do this was with explicit fences. This
adds implicit/automatic fences to task termination to simplify common cases.

For bale-histogram, previously we did something like:

```chpl
forall r in rindex do
  A[r].addBuff(1);
flushAtomicBuff();
```

and now we can simply write:

```chpl
forall r in rindex do
  A[r].addBuff(1);
```

To support that, this PR adds a new comm layer routine `chpl_comm_task_end`,
which is a hook that's called on task completion. For ugni we use this to flush
any operations that were buffered as part of an unordered op, and it's
currently a no-op for other comm layers. A more elegant solution might have
been to have some sort of callback interface where module code could register
things to be done on task completion (similar to what we have in the runtime)
but I wasn't quite sure how to do that cheaply and cleanly.

Since we're now calling these fencing operations on every task join, we need
them to be as fast as possible, especially in the no-op case. To support that,
this adds very fast per-task fences. For tasking layers where tasks can't
migrate between threads, this is a non-atomic conditional in the no-op case so
there shouldn't be any noticeable overhead. If there are pending operations, we
only have to lock the current thread so there shouldn't be any contention.

Closes #12065
Closes #12066

Author: ronawho

modules/internal/ChapelBase.chpl

@@ -1007,6 +1007,8 @@ module ChapelBase {
   pragma "down end count fn"
   proc _downEndCount(e: _EndCount, err: unmanaged Error) {
     chpl_save_task_error(e, err);
+    extern proc chpl_comm_task_end(): void;
+    chpl_comm_task_end();
     // inform anybody waiting that we're done
     e.i.sub(1, memory_order_release);
   }

runtime/include/chpl-cache.h

@@ -34,7 +34,9 @@ extern const int CHPL_CACHE_REMOTE;
 static inline
 int chpl_cache_enabled(void)
 {
-  return CHPL_CACHE_REMOTE && chpl_task_supportsRemoteCache();
+  // The remote cache uses thread local storage, so if tasks can migrate
+  // between threads we lose out ability to correctly fence.
+  return CHPL_CACHE_REMOTE && !chpl_task_canMigrateThreads();
 }
 
 

runtime/include/chpl-comm-native-atomics.h

@@ -163,5 +163,6 @@ DECL_CHPL_COMM_ATOMIC_BINARY(sub, real32)
 DECL_CHPL_COMM_ATOMIC_BINARY(sub, real64)
 
 void chpl_comm_atomic_unordered_fence(void);
+void chpl_comm_atomic_unordered_task_fence(void);
 
 #endif // _chpl_comm_native_atomics_h_

runtime/include/chpl-comm.h

@@ -492,6 +492,10 @@ int chpl_comm_numPollingTasks(void);
 // an atomic variable for other tasks to finish).
 void chpl_comm_make_progress(void);
 
+// This is a hook that's called when a task is ending. It allows for things
+// like say flushing task private buffers.
+void chpl_comm_task_end(void);
+
 //
 // Comm diagnostics stuff
 //

runtime/include/chpl-tasks.h

@@ -283,20 +283,6 @@ chpl_task_ChapelData_t* chpl_task_getChapelData(void)
 }
 
 
-//
-// Can this tasking layer support remote caching?
-//
-// (In practice this answers: "Are tasks bound to specific pthreads
-// or, if not, does the tasking layer make memory consistency calls
-// whenever it might move a task from one pthread to another?"  Remote
-// caching uses pthread-specific data (TLS) extensively, so it turns
-// itself off when it's used with a tasking layer that can't support
-// that.)
-//
-#ifndef CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL
-int chpl_task_supportsRemoteCache(void);
-#endif
-
 //
 // Returns the maximum width of parallelism the tasking layer expects
 // to be able to provide on the calling (sub)locale.  With some
@@ -366,6 +352,22 @@ uint32_t chpl_task_isFixedThread(void) {
   return CHPL_TASK_IMPL_IS_FIXED_THREAD();
 }
 
+//
+// If the tasking layer will always execute tasks on the same thread
+// they started on, this returns true.  Otherwise, it returns false.
+// For example CHPL_TASKS=fifo a task is a thread, so tasks can't
+// migrate.  For CHPL_TASKS=qthreads some schedulers support
+// work-stealing where tasks can be stolen and moved to a diferent
+// then they started on.
+//
+#ifndef CHPL_TASK_IMPL_CAN_MIGRATE_THREADS
+#define CHPL_TASK_IMPL_CAN_MIGRATE_THREADS() 1
+#endif
+static inline
+uint32_t chpl_task_canMigrateThreads(void) {
+  return CHPL_TASK_IMPL_CAN_MIGRATE_THREADS();
+}
+
 //
 // returns the total number of threads that currently exist, whether running,
 // blocked, or idle

runtime/include/comm/ugni/chpl-comm-impl.h

@@ -66,6 +66,7 @@ void chpl_comm_get_unordered(void *addr, c_nodeid_t node, void* raddr,
                              int ln, int32_t fn);
 
 void chpl_comm_get_unordered_fence(void);
+void chpl_comm_get_unordered_task_fence(void);
 
 //
 // Internal statistics gathering and reporting.

runtime/include/tasks/fifo/chpl-tasks-impl.h

@@ -126,16 +126,7 @@ c_sublocid_t chpl_task_getRequestedSubloc(void) {
   return c_sublocid_any;
 }
 
-
-#ifdef CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL
-#error "CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL is already defined!"
-#else
-#define CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL 1
-#endif
-static inline
-int chpl_task_supportsRemoteCache(void) {
-  return 1;
-}
+#define CHPL_TASK_IMPL_CAN_MIGRATE_THREADS() 0
 
 #ifdef __cplusplus
 } // end extern "C"

runtime/include/tasks/qthreads/chpl-tasks-impl.h

@@ -236,22 +236,9 @@ void chpl_task_setSubloc(c_sublocid_t full_subloc)
     chpl_task_impl_getFixedNumThreads()
 uint32_t chpl_task_impl_getFixedNumThreads(void);
 
-
 #define CHPL_TASK_IMPL_IS_FIXED_THREAD() (qthread_shep() != NO_SHEPHERD)
 
-
-//
-// Can we support remote caching?
-//
-#ifdef CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL
-#error "CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL is already defined!"
-#else
-#define CHPL_TASK_SUPPORTS_REMOTE_CACHE_IMPL_DECL 1
-#endif
-static inline
-int chpl_task_supportsRemoteCache(void) {
-  return CHPL_QTHREAD_SUPPORTS_REMOTE_CACHE;
-}
+#define CHPL_TASK_IMPL_CAN_MIGRATE_THREADS() CHPL_QTHREAD_TASKS_CAN_MIGRATE_THREADS
 
 #ifdef __cplusplus
 } // end extern "C"

runtime/src/comm/gasnet/comm-gasnet.c

@@ -1586,6 +1586,7 @@ void chpl_comm_make_progress(void)
   gasnet_AMPoll();
 }
 
+void chpl_comm_task_end(void) { }
 
 void chpl_startVerboseComm() {
   chpl_verbose_comm = 1;

runtime/src/comm/none/comm-none.c

@@ -219,9 +219,9 @@ void chpl_comm_execute_on_fast(c_nodeid_t node, c_sublocid_t subloc,
 
 int chpl_comm_numPollingTasks(void) { return 0; }
 
-void chpl_comm_make_progress(void)
-{
-}
+void chpl_comm_make_progress(void) { }
+
+void chpl_comm_task_end(void) { }
 
 void chpl_startVerboseComm() { }
 void chpl_stopVerboseComm() { }