[Git][ghc/ghc][ghc-9.6] 4 commits: nonmoving: Account for mutator allocations in bytes_allocated
Ben Gamari (@bgamari)
gitlab at gitlab.haskell.org
Sun May 21 23:47:24 UTC 2023
Ben Gamari pushed to branch ghc-9.6 at Glasgow Haskell Compiler / GHC
Commits:
7b39870b by Ben Gamari at 2023-05-21T14:30:51-04:00
nonmoving: Account for mutator allocations in bytes_allocated
Previously we failed to account direct mutator allocations into the
nonmoving heap against the mutator's allocation limit and
`cap->total_allocated`. This only manifests during CAF evaluation (since
we allocate the CAF's blackhole directly into the nonmoving heap).
Fixes #23312.
(cherry picked from commit b2cdb7dacc095142e29c0f28a956b7fa97cdb4b1)
- - - - -
3d0a7cd3 by Teo Camarasu at 2023-05-21T14:45:11-04:00
Add regression test for #17574
This test currently fails in the nonmoving way
(cherry picked from commit a56141a69842a78d56ec11be85a775eb703219bf)
- - - - -
f0f96536 by Teo Camarasu at 2023-05-21T14:45:20-04:00
fix: account for large and compact object stats with nonmoving gc
Make sure that we keep track of the size of large and compact objects that have been moved onto the nonmoving heap.
We keep track of their size and add it to the amount of live bytes in nonmoving segments to get the total size of the live nonmoving heap.
Resolves #17574
(cherry picked from commit 20c6669fc46c567e00d3cdf22aa84479b6d8dc17)
- - - - -
07243d1b by Ben Gamari at 2023-05-21T15:03:36-04:00
configure: Release 9.6.2
- - - - -
11 changed files:
- configure.ac
- rts/sm/NonMoving.c
- rts/sm/NonMoving.h
- rts/sm/NonMovingAllocate.c
- rts/sm/NonMovingMark.c
- rts/sm/NonMovingMark.h
- rts/sm/Storage.c
- rts/sm/Storage.h
- + testsuite/tests/rts/T17574.hs
- + testsuite/tests/rts/T17574.stdout
- testsuite/tests/rts/all.T
Changes:
=====================================
configure.ac
=====================================
@@ -13,7 +13,7 @@ dnl
# see what flags are available. (Better yet, read the documentation!)
#
-AC_INIT([The Glorious Glasgow Haskell Compilation System], [9.6.1], [glasgow-haskell-bugs at haskell.org], [ghc-AC_PACKAGE_VERSION])
+AC_INIT([The Glorious Glasgow Haskell Compilation System], [9.6.2], [glasgow-haskell-bugs at haskell.org], [ghc-AC_PACKAGE_VERSION])
# Version on master must be X.Y (not X.Y.Z) for ProjectVersionMunged variable
# to be useful (cf #19058). However, the version must have three components
# (X.Y.Z) on stable branches (e.g. ghc-9.2) to ensure that pre-releases are
=====================================
rts/sm/NonMoving.c
=====================================
@@ -395,7 +395,8 @@ Mutex concurrent_coll_finished_lock;
* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* The nonmoving collector uses an approximate heuristic for reporting live
* data quantity. Specifically, during mark we record how much live data we
- * find in nonmoving_live_words. At the end of mark we declare this amount to
+ * find in nonmoving_segment_live_words. At the end of mark this is combined with nonmoving_large_words
+ * and nonmoving_compact_words, and we declare this amount to
* be how much live data we have on in the nonmoving heap (by setting
* oldest_gen->live_estimate).
*
@@ -540,7 +541,7 @@ Mutex concurrent_coll_finished_lock;
*
*/
-memcount nonmoving_live_words = 0;
+memcount nonmoving_segment_live_words = 0;
// See Note [Sync phase marking budget].
MarkBudget sync_phase_marking_budget = 200000;
@@ -682,10 +683,11 @@ static void nonmovingPrepareMark(void)
dbl_link_onto(bd, &nonmoving_large_objects);
}
n_nonmoving_large_blocks += oldest_gen->n_large_blocks;
+ nonmoving_large_words += oldest_gen->n_large_words;
oldest_gen->large_objects = NULL;
oldest_gen->n_large_words = 0;
oldest_gen->n_large_blocks = 0;
- nonmoving_live_words = 0;
+ nonmoving_segment_live_words = 0;
// Clear compact object mark bits
for (bdescr *bd = nonmoving_compact_objects; bd; bd = bd->link) {
@@ -700,6 +702,7 @@ static void nonmovingPrepareMark(void)
dbl_link_onto(bd, &nonmoving_compact_objects);
}
n_nonmoving_compact_blocks += oldest_gen->n_compact_blocks;
+ nonmoving_compact_words += oldest_gen->n_compact_blocks * BLOCK_SIZE_W;
oldest_gen->n_compact_blocks = 0;
oldest_gen->compact_objects = NULL;
// TODO (osa): what about "in import" stuff??
@@ -1053,7 +1056,9 @@ concurrent_marking:
freeMarkQueue(mark_queue);
stgFree(mark_queue);
- oldest_gen->live_estimate = nonmoving_live_words;
+ nonmoving_large_words = countOccupied(nonmoving_marked_large_objects);
+ nonmoving_compact_words = n_nonmoving_marked_compact_blocks * BLOCK_SIZE_W;
+ oldest_gen->live_estimate = nonmoving_segment_live_words + nonmoving_large_words + nonmoving_compact_words;
oldest_gen->n_old_blocks = 0;
resizeGenerations();
=====================================
rts/sm/NonMoving.h
=====================================
@@ -120,7 +120,7 @@ struct NonmovingHeap {
extern struct NonmovingHeap nonmovingHeap;
-extern memcount nonmoving_live_words;
+extern memcount nonmoving_segment_live_words;
#if defined(THREADED_RTS)
extern bool concurrent_coll_running;
=====================================
rts/sm/NonMovingAllocate.c
=====================================
@@ -253,5 +253,9 @@ void *nonmovingAllocateGC(Capability *cap, StgWord sz)
GNUC_ATTR_HOT
void *nonmovingAllocate(Capability *cap, StgWord sz)
{
+ // Handle "bytes allocated" accounting in the same way we
+ // do in Storage.c:allocate. See #23312.
+ accountAllocation(cap, sz);
+ cap->total_allocated += sz;
return nonmovingAllocate_(SM_LOCK, cap, sz);
}
=====================================
rts/sm/NonMovingMark.c
=====================================
@@ -76,6 +76,10 @@ static bool is_nonmoving_weak(StgWeak *weak);
* consequently will trace the pointers of only one object per block. However,
* this is okay since the only type of pinned object supported by GHC is the
* pinned ByteArray#, which has no pointers.
+ *
+ * We need to take care that the stats department is made aware of the amount of
+ * live large (and compact) objects, since they no longer live on gen[i]->large_objects.
+ * Failing to do so caused #17574.
*/
bdescr *nonmoving_large_objects = NULL;
@@ -83,6 +87,9 @@ bdescr *nonmoving_marked_large_objects = NULL;
memcount n_nonmoving_large_blocks = 0;
memcount n_nonmoving_marked_large_blocks = 0;
+memcount nonmoving_large_words = 0;
+memcount nonmoving_compact_words = 0;
+
bdescr *nonmoving_compact_objects = NULL;
bdescr *nonmoving_marked_compact_objects = NULL;
memcount n_nonmoving_compact_blocks = 0;
@@ -1745,7 +1752,7 @@ mark_closure (MarkQueue *queue, const StgClosure *p0, StgClosure **origin)
struct NonmovingSegment *seg = nonmovingGetSegment((StgPtr) p);
nonmoving_block_idx block_idx = nonmovingGetBlockIdx((StgPtr) p);
nonmovingSetMark(seg, block_idx);
- nonmoving_live_words += nonmovingSegmentBlockSize(seg) / sizeof(W_);
+ nonmoving_segment_live_words += nonmovingSegmentBlockSize(seg) / sizeof(W_);
}
// If we found a indirection to shortcut keep going.
=====================================
rts/sm/NonMovingMark.h
=====================================
@@ -128,6 +128,11 @@ extern bdescr *nonmoving_large_objects, *nonmoving_marked_large_objects,
extern memcount n_nonmoving_large_blocks, n_nonmoving_marked_large_blocks,
n_nonmoving_compact_blocks, n_nonmoving_marked_compact_blocks;
+// The size of live large/compact objects in words.
+// Only updated at the end of nonmoving GC.
+extern memcount nonmoving_large_words,
+ nonmoving_compact_words;
+
extern StgTSO *nonmoving_old_threads;
extern StgWeak *nonmoving_old_weak_ptr_list;
extern StgTSO *nonmoving_threads;
=====================================
rts/sm/Storage.c
=====================================
@@ -42,6 +42,7 @@
#include "GC.h"
#include "Evac.h"
#include "NonMovingAllocate.h"
+#include "sm/NonMovingMark.h"
#if defined(ios_HOST_OS) || defined(darwin_HOST_OS)
#include "Hash.h"
#endif
@@ -965,7 +966,7 @@ move_STACK (StgStack *src, StgStack *dest)
dest->sp = (StgPtr)dest->sp + diff;
}
-STATIC_INLINE void
+void
accountAllocation(Capability *cap, W_ n)
{
TICK_ALLOC_HEAP_NOCTR(WDS(n));
@@ -1615,7 +1616,12 @@ W_ genLiveWords (generation *gen)
W_ genLiveBlocks (generation *gen)
{
- return gen->n_blocks + gen->n_large_blocks + gen->n_compact_blocks;
+ W_ nonmoving_blocks = 0;
+ // The nonmoving heap contains some blocks that live outside the regular generation structure.
+ if (gen == oldest_gen && RtsFlags.GcFlags.useNonmoving){
+ nonmoving_blocks = n_nonmoving_large_blocks + n_nonmoving_marked_large_blocks + n_nonmoving_compact_blocks + n_nonmoving_marked_compact_blocks;
+ }
+ return gen->n_blocks + gen->n_large_blocks + gen->n_compact_blocks + nonmoving_blocks;
}
W_ gcThreadLiveWords (uint32_t i, uint32_t g)
@@ -1711,6 +1717,9 @@ StgWord calcTotalLargeObjectsW (void)
for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
totalW += generations[g].n_large_words;
}
+
+ totalW += nonmoving_large_words;
+
return totalW;
}
@@ -1722,6 +1731,9 @@ StgWord calcTotalCompactW (void)
for (g = 0; g < RtsFlags.GcFlags.generations; g++) {
totalW += generations[g].n_compact_blocks * BLOCK_SIZE_W;
}
+
+ totalW += nonmoving_compact_words;
+
return totalW;
}
=====================================
rts/sm/Storage.h
=====================================
@@ -125,6 +125,8 @@ StgWord genLiveBlocks (generation *gen);
StgWord calcTotalLargeObjectsW (void);
StgWord calcTotalCompactW (void);
+void accountAllocation(Capability *cap, W_ n);
+
/* ----------------------------------------------------------------------------
Storage manager internal APIs and globals
------------------------------------------------------------------------- */
=====================================
testsuite/tests/rts/T17574.hs
=====================================
@@ -0,0 +1,40 @@
+-- | Check that large objects are properly accounted for by GHC.Stats
+module Main (main) where
+
+import Control.Monad
+import Control.Exception
+import Control.Concurrent
+import System.Mem
+import System.Exit
+import GHC.Stats
+import GHC.Compact
+import Data.List (replicate)
+
+import qualified Data.ByteString.Char8 as BS
+
+doGC :: IO ()
+doGC = do
+ performMajorGC
+ threadDelay 1000 -- small delay to allow GC to run when using concurrent gc
+
+main :: IO ()
+main = do
+ let size = 4096*2
+ largeString <- evaluate $ BS.replicate size 'A'
+ compactString <- compact $ replicate size 'A'
+ doGC
+ doGC -- run GC twice to make sure the objects end up in the oldest gen
+ stats <- getRTSStats
+ let large_obj_bytes = gcdetails_large_objects_bytes $ gc stats
+ let compact_obj_bytes = gcdetails_compact_bytes $ gc stats
+ -- assert that large_obj_bytes is at least as big as size
+ -- this indicates that `largeString` is being accounted for by the stats department
+ when (large_obj_bytes < fromIntegral size) $ do
+ putStrLn $ "large_obj_bytes is: " <> show large_obj_bytes <> " but expected at least: " <> show size
+ exitFailure
+ when (compact_obj_bytes < fromIntegral size) $ do
+ putStrLn $ "compact_obj_bytes is: " <> show large_obj_bytes <> " but expected at least: " <> show size
+ exitFailure
+ -- keep them alive
+ print $ BS.length largeString
+ print $ length $ getCompact compactString
=====================================
testsuite/tests/rts/T17574.stdout
=====================================
@@ -0,0 +1,2 @@
+8192
+8192
=====================================
testsuite/tests/rts/all.T
=====================================
@@ -568,3 +568,5 @@ test('decodeMyStack_emptyListForMissingFlag',
, ignore_stderr
, js_broken(22261) # cloneMyStack# not yet implemented
], compile_and_run, [''])
+
+test('T17574', [js_skip], compile_and_run, ['-with-rtsopts -T'])
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/15da0925a866aac4c8773daf03d4322c0e21a923...07243d1b1ad92c98f4728afb31fc9c39573c14f0
--
View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/15da0925a866aac4c8773daf03d4322c0e21a923...07243d1b1ad92c98f4728afb31fc9c39573c14f0
You're receiving this email because of your account on gitlab.haskell.org.
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.haskell.org/pipermail/ghc-commits/attachments/20230521/50260e85/attachment-0001.html>
More information about the ghc-commits
mailing list