use single unified struct

Author: rmatif

examples/cli/main.cpp

@@ -1063,8 +1063,7 @@ struct SDGenerationParams {
 
     std::string cache_mode;
     std::string cache_option;
-    sd_easycache_params_t easycache_params;
-    sd_ucache_params_t ucache_params;
+    sd_cache_params_t cache_params;
 
     float moe_boundary  = 0.875f;
     int video_frames    = 1;
@@ -1555,8 +1554,7 @@ struct SDGenerationParams {
             return false;
         }
 
-        easycache_params.enabled = false;
-        ucache_params.enabled    = false;
+        cache_params.mode = SD_CACHE_DISABLED;
 
         if (!cache_mode.empty()) {
             std::string option_str = cache_option;
@@ -1617,18 +1615,15 @@ struct SDGenerationParams {
                 return false;
             }
 
+            cache_params.reuse_threshold        = values[0];
+            cache_params.start_percent          = values[1];
+            cache_params.end_percent            = values[2];
+            cache_params.error_decay_rate       = values[3];
+            cache_params.use_relative_threshold = (values[4] != 0.0f);
             if (cache_mode == "easycache") {
-                easycache_params.enabled         = true;
-                easycache_params.reuse_threshold = values[0];
-                easycache_params.start_percent   = values[1];
-                easycache_params.end_percent     = values[2];
+                cache_params.mode = SD_CACHE_EASYCACHE;
             } else {
-                ucache_params.enabled                = true;
-                ucache_params.reuse_threshold        = values[0];
-                ucache_params.start_percent          = values[1];
-                ucache_params.end_percent            = values[2];
-                ucache_params.error_decay_rate       = values[3];
-                ucache_params.use_relative_threshold = (values[4] != 0.0f);
+                cache_params.mode = SD_CACHE_UCACHE;
             }
         }
 
@@ -1726,16 +1721,12 @@ struct SDGenerationParams {
             << "  high_noise_sample_params: " << high_noise_sample_params_str << ",\n"
             << "  cache_mode: \"" << cache_mode << "\",\n"
             << "  cache_option: \"" << cache_option << "\",\n"
-            << "  easycache: "
-            << (easycache_params.enabled ? "enabled" : "disabled")
-            << " (threshold=" << easycache_params.reuse_threshold
-            << ", start=" << easycache_params.start_percent
-            << ", end=" << easycache_params.end_percent << "),\n"
-            << "  ucache: "
-            << (ucache_params.enabled ? "enabled" : "disabled")
-            << " (threshold=" << ucache_params.reuse_threshold
-            << ", start=" << ucache_params.start_percent
-            << ", end=" << ucache_params.end_percent << "),\n"
+            << "  cache: "
+            << (cache_params.mode == SD_CACHE_DISABLED ? "disabled" :
+                (cache_params.mode == SD_CACHE_EASYCACHE ? "easycache" : "ucache"))
+            << " (threshold=" << cache_params.reuse_threshold
+            << ", start=" << cache_params.start_percent
+            << ", end=" << cache_params.end_percent << "),\n"
             << "  moe_boundary: " << moe_boundary << ",\n"
             << "  video_frames: " << video_frames << ",\n"
             << "  fps: " << fps << ",\n"
@@ -2315,8 +2306,7 @@ int main(int argc, const char* argv[]) {
                     gen_params.pm_style_strength,
                 },  // pm_params
                 ctx_params.vae_tiling_params,
-                gen_params.easycache_params,
-                gen_params.ucache_params,
+                gen_params.cache_params,
             };
 
             results     = generate_image(sd_ctx, &img_gen_params);
@@ -2341,8 +2331,7 @@ int main(int argc, const char* argv[]) {
                 gen_params.seed,
                 gen_params.video_frames,
                 gen_params.vace_strength,
-                gen_params.easycache_params,
-                gen_params.ucache_params,
+                gen_params.cache_params,
             };
 
             results = generate_video(sd_ctx, &vid_gen_params, &num_results);

stable-diffusion.cpp

@@ -1477,8 +1477,7 @@ class StableDiffusionGGML {
                         ggml_tensor* denoise_mask                     = nullptr,
                         ggml_tensor* vace_context                     = nullptr,
                         float vace_strength                           = 1.f,
-                        const sd_easycache_params_t* easycache_params = nullptr,
-                        const sd_ucache_params_t* ucache_params       = nullptr) {
+                        const sd_cache_params_t* cache_params         = nullptr) {
         if (shifted_timestep > 0 && !sd_version_is_sdxl(version)) {
             LOG_WARN("timestep shifting is only supported for SDXL models!");
             shifted_timestep = 0;
@@ -1495,65 +1494,54 @@ class StableDiffusionGGML {
         }
 
         EasyCacheState easycache_state;
+        UCacheState ucache_state;
         bool easycache_enabled = false;
-        if (easycache_params != nullptr && easycache_params->enabled) {
-            bool easycache_supported = sd_version_is_dit(version);
-            if (!easycache_supported) {
-                LOG_WARN("EasyCache requested but not supported for this model type");
-            } else {
-                EasyCacheConfig easycache_config;
-                easycache_config.enabled         = true;
-                easycache_config.reuse_threshold = std::max(0.0f, easycache_params->reuse_threshold);
-                easycache_config.start_percent   = easycache_params->start_percent;
-                easycache_config.end_percent     = easycache_params->end_percent;
-                bool percent_valid               = easycache_config.start_percent >= 0.0f &&
-                                     easycache_config.start_percent < 1.0f &&
-                                     easycache_config.end_percent > 0.0f &&
-                                     easycache_config.end_percent <= 1.0f &&
-                                     easycache_config.start_percent < easycache_config.end_percent;
-                if (!percent_valid) {
-                    LOG_WARN("EasyCache disabled due to invalid percent range (start=%.3f, end=%.3f)",
-                             easycache_config.start_percent,
-                             easycache_config.end_percent);
+        bool ucache_enabled    = false;
+
+        if (cache_params != nullptr && cache_params->mode != SD_CACHE_DISABLED) {
+            bool percent_valid = cache_params->start_percent >= 0.0f &&
+                                 cache_params->start_percent < 1.0f &&
+                                 cache_params->end_percent > 0.0f &&
+                                 cache_params->end_percent <= 1.0f &&
+                                 cache_params->start_percent < cache_params->end_percent;
+
+            if (!percent_valid) {
+                LOG_WARN("Cache disabled due to invalid percent range (start=%.3f, end=%.3f)",
+                         cache_params->start_percent,
+                         cache_params->end_percent);
+            } else if (cache_params->mode == SD_CACHE_EASYCACHE) {
+                bool easycache_supported = sd_version_is_dit(version);
+                if (!easycache_supported) {
+                    LOG_WARN("EasyCache requested but not supported for this model type");
                 } else {
+                    EasyCacheConfig easycache_config;
+                    easycache_config.enabled         = true;
+                    easycache_config.reuse_threshold = std::max(0.0f, cache_params->reuse_threshold);
+                    easycache_config.start_percent   = cache_params->start_percent;
+                    easycache_config.end_percent     = cache_params->end_percent;
                     easycache_state.init(easycache_config, denoiser.get());
                     if (easycache_state.enabled()) {
                         easycache_enabled = true;
-                        LOG_INFO("EasyCache enabled - threshold: %.3f, start_percent: %.2f, end_percent: %.2f",
+                        LOG_INFO("EasyCache enabled - threshold: %.3f, start: %.2f, end: %.2f",
                                  easycache_config.reuse_threshold,
                                  easycache_config.start_percent,
                                  easycache_config.end_percent);
                     } else {
                         LOG_WARN("EasyCache requested but could not be initialized for this run");
                     }
                 }
-            }
-        }
-
-        UCacheState ucache_state;
-        bool ucache_enabled = false;
-        if (ucache_params != nullptr && ucache_params->enabled) {
-            bool ucache_supported = sd_version_is_unet(version);
-            if (!ucache_supported) {
-                LOG_WARN("UCache requested but not supported for this model type (only UNET models)");
-            } else {
-                UCacheConfig ucache_config;
-                ucache_config.enabled                = true;
-                ucache_config.reuse_threshold        = std::max(0.0f, ucache_params->reuse_threshold);
-                ucache_config.start_percent          = ucache_params->start_percent;
-                ucache_config.end_percent            = ucache_params->end_percent;
-                ucache_config.error_decay_rate       = std::max(0.0f, std::min(1.0f, ucache_params->error_decay_rate));
-                ucache_config.use_relative_threshold = ucache_params->use_relative_threshold;
-                bool percent_valid            = ucache_config.start_percent >= 0.0f &&
-                                     ucache_config.start_percent < 1.0f &&
-                                     ucache_config.end_percent > 0.0f &&
-                                     ucache_config.end_percent <= 1.0f &&
-                                     ucache_config.start_percent < ucache_config.end_percent;
-                if (!percent_valid) {
-                    LOG_WARN("UCache disabled due to invalid percent range (start=%.3f, end=%.3f)",
-                             ucache_config.start_percent,
-                             ucache_config.end_percent);
+            } else if (cache_params->mode == SD_CACHE_UCACHE) {
+                bool ucache_supported = sd_version_is_unet(version);
+                if (!ucache_supported) {
+                    LOG_WARN("UCache requested but not supported for this model type (only UNET models)");
                 } else {
+                    UCacheConfig ucache_config;
+                    ucache_config.enabled                = true;
+                    ucache_config.reuse_threshold        = std::max(0.0f, cache_params->reuse_threshold);
+                    ucache_config.start_percent          = cache_params->start_percent;
+                    ucache_config.end_percent            = cache_params->end_percent;
+                    ucache_config.error_decay_rate       = std::max(0.0f, std::min(1.0f, cache_params->error_decay_rate));
+                    ucache_config.use_relative_threshold = cache_params->use_relative_threshold;
                     ucache_state.init(ucache_config, denoiser.get());
                     if (ucache_state.enabled()) {
                         ucache_enabled = true;
@@ -2601,22 +2589,14 @@ enum lora_apply_mode_t str_to_lora_apply_mode(const char* str) {
     return LORA_APPLY_MODE_COUNT;
 }
 
-void sd_easycache_params_init(sd_easycache_params_t* easycache_params) {
-    *easycache_params                 = {};
-    easycache_params->enabled         = false;
-    easycache_params->reuse_threshold = 0.2f;
-    easycache_params->start_percent   = 0.15f;
-    easycache_params->end_percent     = 0.95f;
-}
-
-void sd_ucache_params_init(sd_ucache_params_t* ucache_params) {
-    *ucache_params                        = {};
-    ucache_params->enabled                = false;
-    ucache_params->reuse_threshold        = 1.0f;
-    ucache_params->start_percent          = 0.15f;
-    ucache_params->end_percent            = 0.95f;
-    ucache_params->error_decay_rate       = 1.0f;
-    ucache_params->use_relative_threshold = true;
+void sd_cache_params_init(sd_cache_params_t* cache_params) {
+    *cache_params                        = {};
+    cache_params->mode                   = SD_CACHE_DISABLED;
+    cache_params->reuse_threshold        = 1.0f;
+    cache_params->start_percent          = 0.15f;
+    cache_params->end_percent            = 0.95f;
+    cache_params->error_decay_rate       = 1.0f;
+    cache_params->use_relative_threshold = true;
 }
 
 void sd_ctx_params_init(sd_ctx_params_t* sd_ctx_params) {
@@ -2777,8 +2757,7 @@ void sd_img_gen_params_init(sd_img_gen_params_t* sd_img_gen_params) {
     sd_img_gen_params->control_strength  = 0.9f;
     sd_img_gen_params->pm_params         = {nullptr, 0, nullptr, 20.f};
     sd_img_gen_params->vae_tiling_params = {false, 0, 0, 0.5f, 0.0f, 0.0f};
-    sd_easycache_params_init(&sd_img_gen_params->easycache);
-    sd_ucache_params_init(&sd_img_gen_params->ucache);
+    sd_cache_params_init(&sd_img_gen_params->cache);
 }
 
 char* sd_img_gen_params_to_str(const sd_img_gen_params_t* sd_img_gen_params) {
@@ -2822,12 +2801,18 @@ char* sd_img_gen_params_to_str(const sd_img_gen_params_t* sd_img_gen_params) {
              sd_img_gen_params->pm_params.id_images_count,
              SAFE_STR(sd_img_gen_params->pm_params.id_embed_path),
              BOOL_STR(sd_img_gen_params->vae_tiling_params.enabled));
+    const char* cache_mode_str = "disabled";
+    if (sd_img_gen_params->cache.mode == SD_CACHE_EASYCACHE) {
+        cache_mode_str = "easycache";
+    } else if (sd_img_gen_params->cache.mode == SD_CACHE_UCACHE) {
+        cache_mode_str = "ucache";
+    }
     snprintf(buf + strlen(buf), 4096 - strlen(buf),
-             "easycache: %s (threshold=%.3f, start=%.2f, end=%.2f)\n",
-             sd_img_gen_params->easycache.enabled ? "enabled" : "disabled",
-             sd_img_gen_params->easycache.reuse_threshold,
-             sd_img_gen_params->easycache.start_percent,
-             sd_img_gen_params->easycache.end_percent);
+             "cache: %s (threshold=%.3f, start=%.2f, end=%.2f)\n",
+             cache_mode_str,
+             sd_img_gen_params->cache.reuse_threshold,
+             sd_img_gen_params->cache.start_percent,
+             sd_img_gen_params->cache.end_percent);
     free(sample_params_str);
     return buf;
 }
@@ -2844,8 +2829,7 @@ void sd_vid_gen_params_init(sd_vid_gen_params_t* sd_vid_gen_params) {
     sd_vid_gen_params->video_frames                          = 6;
     sd_vid_gen_params->moe_boundary                          = 0.875f;
     sd_vid_gen_params->vace_strength                         = 1.f;
-    sd_easycache_params_init(&sd_vid_gen_params->easycache);
-    sd_ucache_params_init(&sd_vid_gen_params->ucache);
+    sd_cache_params_init(&sd_vid_gen_params->cache);
 }
 
 struct sd_ctx_t {
@@ -2923,8 +2907,7 @@ sd_image_t* generate_image_internal(sd_ctx_t* sd_ctx,
                                     bool increase_ref_index,
                                     ggml_tensor* concat_latent                    = nullptr,
                                     ggml_tensor* denoise_mask                     = nullptr,
-                                    const sd_easycache_params_t* easycache_params = nullptr,
-                                    const sd_ucache_params_t* ucache_params       = nullptr) {
+                                    const sd_cache_params_t* cache_params         = nullptr) {
     if (seed < 0) {
         // Generally, when using the provided command line, the seed is always >0.
         // However, to prevent potential issues if 'stable-diffusion.cpp' is invoked as a library
@@ -3213,8 +3196,7 @@ sd_image_t* generate_image_internal(sd_ctx_t* sd_ctx,
                                                      denoise_mask,
                                                      nullptr,
                                                      1.0f,
-                                                     easycache_params,
-                                                     ucache_params);
+                                                     cache_params);
         int64_t sampling_end    = ggml_time_ms();
         if (x_0 != nullptr) {
             // print_ggml_tensor(x_0);
@@ -3548,8 +3530,7 @@ sd_image_t* generate_image(sd_ctx_t* sd_ctx, const sd_img_gen_params_t* sd_img_g
                                                         sd_img_gen_params->increase_ref_index,
                                                         concat_latent,
                                                         denoise_mask,
-                                                        &sd_img_gen_params->easycache,
-                                                        &sd_img_gen_params->ucache);
+                                                        &sd_img_gen_params->cache);
 
     size_t t2 = ggml_time_ms();
 
@@ -3914,8 +3895,7 @@ SD_API sd_image_t* generate_video(sd_ctx_t* sd_ctx, const sd_vid_gen_params_t* s
                                  denoise_mask,
                                  vace_context,
                                  sd_vid_gen_params->vace_strength,
-                                 &sd_vid_gen_params->easycache,
-                                 &sd_vid_gen_params->ucache);
+                                 &sd_vid_gen_params->cache);
 
         int64_t sampling_end = ggml_time_ms();
         LOG_INFO("sampling(high noise) completed, taking %.2fs", (sampling_end - sampling_start) * 1.0f / 1000);
@@ -3952,8 +3932,7 @@ SD_API sd_image_t* generate_video(sd_ctx_t* sd_ctx, const sd_vid_gen_params_t* s
                                           denoise_mask,
                                           vace_context,
                                           sd_vid_gen_params->vace_strength,
-                                          &sd_vid_gen_params->easycache,
-                                          &sd_vid_gen_params->ucache);
+                                          &sd_vid_gen_params->cache);
 
         int64_t sampling_end = ggml_time_ms();
         LOG_INFO("sampling completed, taking %.2fs", (sampling_end - sampling_start) * 1.0f / 1000);

stable-diffusion.h

@@ -236,21 +236,20 @@ typedef struct {
     float style_strength;
 } sd_pm_params_t;  // photo maker
 
-typedef struct {
-    bool enabled;
-    float reuse_threshold;
-    float start_percent;
-    float end_percent;
-} sd_easycache_params_t;
+enum sd_cache_mode_t {
+    SD_CACHE_DISABLED = 0,
+    SD_CACHE_EASYCACHE,
+    SD_CACHE_UCACHE,
+};
 
 typedef struct {
-    bool enabled;
+    enum sd_cache_mode_t mode;
     float reuse_threshold;
     float start_percent;
     float end_percent;
     float error_decay_rate;
     bool use_relative_threshold;
-} sd_ucache_params_t;
+} sd_cache_params_t;
 
 typedef struct {
     bool is_high_noise;
@@ -280,8 +279,7 @@ typedef struct {
     float control_strength;
     sd_pm_params_t pm_params;
     sd_tiling_params_t vae_tiling_params;
-    sd_easycache_params_t easycache;
-    sd_ucache_params_t ucache;
+    sd_cache_params_t cache;
 } sd_img_gen_params_t;
 
 typedef struct {
@@ -303,8 +301,7 @@ typedef struct {
     int64_t seed;
     int video_frames;
     float vace_strength;
-    sd_easycache_params_t easycache;
-    sd_ucache_params_t ucache;
+    sd_cache_params_t cache;
 } sd_vid_gen_params_t;
 
 typedef struct sd_ctx_t sd_ctx_t;
@@ -334,8 +331,7 @@ SD_API enum preview_t str_to_preview(const char* str);
 SD_API const char* sd_lora_apply_mode_name(enum lora_apply_mode_t mode);
 SD_API enum lora_apply_mode_t str_to_lora_apply_mode(const char* str);
 
-SD_API void sd_easycache_params_init(sd_easycache_params_t* easycache_params);
-SD_API void sd_ucache_params_init(sd_ucache_params_t* ucache_params);
+SD_API void sd_cache_params_init(sd_cache_params_t* cache_params);
 
 SD_API void sd_ctx_params_init(sd_ctx_params_t* sd_ctx_params);
 SD_API char* sd_ctx_params_to_str(const sd_ctx_params_t* sd_ctx_params);