Don't capture local variables in loop by reference (#623)

* Don't capture local variables in loop by reference

1 files changed, 27 insertions, 27 deletions

diff --git a/src/zenstore/gc.cpp b/src/zenstore/gc.cpp
index 4cc2c3ed1..8c02e82c5 100644
--- a/src/zenstore/gc.cpp
+++ b/src/zenstore/gc.cpp
@@ -646,18 +646,18 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 						return Sum(Result, true);
 					}
 					GcReferencer*							   Owner = m_GcReferencers[Index];
-					std::pair<std::string, GcReferencerStats>& Stats = Result.ReferencerStats[Index];
+					std::pair<std::string, GcReferencerStats>* Stats = &Result.ReferencerStats[Index];
 					WorkLeft.AddCount(1);
-					ThreadPool.ScheduleWork([&Ctx, &WorkLeft, Owner, &Stats, &StoreCompactorsLock, &StoreCompactors]() {
-						auto _		= MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
-						Stats.first = Owner->GetGcName(Ctx);
-						SCOPED_TIMER(Stats.second.RemoveExpiredDataStats.ElapsedMS = std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
+					ThreadPool.ScheduleWork([&Ctx, &WorkLeft, Owner, Stats, &StoreCompactorsLock, &StoreCompactors]() {
+						auto _		 = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
+						Stats->first = Owner->GetGcName(Ctx);
+						SCOPED_TIMER(Stats->second.RemoveExpiredDataStats.ElapsedMS = std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
 						std::unique_ptr<GcStoreCompactor> StoreCompactor(
-							Owner->RemoveExpiredData(Ctx, Stats.second.RemoveExpiredDataStats));
+							Owner->RemoveExpiredData(Ctx, Stats->second.RemoveExpiredDataStats));
 						if (StoreCompactor)
 						{
 							RwLock::ExclusiveLockScope __(StoreCompactorsLock);
-							StoreCompactors.insert_or_assign(std::move(StoreCompactor), &Stats.second.CompactStoreStats);
+							StoreCompactors.insert_or_assign(std::move(StoreCompactor), &Stats->second.CompactStoreStats);
 						}
 					});
 				}
@@ -703,19 +703,19 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 						}
 
 						GcReferenceStore*							   ReferenceStore = m_GcReferenceStores[Index];
-						std::pair<std::string, GcReferenceStoreStats>& Stats		  = Result.ReferenceStoreStats[Index];
+						std::pair<std::string, GcReferenceStoreStats>* Stats		  = &Result.ReferenceStoreStats[Index];
 						WorkLeft.AddCount(1);
 						ThreadPool.ScheduleWork(
-							[&Ctx, ReferenceStore, &Stats, Index, &WorkLeft, &ReferencePrunersLock, &ReferencePruners]() {
-								auto _		= MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
-								Stats.first = ReferenceStore->GetGcName(Ctx);
+							[&Ctx, ReferenceStore, Stats, Index, &WorkLeft, &ReferencePrunersLock, &ReferencePruners]() {
+								auto _		 = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
+								Stats->first = ReferenceStore->GetGcName(Ctx);
 								std::unique_ptr<GcReferencePruner> ReferencePruner;
 								{
-									SCOPED_TIMER(Stats.second.CreateReferencePrunersMS =
+									SCOPED_TIMER(Stats->second.CreateReferencePrunersMS =
 													 std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
 									// The ReferenceStore will pick a list of CId entries to check, returning a collector
 									ReferencePruner =
-										std::unique_ptr<GcReferencePruner>(ReferenceStore->CreateReferencePruner(Ctx, Stats.second));
+										std::unique_ptr<GcReferencePruner>(ReferenceStore->CreateReferencePruner(Ctx, Stats->second));
 								}
 								if (ReferencePruner)
 								{
@@ -764,16 +764,16 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 							}
 
 							GcReferencer*							   Referencer = m_GcReferencers[Index];
-							std::pair<std::string, GcReferencerStats>& Stats	  = Result.ReferencerStats[Index];
+							std::pair<std::string, GcReferencerStats>* Stats	  = &Result.ReferencerStats[Index];
 							WorkLeft.AddCount(1);
 							ThreadPool.ScheduleWork(
-								[&Ctx, &WorkLeft, Referencer, Index, &Stats, &ReferenceCheckersLock, &ReferenceCheckers]() {
+								[&Ctx, &WorkLeft, Referencer, Index, Stats, &ReferenceCheckersLock, &ReferenceCheckers]() {
 									auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 									// The Referencer will create a reference checker that guarrantees that the references do not change as
 									// long as it lives
 									std::vector<GcReferenceChecker*> Checkers;
 									{
-										SCOPED_TIMER(Stats.second.CreateReferenceCheckersMS =
+										SCOPED_TIMER(Stats->second.CreateReferenceCheckersMS =
 														 std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
 										Checkers = Referencer->CreateReferenceCheckers(Ctx);
 									}
@@ -835,11 +835,11 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 
 								GcReferenceChecker*						   Checker = It.first.get();
 								size_t									   Index   = It.second;
-								std::pair<std::string, GcReferencerStats>& Stats   = Result.ReferencerStats[Index];
+								std::pair<std::string, GcReferencerStats>* Stats   = &Result.ReferencerStats[Index];
 								WorkLeft.AddCount(1);
-								ThreadPool.ScheduleWork([&Ctx, Checker, Index, &Stats, &WorkLeft]() {
+								ThreadPool.ScheduleWork([&Ctx, Checker, Index, Stats, &WorkLeft]() {
 									auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
-									SCOPED_TIMER(Stats.second.PreCacheStateMS = std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
+									SCOPED_TIMER(Stats->second.PreCacheStateMS = std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
 									Checker->PreCache(Ctx);
 								});
 							}
@@ -884,11 +884,11 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 
 								GcReferenceChecker*						   Checker = It.first.get();
 								size_t									   Index   = It.second;
-								std::pair<std::string, GcReferencerStats>& Stats   = Result.ReferencerStats[Index];
+								std::pair<std::string, GcReferencerStats>* Stats   = &Result.ReferencerStats[Index];
 								WorkLeft.AddCount(1);
-								ThreadPool.ScheduleWork([&Ctx, Checker, Index, &Stats, &WorkLeft]() {
+								ThreadPool.ScheduleWork([&Ctx, Checker, Index, Stats, &WorkLeft]() {
 									auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
-									SCOPED_TIMER(Stats.second.LockStateMS = std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
+									SCOPED_TIMER(Stats->second.LockStateMS = std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
 									Checker->LockState(Ctx);
 								});
 							}
@@ -940,26 +940,26 @@ GcManager::CollectGarbage(const GcSettings& Settings)
 
 								GcReferencePruner*	   Pruner = It.second.get();
 								size_t				   Index  = It.first;
-								GcReferenceStoreStats& Stats  = Result.ReferenceStoreStats[Index].second;
+								GcReferenceStoreStats* Stats  = &Result.ReferenceStoreStats[Index].second;
 								WorkLeft.AddCount(1);
 								ThreadPool.ScheduleWork(
-									[&Ctx, Pruner, &Stats, &WorkLeft, &GetUnusedReferences, &StoreCompactorsLock, &StoreCompactors]() {
+									[&Ctx, Pruner, Stats, &WorkLeft, &GetUnusedReferences, &StoreCompactorsLock, &StoreCompactors]() {
 										auto _ = MakeGuard([&WorkLeft]() { WorkLeft.CountDown(); });
 										// Go through all the ReferenceCheckers to see if the list of Cids the collector selected are
 										// referenced or not.
 										std::unique_ptr<GcStoreCompactor> StoreCompactor;
 										{
-											SCOPED_TIMER(Stats.RemoveUnreferencedDataStats.ElapsedMS =
+											SCOPED_TIMER(Stats->RemoveUnreferencedDataStats.ElapsedMS =
 															 std::chrono::milliseconds(Timer.GetElapsedTimeMs()););
 											StoreCompactor = std::unique_ptr<GcStoreCompactor>(
 												Pruner->RemoveUnreferencedData(Ctx,
-																			   Stats.RemoveUnreferencedDataStats,
+																			   Stats->RemoveUnreferencedDataStats,
 																			   GetUnusedReferences));
 										}
 										if (StoreCompactor)
 										{
 											RwLock::ExclusiveLockScope __(StoreCompactorsLock);
-											StoreCompactors.insert_or_assign(std::move(StoreCompactor), &Stats.CompactStoreStats);
+											StoreCompactors.insert_or_assign(std::move(StoreCompactor), &Stats->CompactStoreStats);
 										}
 									});
 							}