Add llama_beam_search().

Author: mattpulver

llama-util.h

@@ -12,6 +12,7 @@
 #include <cstdlib>
 #include <climits>
 
+#include <memory>
 #include <string>
 #include <vector>
 #include <stdexcept>
@@ -413,89 +414,80 @@ struct llama_mlock {
 
 // Replacement for std::vector<uint8_t> that doesn't require zero-initialization.
 struct llama_buffer {
-    uint8_t * addr = NULL;
+#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
     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
-        free(addr);
-        int result = posix_memalign((void **) &addr, getpagesize(), len);
+        size = 0;
+        uint8_t* ptr;
+        int result = posix_memalign((void **) &ptr, getpagesize(), len);
         if (result == 0) {
-            memset(addr, 0, len);
-        }
-        else {
-            addr = NULL;
+            memset(ptr, 0, len);
+            addr.reset(ptr);
+            size = len;
         }
 #else
-        delete[] addr;
-        addr = new uint8_t[len];
-#endif
+        addr.reset(new uint8_t[len]);
         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 {
-    uint8_t * addr = NULL;
-    bool is_cuda;
+    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;
     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 size) {
-        free();
+    void resize(size_t len) {
+        addr.reset();
 
-        addr = (uint8_t *) ggml_cuda_host_malloc(size);
-        if (addr) {
-            is_cuda = true;
-        }
-        else {
+        bool is_cuda = true;
+        auto* ptr = (uint8_t*) ggml_cuda_host_malloc(len);
+        if (!ptr) {
             // fall back to pageable memory
-            addr = new uint8_t[size];
+            ptr = new uint8_t[len];
             is_cuda = false;
         }
-        this->size = size;
-    }
-
-    void free() {
-        if (addr) {
-            if (is_cuda) {
-                ggml_cuda_host_free(addr);
-            }
-            else {
-                delete[] addr;
-            }
-        }
-        addr = NULL;
-    }
-
-    ~llama_ctx_buffer() {
-        free();
+        addr = Addr(ptr, {is_cuda});
+        size = len;
     }
-
-    // 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;