Upload folder using huggingface_hub

conftest.py

@@ -2,19 +2,18 @@
 # Copyright (c) 2025 Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause
 # ---------------------------------------------------------------------
-"""Shared pytest fixtures for QDC on-device test runners."""
+"""Shared pytest fixtures for QDC on-device test runners (Linux IoT)."""
 
 import os
 
 import pytest
-from appium import webdriver
 
-from utils import options, write_qdc_log
+from utils import write_qdc_log
 
 
 @pytest.fixture(scope="session", autouse=True)
 def driver():
-    return webdriver.Remote(command_executor="http://127.0.0.1:4723/wd/hub", options=options)
+    return None
 
 
 def pytest_sessionfinish(session, exitstatus):

requirements.txt

@@ -1,22 +1,6 @@
-Appium-Python-Client==5.2.4
-attrs==25.4.0
-certifi==2025.10.5
 exceptiongroup==1.3.0
-h11==0.16.0
-idna==3.11
 iniconfig==2.1.0
-outcome==1.3.0.post0
 packaging==25.0
 pluggy==1.6.0
-PySocks==1.7.1
 pytest==8.4.2
-selenium==4.36.0
-sniffio==1.3.1
-sortedcontainers==2.4.0
 tomli==2.3.0
-trio==0.31.0
-trio-websocket==0.12.2
-typing_extensions==4.15.0
-urllib3==2.5.0
-websocket-client==1.9.0
-wsproto==1.2.0

run_backend_ops_posix.py

@@ -5,8 +5,7 @@
 """
 On-device test-backend-ops runner for llama.cpp (HTP0 backend).
 
-Executed by QDC's Appium test framework on the QDC runner.
-The runner has ADB access to the allocated device.
+Runs directly on a Linux IoT device via QDC.
 """
 
 import os
@@ -14,7 +13,7 @@ import sys
 
 import pytest
 
-from utils import BIN_PATH, CMD_PREFIX, push_bundle_if_needed, run_adb_command, write_qdc_log
+from utils import BIN_PATH, CMD_PREFIX, push_bundle_if_needed, run_shell_command, write_qdc_log
 
 
 @pytest.fixture(scope="session", autouse=True)
@@ -29,10 +28,7 @@ def test_backend_ops_htp0(type_a):
         cmd += r' -p "^(?=.*type_a=q4_0)(?!.*type_b=f32,m=576,n=512,k=576).*$"'
     else:
         cmd += f" -p type_a={type_a}"
-    result = run_adb_command(
-        cmd,
-        check=False,
-    )
+    result = run_shell_command(cmd, check=False)
     write_qdc_log(f"backend_ops_{type_a}.log", result.stdout or "")
     assert result.returncode == 0, f"test-backend-ops type_a={type_a} failed (exit {result.returncode})"
 

run_bench_tests_posix.py

@@ -5,22 +5,20 @@
 """
 On-device bench and completion test runner for llama.cpp (CPU, GPU, NPU backends).
 
-Executed by QDC's Appium test framework on the QDC runner.
-The runner has ADB access to the allocated device.
+Runs directly on a Linux IoT device via QDC.
 
 Placeholders replaced at artifact creation time by run_qdc_jobs.py:
   <<MODEL_URL>>  Direct URL to the GGUF model file (downloaded on-device via curl)
 """
 
 import os
-import subprocess
 import sys
 
 import pytest
 
-from utils import BIN_PATH, CMD_PREFIX, push_bundle_if_needed, run_adb_command, write_qdc_log
+from utils import BIN_PATH, CMD_PREFIX, push_bundle_if_needed, run_shell_command, write_qdc_log
 
-MODEL_PATH = "/data/local/tmp/model.gguf"
+MODEL_PATH = "/tmp/model.gguf"
 PROMPT     = "What is the capital of France?"
 CLI_OPTS   = "--batch-size 128 -n 128 -no-cnv --seed 42"
 
@@ -29,13 +27,8 @@ CLI_OPTS   = "--batch-size 128 -n 128 -no-cnv --seed 42"
 def install(driver):
     push_bundle_if_needed(f"{BIN_PATH}/llama-cli")
 
-    # Skip model download if already present
-    check = subprocess.run(
-        ["adb", "shell", f"ls {MODEL_PATH}"],
-        text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-    )
-    if check.returncode != 0:
-        run_adb_command(f'curl -L -J --output {MODEL_PATH} "<<MODEL_URL>>"')
+    if not os.path.exists(MODEL_PATH):
+        run_shell_command(f'curl -L -J --output {MODEL_PATH} "<<MODEL_URL>>"')
 
 
 @pytest.mark.parametrize("device,extra_flags", [
@@ -44,7 +37,7 @@ def install(driver):
     pytest.param("HTP0",      "-ctk q8_0 -ctv q8_0", id="npu"),
 ])
 def test_llama_completion(device, extra_flags):
-    result = run_adb_command(
+    result = run_shell_command(
         f'{CMD_PREFIX} {BIN_PATH}/llama-completion'
         f' -m {MODEL_PATH} --device {device} -ngl 99 -t 4 {CLI_OPTS} {extra_flags} -fa on'
         f' -p "{PROMPT}"',
@@ -63,7 +56,7 @@ _DEVICE_LOG_NAME = {"none": "cpu", "GPUOpenCL": "gpu", "HTP0": "htp"}
     pytest.param("HTP0",      id="npu"),
 ])
 def test_llama_bench(device):
-    result = run_adb_command(
+    result = run_shell_command(
         f"{CMD_PREFIX} {BIN_PATH}/llama-bench"
         f" -m {MODEL_PATH} --device {device} -ngl 99 --batch-size 128 -t 4 -p 128 -n 32",
         check=False,

run_scorecard_posix.py

@@ -3,69 +3,52 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # ---------------------------------------------------------------------
 """
-Scorecard benchmark script for llama.cpp on Android devices via Appium.
+Scorecard benchmark script for llama.cpp on Linux IoT devices.
 
-This script runs comprehensive benchmarks using the run-*.sh scripts from
-llama.cpp/scripts/snapdragon/adb/:
-  1. Performance benchmarks (CPU/GPU/HTP x 3 context lengths)
-  2. Fallback ops detection (SCHED=1)
-  3. Perplexity (WikiText-2)
+Runs directly on a Linux IoT device via QDC — no Appium/ADB needed.
 
 Placeholders are replaced at artifact creation time:
   - <<MODEL_URL>>: URL to download the model
+  - <<NUM_HTPS>>: Number of HTP cores
 """
 
 import os
+import shutil
 import subprocess
 import sys
 
 import pytest
-from appium import webdriver
-from appium.options.common import AppiumOptions
 
-options = AppiumOptions()
-options.set_capability("automationName", "UiAutomator2")
-options.set_capability("platformName", "Android")
-options.set_capability("deviceName", os.getenv("ANDROID_DEVICE_VERSION"))
+from utils import write_qdc_log
 
-# Context lengths to benchmark
 CONTEXT_LENGTHS = [128, 1024, 4096]
-
-# System prompt for completion benchmarks
 SYSTEM_PROMPT = "You are a helpful assistant. Be helpful but brief."
 
 
 class TestScorecard:
-    @pytest.fixture
-    def driver(self) -> webdriver.Remote:
-        return webdriver.Remote(
-            command_executor="http://127.0.0.1:4723/wd/hub", options=options
-        )
-
-    def test_scorecard(self, driver: webdriver.Remote) -> None:
+    def test_scorecard(self) -> None:
         """Run comprehensive llama.cpp scorecard benchmarks."""
         model_url = "<<MODEL_URL>>"
         num_htps = "<<NUM_HTPS>>"
 
-        # On-device paths (matching llama.cpp scripts/snapdragon/adb conventions)
-        basedir = "/data/local/tmp/llama.cpp"
-        model_path = "/data/local/tmp/gguf/model.gguf"
-        log_file = "/data/local/tmp/QDC_logs/scorecard.log"
+        bundle_path = "/tmp/llama_cpp_bundle"
+        model_path = "/tmp/gguf/model.gguf"
+        log_file = "/tmp/QDC_logs/scorecard.log"
 
         scorecard_script = f"""
-cd /data/local/tmp/llama_cpp_bundle
+cd {bundle_path}
 
-export LD_LIBRARY_PATH=/data/local/tmp/llama_cpp_bundle/lib:$LD_LIBRARY_PATH
-export ADSP_LIBRARY_PATH="/data/local/tmp/llama_cpp_bundle/lib;/system/lib/rfsa/adsp;/system/vendor/lib/rfsa/adsp;/dsp"
-chmod +x /data/local/tmp/llama_cpp_bundle/bin/*
+export LD_LIBRARY_PATH={bundle_path}/lib:$LD_LIBRARY_PATH
+export ADSP_LIBRARY_PATH={bundle_path}/lib
+chmod +x {bundle_path}/bin/*
 
-BASEDIR=/data/local/tmp/llama_cpp_bundle
+BASEDIR={bundle_path}
 MODEL={model_path}
 LOG_FILE={log_file}
 NUM_HTPS={num_htps}
 HTP_FLAGS="--no-mmap --poll 1000 -t 6 --cpu-mask 0xfc --cpu-strict 1 -fa on -ngl 99"
 
-mkdir -p /data/local/tmp/gguf /data/local/tmp/QDC_logs
+mkdir -p /tmp/gguf /tmp/QDC_logs
 
 echo "Downloading model from {model_url}..."
 curl -L -J --output $MODEL "{model_url}"
@@ -206,24 +189,13 @@ echo "=== SCORECARD COMPLETE ===" >> $LOG_FILE
 echo "============================================================" >> $LOG_FILE
 """
 
-        # Push the bundle to the device
-        subprocess.run(
-            ["adb", "push", "/qdc/appium/llama_cpp_bundle/", "/data/local/tmp"],
-            capture_output=True,
-            encoding="utf-8",
-            errors="replace",
-            check=True,
-        )
+        src = "/qdc/appium/llama_cpp_bundle"
+        if os.path.isdir(src):
+            shutil.copytree(src, bundle_path, dirs_exist_ok=True)
+        subprocess.run(["chmod", "-R", "+x", f"{bundle_path}/bin"], check=False)
 
-        # Run the scorecard script
         result = subprocess.run(
-            [
-                "adb",
-                "shell",
-                "sh",
-                "-c",
-                scorecard_script,
-            ],
+            ["sh", "-c", scorecard_script],
             capture_output=True,
             encoding="utf-8",
             errors="replace",

utils.py

@@ -2,92 +2,53 @@
 # Copyright (c) 2025 Qualcomm Technologies, Inc. and/or its subsidiaries.
 # SPDX-License-Identifier: BSD-3-Clause
 # ---------------------------------------------------------------------
-"""Shared helpers for QDC on-device test runners."""
+"""Shared helpers for QDC on-device test runners (Linux IoT)."""
 
 import os
+import shutil
 import subprocess
-import tempfile
-
-from appium.options.common import AppiumOptions
 
 # ---------------------------------------------------------------------------
 # On-device paths
 # ---------------------------------------------------------------------------
 
-BUNDLE_PATH  = "/data/local/tmp/llama_cpp_bundle"
-QDC_LOGS_PATH = "/data/local/tmp/QDC_logs"
+BUNDLE_PATH  = "/tmp/llama_cpp_bundle"
+QDC_LOGS_PATH = "/tmp/QDC_logs"
 LIB_PATH    = f"{BUNDLE_PATH}/lib"
 BIN_PATH    = f"{BUNDLE_PATH}/bin"
 ENV_PREFIX  = (
-    f"export LD_LIBRARY_PATH={LIB_PATH} && "
+    f"export LD_LIBRARY_PATH={LIB_PATH}:$LD_LIBRARY_PATH && "
     f"export ADSP_LIBRARY_PATH={LIB_PATH} && "
     f"chmod +x {BIN_PATH}/* &&"
 )
 CMD_PREFIX  = f"cd {BUNDLE_PATH} && {ENV_PREFIX}"
 
 # ---------------------------------------------------------------------------
-# Appium session options
-# ---------------------------------------------------------------------------
-
-options = AppiumOptions()
-options.set_capability("automationName", "UiAutomator2")
-options.set_capability("platformName", "Android")
-options.set_capability("deviceName", os.getenv("ANDROID_DEVICE_VERSION"))
-
-# ---------------------------------------------------------------------------
-# ADB helpers
+# Shell helpers
 # ---------------------------------------------------------------------------
 
-def run_adb_command(cmd: str, *, check: bool = True) -> subprocess.CompletedProcess:
-    # Append exit-code sentinel because `adb shell` doesn't reliably propagate
-    # the on-device exit code (older ADB versions always return 0).
-    raw = subprocess.run(
-        ["adb", "shell", f"{cmd}; echo __RC__:$?"],
+def run_shell_command(cmd: str, *, check: bool = True) -> subprocess.CompletedProcess:
+    result = subprocess.run(
+        ["sh", "-c", cmd],
         text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
     )
-    stdout = raw.stdout
-    returncode = raw.returncode
-    if stdout:
-        lines = stdout.rstrip("\n").split("\n")
-        if lines and lines[-1].startswith("__RC__:"):
-            try:
-                returncode = int(lines[-1][7:])
-                stdout = "\n".join(lines[:-1]) + "\n"
-            except ValueError:
-                pass
-    print(stdout)
-    result = subprocess.CompletedProcess(raw.args, returncode, stdout=stdout)
+    print(result.stdout)
     if check:
-        assert returncode == 0, f"Command failed (exit {returncode})"
+        assert result.returncode == 0, f"Command failed (exit {result.returncode})"
     return result
 
 
 def write_qdc_log(filename: str, content: str) -> None:
-    """Push content as a log file to QDC_LOGS_PATH on the device for QDC log collection."""
-    subprocess.run(
-        ["adb", "shell", f"mkdir -p {QDC_LOGS_PATH}"],
-        stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-    )
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".log", delete=False) as f:
+    """Write content as a log file to QDC_LOGS_PATH for QDC log collection."""
+    os.makedirs(QDC_LOGS_PATH, exist_ok=True)
+    with open(f"{QDC_LOGS_PATH}/{filename}", "w") as f:
         f.write(content)
-        tmp_path = f.name
-    try:
-        subprocess.run(
-            ["adb", "push", tmp_path, f"{QDC_LOGS_PATH}/{filename}"],
-            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-        )
-    finally:
-        os.unlink(tmp_path)
 
 
 def push_bundle_if_needed(check_binary: str) -> None:
-    """Push llama_cpp_bundle to the device if check_binary is not already present."""
-    result = subprocess.run(
-        ["adb", "shell", f"ls {check_binary}"],
-        text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-    )
-    if result.returncode != 0:
-        subprocess.run(
-            ["adb", "push", "/qdc/appium/llama_cpp_bundle/", "/data/local/tmp"],
-            text=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
-        )
+    """Copy llama_cpp_bundle to /tmp if check_binary is not already present."""
+    if not os.path.exists(check_binary):
+        src = "/qdc/appium/llama_cpp_bundle"
+        if os.path.isdir(src):
+            shutil.copytree(src, BUNDLE_PATH, dirs_exist_ok=True)
+        subprocess.run(["chmod", "-R", "+x", BIN_PATH], check=False)