fix potential duplicate issue

leejet · leejet · commit 1e72471d4414 · 2025-09-14T22:27:11.000+08:00
diff --git a/lora.hpp b/lora.hpp
@@ -1,8 +1,8 @@
 #ifndef __LORA_HPP__
 #define __LORA_HPP__
 
-#include "ggml_extend.hpp"
 #include <mutex>
+#include "ggml_extend.hpp"
 
 #define LORA_GRAPH_BASE_SIZE 10240
 
@@ -157,13 +157,13 @@ struct LoraModel : public GGMLRunner {
         model_loader.load_tensors(on_new_tensor_cb, n_threads);
 
         for (const auto& pair : tensors_to_create) {
-            const auto& name = pair.first;
-            const auto& ts   = pair.second;
+            const auto& name         = pair.first;
+            const auto& ts           = pair.second;
             struct ggml_tensor* real = ggml_new_tensor(params_ctx,
                                                        ts.type,
                                                        ts.n_dims,
                                                        ts.ne);
-            lora_tensors[name] = real;
+            lora_tensors[name]       = real;
         }
 
         alloc_params_buffer();
diff --git a/model.cpp b/model.cpp
@@ -1982,8 +1982,13 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
     std::vector<TensorStorage> processed_tensor_storages;
 
     {
-        std::unordered_map<std::string, TensorStorage> processed_map;
-        std::mutex map_mutex;
+        struct IndexedStorage {
+            size_t index;
+            TensorStorage ts;
+        };
+
+        std::mutex vec_mutex;
+        std::vector<IndexedStorage> all_results;
 
         int n_threads = std::min(num_threads_to_use, (int)tensor_storages.size());
         if (n_threads < 1) {
@@ -1993,7 +1998,7 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
 
         for (int i = 0; i < n_threads; ++i) {
             workers.emplace_back([&, thread_id = i]() {
-                std::unordered_map<std::string, TensorStorage> local_processed_map;
+                std::vector<IndexedStorage> local_results;
                 std::vector<TensorStorage> temp_storages;
 
                 for (size_t j = thread_id; j < tensor_storages.size(); j += n_threads) {
@@ -2006,23 +2011,29 @@ bool ModelLoader::load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_thread
                     preprocess_tensor(tensor_storage, temp_storages);
 
                     for (const auto& ts : temp_storages) {
-                        local_processed_map[ts.name] = ts;
+                        local_results.push_back({j, ts});
                     }
                 }
 
-                if (!local_processed_map.empty()) {
-                    std::lock_guard<std::mutex> lock(map_mutex);
-                    processed_map.merge(local_processed_map);
+                if (!local_results.empty()) {
+                    std::lock_guard<std::mutex> lock(vec_mutex);
+                    all_results.insert(all_results.end(),
+                                       local_results.begin(), local_results.end());
                 }
             });
         }
         for (auto& w : workers) {
             w.join();
         }
 
-        processed_tensor_storages.reserve(processed_map.size());
-        for (auto const& [name, ts] : processed_map) {
-            processed_tensor_storages.push_back(ts);
+        std::unordered_map<std::string, IndexedStorage> latest_map;
+        for (auto& entry : all_results) {
+            latest_map[entry.ts.name] = entry;
+        }
+
+        processed_tensor_storages.reserve(latest_map.size());
+        for (auto& [name, entry] : latest_map) {
+            processed_tensor_storages.push_back(entry.ts);
         }
     }
 
diff --git a/model.h b/model.h
@@ -250,7 +250,7 @@ class ModelLoader {
     bool load_tensors(on_new_tensor_cb_t on_new_tensor_cb, int n_threads = 0);
     bool load_tensors(std::map<std::string, struct ggml_tensor*>& tensors,
                       std::set<std::string> ignore_tensors = {},
-                      int n_threads = 0);
+                      int n_threads                        = 0);
 
     bool save_to_gguf_file(const std::string& file_path, ggml_type type, const std::string& tensor_type_rules);
     bool tensor_should_be_converted(const TensorStorage& tensor_storage, ggml_type type);
