Merge branch 'master' into rc

Author: elliottslaughter

runtime/legion/api/argument_map.cc

@@ -515,7 +515,8 @@ namespace Legion {
       }
       else
         future_map = ctx->construct_future_map(
-            point_set->handle, arguments, provenance, true /*internal*/);
+            point_set->handle, arguments, provenance, false /*collective*/,
+            0 /*sharding id*/, true /*internal*/, false /*check space*/);
       equivalent = true;      // mark that these are equivalent
       dependent_futures = 0;  // reset this for the next unpack
       return future_map;

runtime/legion/kernel/runtime.cc

@@ -113,6 +113,16 @@ namespace Legion {
     void LgEvent::end_wait(Context ctx, bool from_application) const
     //--------------------------------------------------------------------------
     {
+      if ((runtime->profiler != nullptr) && (implicit_profiler == nullptr) &&
+          implicit_fevent.exists())
+      {
+        // This can occur when a (meta-)task that was previously running,
+        // but waited on a event, and Realm wakes it up on a new kernel
+        // thread that has never run a task before and therefore hasn't
+        // been assigned an implicit profiler yet
+        implicit_profiler =
+            runtime->profiler->find_or_create_profiling_instance();
+      }
       if (ctx != nullptr)
         ctx->end_wait(*this, from_application);
       else if (

runtime/legion/tools/profiler.cc

@@ -237,7 +237,7 @@ namespace Legion {
         owner(own)
     //--------------------------------------------------------------------------
     {
-      if (external_fevent.exists())
+      if (external_fevent.exists() && !implicit_fevent.exists())
         implicit_fevent = external_fevent;
     }
 

tools/legion_prof_rs/src/backend/analyze.rs

@@ -1,7 +1,7 @@
 use std::cmp::{Reverse, max, min};
 use std::collections::BTreeMap;
 
-use crate::state::{Proc, ProcEntry, ProcEntryKind, State, Timestamp};
+use crate::state::{Container, Proc, ProcEntry, ProcEntryKind, State, Timestamp};
 
 #[derive(Debug, Copy, Clone)]
 struct ProcEntryStats {
@@ -61,11 +61,7 @@ fn accumulate_statistics(
         for wait in &entry.waiters.wait_intervals {
             let waiting = wait.end - wait.start;
             assert!(waiting <= total);
-            if waiting <= total {
-                total -= waiting;
-            } else {
-                total = Timestamp::ZERO;
-            }
+            total -= waiting;
         }
         stats.running_time += total;
     }
@@ -141,11 +137,27 @@ fn print_statistics(
                         state.meta_variants.get(variant_id).unwrap().name
                     );
                 }
-                ProcEntryKind::MapperCall(_, _, call_kind) => {
-                    println!(
-                        "      Mapper Call {}",
-                        state.mapper_call_kinds.get(call_kind).unwrap().name
-                    );
+                ProcEntryKind::MapperCall(mapper_id, proc_id, call_kind) => {
+                    let proc_name = if let Some(proc) = state.procs.get(&proc_id) {
+                        &proc.name(state)
+                    } else {
+                        "NO_PROC"
+                    };
+                    if let Some(mapper) = state.mappers.get(&(*mapper_id, *proc_id)) {
+                        println!(
+                            "      Mapper Call {} for mapper {} on proc {}",
+                            state.mapper_call_kinds.get(call_kind).unwrap().name,
+                            mapper.name,
+                            proc_name
+                        );
+                    } else {
+                        println!(
+                            "      Mapper Call {} for mapper {} on proc {}",
+                            state.mapper_call_kinds.get(call_kind).unwrap().name,
+                            mapper_id.0,
+                            proc_name
+                        );
+                    }
                 }
                 ProcEntryKind::RuntimeCall(call_kind) => {
                     println!(