Move te_prof_sample_event_lookahead into src/jemalloc.c

The function only had production callers in src/jemalloc.c.  It was
parked in prof_inlines.h because its body uses tsd accessors that
aren't visible from prof.h.  Moving it to file scope in jemalloc.c
gets it out of the shared header without losing inlining, and the
name drops the misleading te_ prefix -- it isn't a thread_event
facility, just a one-off prof helper.

Renamed prof_sample_lookahead for clarity.

include/jemalloc/internal/prof_inlines.h

@@ -9,32 +9,6 @@
 #include "jemalloc/internal/sz.h"
 #include "jemalloc/internal/thread_event.h"
 
-/*
- * The lookahead functionality facilitates events to be able to lookahead, i.e.
- * without touching the event counters, to determine whether an event would be
- * triggered.  The event counters are not advanced until the end of the
- * allocation / deallocation calls, so the lookahead can be useful if some
- * preparation work for some event must be done early in the allocation /
- * deallocation calls.
- *
- * Currently only the profiling sampling event needs the lookahead
- * functionality, so we don't yet define general purpose lookahead functions.
- *
- * Defined here rather than prof.h because the inline body depends on tsd
- * accessors that aren't visible until tsd inlines are loaded.
- */
-
-JEMALLOC_ALWAYS_INLINE bool
-te_prof_sample_event_lookahead(tsd_t *tsd, size_t usize) {
-	if (unlikely(!tsd_nominal(tsd) || tsd_reentrancy_level_get(tsd) > 0)) {
-		return false;
-	}
-	/* The subtraction is intentionally susceptible to underflow. */
-	uint64_t accumbytes = tsd_thread_allocated_get(tsd) + usize
-	    - tsd_thread_allocated_last_event_get(tsd);
-	return accumbytes >= tsd_prof_sample_event_wait_get(tsd);
-}
-
 JEMALLOC_ALWAYS_INLINE void
 prof_active_assert(void) {
 	cassert(config_prof);

src/jemalloc.c

@@ -149,6 +149,24 @@ const char *const zero_realloc_mode_names[] = {
     "abort",
 };
 
+/*
+ * Check whether the next allocation would trip the profiling sampler without
+ * advancing the event counter (the counter only advances at the end of the
+ * alloc/dalloc call).  Lets the allocation path pre-compute the prof context
+ * before committing.  Lives here -- not in prof_inlines.h -- because jemalloc.c
+ * is the only production caller.
+ */
+JEMALLOC_ALWAYS_INLINE bool
+prof_sample_lookahead(tsd_t *tsd, size_t usize) {
+	if (unlikely(!tsd_nominal(tsd) || tsd_reentrancy_level_get(tsd) > 0)) {
+		return false;
+	}
+	/* The subtraction is intentionally susceptible to underflow. */
+	uint64_t accumbytes = tsd_thread_allocated_get(tsd) + usize
+	    - tsd_thread_allocated_last_event_get(tsd);
+	return accumbytes >= tsd_prof_sample_event_wait_get(tsd);
+}
+
 /*
  * These are the documented values for junk fill debugging facilities -- see the
  * man page.
@@ -610,7 +628,7 @@ imalloc_body(static_opts_t *sopts, dynamic_opts_t *dopts, tsd_t *tsd) {
 	/* If profiling is on, get our profiling context. */
 	if (config_prof && opt_prof) {
 		bool prof_active = prof_active_get_unlocked();
-		bool sample_event = te_prof_sample_event_lookahead(tsd, usize);
+		bool sample_event = prof_sample_lookahead(tsd, usize);
 		prof_tctx_t *tctx = prof_alloc_prep(
 		    tsd, prof_active, sample_event);
 
@@ -1412,7 +1430,7 @@ irallocx_prof(tsd_t *tsd, void *old_ptr, size_t old_usize, size_t size,
 	prof_info_t old_prof_info;
 	prof_info_get_and_reset_recent(tsd, old_ptr, alloc_ctx, &old_prof_info);
 	bool         prof_active = prof_active_get_unlocked();
-	bool         sample_event = te_prof_sample_event_lookahead(tsd, usize);
+	bool         sample_event = prof_sample_lookahead(tsd, usize);
 	prof_tctx_t *tctx = prof_alloc_prep(tsd, prof_active, sample_event);
 	void        *p;
 	if (unlikely(tctx != PROF_TCTX_SENTINEL)) {
@@ -1650,7 +1668,7 @@ ixallocx_prof(tsd_t *tsd, void *ptr, size_t old_usize, size_t size,
 		usize_max = SC_LARGE_MAXCLASS;
 	}
 	bool prof_active = prof_active_get_unlocked();
-	bool sample_event = te_prof_sample_event_lookahead(tsd, usize_max);
+	bool sample_event = prof_sample_lookahead(tsd, usize_max);
 	prof_tctx_t *tctx = prof_alloc_prep(tsd, prof_active, sample_event);
 
 	size_t usize;
@@ -1685,7 +1703,7 @@ ixallocx_prof(tsd_t *tsd, void *ptr, size_t old_usize, size_t size,
 		prof_info_get_and_reset_recent(
 		    tsd, ptr, &new_alloc_ctx, &prof_info);
 		assert(usize <= usize_max);
-		sample_event = te_prof_sample_event_lookahead(tsd, usize);
+		sample_event = prof_sample_lookahead(tsd, usize);
 		prof_realloc(tsd, ptr, size, usize, tctx, prof_active, ptr,
 		    old_usize, &prof_info, sample_event);
 	}