Fix topdown build

src/services/papi/Papi.cpp

@@ -170,8 +170,7 @@ class PapiService
 
             int num = static_cast<int>(p.second->codes.size());
 
-            if (!m_disable_multiplex && cpi
-                && (num > 4 /* magic number for Intel counter support :-( */ || m_enable_multiplex)) {
+            if (m_enable_multiplex) {
                 if (Log::verbosity() >= 2)
                     Log(2).stream() << "papi: Initializing multiplex support for component " << p.first << " ("
                                     << cpi->name << ")" << std::endl;
@@ -498,15 +497,9 @@ const char* PapiService::s_spec = R"json(
  },
  {
   "name": "enable_multiplexing",
-  "description": "Always enable multiplexing",
+  "description": "Enable multiplexing",
   "type": "bool",
-  "value": "False"
- },
- {
-  "name": "disable_multiplexing",
-  "description": "Always disable multiplexing",
-  "type": "bool",
-  "value": "False"
+  "value": "false"
  }
 ]
 }

src/services/topdown/HaswellTopdown.cpp

@@ -1,5 +1,10 @@
 #include "HaswellTopdown.h"
 
+#include "../Services.h"
+
+#include "caliper/common/Log.h"
+#include "caliper/common/RuntimeConfig.h"
+
 #include <algorithm>
 
 namespace cali
@@ -53,9 +58,17 @@ HaswellTopdown::HaswellTopdown(IntelTopdownLevel level)
     )
 {}
 
-bool HaswellTopdown::check_for_disabled_multiplex() const
+bool HaswellTopdown::setup_config(Caliper& c, Channel& channel) const
 {
-    return false;
+    channel.config().set("CALI_PAPI_COUNTERS", m_level == All ? m_all_counters : m_top_counters);
+    channel.config().set("CALI_PAPI_ENABLE_MULTIPLEXING", "true");
+    if (!cali::services::register_service(&c, &channel, "papi")) {
+        Log(0).stream() << channel.name() << ": topdown: Unable to register papi service, skipping topdown"
+            << std::endl;
+        return false;
+    }
+
+    return true;
 }
 
 std::vector<Entry> HaswellTopdown::compute_toplevel(const std::vector<Entry>& rec)

src/services/topdown/HaswellTopdown.h

@@ -16,26 +16,17 @@ class HaswellTopdown : public TopdownCalculator
 
     virtual ~HaswellTopdown() = default;
 
-    virtual bool check_for_disabled_multiplex() const override;
+    virtual bool setup_config(Caliper& c, Channel& channel) const override;
 
     virtual std::vector<Entry> compute_toplevel(const std::vector<Entry>& rec) override;
-
     virtual std::size_t get_num_expected_toplevel() const override;
-
     virtual std::vector<Entry> compute_retiring(const std::vector<Entry>& rec) override;
-
     virtual std::size_t get_num_expected_retiring() const override;
-
     virtual std::vector<Entry> compute_backend_bound(const std::vector<Entry>& rec) override;
-
     virtual std::size_t get_num_expected_backend_bound() const override;
-
     virtual std::vector<Entry> compute_frontend_bound(const std::vector<Entry>& rec) override;
-
     virtual std::size_t get_num_expected_frontend_bound() const override;
-
     virtual std::vector<Entry> compute_bad_speculation(const std::vector<Entry>& rec) override;
-
     virtual std::size_t get_num_expected_bad_speculation() const override;
 };
 

src/services/topdown/IntelTopdown.cpp

@@ -20,6 +20,7 @@
 #include "../Services.h"
 
 #include <algorithm>
+#include <memory>
 #include <sstream>
 
 using namespace cali;
@@ -40,13 +41,18 @@ class IntelTopdown
     unsigned num_ret_computed;
     unsigned num_ret_skipped;
 
-    cali::topdown::IntelTopdownLevel m_level;
+    topdown::IntelTopdownLevel m_level;
+    std::shared_ptr<topdown::TopdownCalculator> m_calculator;
 
-    cali::topdown::TopdownCalculator* m_calculator;
-
-    bool find_counter_attrs(CaliperMetadataAccessInterface& db) { return m_calculator->find_counter_attrs(db); }
+    bool find_counter_attrs(CaliperMetadataAccessInterface& db)
+    {
+        return m_calculator->find_counter_attrs(db);
+    }
 
-    void make_result_attrs(CaliperMetadataAccessInterface& db) { m_calculator->make_result_attrs(db); }
+    void make_result_attrs(CaliperMetadataAccessInterface& db)
+    {
+        m_calculator->make_result_attrs(db);
+    }
 
     void postprocess_snapshot_cb(std::vector<Entry>& rec)
     {
@@ -122,7 +128,7 @@ class IntelTopdown
         }
     }
 
-    explicit IntelTopdown(cali::topdown::TopdownCalculator* calculator)
+    explicit IntelTopdown(std::shared_ptr<topdown::TopdownCalculator>& calculator)
         : num_top_computed(0),
           num_top_skipped(0),
           num_be_computed(0),
@@ -133,17 +139,17 @@ class IntelTopdown
           num_bsp_skipped(0),
           m_level(calculator->get_level()),
           m_calculator(calculator)
-    {}
+    {
+    }
 
     ~IntelTopdown()
     {
-        if (m_calculator != nullptr) {
-            delete m_calculator;
-        }
     }
 
 public:
 
+    static const char* s_spec;
+
     static void intel_topdown_register(Caliper* c, Channel* channel)
     {
         cali::topdown::IntelTopdownLevel level = cali::topdown::Top;
@@ -159,32 +165,18 @@ class IntelTopdown
             return;
         }
 
-        cali::topdown::TopdownCalculator* calculator;
-
+        std::shared_ptr<topdown::TopdownCalculator> calculator;
 #if defined(CALIPER_HAVE_ARCH)
         if (std::string(CALIPER_HAVE_ARCH) == "sapphirerapids") {
-            calculator = new cali::topdown::SapphireRapidsTopdown(level);
+            calculator = std::shared_ptr<topdown::TopdownCalculator>(new topdown::SapphireRapidsTopdown(level));
         } else {
 #endif
-            calculator = new cali::topdown::HaswellTopdown(level); // Default type of calculation
+            calculator = std::shared_ptr<topdown::TopdownCalculator>(new topdown::HaswellTopdown(level)); // Default type of calculation
 #if defined(CALIPER_HAVE_ARCH)
         }
 #endif
 
-        channel->config().set("CALI_PAPI_COUNTERS", calculator->get_counters());
-        // Some PAPI counters for topdown (particularly on SPR) don't play nice
-        // with PAPI multiplexing. Ask the TopdownCalculator class whether we need
-        // to disable multiplexing for the corresponding architecture.
-        channel->config().set(
-            "CALI_PAPI_DISABLE_MULTIPLEXING",
-            calculator->check_for_disabled_multiplex() ? "true" : "false"
-        );
-
-        if (!cali::services::register_service(c, channel, "papi")) {
-            Log(0).stream() << channel->name() << ": topdown: Unable to register papi service, skipping topdown"
-                            << std::endl;
-            return;
-        }
+        calculator->setup_config(*c, *channel);
 
         IntelTopdown* instance = new IntelTopdown(calculator);
 
@@ -207,15 +199,18 @@ class IntelTopdown
 };
 
 const char* IntelTopdown::s_spec = R"json(
-{   "name": "topdown",
-    "description": "Record PAPI counters and compute top-down analysis for Intel CPUs",
-    "config": [
-        {   "name": "level",
-            "description": "Top-down analysis level to compute ('all' or 'top')",
-            "type": "string",
-            "value": "top"
-        }
-    ]
+{
+ "name": "topdown",
+ "description": "Record PAPI counters and compute top-down analysis for Intel CPUs",
+ "config":
+ [
+  {
+   "name": "level",
+   "description": "Top-down analysis level to compute ('all' or 'top')",
+   "type": "string",
+   "value": "top"
+  }
+ ]
 }
 )json";
 

src/services/topdown/SapphireRapidsTopdown.h

@@ -16,7 +16,7 @@ class SapphireRapidsTopdown : public TopdownCalculator
 
     virtual ~SapphireRapidsTopdown() = default;
 
-    virtual bool check_for_disabled_multiplex() const override;
+    virtual bool setup_config(Caliper& c, Channel& channel) const override;
 
     virtual std::vector<Entry> compute_toplevel(const std::vector<Entry>& rec) override;
 

src/services/topdown/SapphireRapidsTopdown_rdpmc.cpp

@@ -1,5 +1,10 @@
 #include "SapphireRapidsTopdown.h"
 
+#include "../Services.h"
+
+#include "caliper/common/Log.h"
+#include "caliper/common/RuntimeConfig.h"
+
 #include <algorithm>
 
 #define RETIRING_OFFSET 0
@@ -49,8 +54,17 @@ SapphireRapidsTopdown::SapphireRapidsTopdown(IntelTopdownLevel level)
     )
 {}
 
-bool SapphireRapidsTopdown::check_for_disabled_multiplex() const
+
+bool SapphireRapidsTopdown::setup_config(Caliper& c, Channel& channel) const
 {
+    channel.config().set("CALI_PAPI_COUNTERS", m_level == All ? m_all_counters : m_top_counters);
+
+    if (!cali::services::register_service(&c, &channel, "papi")) {
+        Log(0).stream() << channel.name() << ": topdown: Unable to register papi service, skipping topdown"
+            << std::endl;
+        return false;
+    }
+
     return true;
 }
 

src/services/topdown/SapphireRapidsTopdown_read.cpp

@@ -1,5 +1,10 @@
 #include "SapphireRapidsTopdown.h"
 
+#include "../Services.h"
+
+#include "caliper/common/Log.h"
+#include "caliper/common/RuntimeConfig.h"
+
 #include <algorithm>
 
 namespace cali
@@ -46,8 +51,16 @@ SapphireRapidsTopdown::SapphireRapidsTopdown(IntelTopdownLevel level)
     )
 {}
 
-bool SapphireRapidsTopdown::check_for_disabled_multiplex() const
+bool SapphireRapidsTopdown::setup_config(Caliper& c, Channel& channel) const
 {
+    channel.config().set("CALI_PAPI_COUNTERS", m_level == All ? m_all_counters : m_top_counters);
+
+    if (!cali::services::register_service(&c, &channel, "papi")) {
+        Log(0).stream() << channel.name() << ": topdown: Unable to register papi service, skipping topdown"
+            << std::endl;
+        return false;
+    }
+
     return true;
 }
 

src/services/topdown/TopdownCalculator.h

@@ -59,9 +59,8 @@ class TopdownCalculator
 
     virtual ~TopdownCalculator() = default;
 
-    // Returns true if PAPI multiplexing cannot be used for the
-    // counters and/or architecture needed for the subclass
-    virtual bool check_for_disabled_multiplex() const = 0;
+    // Setup the hardware counters. Returns "true" if successful.
+    virtual bool setup_config(Caliper& c, Channel& channel) const = 0;
 
     // Computes the L1 topdown metrics using the counters contained
     // in the Caliper Entries.