optimizing build

Author: hazelnutcloud

build.zig

@@ -34,6 +34,10 @@ pub fn build(b: *std.Build) !void {
         "The compute backend to use.",
     ) orelse ComputeBackend.cpu;
 
+    const gen_run = b.addSystemCommand(&.{ "python", "binding_generator.py" });
+    gen_run.addFileArg(b.path("godot_cpp/gdextension/extension_api.json"));
+    const gen_out = gen_run.addOutputDirectoryArg("godot-cpp-gen");
+
     // godot-llama-cpp
     const plugin = b.addSharedLibrary(.{
         .name = b.fmt("{s}-{s}-{s}", .{ extension_name, triple, @tagName(optimize) }),
@@ -42,14 +46,16 @@ pub fn build(b: *std.Build) !void {
     });
     b.installArtifact(plugin);
 
-    plugin.addCSourceFiles(.{ .files = try findFilesRecursive(b, "src/", &cfiles_exts) });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "src/" } });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "godot_cpp/gdextension/" } });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "godot_cpp/include/" } });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "godot_cpp/gen/include" } });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "llama.cpp/include" } });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "llama.cpp/common" } });
-    plugin.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "llama.cpp/ggml/include" } });
+    plugin.addCSourceFiles(.{ .files = try findFilesRecursive(b, "src", &cfiles_exts) });
+    plugin.addIncludePath(b.path("src"));
+    plugin.addIncludePath(b.path("godot_cpp/gdextension"));
+    plugin.addIncludePath(b.path("godot_cpp/include"));
+    plugin.addIncludePath(gen_out.path(b, "gen/include"));
+    plugin.addIncludePath(b.path("llama.cpp/src"));
+    plugin.addIncludePath(b.path("llama.cpp/include"));
+    plugin.addIncludePath(b.path("llama.cpp/common"));
+    plugin.addIncludePath(b.path("llama.cpp/ggml/include"));
+    plugin.addIncludePath(b.path("llama.cpp/ggml/src"));
 
     // godot-cpp
     const lib_godot = b.addStaticLibrary(.{
@@ -58,26 +64,25 @@ pub fn build(b: *std.Build) !void {
         .optimize = optimize,
     });
     plugin.linkLibrary(lib_godot);
-
-    b.build_root.handle.access("godot_cpp/gen", .{}) catch |e| {
-        switch (e) {
-            error.FileNotFound => {
-                _ = try std.process.Child.run(.{
-                    .allocator = b.allocator,
-                    .argv = &.{ "python", "binding_generator.py", "godot_cpp/gdextension/extension_api.json", "godot_cpp" },
-                    .cwd_dir = b.build_root.handle,
-                });
-            },
-            else => {},
-        }
-    };
     lib_godot.linkLibCpp();
-    lib_godot.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "godot_cpp/gdextension/" } });
-    lib_godot.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "godot_cpp/include/" } });
-    lib_godot.addIncludePath(.{ .src_path = .{ .owner = b, .sub_path = "godot_cpp/gen/include" } });
+    lib_godot.step.dependOn(&gen_run.step);
+
+    lib_godot.addIncludePath(b.path("godot_cpp/gdextension"));
+    lib_godot.addIncludePath(b.path("godot_cpp/include"));
+    lib_godot.addIncludePath(gen_out.path(b, "gen/include"));
+
+    const concat_gen_exe = b.addExecutable(.{
+        .name = "concat_gen",
+        .target = target,
+        .optimize = optimize,
+        .root_source_file = b.path("tools/concat_files.zig"),
+    });
+    var concat_gen_run = b.addRunArtifact(concat_gen_exe);
+    concat_gen_run.addDirectoryArg(gen_out.path(b, "gen/src"));
+    const concat_gen_out = concat_gen_run.addOutputFileArg("gen_concat.cpp");
     const lib_godot_sources = try findFilesRecursive(b, "godot_cpp/src", &cfiles_exts);
-    const lib_godot_gen_sources = try findFilesRecursive(b, "godot_cpp/gen/src", &cfiles_exts);
-    lib_godot.addCSourceFiles(.{ .files = lib_godot_gen_sources, .flags = &.{ "-std=c++17", "-fno-exceptions" } });
+
+    lib_godot.addCSourceFile(.{ .file = concat_gen_out, .flags = &.{ "-std=c++17", "-fno-exceptions" } });
     lib_godot.addCSourceFiles(.{ .files = lib_godot_sources, .flags = &.{ "-std=c++17", "-fno-exceptions" } });
 
     // llama.cpp
@@ -91,18 +96,20 @@ pub fn build(b: *std.Build) !void {
     var base_flags = std.ArrayList([]const u8).init(b.allocator);
     var c_flags = std.ArrayList([]const u8).init(b.allocator);
     var cpp_flags = std.ArrayList([]const u8).init(b.allocator);
-    var include_paths = std.ArrayList([]const u8).init(b.allocator);
+    var include_paths = std.ArrayList(std.Build.LazyPath).init(b.allocator);
     var system_libs = std.ArrayList([]const u8).init(b.allocator);
     var library_paths = std.ArrayList(std.Build.LazyPath).init(b.allocator);
 
     var sources = std.ArrayList(Source).init(b.allocator);
 
     try c_flags.append("-std=c11");
-    try cpp_flags.append("-std=c++11");
+    try cpp_flags.append("-std=c++17");
     try include_paths.appendSlice(&.{
-        "llama.cpp/include",
-        "llama.cpp/common",
-        "llama.cpp/ggml/include",
+        b.path("llama.cpp/src"),
+        b.path("llama.cpp/include"),
+        b.path("llama.cpp/common"),
+        b.path("llama.cpp/ggml/include"),
+        b.path("llama.cpp/ggml/src"),
     });
 
     switch (target.result.os.tag) {
@@ -127,13 +134,13 @@ pub fn build(b: *std.Build) !void {
             const expand_metal = b.addExecutable(.{
                 .name = "expand_metal",
                 .target = target,
-                .root_source_file = .{ .src_path = .{ .owner = b, .sub_path = "tools/expand_metal.zig" } },
+                .root_source_file = b.path("tools/expand_metal.zig"),
             });
             var run_expand_metal = b.addRunArtifact(expand_metal);
             run_expand_metal.addArg("--metal-file");
-            run_expand_metal.addFileArg(.{ .src_path = .{ .owner = b, .sub_path = "llama.cpp/ggml/src/ggml-metal.metal" } });
+            run_expand_metal.addFileArg(b.path("llama.cpp/ggml/src/ggml-metal.metal"));
             run_expand_metal.addArg("--common-file");
-            run_expand_metal.addFileArg(.{ .src_path = .{ .owner = b, .sub_path = "llama.cpp/ggml/src/ggml-common.h" } });
+            run_expand_metal.addFileArg(b.path("llama.cpp/ggml/src/ggml-common.h"));
             run_expand_metal.addArg("--output-file");
             const metal_expanded = run_expand_metal.addOutputFileArg("ggml-metal.metal");
             const install_metal = b.addInstallFileWithDir(metal_expanded, .lib, "ggml-metal.metal");
@@ -148,7 +155,7 @@ pub fn build(b: *std.Build) !void {
 
             const vk_library_path = b.pathJoin(&.{ vulkan_sdk, "lib" });
             const vk_include_path = b.pathJoin(&.{ vulkan_sdk, "include" });
-            try include_paths.append(vk_include_path);
+            try include_paths.append(std.Build.LazyPath{ .cwd_relative = vk_include_path });
             try library_paths.append(.{ .cwd_relative = vk_library_path });
             try system_libs.append("vulkan");
 
@@ -195,7 +202,6 @@ pub fn build(b: *std.Build) !void {
             .name = source.name,
             .target = target,
             .optimize = optimize,
-            .pic = true,
         });
         lib_llama_cpp.addObject(obj);
         if (source.dependencies) |deps| {
@@ -206,12 +212,7 @@ pub fn build(b: *std.Build) !void {
         const file = if (source.root) |root|
             root.path(b, source.source_file)
         else
-            std.Build.LazyPath{
-                .src_path = .{
-                    .owner = b,
-                    .sub_path = source.source_file,
-                },
-            };
+            b.path(source.source_file);
         const extension = std.meta.stringToEnum(
             Extension,
             std.fs.path.extension(source.source_file),
@@ -225,9 +226,7 @@ pub fn build(b: *std.Build) !void {
             .flags = flags,
         });
         for (include_paths.items) |path| {
-            obj.addIncludePath(.{
-                .src_path = .{ .owner = b, .sub_path = path },
-            });
+            obj.addIncludePath(path);
         }
         for (system_libs.items) |lib| {
             obj.linkSystemLibrary(lib);

godot_cpp

@@ -67,6 +67,8 @@ void LlamaContext::_ready() {
 		return;
 	}
 
+	model->load_model();
+
 	if (model->model == NULL) {
 		UtilityFunctions::printerr(vformat("%s: Failed to initialize llama context, model property not defined", __func__));
 		return;
@@ -269,24 +271,24 @@ Ref<LlamaModel> LlamaContext::get_model() {
 	return model;
 }
 
-int LlamaContext::get_seed() {
+uint32_t LlamaContext::get_seed() {
 	return ctx_params.seed;
 }
-void LlamaContext::set_seed(int seed) {
+void LlamaContext::set_seed(uint32_t seed) {
 	ctx_params.seed = seed;
 }
 
-int LlamaContext::get_n_ctx() {
+uint32_t LlamaContext::get_n_ctx() {
 	return ctx_params.n_ctx;
 }
-void LlamaContext::set_n_ctx(int n_ctx) {
+void LlamaContext::set_n_ctx(uint32_t n_ctx) {
 	ctx_params.n_ctx = n_ctx;
 }
 
-int LlamaContext::get_n_len() {
+int32_t LlamaContext::get_n_len() {
 	return n_len;
 }
-void LlamaContext::set_n_len(int n_len) {
+void LlamaContext::set_n_len(int32_t n_len) {
 	this->n_len = n_len;
 }
 
@@ -334,7 +336,11 @@ void LlamaContext::_exit_tree() {
 	if (ctx) {
 		llama_free(ctx);
 	}
-
-	llama_sampling_free(sampling_ctx);
+	if (model->model) {
+		llama_free_model(model->model);
+	}
+	if (sampling_ctx) {
+		llama_sampling_free(sampling_ctx);
+	}
 	llama_backend_free();
 }

src/llama_context.cpp

@@ -25,7 +25,7 @@ class LlamaContext : public Node {
   llama_sampling_context *sampling_ctx = nullptr;
 	llama_context_params ctx_params;
   llama_sampling_params sampling_params;
-  int n_len = 1024;
+  int32_t n_len = 1024;
 	int request_id = 0;
 	Vector<completion_request> completion_requests;
 
@@ -45,12 +45,12 @@ class LlamaContext : public Node {
 	int request_completion(const String &prompt);
 	void __thread_loop();
 
-	int get_seed();
-	void set_seed(int seed);
-	int get_n_ctx();
-	void set_n_ctx(int n_ctx);
-  int get_n_len();
-  void set_n_len(int n_len);
+	uint32_t get_seed();
+	void set_seed(uint32_t seed);
+	uint32_t get_n_ctx();
+	void set_n_ctx(uint32_t n_ctx);
+  int32_t get_n_len();
+  void set_n_len(int32_t n_len);
   float get_temperature();
   void set_temperature(float temperature);
   float get_top_p();

src/llama_context.h

@@ -7,7 +7,7 @@
 using namespace godot;
 
 void LlamaModel::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("load_model", "path"), &LlamaModel::load_model);
+	ClassDB::bind_method(D_METHOD("load_model"), &LlamaModel::load_model);
 
 	ClassDB::bind_method(D_METHOD("get_n_gpu_layers"), &LlamaModel::get_n_gpu_layers);
 	ClassDB::bind_method(D_METHOD("set_n_gpu_layers", "n"), &LlamaModel::set_n_gpu_layers);
@@ -18,12 +18,12 @@ LlamaModel::LlamaModel() {
 	model_params = llama_model_default_params();
 }
 
-void LlamaModel::load_model(const String &path) {
+void LlamaModel::load_model() {
 	if (model) {
-		llama_free_model(model);
+		return;
 	}
 
-	String absPath = ProjectSettings::get_singleton()->globalize_path(path);
+	String absPath = ProjectSettings::get_singleton()->globalize_path(get_path());
 
 	model = llama_load_model_from_file(absPath.utf8().get_data(), model_params);
 
@@ -35,11 +35,11 @@ void LlamaModel::load_model(const String &path) {
 	UtilityFunctions::print(vformat("%s: Model loaded from %s", __func__, absPath));
 }
 
-int LlamaModel::get_n_gpu_layers() {
+int32_t LlamaModel::get_n_gpu_layers() {
 	return model_params.n_gpu_layers;
 }
 
-void LlamaModel::set_n_gpu_layers(int n) {
+void LlamaModel::set_n_gpu_layers(int32_t n) {
 	model_params.n_gpu_layers = n;
 }
 

src/llama_model.cpp

@@ -17,10 +17,10 @@ class LlamaModel : public Resource {
 
 public:
 	llama_model *model = nullptr;
-	void load_model(const String &path);
+	void load_model();
 
-	int get_n_gpu_layers();
-	void set_n_gpu_layers(int n);
+	int32_t get_n_gpu_layers();
+	void set_n_gpu_layers(int32_t n);
 
 	LlamaModel();
 	~LlamaModel();

src/llama_model.h

@@ -19,11 +19,7 @@ Variant godot::LlamaModelLoader::_load(const String &path, const String &origina
 		return ERR_FILE_NOT_FOUND;
 	}
 
-  if (Engine::get_singleton()->is_editor_hint()) {
-    return { model };
-  }
-
-	model->load_model(path);
+  model->set_path(path);
 
 	return { model };
 }

src/llama_model_loader.cpp

@@ -0,0 +1,58 @@
+const std = @import("std");
+
+const usage = "Usage: ./concat_files <input-dir-1> <input-dir-2> ... <output-file>";
+
+pub fn main() !void {
+    var arena_state = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena_state.deinit();
+    const arena = arena_state.allocator();
+
+    const args = try std.process.argsAlloc(arena);
+
+    if (args.len < 3) {
+        std.debug.panic("expected at least 2 arguments", .{});
+    }
+
+    var input_dirs = std.ArrayList([]const u8).init(arena);
+    var output_file_path: []const u8 = undefined;
+
+    {
+        var i: usize = 1;
+        while (i < args.len) : (i += 1) {
+            const arg = args[i];
+            if (std.mem.eql(u8, "-h", arg) or std.mem.eql(u8, "--help", arg)) {
+                try std.io.getStdOut().writeAll(usage);
+                return std.process.cleanExit();
+            } else if (i == args.len - 1) {
+                output_file_path = arg;
+            } else {
+                try input_dirs.append(arg);
+            }
+        }
+    }
+
+    const cwd = std.fs.cwd();
+    const output = try cwd.createFile(output_file_path, .{});
+    var pos: u64 = 0;
+
+    for (input_dirs.items) |dir_path| {
+        var dir = try cwd.openDir(dir_path, .{ .iterate = true });
+        defer dir.close();
+
+        var walker = try dir.walk(arena);
+        defer walker.deinit();
+
+        while (try walker.next()) |entry| {
+            if (entry.kind != .file) continue;
+            const file = try entry.dir.openFile(entry.basename, .{});
+            defer file.close();
+
+            const len = (try file.stat()).size;
+            const bytes_copied = try file.copyRangeAll(0, output, pos, len);
+            pos += bytes_copied;
+
+            try output.pwriteAll("\n", pos);
+            pos += 1;
+        }
+    }
+}