maxOutstandingSnoopCheck(p->max_outstanding_snoops),
       maxRoutingTableSizeCheck(p->max_routing_table_size),
       pointOfCoherency(p->point_of_coherency),
-      pointOfUnification(p->point_of_unification)
+      pointOfUnification(p->point_of_unification),
+
+      snoops(this, "snoops", "Total snoops (count)"),
+      snoopTraffic(this, "snoopTraffic", "Total snoop traffic (bytes)"),
+      snoopFanout(this, "snoop_fanout", "Request fanout histogram")
 {
     // create the ports based on the size of the master and slave
     // vector ports, and the presence of the default port, the ports
         MasterPort* bp = new CoherentXBarMasterPort(portName, *this, i);
         masterPorts.push_back(bp);
         reqLayers.push_back(new ReqLayer(*bp, *this,
-                                         csprintf(".reqLayer%d", i)));
+                                         csprintf("reqLayer%d", i)));
         snoopLayers.push_back(
-                new SnoopRespLayer(*bp, *this, csprintf(".snoopLayer%d", i)));
+                new SnoopRespLayer(*bp, *this, csprintf("snoopLayer%d", i)));
     }
 
     // see if we have a default slave device connected and if so add
         MasterPort* bp = new CoherentXBarMasterPort(portName, *this,
                                                     defaultPortID);
         masterPorts.push_back(bp);
-        reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d",
+        reqLayers.push_back(new ReqLayer(*bp, *this, csprintf("reqLayer%d",
                                          defaultPortID)));
         snoopLayers.push_back(new SnoopRespLayer(*bp, *this,
-                                                 csprintf(".snoopLayer%d",
+                                                 csprintf("snoopLayer%d",
                                                           defaultPortID)));
     }
 
         QueuedSlavePort* bp = new CoherentXBarSlavePort(portName, *this, i);
         slavePorts.push_back(bp);
         respLayers.push_back(new RespLayer(*bp, *this,
-                                           csprintf(".respLayer%d", i)));
+                                           csprintf("respLayer%d", i)));
         snoopRespPorts.push_back(new SnoopRespPort(*bp, *this));
     }
 }
 void
 CoherentXBar::regStats()
 {
-    // register the stats of the base class and our layers
     BaseXBar::regStats();
-    for (auto l: reqLayers)
-        l->regStats();
-    for (auto l: respLayers)
-        l->regStats();
-    for (auto l: snoopLayers)
-        l->regStats();
-
-    snoops
-        .name(name() + ".snoops")
-        .desc("Total snoops (count)")
-    ;
-
-    snoopTraffic
-        .name(name() + ".snoopTraffic")
-        .desc("Total snoop traffic (bytes)")
-    ;
-
-    snoopFanout
-        .init(0, snoopPorts.size(), 1)
-        .name(name() + ".snoop_fanout")
-        .desc("Request fanout histogram")
-    ;
+
+    snoopFanout.init(0, snoopPorts.size(), 1);
 }
 
 CoherentXBar *
 
 /*
- * Copyright (c) 2011-2015, 2018 ARM Limited
+ * Copyright (c) 2011-2015, 2018-2019 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
         MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this, i);
         masterPorts.push_back(bp);
         reqLayers.push_back(new ReqLayer(*bp, *this,
-                                         csprintf(".reqLayer%d", i)));
+                                         csprintf("reqLayer%d", i)));
     }
 
     // see if we have a default slave device connected and if so add
         MasterPort* bp = new NoncoherentXBarMasterPort(portName, *this,
                                                       defaultPortID);
         masterPorts.push_back(bp);
-        reqLayers.push_back(new ReqLayer(*bp, *this, csprintf(".reqLayer%d",
+        reqLayers.push_back(new ReqLayer(*bp, *this, csprintf("reqLayer%d",
                                                               defaultPortID)));
     }
 
         QueuedSlavePort* bp = new NoncoherentXBarSlavePort(portName, *this, i);
         slavePorts.push_back(bp);
         respLayers.push_back(new RespLayer(*bp, *this,
-                                           csprintf(".respLayer%d", i)));
+                                           csprintf("respLayer%d", i)));
     }
 }
 
 {
     return new NoncoherentXBar(this);
 }
-
-void
-NoncoherentXBar::regStats()
-{
-    // register the stats of the base class and our layers
-    BaseXBar::regStats();
-    for (auto l: reqLayers)
-        l->regStats();
-    for (auto l: respLayers)
-        l->regStats();
-}
 
 /*
- * Copyright (c) 2011-2015 ARM Limited
+ * Copyright (c) 2011-2015, 2019 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
     NoncoherentXBar(const NoncoherentXBarParams *p);
 
     virtual ~NoncoherentXBar();
-
-    void regStats() override;
-    Stats::Scalar totPktSize;
 };
 
 #endif //__MEM_NONCOHERENT_XBAR_HH__
 
 /*
- * Copyright (c) 2011-2015, 2018 ARM Limited
+ * Copyright (c) 2011-2015, 2018-2019 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
       gotAddrRanges(p->port_default_connection_count +
                           p->port_master_connection_count, false),
       gotAllAddrRanges(false), defaultPortID(InvalidPortID),
-      useDefaultRange(p->use_default_range)
-{}
+      useDefaultRange(p->use_default_range),
+
+      transDist(this, "trans_dist", "Transaction distribution"),
+      pktCount(this, "pkt_count",
+                   "Packet count per connected master and slave (bytes)"),
+      pktSize(this, "pkt_size",
+              "Cumulative packet size per connected master and slave (bytes)")
+{
+}
 
 BaseXBar::~BaseXBar()
 {
 template <typename SrcType, typename DstType>
 BaseXBar::Layer<SrcType, DstType>::Layer(DstType& _port, BaseXBar& _xbar,
                                        const std::string& _name) :
-    port(_port), xbar(_xbar), _name(_name), state(IDLE),
-    waitingForPeer(NULL), releaseEvent([this]{ releaseLayer(); }, name())
+    Stats::Group(&_xbar, _name.c_str()),
+    port(_port), xbar(_xbar), _name(xbar.name() + "." + _name), state(IDLE),
+    waitingForPeer(NULL), releaseEvent([this]{ releaseLayer(); }, name()),
+    ADD_STAT(occupancy, "Layer occupancy (ticks)"),
+    ADD_STAT(utilization, "Layer utilization (%)")
 {
+    occupancy
+        .flags(Stats::nozero);
+
+    utilization
+        .precision(1)
+        .flags(Stats::nozero);
+
+    utilization = 100 * occupancy / simTicks;
 }
 
 template <typename SrcType, typename DstType>
 
     transDist
         .init(MemCmd::NUM_MEM_CMDS)
-        .name(name() + ".trans_dist")
-        .desc("Transaction distribution")
         .flags(nozero);
 
     // get the string representation of the commands
 
     pktCount
         .init(slavePorts.size(), masterPorts.size())
-        .name(name() + ".pkt_count")
-        .desc("Packet count per connected master and slave (bytes)")
         .flags(total | nozero | nonan);
 
     pktSize
         .init(slavePorts.size(), masterPorts.size())
-        .name(name() + ".pkt_size")
-        .desc("Cumulative packet size per connected master and slave (bytes)")
         .flags(total | nozero | nonan);
 
     // both the packet count and total size are two-dimensional
     }
 }
 
-template <typename SrcType, typename DstType>
-void
-BaseXBar::Layer<SrcType, DstType>::regStats()
-{
-    using namespace Stats;
-
-    occupancy
-        .name(name() + ".occupancy")
-        .desc("Layer occupancy (ticks)")
-        .flags(nozero);
-
-    utilization
-        .name(name() + ".utilization")
-        .desc("Layer utilization (%)")
-        .precision(1)
-        .flags(nozero);
-
-    utilization = 100 * occupancy / simTicks;
-}
-
 /**
  * Crossbar layer template instantiations. Could be removed with _impl.hh
  * file, but since there are only two given options (MasterPort and
 
 /*
- * Copyright (c) 2011-2015, 2018 ARM Limited
+ * Copyright (c) 2011-2015, 2018-2019 ARM Limited
  * All rights reserved
  *
  * The license below extends only to copyright in the software and shall
      * ports, whereas a response layer holds master ports.
      */
     template <typename SrcType, typename DstType>
-    class Layer : public Drainable
+    class Layer : public Drainable, public Stats::Group
     {
 
       public:
          */
         DrainState drain() override;
 
-        const std::string name() const { return xbar.name() + _name; }
+        const std::string name() const { return _name; }
 
 
         /**
          */
         void recvRetry();
 
-        void regStats();
-
       protected:
 
         /**