@mytec: iter2.4 ready for testing

backend/app/services/coverage_service.py

@@ -55,6 +55,7 @@ from app.services.indoor_service import indoor_service
 from app.services.atmospheric_service import atmospheric_service
 from app.services.parallel_coverage_service import (
     calculate_coverage_parallel, get_cpu_count, get_parallel_backend,
+    CancellationToken,
 )
 
 
@@ -280,7 +281,8 @@ class CoverageService:
     async def calculate_coverage(
         self,
         site: SiteParams,
-        settings: CoverageSettings
+        settings: CoverageSettings,
+        cancel_token: Optional[CancellationToken] = None,
     ) -> List[CoveragePoint]:
         """
         Calculate coverage grid for a single site
@@ -352,6 +354,32 @@ class CoverageService:
               f"pre-computed {len(grid)} elevations")
         _clog(f"━━━ PHASE 2 done: {terrain_time:.1f}s ━━━")
 
+        # ━━━ PHASE 2.5: Vectorized pre-computation (GPU/NumPy) ━━━
+        from app.services.gpu_service import gpu_service
+
+        t_gpu = time.time()
+        grid_lats = np.array([lat for lat, lon in grid])
+        grid_lons = np.array([lon for lat, lon in grid])
+
+        pre_distances = gpu_service.precompute_distances(
+            grid_lats, grid_lons, site.lat, site.lon
+        )
+        pre_path_loss = gpu_service.precompute_path_loss(
+            pre_distances, site.frequency, site.height
+        )
+
+        # Build lookup dict for point loop
+        precomputed = {}
+        for i, (lat, lon) in enumerate(grid):
+            precomputed[(lat, lon)] = {
+                'distance': float(pre_distances[i]),
+                'path_loss': float(pre_path_loss[i]),
+            }
+
+        gpu_time = time.time() - t_gpu
+        _clog(f"━━━ PHASE 2.5: Vectorized pre-computation done: {gpu_time:.3f}s "
+              f"({len(grid)} points, backend={'GPU' if gpu_service.available else 'CPU/NumPy'}) ━━━")
+
         # ━━━ PHASE 3: Point calculation ━━━
         dominant_path_service._log_count = 0  # Reset diagnostic counter
         t_points = time.time()
@@ -368,12 +396,15 @@ class CoverageService:
                 loop = asyncio.get_event_loop()
                 result_dicts, timing = await loop.run_in_executor(
                     None,
-                    calculate_coverage_parallel,
-                    grid, point_elevations,
-                    site.model_dump(), settings.model_dump(),
-                    self.terrain._tile_cache,
-                    buildings, streets, water_bodies, vegetation_areas,
-                    site_elevation, num_workers, _clog,
+                    lambda: calculate_coverage_parallel(
+                        grid, point_elevations,
+                        site.model_dump(), settings.model_dump(),
+                        self.terrain._tile_cache,
+                        buildings, streets, water_bodies, vegetation_areas,
+                        site_elevation, num_workers, _clog,
+                        cancel_token=cancel_token,
+                        precomputed=precomputed,
+                    ),
                 )
 
                 # Convert dicts back to CoveragePoint objects
@@ -389,10 +420,13 @@ class CoverageService:
             loop = asyncio.get_event_loop()
             points, timing = await loop.run_in_executor(
                 None,
-                self._run_point_loop,
-                grid, site, settings, buildings, streets,
-                spatial_idx, water_bodies, vegetation_areas,
-                site_elevation, point_elevations
+                lambda: self._run_point_loop(
+                    grid, site, settings, buildings, streets,
+                    spatial_idx, water_bodies, vegetation_areas,
+                    site_elevation, point_elevations,
+                    cancel_token=cancel_token,
+                    precomputed=precomputed,
+                ),
             )
 
         points_time = time.time() - t_points
@@ -423,7 +457,8 @@ class CoverageService:
     async def calculate_multi_site_coverage(
         self,
         sites: List[SiteParams],
-        settings: CoverageSettings
+        settings: CoverageSettings,
+        cancel_token: Optional[CancellationToken] = None,
     ) -> List[CoveragePoint]:
         """
         Calculate combined coverage from multiple sites
@@ -437,7 +472,7 @@ class CoverageService:
 
         # Get all individual coverages
         all_coverages = await asyncio.gather(*[
-            self.calculate_coverage(site, settings)
+            self.calculate_coverage(site, settings, cancel_token)
             for site in sites
         ])
 
@@ -485,7 +520,8 @@ class CoverageService:
     def _run_point_loop(
         self, grid, site, settings, buildings, streets,
         spatial_idx, water_bodies, vegetation_areas,
-        site_elevation, point_elevations
+        site_elevation, point_elevations,
+        cancel_token=None, precomputed=None,
     ):
         """Sync point loop - runs in ThreadPoolExecutor, bypasses event loop."""
         points = []
@@ -496,14 +532,22 @@ class CoverageService:
         log_interval = max(1, total // 20)
 
         for i, (lat, lon) in enumerate(grid):
+            if cancel_token and cancel_token.is_cancelled:
+                _clog(f"Cancelled at {i}/{total}")
+                break
+
             if i % log_interval == 0:
                 _clog(f"Progress: {i}/{total} ({i*100//total}%)")
 
+            pre = precomputed.get((lat, lon)) if precomputed else None
+
             point = self._calculate_point_sync(
                 site, lat, lon, settings, buildings, streets,
                 spatial_idx, water_bodies, vegetation_areas,
                 site_elevation, point_elevations.get((lat, lon), 0.0),
-                timing
+                timing,
+                precomputed_distance=pre.get('distance') if pre else None,
+                precomputed_path_loss=pre.get('path_loss') if pre else None,
             )
             if point.rsrp >= settings.min_signal:
                 points.append(point)
@@ -523,17 +567,25 @@ class CoverageService:
         vegetation_areas: List[VegetationArea],
         site_elevation: float,
         point_elevation: float,
-        timing: dict
+        timing: dict,
+        precomputed_distance: Optional[float] = None,
+        precomputed_path_loss: Optional[float] = None,
     ) -> CoveragePoint:
         """Fully synchronous point calculation. All terrain tiles must be pre-loaded."""
 
-        # Distance
-        distance = TerrainService.haversine_distance(site.lat, site.lon, lat, lon)
+        # Distance (use precomputed if available)
+        if precomputed_distance is not None:
+            distance = precomputed_distance
+        else:
+            distance = TerrainService.haversine_distance(site.lat, site.lon, lat, lon)
         if distance < 1:
             distance = 1
 
-        # Base path loss
-        path_loss = self._okumura_hata(distance, site.frequency, site.height, 1.5)
+        # Base path loss (use precomputed if available)
+        if precomputed_path_loss is not None:
+            path_loss = precomputed_path_loss
+        else:
+            path_loss = self._okumura_hata(distance, site.frequency, site.height, 1.5)
 
         # Antenna pattern
         antenna_loss = 0.0

backend/app/services/gpu_service.py

@@ -0,0 +1,119 @@
+"""
+GPU-accelerated computation service using CuPy.
+Falls back to NumPy when CuPy/CUDA is not available.
+
+Provides vectorized batch operations for coverage calculation:
+  - Haversine distance (site → all grid points)
+  - Okumura-Hata path loss (all distances at once)
+
+Usage:
+    from app.services.gpu_service import gpu_service, GPU_AVAILABLE
+"""
+
+import numpy as np
+from typing import Dict, Any, Optional
+
+# ── Try CuPy import ──
+
+GPU_AVAILABLE = False
+GPU_INFO: Optional[Dict[str, Any]] = None
+cp = None
+
+try:
+    import cupy as _cp
+    if _cp.cuda.runtime.getDeviceCount() > 0:
+        cp = _cp
+        GPU_AVAILABLE = True
+        props = _cp.cuda.runtime.getDeviceProperties(0)
+        GPU_INFO = {
+            "name": props["name"].decode() if isinstance(props["name"], bytes) else str(props["name"]),
+            "memory_mb": props["totalGlobalMem"] // (1024 * 1024),
+            "cuda_version": _cp.cuda.runtime.runtimeGetVersion(),
+        }
+        print(f"[GPU] CUDA available: {GPU_INFO['name']} ({GPU_INFO['memory_mb']} MB)", flush=True)
+except ImportError:
+    print("[GPU] CuPy not installed — using CPU/NumPy", flush=True)
+except Exception as e:
+    print(f"[GPU] CUDA check failed: {e} — using CPU/NumPy", flush=True)
+
+
+# Array module: cupy on GPU, numpy on CPU
+xp = cp if GPU_AVAILABLE else np
+
+
+def _to_cpu(arr):
+    """Transfer array to CPU numpy if on GPU."""
+    if GPU_AVAILABLE and hasattr(arr, 'get'):
+        return arr.get()
+    return np.asarray(arr)
+
+
+class GPUService:
+    """GPU-accelerated batch operations for coverage calculation."""
+
+    @property
+    def available(self) -> bool:
+        return GPU_AVAILABLE
+
+    def get_info(self) -> Dict[str, Any]:
+        """Return GPU info dict for system endpoint."""
+        if not GPU_AVAILABLE:
+            return {"available": False, "name": None, "memory_mb": None}
+        return {"available": True, **GPU_INFO}
+
+    def precompute_distances(
+        self,
+        grid_lats: np.ndarray,
+        grid_lons: np.ndarray,
+        site_lat: float,
+        site_lon: float,
+    ) -> np.ndarray:
+        """Vectorized haversine distance from site to all grid points.
+
+        Returns distances in meters as a CPU numpy array.
+        """
+        lat1 = xp.radians(xp.asarray(grid_lats, dtype=xp.float64))
+        lon1 = xp.radians(xp.asarray(grid_lons, dtype=xp.float64))
+        lat2 = xp.radians(xp.float64(site_lat))
+        lon2 = xp.radians(xp.float64(site_lon))
+
+        dlat = lat2 - lat1
+        dlon = lon2 - lon1
+
+        a = xp.sin(dlat / 2) ** 2 + xp.cos(lat1) * xp.cos(lat2) * xp.sin(dlon / 2) ** 2
+        c = 2 * xp.arcsin(xp.sqrt(a))
+
+        distances = 6371000.0 * c
+        return _to_cpu(distances)
+
+    def precompute_path_loss(
+        self,
+        distances: np.ndarray,
+        frequency_mhz: float,
+        tx_height: float,
+        rx_height: float = 1.5,
+    ) -> np.ndarray:
+        """Vectorized Okumura-Hata path loss for all distances.
+
+        Returns path loss in dB as a CPU numpy array.
+        """
+        d_arr = xp.asarray(distances, dtype=xp.float64)
+        d_km = xp.maximum(d_arr / 1000.0, 0.1)
+
+        freq = float(frequency_mhz)
+        h_tx = float(tx_height)
+        h_rx = float(rx_height)
+
+        log_f = xp.log10(xp.float64(freq))
+        log_hb = xp.log10(xp.float64(h_tx))
+
+        a_hm = (1.1 * log_f - 0.7) * h_rx - (1.56 * log_f - 0.8)
+
+        L = (69.55 + 26.16 * log_f - 13.82 * log_hb - a_hm
+             + (44.9 - 6.55 * log_hb) * xp.log10(d_km))
+
+        return _to_cpu(L)
+
+
+# Singleton
+gpu_service = GPUService()

backend/app/services/parallel_coverage_service.py

@@ -24,11 +24,28 @@ Usage:
 import os
 import sys
 import time
+import threading
 import multiprocessing as mp
 from typing import List, Dict, Tuple, Any, Optional, Callable
 import numpy as np
 
 
+# ── Cancellation token ──
+
+class CancellationToken:
+    """Thread-safe cancellation token for cooperative cancellation."""
+
+    def __init__(self):
+        self._event = threading.Event()
+
+    def cancel(self):
+        self._event.set()
+
+    @property
+    def is_cancelled(self) -> bool:
+        return self._event.is_set()
+
+
 # ── Try to import Ray ──
 
 RAY_AVAILABLE = False
@@ -80,14 +97,19 @@ def _ray_process_chunk_impl(chunk, terrain_cache, buildings, osm_data, config):
         "reflection": 0.0, "vegetation": 0.0,
     }
 
+    precomputed = config.get('precomputed')
+
     results = []
     for lat, lon, point_elev in chunk:
+        pre = precomputed.get((lat, lon)) if precomputed else None
         point = svc._calculate_point_sync(
             site, lat, lon, settings,
             buildings, osm_data.get('streets', []),
             _worker_spatial_idx, osm_data.get('water_bodies', []),
             osm_data.get('vegetation_areas', []),
             config['site_elevation'], point_elev, timing,
+            precomputed_distance=pre.get('distance') if pre else None,
+            precomputed_path_loss=pre.get('path_loss') if pre else None,
         )
         if point.rsrp >= settings.min_signal:
             results.append(point.model_dump())
@@ -162,13 +184,16 @@ def calculate_coverage_parallel(
     site_elevation: float,
     num_workers: Optional[int] = None,
     log_fn: Optional[Callable[[str], None]] = None,
+    cancel_token: Optional[CancellationToken] = None,
+    precomputed: Optional[Dict] = None,
 ) -> Tuple[List[Dict], Dict[str, float]]:
     """Calculate coverage points in parallel.
 
     Uses Ray if available (shared memory, zero-copy numpy), otherwise
-    falls back to sequential single-threaded calculation.
+    falls back to ProcessPoolExecutor or sequential single-threaded calculation.
 
-    Same signature as before — drop-in replacement.
+    cancel_token: cooperative cancellation — checked between chunks.
+    precomputed: dict mapping (lat, lon) -> {distance, path_loss} from GPU pre-computation.
     """
     if log_fn is None:
         log_fn = lambda msg: print(f"[PARALLEL] {msg}", flush=True)
@@ -185,7 +210,7 @@ def calculate_coverage_parallel(
                 grid, point_elevations, site_dict, settings_dict,
                 terrain_cache, buildings, streets, water_bodies,
                 vegetation_areas, site_elevation,
-                num_workers, log_fn,
+                num_workers, log_fn, cancel_token, precomputed,
             )
         except Exception as e:
             log_fn(f"Ray execution failed: {e} — falling back to sequential")
@@ -198,7 +223,7 @@ def calculate_coverage_parallel(
                 grid, point_elevations, site_dict, settings_dict,
                 terrain_cache, buildings, streets, water_bodies,
                 vegetation_areas, site_elevation,
-                pool_workers, log_fn,
+                pool_workers, log_fn, cancel_token, precomputed,
             )
         except Exception as e:
             log_fn(f"ProcessPool failed: {e} — falling back to sequential")
@@ -208,7 +233,7 @@ def calculate_coverage_parallel(
     return _calculate_sequential(
         grid, point_elevations, site_dict, settings_dict,
         buildings, streets, water_bodies, vegetation_areas,
-        site_elevation, log_fn,
+        site_elevation, log_fn, cancel_token, precomputed,
     )
 
 
@@ -219,15 +244,13 @@ def _calculate_with_ray(
     grid, point_elevations, site_dict, settings_dict,
     terrain_cache, buildings, streets, water_bodies,
     vegetation_areas, site_elevation,
-    num_workers, log_fn,
+    num_workers, log_fn, cancel_token=None, precomputed=None,
 ):
     """Execute using Ray shared-memory object store."""
     total_points = len(grid)
     log_fn(f"Ray mode: {total_points} points, {num_workers} workers")
 
     # ── Put large data into Ray object store ──
-    # Numpy arrays (terrain tiles) get zero-copy shared memory.
-    # Python objects (buildings) get serialized once, stored in plasma.
     t_put = time.time()
 
     terrain_ref = ray.put(terrain_cache)
@@ -239,12 +262,15 @@ def _calculate_with_ray(
     })
 
     cache_key = f"{site_dict['lat']:.4f},{site_dict['lon']:.4f},{len(buildings)}"
-    config_ref = ray.put({
+    config = {
         'site_dict': site_dict,
         'settings_dict': settings_dict,
         'site_elevation': site_elevation,
         'cache_key': cache_key,
-    })
+    }
+    if precomputed:
+        config['precomputed'] = precomputed
+    config_ref = ray.put(config)
 
     put_time = time.time() - t_put
     log_fn(f"ray.put() done in {put_time:.1f}s")
@@ -273,9 +299,19 @@ def _calculate_with_ray(
     completed_chunks = 0
 
     while remaining:
+        # Check cancellation before waiting
+        if cancel_token and cancel_token.is_cancelled:
+            log_fn(f"Cancelled — aborting {len(remaining)} remaining Ray chunks")
+            for ref in remaining:
+                try:
+                    ray.cancel(ref, force=True)
+                except Exception:
+                    pass
+            break
+
         # Wait for at least 1 result, batch up to ~10% for progress logging
         batch = max(1, min(len(remaining), total_chunks // 10 or 1))
-        done, remaining = ray.wait(remaining, num_returns=batch, timeout=600)
+        done, remaining = ray.wait(remaining, num_returns=batch, timeout=30)
 
         for ref in done:
             try:
@@ -333,14 +369,19 @@ def _pool_worker_process_chunk(args):
         "reflection": 0.0, "vegetation": 0.0,
     }
 
+    precomputed = config.get('precomputed')
+
     results = []
     for lat, lon, point_elev in chunk:
+        pre = precomputed.get((lat, lon)) if precomputed else None
         point = svc._calculate_point_sync(
             site, lat, lon, settings,
             buildings, osm_data.get('streets', []),
             spatial_idx, osm_data.get('water_bodies', []),
             osm_data.get('vegetation_areas', []),
             config['site_elevation'], point_elev, timing,
+            precomputed_distance=pre.get('distance') if pre else None,
+            precomputed_path_loss=pre.get('path_loss') if pre else None,
         )
         if point.rsrp >= settings.min_signal:
             results.append(point.model_dump())
@@ -352,7 +393,7 @@ def _calculate_with_process_pool(
     grid, point_elevations, site_dict, settings_dict,
     terrain_cache, buildings, streets, water_bodies,
     vegetation_areas, site_elevation,
-    num_workers, log_fn,
+    num_workers, log_fn, cancel_token=None, precomputed=None,
 ):
     """Execute using ProcessPoolExecutor with reduced workers to limit memory."""
     from concurrent.futures import ProcessPoolExecutor, as_completed
@@ -375,6 +416,8 @@ def _calculate_with_process_pool(
         'settings_dict': settings_dict,
         'site_elevation': site_elevation,
     }
+    if precomputed:
+        config['precomputed'] = precomputed
     osm_data = {
         'streets': streets,
         'water_bodies': water_bodies,
@@ -395,6 +438,13 @@ def _calculate_with_process_pool(
 
         completed_chunks = 0
         for future in as_completed(futures):
+            # Check cancellation between chunks
+            if cancel_token and cancel_token.is_cancelled:
+                log_fn(f"Cancelled — cancelling {len(futures) - completed_chunks - 1} pending futures")
+                for f in futures:
+                    f.cancel()
+                break
+
             try:
                 chunk_results = future.result()
                 all_results.extend(chunk_results)
@@ -428,7 +478,7 @@ def _calculate_with_process_pool(
 def _calculate_sequential(
     grid, point_elevations, site_dict, settings_dict,
     buildings, streets, water_bodies, vegetation_areas,
-    site_elevation, log_fn,
+    site_elevation, log_fn, cancel_token=None, precomputed=None,
 ):
     """Sequential fallback — no extra dependencies, runs in calling thread."""
     from app.services.coverage_service import CoverageService, SiteParams, CoverageSettings
@@ -453,15 +503,26 @@ def _calculate_sequential(
     t0 = time.time()
     results = []
     for i, (lat, lon) in enumerate(grid):
+        # Check cancellation
+        if cancel_token and cancel_token.is_cancelled:
+            log_fn(f"Sequential cancelled at {i}/{total}")
+            break
+
         if i % log_interval == 0:
             log_fn(f"Sequential: {i}/{total} ({i * 100 // total}%)")
 
         point_elev = point_elevations.get((lat, lon), 0.0)
+
+        # Use precomputed values if available
+        pre = precomputed.get((lat, lon)) if precomputed else None
+
         point = svc._calculate_point_sync(
             site, lat, lon, settings,
             buildings, streets, spatial_idx,
             water_bodies, vegetation_areas,
             site_elevation, point_elev, timing,
+            precomputed_distance=pre.get('distance') if pre else None,
+            precomputed_path_loss=pre.get('path_loss') if pre else None,
         )
         if point.rsrp >= settings.min_signal:
             results.append(point.model_dump())