Build spot and loop-report without MPI (LLNL#394)

* Move create_filename() into utils

* Add serial SpotController

* Re-add loop-report

* Simplify CustomOutputController default flush

* Fixes and cleanup

* Fix warnings

* Test loop-report and spot always

* Fix loop-report output option

Author: daboehme

include/caliper/ChannelController.h

@@ -40,9 +40,6 @@ class ChannelController
 
 protected:
 
-    /// \brief Return the underlying %Caliper channel object.
-    Channel*      channel();
-
     /// \brief Provide access to the underlying config map.
     ///
     ///   Note that configuration modifications are only effective before
@@ -62,6 +59,9 @@ class ChannelController
 
 public:
 
+    /// \brief Return the underlying %Caliper channel object.
+    Channel*      channel();
+
     /// \brief Create and activate the %Caliper channel,
     ///   or reactivate a stopped %Caliper channel.
     void start();

include/caliper/CollectiveOutputChannel.h

@@ -9,15 +9,14 @@
 #ifndef CALI_COLLECTIVE_CHANNEL_CONTROLLER_H
 #define CALI_COLLECTIVE_CHANNEL_CONTROLLER_H
 
-#include "ChannelController.h"
-
 #include <mpi.h>
 
 #include <memory>
 
 namespace cali
 {
 
+class ChannelController;
 class OutputStream;
 
 /// \class CollectiveOutputChannel
@@ -30,12 +29,15 @@ class OutputStream;
 /// communicator and/or C++ I/O stream.
 ///
 /// \sa make_collective_output_channel()
-class CollectiveOutputChannel : public cali::ChannelController
+class CollectiveOutputChannel
 {
 public:
 
-    /// \brief Create channel controller with given name, flags, and config.
-    CollectiveOutputChannel(const char* name, int flags, const config_map_t& cfg);
+    /// \brief Start the underlying channel
+    virtual void start() = 0;
+
+    /// \brief Stop/pause the underlying channel
+    virtual void stop() = 0;
 
     /// \brief Try to create a CollectiveOutputChannel based on the
     ///   configuration in \a from.
@@ -78,17 +80,6 @@ class CollectiveOutputChannel : public cali::ChannelController
     /// \param comm MPI communicator
     virtual void collective_flush(MPI_Comm comm);
 
-    /// \brief Aggregate and flush data.
-    ///
-    /// The default behavior aggregates data across all ranks in the
-    /// \c MPI_COMM_WORLD communicator and writes it to stdout. This is a
-    /// collective operation on \c MPI_COMM_WORLD.
-    ///
-    /// If MPI was never initialized, the calling process will aggregate and
-    /// write its local data. If MPI was initialized but has been finalized,
-    /// the function does nothing.
-    virtual void flush() override;
-
     virtual ~CollectiveOutputChannel();
 };
 

src/caliper/CMakeLists.txt

@@ -5,6 +5,7 @@ set(CALIPER_RUNTIME_SOURCES
   Caliper.cpp
   ChannelController.cpp
   ConfigManager.cpp
+  CustomOutputController.cpp
   MemoryPool.cpp
   MetadataTree.cpp
   RegionProfile.cpp
@@ -30,6 +31,7 @@ list(APPEND CALIPER_SERIAL_OBJS
   caliper/setup_serial.cpp)
 
 if (CALIPER_HAVE_MPI)
+  target_include_directories(caliper-runtime PRIVATE ${MPI_CXX_INCLUDE_PATH})
   list(APPEND CALIPER_ALL_OBJS
     caliper/machine_mpi.cpp
     caliper/setup_mpi.cpp)

src/caliper/CustomOutputController.cpp

@@ -0,0 +1,73 @@
+// Copyright (c) 2021, Lawrence Livermore National Security, LLC.
+// See top-level LICENSE file for details.
+
+#include "CustomOutputController.h"
+
+#include "caliper/Caliper.h"
+
+#include "caliper/common/Log.h"
+#include "caliper/common/OutputStream.h"
+
+using namespace cali;
+using namespace cali::internal;
+
+CustomOutputController::FlushFn CustomOutputController::s_flush_fn { nullptr };
+
+void
+CustomOutputController::set_flush_fn(FlushFn flush_fn)
+{
+    s_flush_fn = flush_fn;
+}
+
+//
+// --- CustomOutputController::Comm
+//
+
+CustomOutputController::Comm::~Comm()
+{
+}
+
+int CustomOutputController::Comm::rank() const
+{
+    return 0;
+}
+
+int CustomOutputController::Comm::bcast_int(int val) const
+{
+    return val;
+}
+
+std::string CustomOutputController::Comm::bcast_str(const std::string& val) const
+{
+    return val;
+}
+
+void CustomOutputController::Comm::cross_aggregate(CaliperMetadataDB& db, Aggregator& agg) const
+{
+    // no-op
+}
+
+void CustomOutputController::flush()
+{
+    auto chn = channel();
+
+    if (!chn)
+        return;
+
+    if (s_flush_fn) {
+        (*s_flush_fn)(this);
+    } else {
+        Log(2).stream() << chn->name()
+                        << ": CustomOutputController::flush(): using serial flush"
+                        << std::endl;
+
+        Comm comm;
+        OutputStream stream;
+
+        collective_flush(stream, comm);
+    }
+}
+
+CustomOutputController::CustomOutputController(const char* name, int flags, const config_map_t& initial_cfg)
+    : ChannelController(name, flags, initial_cfg)
+{ }

src/caliper/CustomOutputController.h

@@ -0,0 +1,75 @@
+// Copyright (c) 2021, Lawrence Livermore National Security, LLC.
+// See top-level LICENSE file for details.
+
+#pragma once
+
+#ifndef CALI_CUSTOM_OUTPUT_CONTROLLER_H
+#define CALI_CUSTOM_OUTPUT_CONTROLLER_H
+
+#include "caliper/ChannelController.h"
+
+#include <string>
+
+namespace cali
+{
+
+class Aggregator;
+class CaliperMetadataDB;
+class OutputStream;
+
+namespace internal
+{
+
+///   \brief Base class for a channel controller implementing a custom communication
+/// scheme.
+///
+/// Lets us switch communication between serial, MPI, and potentially other
+/// communication protocols.
+class CustomOutputController : public cali::ChannelController
+{
+    typedef void (*FlushFn)(CustomOutputController*);
+    static FlushFn s_flush_fn;
+
+public:
+
+    /// \brief Set the flush function for MPI (or other) communication
+    ///   protocols.
+    ///
+    /// This callback lets us specify alternate flush implementations, in
+    /// particular for MPI. The MPI build sets this in mpi_setup.cpp.
+    static void set_flush_fn(FlushFn);
+
+    ///   \brief Base class for the communication protocol. Implements serial
+    /// (no-op) communication.
+    class Comm {
+    public:
+
+        virtual ~Comm();
+
+        virtual int rank() const;
+
+        virtual int         bcast_int(int val) const;
+        virtual std::string bcast_str(const std::string& str) const;
+
+        virtual void cross_aggregate(CaliperMetadataDB& db, Aggregator& agg) const;
+    };
+
+    ///   \brief Override to implement custom collective flush operation using
+    /// \a comm and \a stream.
+    virtual void collective_flush(OutputStream& stream, Comm& comm) = 0;
+
+    /// \brief Perform default flush (no user-provided comm or stream)
+    ///
+    ///   Invokes s_flush_fn() if set, which in turn invokes the collective_flush()
+    /// method overriden by derived classes. The s_flush_fn() specifies the
+    /// communication protocol, e.g. MPI. The default implementation is serial.
+    virtual void flush() override;
+
+    CustomOutputController(const char* name, int flags, const config_map_t& initial_config);
+};
+
+} // namespace internal
+
+} // namespace cali
+
+#endif

src/caliper/controllers/CMakeLists.txt

@@ -4,8 +4,10 @@ set(CALIPER_CONTROLLERS_SOURCES
   controllers/CudaActivityReportController.cpp
   controllers/HatchetRegionProfileController.cpp
   controllers/HatchetSampleProfileController.cpp
+  controllers/LoopReportController.cpp
   controllers/OpenMPReportController.cpp
   controllers/RuntimeReportController.cpp
+  controllers/SpotController.cpp
   controllers/controllers.cpp
   controllers/util.cpp)