Revert making llama_context, llama_buffer, and llama_ctx_buffer copyable. Beams now share one llama_context via a pointer, and pass their own growing tokens vector to llama_eval() on each iteration.

Author: mattpulver

llama-util.h

@@ -12,7 +12,6 @@
 #include <cstdlib>
 #include <climits>
 
-#include <memory>
 #include <string>
 #include <vector>
 #include <stdexcept>
@@ -414,80 +413,90 @@ struct llama_mlock {
 
 // Replacement for std::vector<uint8_t> that doesn't require zero-initialization.
 struct llama_buffer {
-#ifdef GGML_USE_METAL
-    struct metal_deleter { void operator()(uint8_t* addr) const { free(addr); } };
-    std::unique_ptr<uint8_t, metal_deleter> addr;
-#else
-    std::unique_ptr<uint8_t[]> addr;
-#endif
+    uint8_t * addr = NULL;
     size_t size = 0;
 
     llama_buffer() = default;
-    llama_buffer(const llama_buffer& rhs) { *this = rhs; }
-    llama_buffer& operator=(const llama_buffer& rhs) {
-      resize(rhs.size);
-      memcpy(addr.get(), rhs.addr.get(), size);
-      return *this;
-    }
 
     void resize(size_t len) {
-        addr.reset();
 #ifdef GGML_USE_METAL
-        size = 0;
-        uint8_t* ptr;
-        int result = posix_memalign((void **) &ptr, getpagesize(), len);
+        free(addr);
+        int result = posix_memalign((void **) &addr, getpagesize(), len);
         if (result == 0) {
-            memset(ptr, 0, len);
-            addr.reset(ptr);
-            size = len;
+            memset(addr, 0, len);
+        }
+        else {
+            addr = NULL;
+            len = 0;
         }
 #else
-        addr.reset(new uint8_t[len]);
+        delete[] addr;
+        addr = new uint8_t[len];
+#endif
         size = len;
+    }
+
+    ~llama_buffer() {
+#ifdef GGML_USE_METAL
+        free(addr);
+#else
+        delete[] addr;
 #endif
+        addr = NULL;
     }
+
+    // disable copy and move
+    llama_buffer(const llama_buffer&) = delete;
+    llama_buffer(llama_buffer&&) = delete;
+    llama_buffer& operator=(const llama_buffer&) = delete;
+    llama_buffer& operator=(llama_buffer&&) = delete;
 };
 
 #ifdef GGML_USE_CUBLAS
 #include "ggml-cuda.h"
 struct llama_ctx_buffer {
-    struct cuda_deleter {
-      bool is_cuda;
-      void operator()(uint8_t* addr) const {
-        if (addr) {
-          if (is_cuda) {
-            ggml_cuda_host_free(addr);
-          } else {
-            delete[] addr;
-          }
-        }
-      }
-    };
-    using Addr = std::unique_ptr<uint8_t, cuda_deleter>;
-    Addr addr;
+    uint8_t * addr = NULL;
+    bool is_cuda;
     size_t size = 0;
 
     llama_ctx_buffer() = default;
-    llama_ctx_buffer(const llama_ctx_buffer& rhs) { *this = rhs; }
-    llama_ctx_buffer& operator=(const llama_ctx_buffer& rhs) {
-        resize(rhs.size);
-        memcpy(addr.get(), rhs.addr.get(), size);
-        return *this;
-    }
 
-    void resize(size_t len) {
-        addr.reset();
+    void resize(size_t size) {
+        free();
 
-        bool is_cuda = true;
-        auto* ptr = (uint8_t*) ggml_cuda_host_malloc(len);
-        if (!ptr) {
+        addr = (uint8_t *) ggml_cuda_host_malloc(size);
+        if (addr) {
+            is_cuda = true;
+        }
+        else {
             // fall back to pageable memory
-            ptr = new uint8_t[len];
+            addr = new uint8_t[size];
             is_cuda = false;
         }
-        addr = Addr(ptr, {is_cuda});
-        size = len;
+        this->size = size;
     }
+
+    void free() {
+        if (addr) {
+            if (is_cuda) {
+                ggml_cuda_host_free(addr);
+            }
+            else {
+                delete[] addr;
+            }
+        }
+        addr = NULL;
+    }
+
+    ~llama_ctx_buffer() {
+        free();
+    }
+
+    // disable copy and move
+    llama_ctx_buffer(const llama_ctx_buffer&) = delete;
+    llama_ctx_buffer(llama_ctx_buffer&&) = delete;
+    llama_ctx_buffer& operator=(const llama_ctx_buffer&) = delete;
+    llama_ctx_buffer& operator=(llama_ctx_buffer&&) = delete;
 };
 #else
 typedef llama_buffer llama_ctx_buffer;