On 9/1/20 2:33 PM, Martin Liška wrote:
The last patch is a refactoring using ONE_* macros.
Thoughts?
Thanks,
Martin
There's rebassed version of the patch.
Patch can bootstrap on x86_64-linux-gnu and survives regression tests.
Ready to be installed?
Thanks,
Martin
>From 5cefff607077503794a387b612585604c2b3d0f0 Mon Sep 17 00:00:00 2001
From: Martin Liska <mli...@suse.cz>
Date: Wed, 2 Sep 2020 14:34:21 +0200
Subject: [PATCH 3/3] Use ONE_? macros.
gcc/ChangeLog:
* ggc-common.c (ggc_rlimit_bound): Use ONE_? macro.
(ggc_min_expand_heuristic): Likewise.
(ggc_min_heapsize_heuristic): Likewise.
* ggc-page.c (ggc_collect): Likewise.
* system.h (ONE_G): Likewise.
---
gcc/ggc-common.c | 16 ++++++++--------
gcc/ggc-page.c | 2 +-
gcc/system.h | 1 +
3 files changed, 10 insertions(+), 9 deletions(-)
diff --git a/gcc/ggc-common.c b/gcc/ggc-common.c
index 50c52fe525b..c21886861f0 100644
--- a/gcc/ggc-common.c
+++ b/gcc/ggc-common.c
@@ -742,7 +742,7 @@ ggc_rlimit_bound (double limit)
appears to be ignored. Ignore such silliness. If a limit
this small was actually effective for mmap, GCC wouldn't even
start up. */
- && rlim.rlim_cur >= 8 * 1024 * 1024)
+ && rlim.rlim_cur >= 8 * ONE_M)
limit = rlim.rlim_cur;
# endif /* RLIMIT_AS or RLIMIT_DATA */
#endif /* HAVE_GETRLIMIT */
@@ -761,7 +761,7 @@ ggc_min_expand_heuristic (void)
/* The heuristic is a percentage equal to 30% + 70%*(RAM/1GB), yielding
a lower bound of 30% and an upper bound of 100% (when RAM >= 1GB). */
- min_expand /= 1024*1024*1024;
+ min_expand /= ONE_G;
min_expand *= 70;
min_expand = MIN (min_expand, 70);
min_expand += 30;
@@ -776,8 +776,8 @@ ggc_min_heapsize_heuristic (void)
double phys_kbytes = physmem_total ();
double limit_kbytes = ggc_rlimit_bound (phys_kbytes * 2);
- phys_kbytes /= 1024; /* Convert to Kbytes. */
- limit_kbytes /= 1024;
+ phys_kbytes /= ONE_K; /* Convert to Kbytes. */
+ limit_kbytes /= ONE_K;
/* The heuristic is RAM/8, with a lower bound of 4M and an upper
bound of 128M (when RAM >= 1GB). */
@@ -790,7 +790,7 @@ ggc_min_heapsize_heuristic (void)
struct rlimit rlim;
if (getrlimit (RLIMIT_RSS, &rlim) == 0
&& rlim.rlim_cur != (rlim_t) RLIM_INFINITY)
- phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / 1024);
+ phys_kbytes = MIN (phys_kbytes, rlim.rlim_cur / ONE_K);
}
# endif
@@ -798,12 +798,12 @@ ggc_min_heapsize_heuristic (void)
*next* GC would be within 20Mb of the limit or within a quarter of
the limit, whichever is larger. If GCC does hit the data limit,
compilation will fail, so this tries to be conservative. */
- limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * 1024));
+ limit_kbytes = MAX (0, limit_kbytes - MAX (limit_kbytes / 4, 20 * ONE_K));
limit_kbytes = (limit_kbytes * 100) / (110 + ggc_min_expand_heuristic ());
phys_kbytes = MIN (phys_kbytes, limit_kbytes);
- phys_kbytes = MAX (phys_kbytes, 4 * 1024);
- phys_kbytes = MIN (phys_kbytes, 128 * 1024);
+ phys_kbytes = MAX (phys_kbytes, 4 * ONE_K);
+ phys_kbytes = MIN (phys_kbytes, 128 * ONE_K);
return phys_kbytes;
}
diff --git a/gcc/ggc-page.c b/gcc/ggc-page.c
index 9405f033a7c..07e108f3e9d 100644
--- a/gcc/ggc-page.c
+++ b/gcc/ggc-page.c
@@ -2184,7 +2184,7 @@ ggc_collect (void)
total allocations haven't expanded much since the last
collection. */
float allocated_last_gc =
- MAX (G.allocated_last_gc, (size_t)param_ggc_min_heapsize * 1024);
+ MAX (G.allocated_last_gc, (size_t)param_ggc_min_heapsize * ONE_K);
/* It is also good time to get memory block pool into limits. */
memory_block_pool::trim ();
diff --git a/gcc/system.h b/gcc/system.h
index 4f0482be25d..b0f3f1dd019 100644
--- a/gcc/system.h
+++ b/gcc/system.h
@@ -1237,6 +1237,7 @@ void gcc_stablesort (void *, size_t, size_t,
#define ONE_K 1024
#define ONE_M (ONE_K * ONE_K)
+#define ONE_G (ONE_K * ONE_M)
/* Display a number as an integer multiple of either:
- 1024, if said integer is >= to 10 K (in base 2)
--
2.28.0
