Fix to make ThreadStatistics a unique pointer in vector

dobrienphd · dobrienphd · commit 935aa803fc35 · 2026-03-11T22:48:22.000-04:00
diff --git a/include/particlezoo/parallel/HistoryBalancedParallelReader.h b/include/particlezoo/parallel/HistoryBalancedParallelReader.h
@@ -228,7 +228,7 @@ namespace ParticleZoo {
             };
 
             std::vector<std::shared_ptr<PhaseSpaceFileReader>> readers_;
-            std::vector<ThreadStatistics> threadStats_;
+            std::vector<std::unique_ptr<ThreadStatistics>> threadStats_;
             std::vector<std::uint64_t> startingHistorys_;
 
             bool hasNativeRepresentedHistoryCount_;
diff --git a/include/particlezoo/parallel/ParticleBalancedParallelReader.h b/include/particlezoo/parallel/ParticleBalancedParallelReader.h
@@ -231,7 +231,7 @@ namespace ParticleZoo {
 
             std::vector<std::shared_ptr<PhaseSpaceFileReader>> readers_;
             std::vector<std::uint64_t> startingParticleIndex_;
-            std::vector<ThreadStatistics> threadStats_;
+            std::vector<std::unique_ptr<ThreadStatistics>> threadStats_;
 
             bool hasNativeRepresentedHistoryCount_;
             bool hasNativeIncrementalHistoryCounters_;
diff --git a/src/parallel/HistoryBalancedParallelReader.cc b/src/parallel/HistoryBalancedParallelReader.cc
@@ -66,18 +66,21 @@ namespace ParticleZoo {
 
         // Calculate starting history for each thread
         startingHistorys_.reserve(numThreads);
-        threadStats_.resize(numThreads);
+        threadStats_.reserve(numThreads);
+        for (size_t i = 0; i < numThreads; ++i) {
+            threadStats_.emplace_back(std::make_unique<ThreadStatistics>());
+        }
         std::uint64_t historiesPerThread = numberOfRepresentedHistories_ / numThreads;
         std::uint64_t remainderHistories = numberOfRepresentedHistories_ % numThreads;
         std::uint64_t currentStartingHistory = 0;
         for (size_t i = 0; i < numThreads; ++i) {
             startingHistorys_.push_back(currentStartingHistory);
-            threadStats_[i].historiesRead = currentStartingHistory;
+            threadStats_[i]->historiesRead = currentStartingHistory;
             // Calculate the correct initial error for this thread based on how many
             // represented histories have been "processed" before this thread's starting point
             if (hasGapsBetweenHistories_) {
                 std::uint64_t initialError = numberOfRepresentedHistories_ / 2;
-                threadStats_[i].emptyHistoryError = (initialError + currentStartingHistory * perHistoryErrorContribution_) % numberOfRepresentedHistories_;
+                threadStats_[i]->emptyHistoryError = (initialError + currentStartingHistory * perHistoryErrorContribution_) % numberOfRepresentedHistories_;
             }
             currentStartingHistory += historiesPerThread;
             if (i < remainderHistories) {
@@ -122,8 +125,8 @@ namespace ParticleZoo {
         }
 
         // check the cache first
-        if (threadStats_[threadIndex].hasMoreParticlesCache != NEEDS_CHECKING) {
-            return threadStats_[threadIndex].hasMoreParticlesCache == HAS_MORE_PARTICLES;
+        if (threadStats_[threadIndex]->hasMoreParticlesCache != NEEDS_CHECKING) {
+            return threadStats_[threadIndex]->hasMoreParticlesCache == HAS_MORE_PARTICLES;
         }
 
         // Check if the reader has more particles
@@ -137,7 +140,7 @@ namespace ParticleZoo {
                                           : numberOfRepresentedHistories_;
 
             // Check if we have completed all histories for this thread
-            if (threadStats_[threadIndex].historiesRead >= targetHistories) {
+            if (threadStats_[threadIndex]->historiesRead >= targetHistories) {
                 // Check if the next particle would start a new history
                 const Particle nextParticle = readers_[threadIndex]->peekNextParticle();
                 // If the next particle starts a new history, we have no more particles for this thread
@@ -146,7 +149,7 @@ namespace ParticleZoo {
         }
 
         // Update the cache
-        threadStats_[threadIndex].hasMoreParticlesCache = hasMoreParticles ? HAS_MORE_PARTICLES : NO_MORE_PARTICLES;
+        threadStats_[threadIndex]->hasMoreParticlesCache = hasMoreParticles ? HAS_MORE_PARTICLES : NO_MORE_PARTICLES;
 
         return hasMoreParticles;
     }
@@ -161,33 +164,33 @@ namespace ParticleZoo {
         }
 
         // reset the cache since we are consuming a particle
-        threadStats_[threadIndex].hasMoreParticlesCache = NEEDS_CHECKING;
+        threadStats_[threadIndex]->hasMoreParticlesCache = NEEDS_CHECKING;
 
         // Get the next particle from the appropriate reader
         Particle particle = readers_[threadIndex]->getNextParticle();
 
         // Update history count if this particle starts a new history
         int32_t incrementalHistoryNumber = 0;
         {
-            std::lock_guard<std::mutex> lock(threadStats_[threadIndex].mutex);
-            threadStats_[threadIndex].particlesRead++;
+            std::lock_guard<std::mutex> lock(threadStats_[threadIndex]->mutex);
+            threadStats_[threadIndex]->particlesRead++;
 
             if (particle.isNewHistory()) {
                 if (hasGapsBetweenHistories_) {
-                    threadStats_[threadIndex].emptyHistoryError += perHistoryErrorContribution_;
-                    if (threadStats_[threadIndex].emptyHistoryError >= numberOfRepresentedHistories_) {
+                    threadStats_[threadIndex]->emptyHistoryError += perHistoryErrorContribution_;
+                    if (threadStats_[threadIndex]->emptyHistoryError >= numberOfRepresentedHistories_) {
                         incrementalHistoryNumber = 2 + emptyHistoriesBetweenEachHistory_;
-                        threadStats_[threadIndex].emptyHistoryError -= numberOfRepresentedHistories_;
+                        threadStats_[threadIndex]->emptyHistoryError -= numberOfRepresentedHistories_;
                     } else {
                         incrementalHistoryNumber = 1 + emptyHistoriesBetweenEachHistory_;
                     }
                 } else {
                     incrementalHistoryNumber = 1;
                 }
-                threadStats_[threadIndex].historiesRead++;
+                threadStats_[threadIndex]->historiesRead++;
             }
 
-            threadStats_[threadIndex].totalHistoriesRead += incrementalHistoryNumber;
+            threadStats_[threadIndex]->totalHistoriesRead += incrementalHistoryNumber;
         }
 
         particle.setIntProperty(IntPropertyType::INCREMENTAL_HISTORY_NUMBER, incrementalHistoryNumber);
@@ -213,27 +216,27 @@ namespace ParticleZoo {
         if (threadIndex >= readers_.size()) {
             throw std::out_of_range("Thread index out of range in getHistoriesRead()");
         }
-        return threadStats_[threadIndex].totalHistoriesRead;
+        return threadStats_[threadIndex]->totalHistoriesRead;
     }
 
     std::uint64_t HistoryBalancedParallelReader::getParticlesRead(size_t threadIndex) const {
         if (threadIndex >= readers_.size()) {
             throw std::out_of_range("Thread index out of range in getParticlesRead()");
         }
-        return threadStats_[threadIndex].particlesRead;
+        return threadStats_[threadIndex]->particlesRead;
     }
 
     std::uint64_t HistoryBalancedParallelReader::getTotalParticlesRead() const {
         std::uint64_t total = 0;
         for (size_t t = 0; t < readers_.size(); t++)
-            total += threadStats_[t].particlesRead;
+            total += threadStats_[t]->particlesRead;
         return total;
     }
 
     std::uint64_t HistoryBalancedParallelReader::getTotalHistoriesRead() const {
         std::uint64_t total = 0;
         for (size_t t = 0; t < readers_.size(); t++)
-            total += threadStats_[t].totalHistoriesRead;
+            total += threadStats_[t]->totalHistoriesRead;
         return total;
     }
 
diff --git a/src/parallel/ParticleBalancedParallelReader.cc b/src/parallel/ParticleBalancedParallelReader.cc
@@ -55,7 +55,10 @@ namespace ParticleZoo {
 
         // Position each reader at its starting particle
         startingParticleIndex_.reserve(numThreads);
-        threadStats_.resize(numThreads);
+        threadStats_.reserve(numThreads);
+        for (size_t i = 0; i < numThreads; ++i) {
+            threadStats_.emplace_back(std::make_unique<ThreadStatistics>());
+        }
         std::uint64_t currentParticleIndex = 0;
         for (size_t i = 0; i < numThreads; ++i) {
             std::uint64_t particlesToRead = particlesPerThread + (i < remainderParticles ? 1 : 0);
@@ -88,7 +91,7 @@ namespace ParticleZoo {
                                             ? startingParticleIndex_[threadIndex + 1]
                                             : numberOfParticlesInPhsp_;
             // Check if we have completed all particles for this thread
-            if (threadStats_[threadIndex].particlesRead >= (targetParticleIndex - startingParticleIndex_[threadIndex])) {
+            if (threadStats_[threadIndex]->particlesRead >= (targetParticleIndex - startingParticleIndex_[threadIndex])) {
                 hasMore = false;
             }
         }
@@ -109,12 +112,12 @@ namespace ParticleZoo {
         Particle particle = readers_[threadIndex]->getNextParticle();
 
         {
-            std::lock_guard<std::mutex> lock(threadStats_[threadIndex].mutex);
-            threadStats_[threadIndex].particlesRead++;
+            std::lock_guard<std::mutex> lock(threadStats_[threadIndex]->mutex);
+            threadStats_[threadIndex]->particlesRead++;
 
             if (particle.isNewHistory()) {
-                threadStats_[threadIndex].representedHistoriesRead++;
-                threadStats_[threadIndex].incrementalHistorySum += particle.getIncrementalHistories();
+                threadStats_[threadIndex]->representedHistoriesRead++;
+                threadStats_[threadIndex]->incrementalHistorySum += particle.getIncrementalHistories();
             }
         }
 
@@ -161,7 +164,7 @@ namespace ParticleZoo {
         if (threadIndex >= readers_.size()) {
             throw std::out_of_range("Thread index out of range in getHistoriesRead()");
         }
-        return threadStats_[threadIndex].particlesRead;
+        return threadStats_[threadIndex]->particlesRead;
     }
 
     std::uint64_t ParticleBalancedParallelReader::getHistoriesRead(size_t threadIndex) const {
@@ -172,21 +175,21 @@ namespace ParticleZoo {
         switch (historyCountMode_) {
             case HistoryCountMode::RATIO:
             {
-                const std::uint64_t representedHistories = threadStats_[threadIndex].representedHistoriesRead;
+                const std::uint64_t representedHistories = threadStats_[threadIndex]->representedHistoriesRead;
                 return (representedHistories * numberOfOriginalHistories_)
                        / numberOfRepresentedHistories_;
             }
             case HistoryCountMode::INCREMENTAL:
-                return threadStats_[threadIndex].incrementalHistorySum;
+                return threadStats_[threadIndex]->incrementalHistorySum;
         }
         
-        return threadStats_[threadIndex].representedHistoriesRead; // unreachable fallback
+        return threadStats_[threadIndex]->representedHistoriesRead; // unreachable fallback
     }
 
     std::uint64_t ParticleBalancedParallelReader::getTotalParticlesRead() const {
         std::uint64_t total = 0;
         for (size_t t = 0; t < numThreads_; t++) {
-            total += threadStats_[t].particlesRead;
+            total += threadStats_[t]->particlesRead;
         }
         return total;
     }
@@ -196,17 +199,17 @@ namespace ParticleZoo {
             case HistoryCountMode::RATIO: {
                 std::uint64_t totalRep = 0;
                 for (size_t t = 0; t < numThreads_; t++) {
-                    totalRep += threadStats_[t].representedHistoriesRead;
+                    totalRep += threadStats_[t]->representedHistoriesRead;
                 }
                 return (totalRep * numberOfOriginalHistories_) / numberOfRepresentedHistories_;
             }
             case HistoryCountMode::INCREMENTAL: {
                 std::uint64_t total = 0;
                 std::uint64_t totalParticles = 0;
                 for (size_t t = 0; t < numThreads_; t++) {
-                    std::lock_guard<std::mutex> lock(threadStats_[t].mutex);
-                    total += threadStats_[t].incrementalHistorySum;
-                    totalParticles += threadStats_[t].particlesRead;
+                    std::lock_guard<std::mutex> lock(threadStats_[t]->mutex);
+                    total += threadStats_[t]->incrementalHistorySum;
+                    totalParticles += threadStats_[t]->particlesRead;
                 }
                 if (totalParticles >= numberOfParticlesInPhsp_)
                     return numberOfOriginalHistories_;

Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,10 @@ namespace ParticleZoo {`
`55`	`55`
`56`	`56`	`// Position each reader at its starting particle`
`57`	`57`	`startingParticleIndex_.reserve(numThreads);`
`58`		`- threadStats_.resize(numThreads);`
	`58`	`+ threadStats_.reserve(numThreads);`
	`59`	`+ for (size_t i = 0; i < numThreads; ++i) {`
	`60`	`+ threadStats_.emplace_back(std::make_unique<ThreadStatistics>());`
	`61`	`+ }`
`59`	`62`	`std::uint64_t currentParticleIndex = 0;`
`60`	`63`	`for (size_t i = 0; i < numThreads; ++i) {`
`61`	`64`	`std::uint64_t particlesToRead = particlesPerThread + (i < remainderParticles ? 1 : 0);`
`@@ -88,7 +91,7 @@ namespace ParticleZoo {`
`88`	`91`	`? startingParticleIndex_[threadIndex + 1]`
`89`	`92`	`: numberOfParticlesInPhsp_;`
`90`	`93`	`// Check if we have completed all particles for this thread`
`91`		`- if (threadStats_[threadIndex].particlesRead >= (targetParticleIndex - startingParticleIndex_[threadIndex])) {`
	`94`	`+ if (threadStats_[threadIndex]->particlesRead >= (targetParticleIndex - startingParticleIndex_[threadIndex])) {`
`92`	`95`	`hasMore = false;`
`93`	`96`	`}`
`94`	`97`	`}`
`@@ -109,12 +112,12 @@ namespace ParticleZoo {`
`109`	`112`	`Particle particle = readers_[threadIndex]->getNextParticle();`
`110`	`113`
`111`	`114`	`{`
`112`		`- std::lock_guard<std::mutex> lock(threadStats_[threadIndex].mutex);`
`113`		`- threadStats_[threadIndex].particlesRead++;`
	`115`	`+ std::lock_guard<std::mutex> lock(threadStats_[threadIndex]->mutex);`
	`116`	`+ threadStats_[threadIndex]->particlesRead++;`
`114`	`117`
`115`	`118`	`if (particle.isNewHistory()) {`
`116`		`- threadStats_[threadIndex].representedHistoriesRead++;`
`117`		`- threadStats_[threadIndex].incrementalHistorySum += particle.getIncrementalHistories();`
	`119`	`+ threadStats_[threadIndex]->representedHistoriesRead++;`
	`120`	`+ threadStats_[threadIndex]->incrementalHistorySum += particle.getIncrementalHistories();`
`118`	`121`	`}`
`119`	`122`	`}`
`120`	`123`
`@@ -161,7 +164,7 @@ namespace ParticleZoo {`
`161`	`164`	`if (threadIndex >= readers_.size()) {`
`162`	`165`	`throw std::out_of_range("Thread index out of range in getHistoriesRead()");`
`163`	`166`	`}`
`164`		`- return threadStats_[threadIndex].particlesRead;`
	`167`	`+ return threadStats_[threadIndex]->particlesRead;`
`165`	`168`	`}`
`166`	`169`
`167`	`170`	`std::uint64_t ParticleBalancedParallelReader::getHistoriesRead(size_t threadIndex) const {`
`@@ -172,21 +175,21 @@ namespace ParticleZoo {`
`172`	`175`	`switch (historyCountMode_) {`
`173`	`176`	`case HistoryCountMode::RATIO:`
`174`	`177`	`{`
`175`		`- const std::uint64_t representedHistories = threadStats_[threadIndex].representedHistoriesRead;`
	`178`	`+ const std::uint64_t representedHistories = threadStats_[threadIndex]->representedHistoriesRead;`
`176`	`179`	`return (representedHistories * numberOfOriginalHistories_)`
`177`	`180`	`/ numberOfRepresentedHistories_;`
`178`	`181`	`}`
`179`	`182`	`case HistoryCountMode::INCREMENTAL:`
`180`		`- return threadStats_[threadIndex].incrementalHistorySum;`
	`183`	`+ return threadStats_[threadIndex]->incrementalHistorySum;`
`181`	`184`	`}`
`182`	`185`
`183`		`- return threadStats_[threadIndex].representedHistoriesRead; // unreachable fallback`
	`186`	`+ return threadStats_[threadIndex]->representedHistoriesRead; // unreachable fallback`
`184`	`187`	`}`
`185`	`188`
`186`	`189`	`std::uint64_t ParticleBalancedParallelReader::getTotalParticlesRead() const {`
`187`	`190`	`std::uint64_t total = 0;`
`188`	`191`	`for (size_t t = 0; t < numThreads_; t++) {`
`189`		`- total += threadStats_[t].particlesRead;`
	`192`	`+ total += threadStats_[t]->particlesRead;`
`190`	`193`	`}`
`191`	`194`	`return total;`
`192`	`195`	`}`
`@@ -196,17 +199,17 @@ namespace ParticleZoo {`
`196`	`199`	`case HistoryCountMode::RATIO: {`
`197`	`200`	`std::uint64_t totalRep = 0;`
`198`	`201`	`for (size_t t = 0; t < numThreads_; t++) {`
`199`		`- totalRep += threadStats_[t].representedHistoriesRead;`
	`202`	`+ totalRep += threadStats_[t]->representedHistoriesRead;`
`200`	`203`	`}`
`201`	`204`	`return (totalRep * numberOfOriginalHistories_) / numberOfRepresentedHistories_;`
`202`	`205`	`}`
`203`	`206`	`case HistoryCountMode::INCREMENTAL: {`
`204`	`207`	`std::uint64_t total = 0;`
`205`	`208`	`std::uint64_t totalParticles = 0;`
`206`	`209`	`for (size_t t = 0; t < numThreads_; t++) {`
`207`		`- std::lock_guard<std::mutex> lock(threadStats_[t].mutex);`
`208`		`- total += threadStats_[t].incrementalHistorySum;`
`209`		`- totalParticles += threadStats_[t].particlesRead;`
	`210`	`+ std::lock_guard<std::mutex> lock(threadStats_[t]->mutex);`
	`211`	`+ total += threadStats_[t]->incrementalHistorySum;`
	`212`	`+ totalParticles += threadStats_[t]->particlesRead;`
`210`	`213`	`}`
`211`	`214`	`if (totalParticles >= numberOfParticlesInPhsp_)`
`212`	`215`	`return numberOfOriginalHistories_;`