Introduce FORCE_DEFRAG compilation option to allow activedefrag run when allocator is not jemalloc

CMakeLists.txt

@@ -41,3 +41,4 @@ unset(BUILD_UNIT_TESTS CACHE)
 unset(BUILD_TEST_MODULES CACHE)
 unset(BUILD_EXAMPLE_MODULES CACHE)
 unset(USE_TLS CACHE)
+unset(FORCE_DEFRAG CACHE)

deps/CMakeLists.txt

@@ -1,4 +1,6 @@
-add_subdirectory(jemalloc)
+if (USE_JEMALLOC)
+    add_subdirectory(jemalloc)
+endif ()
 add_subdirectory(lua)
 
 # Set hiredis options. We need to disable the defaults set in the OPTION(..) we do this by setting them in the CACHE

src/CMakeLists.txt

@@ -22,6 +22,12 @@ if (VALKEY_RELEASE_BUILD)
     set_property(TARGET valkey-server PROPERTY INTERPROCEDURAL_OPTIMIZATION TRUE)
 endif ()
 
+if (FORCE_DEFRAG)
+    message(STATUS "Forcing Active Defrag run on valkey-server")
+    target_compile_definitions(valkey-server PRIVATE FORCE_DEFRAG)
+    target_compile_definitions(valkey-server PRIVATE HAVE_DEFRAG)
+endif ()
+
 # Target: valkey-cli
 list(APPEND CLI_LIBS "linenoise")
 valkey_build_and_install_bin(valkey-cli "${VALKEY_CLI_SRCS}" "${VALKEY_SERVER_LDFLAGS}" "${CLI_LIBS}" "redis-cli")

src/Makefile

@@ -130,6 +130,11 @@ ifdef REDIS_LDFLAGS
     SERVER_LDFLAGS := $(REDIS_LDFLAGS)
 endif
 
+# Special case of forcing defrag to run even though we have no Jemlloc support
+ifeq ($(FORCE_DEFRAG), yes)
+	SERVER_CFLAGS +=-DHAVE_DEFRAG -DFORCE_DEFRAG
+endif
+
 FINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(SERVER_CFLAGS)
 FINAL_LDFLAGS=$(LDFLAGS) $(OPT) $(SERVER_LDFLAGS) $(DEBUG)
 FINAL_LIBS=-lm

src/defrag.c

@@ -755,6 +755,15 @@ void defragScanCallback(void *privdata, const dictEntry *de) {
  * or not, a false detection can cause the defragmenter to waste a lot of CPU
  * without the possibility of getting any results. */
 float getAllocatorFragmentation(size_t *out_frag_bytes) {
+    /* In case we are forcing defrag to run without Jemalloc support we cannot get any
+     * good statistics from the allocator regarding external fragmentation.
+     * This is why we are forcing the report to reflect fragmented system conditions based on the existing configurations. */
+#if defined(FORCE_DEFRAG) || !defined(USE_JEMALLOC)
+
+    *out_frag_bytes = server.active_defrag_ignore_bytes + 1;
+    return server.active_defrag_threshold_upper;
+#else
+
     size_t resident, active, allocated, frag_smallbins_bytes;
     zmalloc_get_allocator_info(&allocated, &active, &resident, NULL, NULL, &frag_smallbins_bytes);
 
@@ -769,6 +778,7 @@ float getAllocatorFragmentation(size_t *out_frag_bytes) {
     serverLog(LL_DEBUG, "allocated=%zu, active=%zu, resident=%zu, frag=%.2f%% (%.2f%% rss), frag_bytes=%zu (%zu rss)",
               allocated, active, resident, frag_pct, rss_pct, frag_smallbins_bytes, rss_bytes);
     return frag_pct;
+#endif
 }
 
 /* Defrag scan callback for the pubsub dictionary. */
@@ -956,7 +966,7 @@ void activeDefragCycle(void) {
     mstime_t latency;
     int all_stages_finished = 0;
     int quit = 0;
-
+#if !defined(FORCE_DEFRAG)
     if (!server.active_defrag_enabled) {
         if (server.active_defrag_running) {
             /* if active defrag was disabled mid-run, start from fresh next time. */
@@ -975,7 +985,10 @@ void activeDefragCycle(void) {
         }
         return;
     }
-
+#else
+    /* Avoid compiler warning */
+    if (0) goto update_metrics;
+#endif
     if (hasActiveChildProcess()) return; /* Defragging memory while there's a fork will just do damage. */
 
     /* Once a second, check if the fragmentation justfies starting a scan
@@ -1134,6 +1147,13 @@ void activeDefragCycle(void) {
     }
 }
 
+#if defined(FORCE_DEFRAG) || !defined(JEMALLOC_FRAG_HINT)
+int je_get_defrag_hint(void *ptr) {
+    UNUSED(ptr);
+    return 1;
+}
+#endif
+
 #else /* HAVE_DEFRAG */
 
 void activeDefragCycle(void) {

src/zmalloc.c

@@ -211,6 +211,7 @@ void *zmalloc_usable(size_t size, size_t *usable) {
  * and go straight to the allocator arena bins.
  * Currently implemented only for jemalloc. Used for online defragmentation. */
 #ifdef HAVE_DEFRAG
+#if defined(USE_JEMALLOC)
 void *zmalloc_no_tcache(size_t size) {
     if (size >= SIZE_MAX / 2) zmalloc_oom_handler(size);
     void *ptr = mallocx(size + PREFIX_SIZE, MALLOCX_TCACHE_NONE);
@@ -224,6 +225,21 @@ void zfree_no_tcache(void *ptr) {
     update_zmalloc_stat_free(zmalloc_size(ptr));
     dallocx(ptr, MALLOCX_TCACHE_NONE);
 }
+#else
+void *zmalloc_no_tcache(size_t size) {
+    if (size >= SIZE_MAX / 2) zmalloc_oom_handler(size);
+    void *ptr = malloc(size + PREFIX_SIZE);
+    if (!ptr) zmalloc_oom_handler(size);
+    update_zmalloc_stat_alloc(zmalloc_size(ptr));
+    return ptr;
+}
+
+void zfree_no_tcache(void *ptr) {
+    if (ptr == NULL) return;
+    update_zmalloc_stat_free(zmalloc_size(ptr));
+    free(ptr);
+}
+#endif
 #endif
 
 /* Try allocating memory and zero it, and return NULL if failed.