Apply pre-commit fixes

src/sst/elements/ember/libs/emberNetworkIOLib.h

@@ -24,7 +24,7 @@ class EmberNetworkIOLib : public EmberLib {
         "Network I/O Library for network-attached storage operations",
         SST::Ember::EmberLib
     )
-    
+
     SST_ELI_DOCUMENT_PARAMS()
 
     EmberNetworkIOLib(Params& params) {}
@@ -38,7 +38,7 @@ class EmberNetworkIOLib : public EmberLib {
     {
         q.push(new EmberNetworkIOWriteEvent(api(), m_output, offset, src, length));
     }
-    
+
 private:
     NetworkIO::Interface& api() { return *static_cast<NetworkIO::Interface*>(m_api); }
 };

src/sst/elements/ember/libs/networkIOEvents/emberNetworkIOEvent.h

@@ -15,11 +15,11 @@ typedef Statistic<uint32_t> EmberEventTimeStatistic;
 
 class EmberNetworkIOEvent : public EmberEvent {
 public:
-    EmberNetworkIOEvent(NetworkIO::Interface& api, Output* output, 
+    EmberNetworkIOEvent(NetworkIO::Interface& api, Output* output,
                    EmberEventTimeStatistic* stat = nullptr) :
         EmberEvent(output, stat), m_api(api)
     {
-        m_state = IssueCallback;  
+        m_state = IssueCallback;
     }
 
 protected:

src/sst/elements/ember/libs/networkIOEvents/emberNetworkIOWriteEvent.h

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright Hewlett Packard Enterprise Development LP
 // SPDX-License-Identifier: BSD-3-Clause
 
-#pragma once 
+#pragma once
 
 #include "emberNetworkIOEvent.h"
 

src/sst/elements/ember/networkIO/emberNetworkIOGen.cc

@@ -6,7 +6,7 @@
 
 using namespace SST::Ember;
 
-EmberNetworkIOGenerator::EmberNetworkIOGenerator(ComponentId_t id, Params& params, std::string name) 
+EmberNetworkIOGenerator::EmberNetworkIOGenerator(ComponentId_t id, Params& params, std::string name)
     : EmberGenerator(id, params, name), m_networkIOLib(nullptr)
 {
     m_shmemLib = nullptr;

src/sst/elements/ember/networkIO/emberNetworkIOGen.h

@@ -21,13 +21,13 @@ class EmberNetworkIOGenerator : public EmberGenerator {
 
 protected:
     EmberShmemLib* m_shmemLib;
-    
-    
+
+
     EmberNetworkIOLib* m_networkIOLib;
     EmberNetworkIOLib& networkIO() { return *m_networkIOLib; }
 
     EmberShmemLib& shmem() { return *m_shmemLib; }
-    
+
     // Barrier macro (same as EmberShmemGen)
     #define enQ_barrier_all shmem().barrier_all
     #define enQ_malloc shmem().malloc

src/sst/elements/ember/networkIO/motifs/emberTestNetworkIO.cc

@@ -7,40 +7,40 @@
 
 using namespace SST::Ember;
 
-EmberTestNetworkIOGenerator::EmberTestNetworkIOGenerator(SST::ComponentId_t id, Params& params) 
+EmberTestNetworkIOGenerator::EmberTestNetworkIOGenerator(SST::ComponentId_t id, Params& params)
     : EmberNetworkIOGenerator(id, params, "TestNetworkIO"), m_phase(0)
 {
         m_messageSize = params.find<uint32_t>("arg.messageSize", 1024);
         m_iterations = params.find<uint32_t>("arg.iterations", 5);
         m_opType = params.find<std::string>("arg.op", "write");
         m_fileSize = params.find<uint64_t>("arg.fileSize", 10485760);  // 10MB default
-        
+
         m_rng = new SST::RNG::MarsagliaRNG();
         m_startTime = 0;
         m_stopTime = 0;
 }
 
-bool EmberTestNetworkIOGenerator::generate( std::queue<EmberEvent*>& evQ) 
+bool EmberTestNetworkIOGenerator::generate( std::queue<EmberEvent*>& evQ)
 {
     bool ret = false;
-    switch(m_phase) 
+    switch(m_phase)
     {
         case 0:
             memSetNotBacked();
             m_localBuffer = memAlloc(m_messageSize);
             enQ_getTime(evQ, &m_startTime);
-            for (uint32_t i = 0; i < m_iterations; i++) 
+            for (uint32_t i = 0; i < m_iterations; i++)
             {
                 uint64_t offset = m_rng->generateNextUInt64() % m_fileSize;
-                
-                if (m_opType == "read") 
+
+                if (m_opType == "read")
                     networkIO().networkIORead(evQ, m_localBuffer, offset, m_messageSize);
-                else 
+                else
                     networkIO().networkIOWrite(evQ, offset, m_localBuffer, m_messageSize);
             }
             enQ_getTime(evQ, &m_stopTime);
             break;
-            
+
         case 1:
             double totalTime = (double)(m_stopTime - m_startTime)/1000000000.0;
             double latency = (totalTime/m_iterations);
@@ -49,7 +49,7 @@ bool EmberTestNetworkIOGenerator::generate( std::queue<EmberEvent*>& evQ)
             ret = true;
             break;
     }
-    
+
     ++m_phase;
     return ret;
 }

src/sst/elements/ember/networkIO/motifs/emberTestNetworkIO.h

@@ -10,7 +10,7 @@
 namespace SST {
 namespace Ember {
 
-class EmberTestNetworkIOGenerator : public EmberNetworkIOGenerator 
+class EmberTestNetworkIOGenerator : public EmberNetworkIOGenerator
 {
 public:
     SST_ELI_REGISTER_SUBCOMPONENT(
@@ -21,7 +21,7 @@ class EmberTestNetworkIOGenerator : public EmberNetworkIOGenerator
         "Network IO Test",
         SST::Ember::EmberGenerator
     )
-    
+
     SST_ELI_DOCUMENT_PARAMS(
         {"arg.messageSize","Message size in bytes","1024"},
         {"arg.iterations","Number of iterations to perform","1"},
@@ -30,25 +30,25 @@ class EmberTestNetworkIOGenerator : public EmberNetworkIOGenerator
     )
 
     EmberTestNetworkIOGenerator(SST::ComponentId_t id, Params& params);
-    
+
     bool generate( std::queue<EmberEvent*>& evQ);
 
 private:
     // Simulation control
     int m_phase;
-    
+
     // Random number generation
     SST::RNG::MarsagliaRNG* m_rng;   // RNG instance for offset generation
-    
+
     // Operation parameters
     uint32_t m_messageSize;          // Size of each read/write operation
     uint32_t m_iterations;           // Number of operations to perform
     uint64_t m_fileSize;             // Total file size for offset generation
     std::string m_opType;            // Operation type: "read" or "write"
-    
+
     // Runtime state
     Hermes::MemAddr m_localBuffer;   // Buffer for data transfer
-    
+
     // Performance measurement
     uint64_t m_startTime;
     uint64_t m_stopTime;

src/sst/elements/ember/test/networkIOParams.py

@@ -71,8 +71,8 @@
     "simpleSSD.writeBandwidthPerSSD_GBps": 6.25,
     "simpleSSD.readOverheadLatency_ns": 500,
     "simpleSSD.writeOverheadLatency_ns": 500,
-    
-    
+
+
     #"numVNs" : 7,
 
     #"getHdrVN" : 1,

src/sst/elements/firefly/Makefile.am

@@ -170,7 +170,7 @@ libfirefly_la_SOURCES = \
 	nicNetworkIO.h \
 	nicNetworkIOStream.cc \
 	nicNetworkIOStream.h \
-	pyfirefly.py 
+	pyfirefly.py
 
 libfirefly_la_LDFLAGS = -module -avoid-version
 

src/sst/elements/firefly/hadesNetworkIO.cc

@@ -19,7 +19,7 @@ HadesNetworkIO::HadesNetworkIO(ComponentId_t id, Params& params) :
 
     m_numSsdNodes = params.find<int64_t>("numStorageNodes", 0);
     m_ssd_start_node = params.find<int64_t>("ssd_start_node", 0);
-    
+
     for (int64_t i = 0; i < m_numSsdNodes; i++) {
         m_storageNodesList.push_back(m_ssd_start_node + i);
     }
@@ -45,15 +45,15 @@ void HadesNetworkIO::setup()
 
 void HadesNetworkIO::networkIORead(Hermes::Vaddr dest, uint64_t offset, uint64_t length, Callback callback)
 {
-    m_dbg.verbose(CALL_INFO, 1, 0, "network_read: dest=%lx offset=%lu length=%lu \n", 
+    m_dbg.verbose(CALL_INFO, 1, 0, "network_read: dest=%lx offset=%lu length=%lu \n",
                   dest, offset, length);
     int targetNid = calcTargetNid(offset);
     m_nicPtr->networkIORead(targetNid, dest, length, callback);
 }
 
 void HadesNetworkIO::networkIOWrite(uint64_t offset, Hermes::Vaddr src, uint64_t length, Callback callback)
 {
-    m_dbg.verbose(CALL_INFO, 1, 0, "network_write: offset=%lu src=%lx length=%lu \n", 
+    m_dbg.verbose(CALL_INFO, 1, 0, "network_write: offset=%lu src=%lx length=%lu \n",
                   offset, src, length);
     int targetNid = calcTargetNid(offset);
     m_nicPtr->networkIOWrite(targetNid, src, length, callback);
@@ -63,7 +63,7 @@ void HadesNetworkIO::networkIOWrite(uint64_t offset, Hermes::Vaddr src, uint64_t
 int64_t HadesNetworkIO::calcTargetNid(int64_t offset)
 {
     assert(m_storageNodesList.size() > 0 && "No storage nodes defined in storageNodesList");
-    
+
     int nodeIndex = (offset/m_storageNodeCapacity)%m_storageNodesList.size();
     return m_storageNodesList.at(nodeIndex);
 }

src/sst/elements/firefly/hadesNetworkIO.h

@@ -44,7 +44,7 @@ class HadesNetworkIO : public Hermes::NetworkIO::Interface {
 
     void networkIORead(Hermes::Vaddr dest, uint64_t offset, uint64_t length,
                       Callback callback) override;
-    
+
     void networkIOWrite(uint64_t offset, Hermes::Vaddr src, uint64_t length,
                        Callback callback) override;
 

src/sst/elements/firefly/nicEvents.h

@@ -528,7 +528,7 @@ class NicRespEvent : public NicRespBaseEvent {
 };
 
 //=============================================================================
-// NetworkIO Command Events 
+// NetworkIO Command Events
 //=============================================================================
 
 class NicNetworkIOCmdEvent : public NicCmdBaseEvent {
@@ -537,27 +537,27 @@ class NicNetworkIOCmdEvent : public NicCmdBaseEvent {
         NetworkIORead,
         NetworkIOWrite
     };
-    
+
     NicNetworkIOCmdEvent(Type type, std::function<void(int)> callback)
         : NicCmdBaseEvent(NetworkIO), type(type), m_callback(callback) {}
-    
+
     virtual ~NicNetworkIOCmdEvent() {}
-    
+
     Type type;
-    
+
     std::string getTypeStr() {
         switch(type) {
             case NetworkIORead: return "NetworkIORead";
             case NetworkIOWrite: return "NetworkIOWrite";
             default: return "Unknown";
         }
     }
-    
+
     std::function<void(int)> getCallback() { return m_callback; }
-    
+
 private:
     std::function<void(int)> m_callback;
-    
+
     NotSerializable(NicNetworkIOCmdEvent)
 };
 

src/sst/elements/firefly/nicNetworkIO.cc

@@ -10,16 +10,16 @@ using namespace SST::Firefly;
 // ========================================================================
 // NetworkIO Constructor - Initialize storage configuration from parameters
 // ========================================================================
-Nic::NetworkIO::NetworkIO(Nic& nic, Params& params, Output& output) : 
+Nic::NetworkIO::NetworkIO(Nic& nic, Params& params, Output& output) :
     m_nic(nic), m_dbg(output)
 {
     m_prefix = "@t:" + std::to_string(nic.getNodeId()) + ":Nic::NetworkIO::@p():@l ";
-    
-       
+
+
     // Initialize per-core pending operation tracking (same size as vNIC count)
     m_pendingOps.resize(nic.getNum_vNics());
-    
-    m_dbg.verbosePrefix(prefix().c_str(), CALL_INFO, 1, NIC_DBG_NETWORKIO, 
+
+    m_dbg.verbosePrefix(prefix().c_str(), CALL_INFO, 1, NIC_DBG_NETWORKIO,
         "storage config:cores=%d\n", nic.getNum_vNics());
 }
 
@@ -28,7 +28,7 @@ Nic::NetworkIO::NetworkIO(Nic& nic, Params& params, Output& output) :
 // ========================================================================
 void Nic::NetworkIO::handleEvent(NicNetworkIOCmdEvent* event, int id)
 {
-    m_dbg.verbosePrefix(prefix().c_str(), CALL_INFO, 1, NIC_DBG_NETWORKIO, 
+    m_dbg.verbosePrefix(prefix().c_str(), CALL_INFO, 1, NIC_DBG_NETWORKIO,
         "core=%d `%s`\n", id, event->getTypeStr().c_str());
 
     // Dispatch based on operation type

src/sst/elements/firefly/nicNetworkIO.h

@@ -29,24 +29,24 @@ class NetworkIO {
                 assert(ops.readCount > 0);
                 --ops.readCount;
         }
-    
+
     void incPendingWrites(int id) {
         ++m_pendingOps[id].writeCount;
     }
-    
+
     void decPendingWrites(int id) {
         PendingOps& ops = m_pendingOps[id];
         assert(ops.writeCount > 0);
         --ops.writeCount;
     }
-    
+
     // Core references
     Nic& m_nic;
     Output& m_dbg;
     std::string m_prefix;
-    
+
     // Per-core tracking of pending non-blocking operations
     std::vector<PendingOps> m_pendingOps;
-    
+
     std::string prefix() { return m_prefix; }
 };