| |
| |
| |
| |
|
|
| import sys |
| import os |
| import argparse |
| import subprocess |
| import platform |
| import shutil |
| import logging |
|
|
| from sdk import validate_windows_sdks |
|
|
| logger = logging.getLogger("build") |
|
|
|
|
| def parse_target(target_str): |
| if not target_str: |
| return None, None |
| if target_str.startswith("adb") or target_str.startswith("android"): |
| parts = target_str.split(":", 1) |
| serial = parts[1] if len(parts) > 1 else None |
| return "android", serial |
| elif target_str.startswith("lnx") or target_str.startswith("linux") or target_str.startswith("ubuntu"): |
| parts = target_str.split(":", 1) |
| host = parts[1] if len(parts) > 1 else None |
| return "linux", host |
| elif target_str in ("wos", "windows"): |
| return "windows", None |
| else: |
| return None, None |
|
|
|
|
| def get_uid_gid(): |
| if platform.system() != "Windows": |
| return [f"{os.getuid()}:{os.getgid()}"] |
| return [] |
|
|
|
|
| def main(): |
| logging.basicConfig(level=logging.INFO, format='%(message)s') |
| parser = argparse.ArgumentParser( |
| description="Build llama.cpp for Snapdragon using cross-compilation docker containers or natively." |
| ) |
| parser.add_argument("--target", default="android", help="Compilation target and deployment definition (e.g. android[:serial]/adb[:serial], linux:[user@]host/lnx:[user@]host/ubuntu:[user@]host, windows/wos) (default: android)") |
| parser.add_argument("--build-dir", help="Build directory name (defaults to build-TARGET[-dbg], e.g. build-android)") |
| parser.add_argument("--install-dir", help="Install directory name (defaults to pkg-TARGET[-dbg], e.g. pkg-android)") |
| parser.add_argument("--jobs", "-j", type=int, help="Number of build jobs (defaults to CPU thread count)") |
| parser.add_argument("--no-docker", action="store_true", help="Build natively on the host instead of in a docker container") |
| parser.add_argument("--preset", help="Override the CMake preset to use") |
| parser.add_argument("--debug", action="store_true", help="Build in debug mode (uses -debug presets instead of -release)") |
|
|
| |
| parser.add_argument("--push", action="store_true", help="Push built package to the target device via ADB or SSH/SCP") |
| parser.add_argument("--target-dir", help="Target directory on the device (default: /data/local/tmp/llama.cpp for Android, ~/llama.cpp for Linux)") |
|
|
| |
| parser.add_argument("--toolchain-version", default="v0.7", help="Docker toolchain image version/tag (default: v0.7)") |
| parser.add_argument("--toolchain-url", default="ghcr.io/snapdragon-toolchain", help="Docker toolchain registry URL/namespace (default: ghcr.io/snapdragon-toolchain)") |
|
|
| args = parser.parse_args() |
|
|
| target_type, target_val = parse_target(args.target) |
| if not target_type: |
| logger.error(f"Error: Invalid target format '{args.target}'. Must be android[:serial]/adb[:serial], linux:[user@]host/lnx:[user@]host/ubuntu:[user@]host, or windows/wos.") |
| sys.exit(1) |
|
|
| if target_type == "windows": |
| logger.info("Windows target selected. Forcing native compilation...") |
| args.no_docker = True |
| if platform.system() != "Windows": |
| logger.warning("Warning: Windows compilation is intended to run on Windows arm64 hosts.") |
| validate_windows_sdks() |
|
|
| |
| preset = args.preset |
| if preset: |
| is_debug = args.debug or ("debug" in preset.lower()) |
| else: |
| is_debug = args.debug |
| config_type = "debug" if is_debug else "release" |
| if args.no_docker: |
| if target_type == "windows" or platform.system() == "Windows": |
| preset = f"arm64-windows-snapdragon-{config_type}" |
| elif target_type == "linux": |
| preset = f"arm64-linux-snapdragon-{config_type}" |
| else: |
| preset = f"arm64-android-snapdragon-{config_type}" |
| else: |
| preset = f"arm64-linux-snapdragon-{config_type}" if target_type == "linux" else f"arm64-android-snapdragon-{config_type}" |
|
|
| target_prefix = args.target.split(":", 1)[0] |
| suffix = "-dbg" if is_debug else "" |
|
|
| build_dir = args.build_dir |
| if not build_dir: |
| build_dir = f"build-{target_prefix}{suffix}" |
|
|
| install_dir = args.install_dir |
| if not install_dir: |
| install_dir = f"pkg-{target_prefix}{suffix}" |
|
|
| repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "..")) |
|
|
| |
| preset_src = os.path.join(repo_root, "docs", "backend", "snapdragon", "CMakeUserPresets.json") |
| preset_dst = os.path.join(repo_root, "CMakeUserPresets.json") |
| if os.path.exists(preset_src): |
| should_copy = False |
| if not os.path.exists(preset_dst): |
| should_copy = True |
| else: |
| |
| src_mtime = os.path.getmtime(preset_src) |
| dst_mtime = os.path.getmtime(preset_dst) |
| if src_mtime > dst_mtime: |
| preset_bak = preset_dst + ".bak" |
| logger.info(f"Docs CMakeUserPresets.json is newer. Backing up existing {preset_dst} to {preset_bak}") |
| shutil.copy2(preset_dst, preset_bak) |
| should_copy = True |
|
|
| if should_copy: |
| logger.info(f"Copying CMakeUserPresets.json from {preset_src} to {preset_dst}") |
| shutil.copy2(preset_src, preset_dst) |
| else: |
| logger.warning("Warning: CMakeUserPresets.json not found in docs/backend/snapdragon/.") |
|
|
| jobs = args.jobs if args.jobs else os.cpu_count() or 4 |
|
|
| if args.no_docker: |
| |
| logger.info("Running native/local CMake build...") |
| install_prefix = os.path.join(repo_root, install_dir, "llama.cpp") |
|
|
| |
| configure_cmd = ["cmake", f"--preset={preset}", "-B", build_dir] |
| logger.info(f"+ {' '.join(configure_cmd)}") |
| res = subprocess.run(configure_cmd, cwd=repo_root) |
| if res.returncode != 0: |
| logger.error("CMake configuration failed.") |
| sys.exit(res.returncode) |
|
|
| |
| build_cmd = ["cmake", "--build", build_dir, "-j", str(jobs)] |
| logger.info(f"+ {' '.join(build_cmd)}") |
| res = subprocess.run(build_cmd, cwd=repo_root) |
| if res.returncode != 0: |
| logger.error("CMake build failed.") |
| sys.exit(res.returncode) |
|
|
| |
| install_cmd = ["cmake", "--install", build_dir, "--prefix", install_prefix] |
| logger.info(f"+ {' '.join(install_cmd)}") |
| res = subprocess.run(install_cmd, cwd=repo_root) |
| if res.returncode != 0: |
| logger.error("CMake install failed.") |
| sys.exit(res.returncode) |
| else: |
| |
| logger.info("Running Docker-based cross-compilation build...") |
| image_name = "arm64-linux" if target_type == "linux" else "arm64-android" |
| image = f"{args.toolchain_url}/{image_name}:{args.toolchain_version}" |
|
|
| install_prefix_container = f"/workspace/{install_dir}/llama.cpp" |
|
|
| build_sh_cmd = ( |
| f"cmake --preset {preset} -B /workspace/{build_dir} && " |
| f"cmake --build /workspace/{build_dir} -j {jobs} && " |
| f"cmake --install /workspace/{build_dir} --prefix {install_prefix_container}" |
| ) |
|
|
| docker_cmd = [ |
| "docker", "run", "--rm", |
| "--volume", f"{repo_root}:/workspace", |
| "--workdir", "/workspace", |
| "--platform", "linux/amd64" |
| ] |
| uid_gid = get_uid_gid() |
| if uid_gid: |
| docker_cmd += ["-u", uid_gid[0]] |
|
|
| docker_cmd += [image, "bash", "-c", build_sh_cmd] |
|
|
| logger.info(f"+ {' '.join(docker_cmd)}") |
| res = subprocess.run(docker_cmd, cwd=repo_root) |
| if res.returncode != 0: |
| logger.error("Docker-based build failed.") |
| sys.exit(res.returncode) |
|
|
| logger.info("\nBuild and installation completed successfully!") |
|
|
| |
| if args.push: |
| src_path = os.path.join(repo_root, install_dir, "llama.cpp") |
| if not os.path.exists(src_path): |
| logger.error(f"Error: installation directory {src_path} does not exist. Cannot deploy.") |
| sys.exit(1) |
|
|
| |
| target_dir = args.target_dir |
| if not target_dir: |
| target_dir = "/data/local/tmp/llama.cpp" if target_type == "android" else "~/llama.cpp" |
| target_dir = target_dir.rstrip("/") |
|
|
| sub_items = [item for item in os.listdir(src_path) if not item.startswith(".")] |
|
|
| if target_type == "android": |
| logger.info("\nPushing built artifacts to Android device via ADB...") |
| adb_cmd = ["adb"] |
| if target_val: |
| adb_cmd += ["-s", target_val] |
|
|
| |
| if sub_items: |
| clean_paths = " ".join(f"{target_dir}/{item}" for item in sub_items) |
| clean_cmd = adb_cmd + ["shell", f"rm -rf {clean_paths}"] |
| logger.info(f"+ {' '.join(clean_cmd)}") |
| subprocess.run(clean_cmd) |
|
|
| |
| push_cmd = adb_cmd + ["push", os.path.join(src_path, "."), target_dir] |
| logger.info(f"+ {' '.join(push_cmd)}") |
| res = subprocess.run(push_cmd) |
| if res.returncode != 0: |
| logger.error("ADB push failed.") |
| sys.exit(res.returncode) |
|
|
| chmod_cmd = adb_cmd + ["shell", f"chmod -R 755 {target_dir}/bin 2>/dev/null || true"] |
| logger.info(f"+ {' '.join(chmod_cmd)}") |
| subprocess.run(chmod_cmd) |
| logger.info("ADB push completed successfully!") |
|
|
| elif target_type == "linux": |
| ssh_host = target_val |
| if not ssh_host: |
| logger.error("Error: SSH host not specified in target (e.g. use linux:user@host, lnx:user@host, or ubuntu:user@host). Cannot deploy.") |
| sys.exit(1) |
| logger.info(f"\nDeploying built artifacts to Linux device {ssh_host} via SSH/SCP...") |
|
|
| |
| if sub_items: |
| clean_paths = " ".join(f"{target_dir}/{item}" for item in sub_items) |
| clean_cmd = ["ssh", ssh_host, f"rm -rf {clean_paths}"] |
| logger.info(f"+ {' '.join(clean_cmd)}") |
| subprocess.run(clean_cmd) |
|
|
| |
| deploy_cmd = ["scp", "-r", os.path.join(src_path, "."), f"{ssh_host}:{target_dir}"] |
| logger.info(f"+ {' '.join(deploy_cmd)}") |
| res = subprocess.run(deploy_cmd) |
| if res.returncode != 0: |
| logger.error("SSH/SCP deploy failed.") |
| sys.exit(res.returncode) |
|
|
| chmod_cmd = ["ssh", ssh_host, f"chmod -R 755 {target_dir}/bin 2>/dev/null || true"] |
| logger.info(f"+ {' '.join(chmod_cmd)}") |
| subprocess.run(chmod_cmd) |
| logger.info("SSH/SCP deploy completed successfully!") |
|
|
| elif target_type == "windows": |
| logger.info("\nPush for Windows on Snapdragon (windows) target is currently a stub.") |
|
|
|
|
| if __name__ == "__main__": |
| try: |
| main() |
| except KeyboardInterrupt: |
| logger.info("\nInterrupted by user.") |
| sys.exit(130) |
| except RuntimeError as err: |
| logger.error("Error: %s", err) |
| sys.exit(1) |
|
|
