mem: stop HG_MALLOC clobbering ROUNDTO for the other allocators

hg_malloc.h did "#undef ROUNDTO" and redefined it as sizeof(void *).
Since common.h includes hg_malloc.h last - after hp_malloc.h - that
definition won in every translation unit including common.h, silently
replacing HP_MALLOC's "ROUNDTO 8UL" inside hp_malloc.c itself.

On 64-bit sizeof(void *) is also 8, so the value was unchanged and
nothing showed. On 32-bit it becomes 4 and size_t is unsigned int, which
broke the build at mem/hp_malloc.o under -Werror=format ("%lu"/"%ld"
against ROUNDTO in hp_malloc.c and hp_malloc_dyn.h), and, more quietly,
changed HP_MALLOC's own geometry there: HP_LINEAR_HASH_SIZE and UN_HASH()
are derived from ROUNDTO, the block struct is aligned to it, and it is
persisted in the shm pattern file.

Give HG_MALLOC its own HG_ROUNDTO instead, the way q_malloc already uses
QM_ROUNDTO, and drop the #undef of the shared macro. No functional change
to HG_MALLOC: HG_ROUNDTO keeps the exact definition ROUNDTO had here.

Author: Lt-Flash

mem/hg_arena.c

@@ -31,7 +31,7 @@
 #include "../dprint.h"
 #include "../globals.h"
 
-/* ~x1.5 ladder, all multiples of 32 so cells stay ROUNDTO-aligned; ported
+/* ~x1.5 ladder, all multiples of 32 so cells stay HG_ROUNDTO-aligned; ported
  * unchanged from cachedb_perf's pcache_arena.c cell_sizes[] - these are
  * TOTAL slot sizes (header + payload), same convention as there */
 static const unsigned int cell_sizes[HG_NCLASSES] = {
@@ -227,8 +227,8 @@ int hg_arena_init(struct hg_block *hb, unsigned long hdr_size)
 		hb->chunk_max = HG_CHUNK_MIN;
 
 	/* size -> class LUT: needed = requested payload + hidden header */
-	for (idx = 0; idx <= HG_CELL_MAX / ROUNDTO; idx++) {
-		needed = idx * ROUNDTO + HG_CELL_HDR;
+	for (idx = 0; idx <= HG_CELL_MAX / HG_ROUNDTO; idx++) {
+		needed = idx * HG_ROUNDTO + HG_CELL_HDR;
 		for (c = 0; c < HG_NCLASSES; c++)
 			if (cell_sizes[c] >= needed)
 				break;
@@ -336,7 +336,7 @@ void *hg_cell_alloc(struct hg_block *hb, unsigned long size)
 		return hg_large_alloc(hb, size);
 #endif
 	}
-	c = hb->size2class[(size + ROUNDTO - 1) / ROUNDTO];
+	c = hb->size2class[(size + HG_ROUNDTO - 1) / HG_ROUNDTO];
 	if (c >= HG_NCLASSES)
 		return NULL;
 
@@ -388,9 +388,9 @@ void *hg_cell_alloc(struct hg_block *hb, unsigned long size)
 	payload = cell_start + HG_CELL_HDR;
 #ifdef DBG_MALLOC
 	{
-		const char **hfile = (const char **)(cell_start + ROUNDTO);
-		const char **hfunc = (const char **)(cell_start + ROUNDTO * 2);
-		unsigned long *hline = (unsigned long *)(cell_start + ROUNDTO * 3);
+		const char **hfile = (const char **)(cell_start + HG_ROUNDTO);
+		const char **hfunc = (const char **)(cell_start + HG_ROUNDTO * 2);
+		unsigned long *hline = (unsigned long *)(cell_start + HG_ROUNDTO * 3);
 		*hfile = file;
 		*hfunc = func;
 		*hline = line;

mem/hg_large.c

@@ -27,7 +27,7 @@
 #include "hg_arena.h"
 #include "../dprint.h"
 
-#define HG_LARGE_MIN_FRAG    ROUNDTO
+#define HG_LARGE_MIN_FRAG    HG_ROUNDTO
 #define HG_LARGE_DEFAULT_CHUNK (1UL << 20)  /* 1 MB - amortizes future churn */
 
 struct hg_large_chunk {
@@ -75,7 +75,7 @@ void *hg_large_alloc(struct hg_block *hb, unsigned long size)
 	struct hg_large_chunk *ch;
 	char *base, *tag;
 
-	/* round to HG_PAYLOAD_ALIGN, not ROUNDTO: a frag's size is what
+	/* round to HG_PAYLOAD_ALIGN, not HG_ROUNDTO: a frag's size is what
 	 * places the NEXT frag (HG_LFRAG_NEXT), so rounding to 4 on 32-bit
 	 * ARM would walk every subsequent frag - and its payload - off the
 	 * 8-byte boundary the first one started on */
@@ -178,9 +178,9 @@ void *hg_large_alloc(struct hg_block *hb, unsigned long size)
 	*(unsigned char *)tag = HG_LARGE_MARKER;
 #ifdef DBG_MALLOC
 	{
-		const char **hfile = (const char **)(tag + ROUNDTO);
-		const char **hfunc = (const char **)(tag + ROUNDTO * 2);
-		unsigned long *hline = (unsigned long *)(tag + ROUNDTO * 3);
+		const char **hfile = (const char **)(tag + HG_ROUNDTO);
+		const char **hfunc = (const char **)(tag + HG_ROUNDTO * 2);
+		unsigned long *hline = (unsigned long *)(tag + HG_ROUNDTO * 3);
 		*hfile = file;
 		*hfunc = func;
 		*hline = line;

mem/hg_malloc.c

@@ -118,9 +118,9 @@ static unsigned long hg_hps(void)
  * all go through this one macro rather than repeating the expression. */
 #define HG_HPS_ROUND(s) (((s) + HG_HPS - 1) & ~(HG_HPS - 1))
 
-/* ROUNDTO=2^k so the following works (same trick as f_malloc.c) */
-#define ROUNDTO_MASK   (~((unsigned long)ROUNDTO-1))
-#define ROUNDUP_TO(s)  (((s)+(ROUNDTO-1))&ROUNDTO_MASK)
+/* HG_ROUNDTO=2^k so the following works (same trick as f_malloc.c) */
+#define ROUNDTO_MASK   (~((unsigned long)HG_ROUNDTO-1))
+#define ROUNDUP_TO(s)  (((s)+(HG_ROUNDTO-1))&ROUNDTO_MASK)
 
 /*
  * Tier ladder + verification, ported near-verbatim from cachedb_perf's
@@ -494,14 +494,14 @@ static void hg_dbg_dump_cb(void *payload, void *ctx)
 	 * is gated on DBG_MALLOC alone, so it must not depend on
 	 * SHM_EXTRA_STATS also being on.
 	 */
-	file = *(const char **)(tag + ROUNDTO);
+	file = *(const char **)(tag + HG_ROUNDTO);
 	if (!file)
 		return;   /* stamped before any hg_malloc_dbg() call ever ran
 		           * on this cell (e.g. still on its very first carve
 		           * without having been freed+realloc'd) - matches
 		           * fm_status_dbg's own "if (f->file)" guard */
-	func = *(const char **)(tag + ROUNDTO * 2);
-	line = *(unsigned long *)(tag + ROUNDTO * 3);
+	func = *(const char **)(tag + HG_ROUNDTO * 2);
+	line = *(unsigned long *)(tag + HG_ROUNDTO * 3);
 
 	if (dbg_ht_update(*c->allocd, file, func, line, hg_frag_size(payload)) < 0)
 		LM_ERR("unable to update the %s allocation summary\n", "HG_MALLOC");

mem/hg_malloc.h

@@ -32,12 +32,12 @@
  * cross-compiler. */
 #include "../globals.h"
 
-#undef ROUNDTO
+#undef HG_ROUNDTO
 
 #if defined(__CPU_sparc64) || defined(__CPU_sparc)
-	#define ROUNDTO		sizeof(long long)
+	#define HG_ROUNDTO		sizeof(long long)
 #else
-	#define ROUNDTO		sizeof(void *)
+	#define HG_ROUNDTO		sizeof(void *)
 #endif
 
 #define HG_NCLASSES  21
@@ -68,34 +68,34 @@ const char *hg_mem_tier_str(enum hg_mem_tier tier);
  *
  *   offset 0                          : class id (immutable, stamped at
  *                                        chunk-carve time)
- *   offset ROUNDTO           (DBG)    : file
- *   offset ROUNDTO*2         (DBG)    : func
- *   offset ROUNDTO*3         (DBG)    : line
- *   offset ROUNDTO+HG_CELL_HDR_DBG
+ *   offset HG_ROUNDTO           (DBG)    : file
+ *   offset HG_ROUNDTO*2         (DBG)    : func
+ *   offset HG_ROUNDTO*3         (DBG)    : line
+ *   offset HG_ROUNDTO+HG_CELL_HDR_DBG
  *          (SHM_EXTRA_STATS)          : statistic_index (mem-group index)
  *   offset HG_CELL_HDR                : payload starts here; while a cell
- *                                        is FREE, the first ROUNDTO*2 bytes
+ *                                        is FREE, the first HG_ROUNDTO*2 bytes
  *                                        of payload double as the free-list
  *                                        link (cell_next()/cell_set_next()
  *                                        in hg_arena.c) - safe, since
  *                                        nobody reads payload of a free cell.
  */
 #ifdef DBG_MALLOC
-#define HG_CELL_HDR_DBG (ROUNDTO * 3)  /* file ptr + func ptr + line */
+#define HG_CELL_HDR_DBG (HG_ROUNDTO * 3)  /* file ptr + func ptr + line */
 #else
 #define HG_CELL_HDR_DBG 0
 #endif
 
 #ifdef SHM_EXTRA_STATS
-#define HG_CELL_HDR_STATS (ROUNDTO)    /* statistic_index */
+#define HG_CELL_HDR_STATS (HG_ROUNDTO)    /* statistic_index */
 #else
 #define HG_CELL_HDR_STATS 0
 #endif
 
 /*
  * Payloads must be aligned for the widest scalar a caller may store in
  * them; 8 covers uint64_t/double everywhere we build. This is NOT implied
- * by ROUNDTO: on 32-bit ARM ROUNDTO is 4, so the raw header below would be
+ * by HG_ROUNDTO: on 32-bit ARM HG_ROUNDTO is 4, so the raw header below would be
  * 4 bytes in a plain build, and since cells always start 32-byte aligned
  * EVERY payload would land at 4 mod 8 - misaligned for any 64-bit field,
  * and an outright fault for the LDREXD/STREXD that gen_lock_t and the
@@ -106,13 +106,13 @@ const char *hg_mem_tier_str(enum hg_mem_tier tier);
  * stays exactly where it was and only the header's total size grows.
  */
 #define HG_PAYLOAD_ALIGN 8
-#define HG_CELL_HDR_RAW  (ROUNDTO + HG_CELL_HDR_DBG + HG_CELL_HDR_STATS)
+#define HG_CELL_HDR_RAW  (HG_ROUNDTO + HG_CELL_HDR_DBG + HG_CELL_HDR_STATS)
 #define HG_CELL_HDR \
 	(((HG_CELL_HDR_RAW + HG_PAYLOAD_ALIGN - 1) / HG_PAYLOAD_ALIGN) \
 	 * HG_PAYLOAD_ALIGN)
 
 /* offset of the statistic_index field, valid only when SHM_EXTRA_STATS */
-#define HG_CELL_STATS_OFF (ROUNDTO + HG_CELL_HDR_DBG)
+#define HG_CELL_STATS_OFF (HG_ROUNDTO + HG_CELL_HDR_DBG)
 
 #define HG_HDR(p)   ((char *)(p) - HG_CELL_HDR)
 #define HG_CLASS(p) (*(unsigned char *)HG_HDR(p))
@@ -138,7 +138,7 @@ struct hg_lfrag;         /* opaque here, defined in hg_large.h */
  * sizeof() on it) to locate a large frag's header from a payload pointer.
  * hg_large.c static_asserts this matches the real struct, so any future
  * field change there fails the build here instead of drifting silently. */
-#define HG_LFRAG_HDR_SIZE (4 * ROUNDTO)
+#define HG_LFRAG_HDR_SIZE (4 * HG_ROUNDTO)
 
 struct hg_chunk {
 	struct hg_chunk *next;    /* global registry, append-only */
@@ -236,8 +236,8 @@ struct hg_block {
 	enum hg_mem_tier      tier;
 	unsigned long         locked_mb;
 
-	unsigned char size2class[(HG_CELL_MAX / ROUNDTO) + 1];
-} __attribute__ ((aligned (ROUNDTO)));
+	unsigned char size2class[(HG_CELL_MAX / HG_ROUNDTO) + 1];
+} __attribute__ ((aligned (HG_ROUNDTO)));
 
 /*
  * Reserves its own huge-page-backed (or gracefully degraded) region of
@@ -334,15 +334,15 @@ void hg_stats_set_index(void *ptr, unsigned long idx);
 #ifdef DBG_MALLOC
 static inline const char *hg_frag_file(void *p)
 {
-	return *(const char **)(HG_HDR(p) + ROUNDTO);
+	return *(const char **)(HG_HDR(p) + HG_ROUNDTO);
 }
 static inline const char *hg_frag_func(void *p)
 {
-	return *(const char **)(HG_HDR(p) + ROUNDTO * 2);
+	return *(const char **)(HG_HDR(p) + HG_ROUNDTO * 2);
 }
 static inline unsigned long hg_frag_line(void *p)
 {
-	return *(unsigned long *)(HG_HDR(p) + ROUNDTO * 3);
+	return *(unsigned long *)(HG_HDR(p) + HG_ROUNDTO * 3);
 }
 #else
 static inline const char *hg_frag_file(void *p) { return NULL; }

mem/hg_malloc_dyn.h

@@ -139,7 +139,7 @@ void *hg_realloc(struct hg_block *hb, void *p, unsigned long size,
 		return NULL;
 	} else {
 		cur_total = hg_cell_total_size(cls);
-		need_total = ((size + ROUNDTO - 1) / ROUNDTO) * ROUNDTO + HG_CELL_HDR;
+		need_total = ((size + HG_ROUNDTO - 1) / HG_ROUNDTO) * HG_ROUNDTO + HG_CELL_HDR;
 		if (need_total <= cur_total)
 			return p;
 	}