hg_malloc: report max_used as the peak of real_used, not the peak carve

max_used was the high-water mark of hb->real_used, which in the slab
path is the CARVE total. Carve only ever grows - each worker carves its
own chunk the first time it touches a size class - so max_used climbed
indefinitely and drifted away from real_used instead of meaning what it
means for every other allocator: the peak that real_used reached.

Track the peak of the reported live figure separately and report that.
The mark is sampled when the stats are read, so a spike between two
reads can be missed, and the unsynchronized update is a benign race - a
lost update can only under-report. The peak carve is still kept in
max_real_used; exposing it belongs in a stat of its own, not in
max_used.

Author: Lt-Flash

mem/hg_malloc.c

@@ -463,11 +463,12 @@ void hg_info(struct hg_block *hb, struct mem_info *info)
 	info->real_used = hb->real_used > recycled ? hb->real_used - recycled : 0;
 	info->free = hb->size - info->real_used;
 
-	/* peak carve: chunks are only ever carved when demand outruns the
-	 * recycled supply, so this is the high-water mark of live commitment
-	 * (and a safe upper bound on it), and stays monotonic like every other
-	 * allocator's max_used */
-	info->max_used = hb->max_real_used;
+	/* the peak of what real_used above actually reached - NOT the peak
+	 * carve (hb->max_real_used), which only ever grows and would drift
+	 * away from real_used forever */
+	if (info->real_used > hb->max_live_used)
+		hb->max_live_used = info->real_used;
+	info->max_used = hb->max_live_used;
 	info->total_frags = hg_fragments(hb);
 }
 

mem/hg_malloc.h

@@ -229,6 +229,16 @@ struct hg_block {
 	 * lock-free fast path, so a plain field is safe here. */
 	unsigned long real_used;
 	unsigned long max_real_used;
+	/* High-water mark of the LIVE figure that hg_get_real_used() reports, as
+	 * opposed to max_real_used above, which is the peak CARVE. They are
+	 * different quantities: carve only ever grows (chunks are never
+	 * un-carved), so reporting it as max_used made max_used drift away from
+	 * real_used forever instead of meaning "the peak real_used reached" -
+	 * unlike every other allocator. Sampled, not exact: refreshed whenever
+	 * the stats are read, so a spike between two reads can be missed. The
+	 * unsynchronized max update is a benign race - a lost update can only
+	 * under-report, never over-report. */
+	unsigned long max_live_used;
 
 	/* the fast-path counters - see struct hg_pstat above. Summed by
 	 * hg_used()/hg_fragments(); never read directly. */
@@ -435,12 +445,18 @@ static inline unsigned long hg_get_free(struct hg_block *hb)
 static inline unsigned long hg_get_real_used(struct hg_block *hb)
 {
 	unsigned long recycled = hg_slab_recycled(hb);
+	unsigned long live = hb->real_used > recycled ?
+	                     hb->real_used - recycled : 0;
 
-	return hb->real_used > recycled ? hb->real_used - recycled : 0;
+	if (live > hb->max_live_used)
+		hb->max_live_used = live;
+	return live;
 }
 static inline unsigned long hg_get_max_real_used(struct hg_block *hb)
 {
-	return hb->max_real_used;
+	/* refresh the mark first, so reading max on its own is not stale */
+	(void)hg_get_real_used(hb);
+	return hb->max_live_used;
 }
 static inline unsigned long hg_get_frags(struct hg_block *hb)
 {