Merge remote-tracking branch 'upstream/master' into feature/unified-streaming

fszontagh · fszontagh · commit d2766bba0fa8 · 2026-05-30T12:41:47.000+02:00
diff --git a/src/conditioner.hpp b/src/conditioner.hpp
@@ -113,7 +113,7 @@ struct Conditioner {
 public:
     virtual SDCondition get_learned_condition(int n_threads,
                                               const ConditionerParams& conditioner_params) = 0;
-    virtual void alloc_params_buffer()                                                     = 0;
+    virtual bool alloc_params_buffer()                                                     = 0;
     virtual void free_params_buffer()                                                      = 0;
     virtual void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors)           = 0;
     virtual size_t get_params_buffer_size()                                                = 0;
@@ -177,11 +177,16 @@ struct FrozenCLIPEmbedderWithCustomWords : public Conditioner {
         }
     }
 
-    void alloc_params_buffer() override {
-        text_model->alloc_params_buffer();
+    bool alloc_params_buffer() override {
+        if (!text_model->alloc_params_buffer()) {
+            return false;
+        }
         if (sd_version_is_sdxl(version)) {
-            text_model2->alloc_params_buffer();
+            if (!text_model2->alloc_params_buffer()) {
+                return false;
+            }
         }
+        return true;
     }
 
     void free_params_buffer() override {
@@ -789,16 +794,23 @@ struct SD3CLIPEmbedder : public Conditioner {
         }
     }
 
-    void alloc_params_buffer() override {
+    bool alloc_params_buffer() override {
         if (clip_l) {
-            clip_l->alloc_params_buffer();
+            if (!clip_l->alloc_params_buffer()) {
+                return false;
+            }
         }
         if (clip_g) {
-            clip_g->alloc_params_buffer();
+            if (!clip_g->alloc_params_buffer()) {
+                return false;
+            }
         }
         if (t5) {
-            t5->alloc_params_buffer();
+            if (!t5->alloc_params_buffer()) {
+                return false;
+            }
         }
+        return true;
     }
 
     void free_params_buffer() override {
@@ -1165,15 +1177,21 @@ struct FluxCLIPEmbedder : public Conditioner {
         }
     }
 
-    void alloc_params_buffer() override {
+    bool alloc_params_buffer() override {
         if (clip_l) {
-            clip_l->alloc_params_buffer();
+            if (!clip_l->alloc_params_buffer()) {
+                return false;
+            }
         }
         if (t5) {
-            t5->alloc_params_buffer();
+            if (!t5->alloc_params_buffer()) {
+                return false;
+            }
         }
+        return true;
     }
 
+
     void free_params_buffer() override {
         if (clip_l) {
             clip_l->free_params_buffer();
@@ -1417,10 +1435,13 @@ struct T5CLIPEmbedder : public Conditioner {
         }
     }
 
-    void alloc_params_buffer() override {
+    bool alloc_params_buffer() override {
         if (t5) {
-            t5->alloc_params_buffer();
+            if (!t5->alloc_params_buffer()) {
+                return false;
+            }
         }
+        return true;
     }
 
     void free_params_buffer() override {
@@ -1613,8 +1634,11 @@ struct AnimaConditioner : public Conditioner {
         llm->get_param_tensors(tensors, "text_encoders.llm");
     }
 
-    void alloc_params_buffer() override {
-        llm->alloc_params_buffer();
+    bool alloc_params_buffer() override {
+        if (!llm->alloc_params_buffer()) {
+                return false;
+            }
+        return true;
     }
 
     void free_params_buffer() override {
@@ -1756,8 +1780,11 @@ struct LLMEmbedder : public Conditioner {
         llm->get_param_tensors(tensors, "text_encoders.llm");
     }
 
-    void alloc_params_buffer() override {
-        llm->alloc_params_buffer();
+    bool alloc_params_buffer() override {
+        if (!llm->alloc_params_buffer()) {
+                return false;
+        }
+        return true;
     }
 
     void free_params_buffer() override {
@@ -2282,9 +2309,14 @@ struct LTXAVEmbedder : public Conditioner {
         projector->get_param_tensors(tensors, "text_embedding_projection");
     }
 
-    void alloc_params_buffer() override {
-        llm->alloc_params_buffer();
-        projector->alloc_params_buffer();
+    bool alloc_params_buffer() override {
+        if (!llm->alloc_params_buffer()) {
+                return false;
+        }
+        if (!projector->alloc_params_buffer()) {
+                return false;
+        }
+        return true;
     }
 
     void free_params_buffer() override {
diff --git a/src/control.hpp b/src/control.hpp
@@ -457,7 +457,11 @@ struct ControlNet : public GGMLRunner {
 
     bool load_from_file(const std::string& file_path, int n_threads) {
         LOG_INFO("loading control net from '%s'", file_path.c_str());
-        alloc_params_buffer();
+        if (!alloc_params_buffer()) {
+            LOG_ERROR("control net model buffer allocation failed");
+            return false;
+        }
+
         std::map<std::string, ggml_tensor*> tensors;
         control_net.get_param_tensors(tensors);
         std::set<std::string> ignore_tensors;
diff --git a/src/esrgan.hpp b/src/esrgan.hpp
@@ -270,7 +270,11 @@ struct ESRGAN : public GGMLRunner {
         rrdb_net = std::make_unique<RRDBNet>(detected_scale, detected_num_block, detected_num_in_ch, detected_num_out_ch, detected_num_feat, detected_num_grow_ch);
         rrdb_net->init(params_ctx, {}, "");
 
-        alloc_params_buffer();
+        if (!alloc_params_buffer()) {
+            LOG_ERROR("esrgan model buffer allocation failed");
+            return false;
+        }
+
         std::map<std::string, ggml_tensor*> esrgan_tensors;
         rrdb_net->get_param_tensors(esrgan_tensors);
 
diff --git a/src/flux.hpp b/src/flux.hpp
@@ -1592,7 +1592,11 @@ namespace Flux {
                                                                             VERSION_FLUX2,
                                                                             false);
 
-            flux->alloc_params_buffer();
+            if (!flux->alloc_params_buffer()) {
+                LOG_ERROR("flux model allocation failed");
+                return;
+            }
+
             std::map<std::string, ggml_tensor*> tensors;
             flux->get_param_tensors(tensors, "model.diffusion_model");
 
diff --git a/src/hidream_o1.hpp b/src/hidream_o1.hpp
@@ -492,8 +492,11 @@ namespace HiDreamO1 {
             vision_runner->get_param_tensors(tensors);
         }
 
-        void alloc_params_buffer() override {
-            vision_runner->alloc_params_buffer();
+        bool alloc_params_buffer() override {
+            if (!vision_runner->alloc_params_buffer()) {
+                return false;
+            }
+            return true;
         }
 
         void free_params_buffer() override {
diff --git a/src/llm.hpp b/src/llm.hpp
@@ -1769,8 +1769,11 @@ namespace LLM {
             model.get_param_tensors(tensors, prefix);
         }
 
-        void alloc_params_buffer() {
-            model.alloc_params_buffer();
+        bool alloc_params_buffer() {
+            if (!model.alloc_params_buffer()) {
+                return false;
+            }
+            return true;
         }
 
         std::tuple<std::vector<int>, std::vector<float>> tokenize(std::string text,
@@ -2012,7 +2015,11 @@ namespace LLM {
                                                                              "text_encoders.llm",
                                                                              true);
 
-            llm->alloc_params_buffer();
+            if (!llm->alloc_params_buffer()) {
+                LOG_ERROR("llm model allocation failed");
+                return;
+            }
+
             std::map<std::string, ggml_tensor*> tensors;
             llm->get_param_tensors(tensors, "text_encoders.llm");
 
diff --git a/src/lora.hpp b/src/lora.hpp
@@ -86,7 +86,11 @@ struct LoraModel : public GGMLRunner {
             lora_tensors[name] = real;
         }
 
-        alloc_params_buffer();
+        if (!alloc_params_buffer()) {
+            LOG_ERROR("lora model buffer allocation failed");
+            return false;
+        }
+
 
         dry_run = false;
         model_loader.load_tensors(on_new_tensor_cb, n_threads);
diff --git a/src/ltx_audio_vae.h b/src/ltx_audio_vae.h
@@ -1068,7 +1068,11 @@ namespace LTXV {
                                                                      tensor_storage_map,
                                                                      prefix);
 
-            ltx_audio_vae->alloc_params_buffer();
+            if (!ltx_audio_vae->alloc_params_buffer()) {
+               LOG_ERROR("ltx audio vae buffer allocation failed");
+               return;
+            }
+
             std::map<std::string, ggml_tensor*> tensors;
             ltx_audio_vae->get_param_tensors(tensors, "");
 
diff --git a/src/ltx_vae.hpp b/src/ltx_vae.hpp
@@ -1534,7 +1534,11 @@ struct LTXVideoVAE : public VAE {
                                                                          true,
                                                                          VERSION_LTXAV);
 
-        vae->alloc_params_buffer();
+        if (!vae->alloc_params_buffer()) {
+            LOG_ERROR("vae buffer allocation failed");
+            return;
+        }
+
         std::map<std::string, ggml_tensor*> tensors;
         vae->get_param_tensors(tensors, "first_stage_model");
 
diff --git a/src/ltxv.hpp b/src/ltxv.hpp
@@ -2017,7 +2017,10 @@ namespace LTXV {
                                                                                tensor_storage_map,
                                                                                "model.diffusion_model");
 
-            ltxav->alloc_params_buffer();
+            if (!ltxav->alloc_params_buffer()) {
+                LOG_ERROR("ltxav buffer allocation failed");
+                return;
+            }
             std::map<std::string, ggml_tensor*> tensors;
             ltxav->get_param_tensors(tensors, "model.diffusion_model");
 
diff --git a/src/mmdit.hpp b/src/mmdit.hpp
@@ -953,7 +953,11 @@ struct MMDiTRunner : public DiffusionModelRunner {
         {
             LOG_INFO("loading from '%s'", file_path.c_str());
 
-            mmdit->alloc_params_buffer();
+            if (!mmdit->alloc_params_buffer()) {
+                LOG_ERROR("mmdit embeds buffer allocation failed");
+                return;
+            }
+
             std::map<std::string, ggml_tensor*> tensors;
             mmdit->get_param_tensors(tensors, "model.diffusion_model");
 
diff --git a/src/model.cpp b/src/model.cpp
@@ -865,8 +865,13 @@ std::vector<MmapTensorStore> ModelLoader::mmap_tensors(std::map<std::string, ggm
             if (dst_tensor == nullptr)
                 continue;
 
-            if (tensor_storage.type != dst_tensor->type)
+            if (tensor_storage.is_f8_e4m3 ||
+                tensor_storage.is_f8_e5m2 ||
+                tensor_storage.is_f64 ||
+                tensor_storage.is_i64 ||
+                tensor_storage.type != dst_tensor->type) {
                 continue;
+            }
 
             size_t tensor_size   = tensor_storage.nbytes();
             size_t tensor_offset = tensor_storage.offset;
@@ -999,6 +1004,12 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
                         continue;
                     }
 
+                    if (dst_tensor->data == nullptr) {
+                        LOG_ERROR("process tensor data failed: '%s'", tensor_storage.name.c_str());
+                        failed = true;
+                        break;
+                    }
+
                     // skip mmapped tensors
                     if (dst_tensor->buffer != nullptr && dst_tensor->buffer == fdata.mmbuffer.get()) {
                         continue;
diff --git a/src/pmid.hpp b/src/pmid.hpp
@@ -615,7 +615,10 @@ struct PhotoMakerIDEmbed : public GGMLRunner {
         };
 
         model_loader->load_tensors(on_new_tensor_cb, n_threads);
-        alloc_params_buffer();
+        if (!alloc_params_buffer()) {
+            LOG_ERROR("PhotoMaker ID embeds buffer allocation failed");
+            return false;
+        }
 
         dry_run = false;
         model_loader->load_tensors(on_new_tensor_cb, n_threads);
diff --git a/src/qwen_image.hpp b/src/qwen_image.hpp
@@ -705,7 +705,11 @@ namespace Qwen {
                                                                                             "model.diffusion_model",
                                                                                             VERSION_QWEN_IMAGE);
 
-            qwen_image->alloc_params_buffer();
+            if (!qwen_image->alloc_params_buffer()) {
+                LOG_ERROR("qwen_image buffer allocation failed");
+                return;
+            }
+
             std::map<std::string, ggml_tensor*> tensors;
             qwen_image->get_param_tensors(tensors, "model.diffusion_model");
 
diff --git a/src/stable-diffusion.cpp b/src/stable-diffusion.cpp
@@ -1020,14 +1020,20 @@ class StableDiffusionGGML {
             ggml_free(ctx);
             return false;
         }
-        if (cond_stage_model) {
-            cond_stage_model->alloc_params_buffer();
+        if (cond_stage_model && !cond_stage_model->alloc_params_buffer()) {
+            LOG_ERROR("Conditioner model params buffer allocation failed");
+            ggml_free(ctx);
+            return false;
         }
-        if (diffusion_model) {
-            diffusion_model->alloc_params_buffer();
+        if (diffusion_model && !diffusion_model->alloc_params_buffer()) {
+            LOG_ERROR("Diffusion model params buffer allocation failed");
+            ggml_free(ctx);
+            return false;
         }
-        if (high_noise_diffusion_model) {
-            high_noise_diffusion_model->alloc_params_buffer();
+        if (high_noise_diffusion_model && !high_noise_diffusion_model->alloc_params_buffer()) {
+            LOG_ERROR("High noise diffusion model params buffer allocation failed");
+            ggml_free(ctx);
+            return false;
         }
         if (first_stage_model && !first_stage_model->alloc_params_buffer()) {
             LOG_ERROR("VAE params buffer allocation failed");
diff --git a/src/t5.hpp b/src/t5.hpp
@@ -475,8 +475,11 @@ struct T5Embedder {
         model.get_param_tensors(tensors, prefix);
     }
 
-    void alloc_params_buffer() {
-        model.alloc_params_buffer();
+    bool alloc_params_buffer() {
+        if (!model.alloc_params_buffer()) {
+            return false;
+         }
+        return true;
     }
 
     std::tuple<std::vector<int>, std::vector<float>, std::vector<float>> tokenize(std::string text,
@@ -578,7 +581,10 @@ struct T5Embedder {
 
         std::shared_ptr<T5Embedder> t5 = std::make_shared<T5Embedder>(backend, backend, tensor_storage_map, "", true);
 
-        t5->alloc_params_buffer();
+        if (!t5->alloc_params_buffer()) {
+            LOG_ERROR("t5 params buffer allocation failed");
+            return;
+        }
         std::map<std::string, ggml_tensor*> tensors;
         t5->get_param_tensors(tensors, "");
 
diff --git a/src/tae.hpp b/src/tae.hpp
diff --git a/src/tokenizers/bpe_tokenizer.cpp b/src/tokenizers/bpe_tokenizer.cpp
diff --git a/src/wan.hpp b/src/wan.hpp
diff --git a/src/z_image.hpp b/src/z_image.hpp

Original file line number	Diff line number	Diff line change
`@@ -113,7 +113,7 @@ struct Conditioner {`
`113`	`113`	`public:`
`114`	`114`	`virtual SDCondition get_learned_condition(int n_threads,`
`115`	`115`	`const ConditionerParams& conditioner_params) = 0;`
`116`		`- virtual void alloc_params_buffer() = 0;`
	`116`	`+ virtual bool alloc_params_buffer() = 0;`
`117`	`117`	`virtual void free_params_buffer() = 0;`
`118`	`118`	`virtual void get_param_tensors(std::map<std::string, ggml_tensor*>& tensors) = 0;`
`119`	`119`	`virtual size_t get_params_buffer_size() = 0;`
`@@ -177,11 +177,16 @@ struct FrozenCLIPEmbedderWithCustomWords : public Conditioner {`
`177`	`177`	`}`
`178`	`178`	`}`
`179`	`179`
`180`		`- void alloc_params_buffer() override {`
`181`		`- text_model->alloc_params_buffer();`
	`180`	`+ bool alloc_params_buffer() override {`
	`181`	`+ if (!text_model->alloc_params_buffer()) {`
	`182`	`+ return false;`
	`183`	`+ }`
`182`	`184`	`if (sd_version_is_sdxl(version)) {`
`183`		`- text_model2->alloc_params_buffer();`
	`185`	`+ if (!text_model2->alloc_params_buffer()) {`
	`186`	`+ return false;`
	`187`	`+ }`
`184`	`188`	`}`
	`189`	`+ return true;`
`185`	`190`	`}`
`186`	`191`
`187`	`192`	`void free_params_buffer() override {`
`@@ -789,16 +794,23 @@ struct SD3CLIPEmbedder : public Conditioner {`
`789`	`794`	`}`
`790`	`795`	`}`
`791`	`796`
`792`		`- void alloc_params_buffer() override {`
	`797`	`+ bool alloc_params_buffer() override {`
`793`	`798`	`if (clip_l) {`
`794`		`- clip_l->alloc_params_buffer();`
	`799`	`+ if (!clip_l->alloc_params_buffer()) {`
	`800`	`+ return false;`
	`801`	`+ }`
`795`	`802`	`}`
`796`	`803`	`if (clip_g) {`
`797`		`- clip_g->alloc_params_buffer();`
	`804`	`+ if (!clip_g->alloc_params_buffer()) {`
	`805`	`+ return false;`
	`806`	`+ }`
`798`	`807`	`}`
`799`	`808`	`if (t5) {`
`800`		`- t5->alloc_params_buffer();`
	`809`	`+ if (!t5->alloc_params_buffer()) {`
	`810`	`+ return false;`
	`811`	`+ }`
`801`	`812`	`}`
	`813`	`+ return true;`
`802`	`814`	`}`
`803`	`815`
`804`	`816`	`void free_params_buffer() override {`
`@@ -1165,15 +1177,21 @@ struct FluxCLIPEmbedder : public Conditioner {`
`1165`	`1177`	`}`
`1166`	`1178`	`}`
`1167`	`1179`
`1168`		`- void alloc_params_buffer() override {`
	`1180`	`+ bool alloc_params_buffer() override {`
`1169`	`1181`	`if (clip_l) {`
`1170`		`- clip_l->alloc_params_buffer();`
	`1182`	`+ if (!clip_l->alloc_params_buffer()) {`
	`1183`	`+ return false;`
	`1184`	`+ }`
`1171`	`1185`	`}`
`1172`	`1186`	`if (t5) {`
`1173`		`- t5->alloc_params_buffer();`
	`1187`	`+ if (!t5->alloc_params_buffer()) {`
	`1188`	`+ return false;`
	`1189`	`+ }`
`1174`	`1190`	`}`
	`1191`	`+ return true;`
`1175`	`1192`	`}`
`1176`	`1193`
	`1194`	`+`
`1177`	`1195`	`void free_params_buffer() override {`
`1178`	`1196`	`if (clip_l) {`
`1179`	`1197`	`clip_l->free_params_buffer();`
`@@ -1417,10 +1435,13 @@ struct T5CLIPEmbedder : public Conditioner {`
`1417`	`1435`	`}`
`1418`	`1436`	`}`
`1419`	`1437`
`1420`		`- void alloc_params_buffer() override {`
	`1438`	`+ bool alloc_params_buffer() override {`
`1421`	`1439`	`if (t5) {`
`1422`		`- t5->alloc_params_buffer();`
	`1440`	`+ if (!t5->alloc_params_buffer()) {`
	`1441`	`+ return false;`
	`1442`	`+ }`
`1423`	`1443`	`}`
	`1444`	`+ return true;`
`1424`	`1445`	`}`
`1425`	`1446`
`1426`	`1447`	`void free_params_buffer() override {`
`@@ -1613,8 +1634,11 @@ struct AnimaConditioner : public Conditioner {`
`1613`	`1634`	`llm->get_param_tensors(tensors, "text_encoders.llm");`
`1614`	`1635`	`}`
`1615`	`1636`
`1616`		`- void alloc_params_buffer() override {`
`1617`		`- llm->alloc_params_buffer();`
	`1637`	`+ bool alloc_params_buffer() override {`
	`1638`	`+ if (!llm->alloc_params_buffer()) {`
	`1639`	`+ return false;`
	`1640`	`+ }`
	`1641`	`+ return true;`
`1618`	`1642`	`}`
`1619`	`1643`
`1620`	`1644`	`void free_params_buffer() override {`
`@@ -1756,8 +1780,11 @@ struct LLMEmbedder : public Conditioner {`
`1756`	`1780`	`llm->get_param_tensors(tensors, "text_encoders.llm");`
`1757`	`1781`	`}`
`1758`	`1782`
`1759`		`- void alloc_params_buffer() override {`
`1760`		`- llm->alloc_params_buffer();`
	`1783`	`+ bool alloc_params_buffer() override {`
	`1784`	`+ if (!llm->alloc_params_buffer()) {`
	`1785`	`+ return false;`
	`1786`	`+ }`
	`1787`	`+ return true;`
`1761`	`1788`	`}`
`1762`	`1789`
`1763`	`1790`	`void free_params_buffer() override {`
`@@ -2282,9 +2309,14 @@ struct LTXAVEmbedder : public Conditioner {`
`2282`	`2309`	`projector->get_param_tensors(tensors, "text_embedding_projection");`
`2283`	`2310`	`}`
`2284`	`2311`
`2285`		`- void alloc_params_buffer() override {`
`2286`		`- llm->alloc_params_buffer();`
`2287`		`- projector->alloc_params_buffer();`
	`2312`	`+ bool alloc_params_buffer() override {`
	`2313`	`+ if (!llm->alloc_params_buffer()) {`
	`2314`	`+ return false;`
	`2315`	`+ }`
	`2316`	`+ if (!projector->alloc_params_buffer()) {`
	`2317`	`+ return false;`
	`2318`	`+ }`
	`2319`	`+ return true;`
`2288`	`2320`	`}`
`2289`	`2321`
`2290`	`2322`	`void free_params_buffer() override {`
Original file line number	Diff line number	Diff line change
`@@ -492,8 +492,11 @@ namespace HiDreamO1 {`
`492`	`492`	`vision_runner->get_param_tensors(tensors);`
`493`	`493`	`}`
`494`	`494`
`495`		`- void alloc_params_buffer() override {`
`496`		`- vision_runner->alloc_params_buffer();`
	`495`	`+ bool alloc_params_buffer() override {`
	`496`	`+ if (!vision_runner->alloc_params_buffer()) {`
	`497`	`+ return false;`
	`498`	`+ }`
	`499`	`+ return true;`
`497`	`500`	`}`
`498`	`501`
`499`	`502`	`void free_params_buffer() override {`