From 576d7047ab93baf37d851136f6ccd4fb38810ded Mon Sep 17 00:00:00 2001
From: David Goldblatt <davidgoldblatt@fb.com>
Date: Fri, 13 Dec 2019 11:33:03 -0800
Subject: [PATCH] Ecache: Should know its arena_ind.

What we call an arena_ind is really the index associated with some particular
set of ehooks; the arena is just the user-visible portion of that.  Making this
explicit, and reframing checks in terms of that, makes the code simpler and
cleaner, and helps us avoid passing the arena itself all throughout extent code.

This lets us put back an arena-specific assert.
---
 include/jemalloc/internal/ecache.h | 9 ++++++++-
 src/arena.c                        | 8 +++++---
 src/ecache.c                       | 3 ++-
 src/extent2.c                      | 2 ++
 4 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/include/jemalloc/internal/ecache.h b/include/jemalloc/internal/ecache.h
index 8532192c..a11418c0 100644
--- a/include/jemalloc/internal/ecache.h
+++ b/include/jemalloc/internal/ecache.h
@@ -10,6 +10,8 @@ struct ecache_s {
 	eset_t eset;
 	/* All stored extents must be in the same state. */
 	extent_state_t state;
+	/* The index of the ehooks the ecache is associated with. */
+	unsigned ind;
 	/*
 	 * If true, delay coalescing until eviction; otherwise coalesce during
 	 * deallocation.
@@ -52,8 +54,13 @@ ecache_nbytes_get(ecache_t *ecache, pszind_t ind) {
 	return eset_nbytes_get(&ecache->eset, ind);
 }
 
+static inline unsigned
+ecache_ind_get(ecache_t *ecache) {
+	return ecache->ind;
+}
+
 bool ecache_init(tsdn_t *tsdn, ecache_t *ecache, extent_state_t state,
-    bool delay_coalesce);
+    unsigned ind, bool delay_coalesce);
 void ecache_prefork(tsdn_t *tsdn, ecache_t *ecache);
 void ecache_postfork_parent(tsdn_t *tsdn, ecache_t *ecache);
 void ecache_postfork_child(tsdn_t *tsdn, ecache_t *ecache);
diff --git a/src/arena.c b/src/arena.c
index b5c8606f..e795acf2 100644
--- a/src/arena.c
+++ b/src/arena.c
@@ -2018,14 +2018,16 @@ arena_new(tsdn_t *tsdn, unsigned ind, extent_hooks_t *extent_hooks) {
 	 * are likely to be reused soon after deallocation, and the cost of
 	 * merging/splitting extents is non-trivial.
 	 */
-	if (ecache_init(tsdn, &arena->ecache_dirty, extent_state_dirty, true)) {
+	if (ecache_init(tsdn, &arena->ecache_dirty, extent_state_dirty, ind,
+	    true)) {
 		goto label_error;
 	}
 	/*
 	 * Coalesce muzzy extents immediately, because operations on them are in
 	 * the critical path much less often than for dirty extents.
 	 */
-	if (ecache_init(tsdn, &arena->ecache_muzzy, extent_state_muzzy, false)) {
+	if (ecache_init(tsdn, &arena->ecache_muzzy, extent_state_muzzy, ind,
+	    false)) {
 		goto label_error;
 	}
 	/*
@@ -2035,7 +2037,7 @@ arena_new(tsdn_t *tsdn, unsigned ind, extent_hooks_t *extent_hooks) {
 	 * in the critical path.
 	 */
 	if (ecache_init(tsdn, &arena->ecache_retained, extent_state_retained,
-	    false)) {
+	    ind, false)) {
 		goto label_error;
 	}
 
diff --git a/src/ecache.c b/src/ecache.c
index a57a0a6f..301b7ca6 100644
--- a/src/ecache.c
+++ b/src/ecache.c
@@ -2,13 +2,14 @@
 #include "jemalloc/internal/jemalloc_internal_includes.h"
 
 bool
-ecache_init(tsdn_t *tsdn, ecache_t *ecache, extent_state_t state,
+ecache_init(tsdn_t *tsdn, ecache_t *ecache, extent_state_t state, unsigned ind,
     bool delay_coalesce) {
 	if (malloc_mutex_init(&ecache->mtx, "extents", WITNESS_RANK_EXTENTS,
 	    malloc_mutex_rank_exclusive)) {
 		return true;
 	}
 	ecache->state = state;
+	ecache->ind = ind;
 	ecache->delay_coalesce = delay_coalesce;
 	eset_init(&ecache->eset, state);
 	return false;
diff --git a/src/extent2.c b/src/extent2.c
index 1b70f202..1dbccf6e 100644
--- a/src/extent2.c
+++ b/src/extent2.c
@@ -1062,6 +1062,8 @@ extent_alloc_wrapper(tsdn_t *tsdn, arena_t *arena, ehooks_t *ehooks,
 static bool
 extent_can_coalesce(ecache_t *ecache, const edata_t *inner,
     const edata_t *outer) {
+	assert(edata_arena_ind_get(inner) == ecache_ind_get(ecache));
+
 	if (edata_arena_ind_get(inner) != edata_arena_ind_get(outer)) {
 		return false;
 	}