slento-mesh-optimizer 0.1.0__tar.gz

slento_mesh_optimizer-0.1.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: slento-mesh-optimizer
+Version: 0.1.0
+Summary: Distributed hardware optimization agent — JEPA-driven job routing, GPU/CPU/FPGA probing, and performance tuning across heterogeneous compute clusters.
+Author-email: Slento Systems <support@slentosystems.com>
+License: Proprietary
+Project-URL: Homepage, https://slentosystems.com
+Project-URL: Documentation, https://docs.slentosystems.com
+Project-URL: Repository, https://github.com/slentoai/mesh-optimizer
+Project-URL: Portal, https://portal.slentosystems.com
+Keywords: gpu,optimization,mesh,distributed,jepa,hardware,profiling
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: System :: Hardware
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: aiohttp>=3.9
+Requires-Dist: fastapi>=0.109
+Requires-Dist: httpx>=0.25
+Requires-Dist: numpy>=1.24
+Requires-Dist: psutil>=5.9
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: uvicorn[standard]>=0.25
+Provides-Extra: ml
+Requires-Dist: torch>=2.0; extra == "ml"
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+
+# Mesh Optimizer
+
+Distributed hardware optimization agent by [Slento Systems](https://slentosystems.com).
+
+JEPA-driven job routing, GPU/CPU/FPGA probing, and performance tuning across heterogeneous compute clusters.
+
+## Quick Start
+
+```bash
+pip install mesh-optimizer
+mesh-optimizer start
+```
+
+## One-Line Install (Linux)
+
+```bash
+curl -fsSL https://mesh.slentosystems.com/install.sh | bash
+```
+
+## Features
+
+- **Hardware Discovery** — Auto-detects GPUs (AMD, NVIDIA), CPUs, FPGAs, memory subsystems
+- **Performance Probing** — Runs targeted benchmarks to map hardware capabilities
+- **JEPA Optimization** — Joint Embedding Predictive Architecture learns your hardware's performance characteristics
+- **Job Routing** — Automatically routes compute jobs to the best-suited hardware
+- **NAT/WAN Support** — Works behind firewalls with outbound-only connections
+- **Multi-Platform** — Linux, macOS, Windows
+
+## Supported Hardware
+
+- AMD Radeon RX 7000 (RDNA3), Instinct MI200/MI300 (CDNA)
+- NVIDIA GeForce RTX 30/40/50, Quadro, Tesla, A100
+- Intel/AMD CPUs (10th gen+, Ryzen/EPYC)
+- Apple M1/M2/M3/M4
+- Xilinx Alveo/UltraScale+ FPGAs
+
+## Documentation
+
+Full docs at [docs.slentosystems.com](https://docs.slentosystems.com)
+
+## License
+
+Proprietary. Free community tier available at [portal.slentosystems.com](https://portal.slentosystems.com).

slento_mesh_optimizer-0.1.0/README.md

@@ -0,0 +1,43 @@
+# Mesh Optimizer
+
+Distributed hardware optimization agent by [Slento Systems](https://slentosystems.com).
+
+JEPA-driven job routing, GPU/CPU/FPGA probing, and performance tuning across heterogeneous compute clusters.
+
+## Quick Start
+
+```bash
+pip install mesh-optimizer
+mesh-optimizer start
+```
+
+## One-Line Install (Linux)
+
+```bash
+curl -fsSL https://mesh.slentosystems.com/install.sh | bash
+```
+
+## Features
+
+- **Hardware Discovery** — Auto-detects GPUs (AMD, NVIDIA), CPUs, FPGAs, memory subsystems
+- **Performance Probing** — Runs targeted benchmarks to map hardware capabilities
+- **JEPA Optimization** — Joint Embedding Predictive Architecture learns your hardware's performance characteristics
+- **Job Routing** — Automatically routes compute jobs to the best-suited hardware
+- **NAT/WAN Support** — Works behind firewalls with outbound-only connections
+- **Multi-Platform** — Linux, macOS, Windows
+
+## Supported Hardware
+
+- AMD Radeon RX 7000 (RDNA3), Instinct MI200/MI300 (CDNA)
+- NVIDIA GeForce RTX 30/40/50, Quadro, Tesla, A100
+- Intel/AMD CPUs (10th gen+, Ryzen/EPYC)
+- Apple M1/M2/M3/M4
+- Xilinx Alveo/UltraScale+ FPGAs
+
+## Documentation
+
+Full docs at [docs.slentosystems.com](https://docs.slentosystems.com)
+
+## License
+
+Proprietary. Free community tier available at [portal.slentosystems.com](https://portal.slentosystems.com).

slento_mesh_optimizer-0.1.0/mesh/__init__.py

@@ -0,0 +1,2 @@
+"""RDNA3 Discovery Mesh — Distributed profiling and job routing."""
+__version__ = "0.1.0"

slento_mesh_optimizer-0.1.0/mesh/_version.py

@@ -0,0 +1,29 @@
+"""Single source of truth for mesh-optimizer version."""
+from __future__ import annotations
+
+import sys
+from datetime import datetime, timezone
+
+
+__version__ = "0.1.0"
+
+
+def get_version_info() -> dict:
+    """Return version metadata including build date and git SHA."""
+    info = {
+        "version": __version__,
+        "build_date": datetime.now(timezone.utc).isoformat(),
+        "python_version": sys.version,
+        "git_sha": None,
+    }
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["git", "rev-parse", "--short", "HEAD"],
+            capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode == 0:
+            info["git_sha"] = result.stdout.strip()
+    except Exception:
+        pass
+    return info

slento_mesh_optimizer-0.1.0/mesh/agent/dataset_tracker.py

@@ -0,0 +1,54 @@
+"""Track which datasets are cached locally on this node."""
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class DatasetTracker:
+    def __init__(self, cache_dir: str = ""):
+        self.cache_dir = cache_dir
+        self._registry_path = Path(cache_dir or "/tmp") / "mesh_dataset_registry.json"
+        self._datasets: Dict[str, dict] = {}
+        self._load()
+
+    def _load(self):
+        if self._registry_path.exists():
+            try:
+                self._datasets = json.loads(self._registry_path.read_text())
+            except Exception as e:
+                logger.warning("Failed to load dataset registry: %s", e)
+                self._datasets = {}
+
+    def _save(self):
+        try:
+            self._registry_path.parent.mkdir(parents=True, exist_ok=True)
+            self._registry_path.write_text(json.dumps(self._datasets, indent=2))
+        except Exception as e:
+            logger.warning("Failed to save dataset registry: %s", e)
+
+    def register(self, dataset_id: str, path: str, size_mb: float = 0.0):
+        self._datasets[dataset_id] = {
+            "path": path,
+            "size_mb": size_mb,
+            "registered_at": datetime.now(timezone.utc).isoformat(),
+        }
+        self._save()
+        logger.info("Dataset registered: %s at %s (%.1f MB)", dataset_id, path, size_mb)
+
+    def unregister(self, dataset_id: str):
+        if dataset_id in self._datasets:
+            del self._datasets[dataset_id]
+            self._save()
+
+    def list_ids(self) -> List[str]:
+        return list(self._datasets.keys())
+
+    def get(self, dataset_id: str) -> Optional[dict]:
+        return self._datasets.get(dataset_id)
+
+    def list_all(self) -> Dict[str, dict]:
+        return dict(self._datasets)

slento_mesh_optimizer-0.1.0/mesh/agent/hardware_scanner.py

@@ -0,0 +1,372 @@
+"""Auto-discovery of hardware on a mesh node."""
+from __future__ import annotations
+
+import logging
+import multiprocessing
+import os
+import platform
+import re
+import shutil
+import subprocess
+from pathlib import Path
+
+import psutil
+
+from mesh.models import CPUInfo, FPGAInfo, GPUInfo, HardwareInventory, MountInfo
+
+logger = logging.getLogger(__name__)
+
+_SLENTO_REQUIRED_LIBS = [
+    "pytorch_compat/libcudart.so.12",
+    "pytorch_compat/libcublas.so.12",
+    "pytorch_compat/libcublasLt.so.12",
+    "pytorch_compat/libcudnn.so.9",
+    "pytorch_compat/libcuda.so.1",
+]
+_SLENTO_GPU_ARCH_MAP = {
+    "7900 XTX": "gfx1100",
+    "7900 XT": "gfx1100",
+    "MI100": "gfx908",
+    "MI250": "gfx90a",
+    "MI300": "gfx942",
+}
+
+
+def scan_hardware(hostname_override: str = "", config=None) -> HardwareInventory:
+    """Detect all hardware on this machine."""
+    inv = HardwareInventory(
+        hostname=hostname_override or platform.node(),
+        platform=platform.system(),
+        memory_total_mb=psutil.virtual_memory().total // (1024 * 1024),
+    )
+    inv.cpu = _detect_cpu()
+    inv.gpus = _detect_gpus()
+    inv.fpgas = _detect_fpgas()
+    inv.has_pytorch = _check_pytorch()
+    inv.has_rocm = shutil.which("rocm-smi") is not None
+    inv.has_cuda = shutil.which("nvidia-smi") is not None
+    inv.mounts = _detect_mounts()
+    inv.scratch_paths = _get_config_value(config, "scratch_paths", []) or []
+
+    slento = _detect_slento_cuda(config=config)
+    inv.has_slento_cuda = slento["has_slento_cuda"]
+    inv.slento_cuda_version = slento["slento_cuda_version"]
+    inv.slento_cuda_gpu_archs = slento["slento_cuda_gpu_archs"]
+    inv.slento_cuda_lib_path = slento["slento_cuda_lib_path"]
+    return inv
+
+
+def _get_config_value(config, key: str, default=None):
+    if config is None:
+        return default
+    if isinstance(config, dict):
+        if key in config:
+            return config[key]
+        node_cfg = config.get("node")
+        if isinstance(node_cfg, dict) and key in node_cfg:
+            return node_cfg[key]
+        return default
+    if hasattr(config, key):
+        return getattr(config, key)
+    node_cfg = getattr(config, "node", None)
+    if node_cfg is not None and hasattr(node_cfg, key):
+        return getattr(node_cfg, key)
+    return default
+
+
+def _detect_cpu() -> CPUInfo:
+    info = CPUInfo(cores=multiprocessing.cpu_count() or 1)
+    # Model name
+    if platform.system() == "Linux":
+        try:
+            with open("/proc/cpuinfo") as f:
+                for line in f:
+                    if "model name" in line:
+                        info.model = line.split(":")[1].strip()
+                        break
+        except Exception:
+            pass
+    elif platform.system() == "Darwin":
+        try:
+            info.model = subprocess.check_output(
+                ["sysctl", "-n", "machdep.cpu.brand_string"],
+                text=True, stderr=subprocess.DEVNULL
+            ).strip()
+        except Exception:
+            pass
+
+    # lscpu for Linux details
+    try:
+        out = subprocess.check_output("lscpu", text=True, stderr=subprocess.DEVNULL)
+        cores_per = 1
+        sockets = 1
+        for line in out.splitlines():
+            if "Core(s) per socket:" in line:
+                cores_per = int(line.split(":")[1].strip())
+            elif "Socket(s):" in line:
+                sockets = int(line.split(":")[1].strip())
+            elif "Thread(s) per core:" in line:
+                info.threads_per_core = int(line.split(":")[1].strip())
+            elif "NUMA node(s):" in line:
+                info.numa_nodes = int(line.split(":")[1].strip())
+            elif "CPU max MHz:" in line:
+                info.freq_mhz = float(line.split(":")[1].strip())
+            elif "CPU MHz:" in line and info.freq_mhz == 0:
+                info.freq_mhz = float(line.split(":")[1].strip())
+        info.physical_cores = cores_per * sockets
+    except Exception:
+        info.physical_cores = info.cores // 2
+
+    # Cache sizes from sysfs
+    try:
+        for idx in range(10):
+            cache_dir = f"/sys/devices/system/cpu/cpu0/cache/index{idx}"
+            if not os.path.exists(cache_dir):
+                break
+            level = open(f"{cache_dir}/level").read().strip()
+            ctype = open(f"{cache_dir}/type").read().strip()
+            size_str = open(f"{cache_dir}/size").read().strip()
+            size_kb = int(re.match(r"(\d+)", size_str).group(1))
+            if "M" in size_str:
+                size_kb *= 1024
+            if level == "1" and "Data" in ctype:
+                info.l1d_kb = size_kb
+            elif level == "2":
+                info.l2_kb = size_kb
+            elif level == "3":
+                info.l3_kb = size_kb
+    except Exception:
+        pass
+    return info
+
+
+def _detect_gpus() -> list[GPUInfo]:
+    gpus = []
+    # NVIDIA GPUs
+    gpus.extend(_detect_nvidia_gpus())
+    # AMD GPUs
+    gpus.extend(_detect_amd_gpus())
+    return gpus
+
+
+def _detect_mounts() -> list[MountInfo]:
+    mounts = []
+    try:
+        for partition in psutil.disk_partitions(all=False):
+            try:
+                usage = psutil.disk_usage(partition.mountpoint)
+            except Exception:
+                continue
+            mounts.append(MountInfo(
+                mountpoint=partition.mountpoint,
+                device=partition.device,
+                fstype=partition.fstype,
+                total_mb=int(usage.total // (1024 * 1024)),
+                free_mb=int(usage.free // (1024 * 1024)),
+            ))
+    except Exception as e:
+        logger.debug("Mount detection failed: %s", e)
+    return mounts
+
+
+def _detect_nvidia_gpus() -> list[GPUInfo]:
+    gpus = []
+    if not shutil.which("nvidia-smi"):
+        return gpus
+    try:
+        out = subprocess.check_output(
+            ["nvidia-smi", "--query-gpu=name,memory.total,driver_version,temperature.gpu,utilization.gpu,memory.used",
+             "--format=csv,noheader,nounits"],
+            text=True, stderr=subprocess.DEVNULL, timeout=10
+        )
+        for line in out.strip().splitlines():
+            parts = [p.strip() for p in line.split(",")]
+            if len(parts) >= 6:
+                gpus.append(GPUInfo(
+                    name=parts[0],
+                    vendor="nvidia",
+                    vram_mb=int(float(parts[1])),
+                    driver=parts[2],
+                    temperature_c=float(parts[3]) if parts[3] != "N/A" else 0.0,
+                    utilization_pct=float(parts[4]) if parts[4] != "N/A" else 0.0,
+                    memory_used_mb=int(float(parts[5])) if parts[5] != "N/A" else 0,
+                ))
+    except Exception as e:
+        logger.warning("nvidia-smi failed: %s", e)
+    return gpus
+
+
+def _detect_amd_gpus() -> list[GPUInfo]:
+    gpus = []
+    if not shutil.which("rocm-smi"):
+        return gpus
+    try:
+        out = subprocess.check_output(
+            ["rocm-smi", "--showproductname", "--showmeminfo", "vram",
+             "--showtemp", "--showuse", "--json"],
+            text=True, stderr=subprocess.DEVNULL, timeout=10
+        )
+        import json
+        data = json.loads(out)
+        for key, val in data.items():
+            if not key.startswith("card"):
+                continue
+            gpu = GPUInfo(vendor="amd")
+            gpu.name = val.get("Card Series", val.get("Card series", "AMD GPU"))
+            vram_total = val.get("VRAM Total Memory (B)", 0)
+            if vram_total:
+                gpu.vram_mb = int(vram_total) // (1024 * 1024)
+            vram_used = val.get("VRAM Total Used Memory (B)", 0)
+            if vram_used:
+                gpu.memory_used_mb = int(vram_used) // (1024 * 1024)
+            temp = val.get("Temperature (Sensor edge) (C)", 0)
+            if temp:
+                gpu.temperature_c = float(temp)
+            use = val.get("GPU use (%)", 0)
+            if use:
+                gpu.utilization_pct = float(use)
+            gpus.append(gpu)
+    except Exception as e:
+        logger.warning("rocm-smi failed: %s", e)
+    # Fallback: check /sys/class/drm
+    if not gpus:
+        try:
+            drm = Path("/sys/class/drm")
+            for card in sorted(drm.glob("card[0-9]*")):
+                device = card / "device"
+                vendor_file = device / "vendor"
+                if vendor_file.exists():
+                    vendor_id = vendor_file.read_text().strip()
+                    if vendor_id == "0x1002":  # AMD
+                        name = "AMD GPU"
+                        product = device / "product_name"
+                        if product.exists():
+                            name = product.read_text().strip()
+                        vram = 0
+                        mem_file = device / "mem_info_vram_total"
+                        if mem_file.exists():
+                            vram = int(mem_file.read_text().strip()) // (1024 * 1024)
+                        gpus.append(GPUInfo(name=name, vendor="amd", vram_mb=vram))
+        except Exception:
+            pass
+    return gpus
+
+
+def _detect_fpgas() -> list[FPGAInfo]:
+    fpgas = []
+    try:
+        out = subprocess.check_output(
+            ["lspci", "-nn"], text=True, stderr=subprocess.DEVNULL, timeout=5
+        )
+        for line in out.splitlines():
+            lower = line.lower()
+            if "xilinx" in lower or "altera" in lower or "intel.*fpga" in lower:
+                bdf = line.split()[0]
+                vendor = "xilinx" if "xilinx" in lower else "altera/intel"
+                name = line.split(": ", 1)[1] if ": " in line else "FPGA"
+                # Check driver
+                driver = ""
+                driver_link = Path(f"/sys/bus/pci/devices/0000:{bdf}/driver")
+                if driver_link.is_symlink():
+                    driver = driver_link.resolve().name
+                fpgas.append(FPGAInfo(
+                    name=name, vendor=vendor, pcie_bdf=bdf, driver=driver
+                ))
+    except Exception:
+        pass
+    return fpgas
+
+
+def _check_pytorch() -> bool:
+    try:
+        import torch
+        return True
+    except ImportError:
+        return False
+
+
+def _detect_slento_cuda(config=None) -> dict[str, object]:
+    result = {
+        "has_slento_cuda": False,
+        "slento_cuda_version": "",
+        "slento_cuda_gpu_archs": [],
+        "slento_cuda_lib_path": "",
+    }
+
+    if platform.system() != "Linux":
+        return result
+    if not shutil.which("rocm-smi"):
+        return result
+
+    amd_gpus = _detect_amd_gpus()
+    if not amd_gpus:
+        return result
+
+    script_path = _find_slento_script(config=config)
+    if not script_path:
+        return result
+
+    base_dir = script_path.parent
+    missing = [rel for rel in _SLENTO_REQUIRED_LIBS if not (base_dir / rel).exists()]
+    if missing:
+        logger.debug("Slento CUDA candidate missing libs under %s: %s", base_dir, missing)
+        return result
+
+    result["has_slento_cuda"] = True
+    result["slento_cuda_version"] = _detect_slento_version(base_dir)
+    result["slento_cuda_gpu_archs"] = _detect_slento_gpu_archs()
+    result["slento_cuda_lib_path"] = str(base_dir / "pytorch_compat")
+    return result
+
+
+def _find_slento_script(config=None) -> Path | None:
+    configured = _get_config_value(config, "slento_cuda_path", "")
+    candidates: list[Path] = []
+    if configured:
+        cfg_path = Path(configured).expanduser()
+        if cfg_path.name == "cuda_emulator_run.sh":
+            candidates.append(cfg_path)
+        else:
+            candidates.append(cfg_path / "cuda_emulator_run.sh")
+    candidates.extend([
+        Path("~/CascadeProjects/rocm-cuda-compat/build/cuda_emulator_run.sh").expanduser(),
+        Path("/opt/slento-cuda/cuda_emulator_run.sh"),
+    ])
+    which_path = shutil.which("cuda_emulator_run.sh")
+    if which_path:
+        candidates.append(Path(which_path))
+
+    for candidate in candidates:
+        if candidate.exists() and candidate.is_file():
+            return candidate.resolve()
+    return None
+
+
+def _detect_slento_version(base_dir: Path) -> str:
+    for version_file in ("VERSION", "version.txt"):
+        path = base_dir / version_file
+        if path.exists():
+            try:
+                return path.read_text().strip()
+            except Exception:
+                pass
+    if re.search(r"slento", str(base_dir), re.IGNORECASE):
+        return base_dir.name
+    return "detected"
+
+
+def _detect_slento_gpu_archs() -> list[str]:
+    archs: list[str] = []
+    try:
+        out = subprocess.check_output(
+            ["rocm-smi", "--showproductname"],
+            text=True,
+            stderr=subprocess.DEVNULL,
+            timeout=10,
+        )
+        for product_name, arch in _SLENTO_GPU_ARCH_MAP.items():
+            if product_name in out and arch not in archs:
+                archs.append(arch)
+    except Exception as e:
+        logger.debug("rocm-smi product lookup failed for Slento CUDA detection: %s", e)
+    return archs