| |
| from __future__ import annotations |
|
|
| import argparse |
| import csv |
| import json |
| import os |
| import re |
| import subprocess |
| from collections import Counter |
| from pathlib import Path |
|
|
| from utils.dataset_pool import count_complete |
|
|
| VIDEO_EXTS = {'.mp4', '.mkv', '.webm', '.mov'} |
| ARRAY_RANGE_RE = re.compile(r'^(\d+)_\[(.+)\]$') |
| PROCESSED_REQUIRED_COLUMNS = { |
| 'video_id', |
| 'download_status', |
| 'process_status', |
| 'upload_status', |
| 'archive_name', |
| } |
| GPU_PARTITIONS = ['gpu', 'gpu-redhat', 'cgpu'] |
| DEFAULT_VIDEOS_PER_DWPOSE_JOB = 20 |
|
|
|
|
| def run_command(cmd: list[str]) -> str: |
| try: |
| proc = subprocess.run(cmd, check=False, capture_output=True, text=True) |
| except OSError: |
| return '' |
| return (proc.stdout or '').strip() |
|
|
|
|
| def count_claims(directory: Path) -> int: |
| if not directory.exists(): |
| return 0 |
| return sum(1 for _ in directory.glob('*.claim')) |
|
|
|
|
| def aggregate_claims_by_job_key(directory: Path) -> dict[str, int]: |
| counts: Counter[str] = Counter() |
| if not directory.exists(): |
| return {} |
| for path in directory.glob('*.claim'): |
| try: |
| lines = path.read_text(encoding='utf-8').splitlines() |
| except OSError: |
| continue |
| job_key = '' |
| for line in lines: |
| if line.startswith('job_key='): |
| job_key = line.split('=', 1)[1].strip() |
| break |
| if job_key: |
| counts[job_key] += 1 |
| return dict(counts) |
|
|
|
|
| def read_videos_per_dwpose_job(root_dir: Path) -> int: |
| worker = root_dir / 'slurm' / 'process_dwpose_array.slurm' |
| if not worker.exists(): |
| return DEFAULT_VIDEOS_PER_DWPOSE_JOB |
| try: |
| for line in worker.read_text().splitlines(): |
| if line.startswith('VIDEOS_PER_JOB='): |
| m = re.search(r'\$\{VIDEOS_PER_JOB:-([0-9]+)\}', line) |
| if m: |
| return int(m.group(1)) |
| except Exception: |
| pass |
| return DEFAULT_VIDEOS_PER_DWPOSE_JOB |
|
|
|
|
| def sum_file_sizes(paths: list[Path]) -> int: |
| total = 0 |
| for path in paths: |
| try: |
| total += path.stat().st_size |
| except FileNotFoundError: |
| continue |
| return total |
|
|
|
|
| def count_uploaded(progress_path: Path) -> tuple[int, int]: |
| if not progress_path.exists(): |
| return 0, 0 |
| try: |
| data = json.loads(progress_path.read_text()) |
| except Exception: |
| return 0, 0 |
| archives = data.get('archives', {}) |
| uploaded_folders = data.get('uploaded_folders', {}) |
| return len(archives), len(uploaded_folders) |
|
|
|
|
| def expand_task_count(jobid_token: str) -> int: |
| m = ARRAY_RANGE_RE.match(jobid_token) |
| if not m: |
| return 1 |
| body = m.group(2) |
| if '%' in body: |
| body = body.split('%', 1)[0] |
| total = 0 |
| for part in body.split(','): |
| part = part.strip() |
| if not part: |
| continue |
| if '-' in part: |
| a, b = part.split('-', 1) |
| try: |
| total += int(b) - int(a) + 1 |
| except ValueError: |
| total += 1 |
| else: |
| total += 1 |
| return max(total, 1) |
|
|
|
|
| def queue_status(username: str) -> dict[str, object]: |
| output = run_command(['squeue', '-u', username, '-h', '-o', '%i|%j|%T|%P']) |
| job_counts: Counter[str] = Counter() |
| partition_counts: Counter[str] = Counter() |
| active_tasks_by_partition: Counter[str] = Counter() |
| running_dwpose = 0 |
| running_download = 0 |
| pending_download = 0 |
| pending_dwpose = 0 |
| if output: |
| for line in output.splitlines(): |
| parts = line.split('|') |
| if len(parts) != 4: |
| continue |
| jobid_token, job, state, partition = parts |
| count = expand_task_count(jobid_token) |
| job_counts[f'{job}|{state}'] += count |
| partition_counts[f'{job}|{partition}|{state}'] += count |
| if state in {'RUNNING', 'PENDING', 'CONFIGURING'}: |
| active_tasks_by_partition[partition] += count |
| if job == 'dwpose' and state == 'RUNNING': |
| running_dwpose += count |
| if job == 'download' and state == 'RUNNING': |
| running_download += count |
| if job == 'download' and state in {'PENDING', 'CONFIGURING'}: |
| pending_download += count |
| if job == 'dwpose' and state in {'PENDING', 'CONFIGURING'}: |
| pending_dwpose += count |
| total_download = running_download + pending_download |
| return { |
| 'running_dwpose': running_dwpose, |
| 'running_download': running_download, |
| 'pending_dwpose_jobs': pending_dwpose, |
| 'pending_download_jobs': pending_download, |
| 'total_download_jobs': total_download, |
| 'job_state_counts': dict(job_counts), |
| 'job_partition_state_counts': dict(partition_counts), |
| 'active_tasks_by_partition': dict(active_tasks_by_partition), |
| } |
|
|
|
|
| def gpu_partition_capacity(partitions: list[str], active_tasks_by_partition: dict[str, int]) -> list[dict[str, object]]: |
| qos_limit_by_part: dict[str, int] = {} |
| qos_output = run_command(['sacctmgr', 'show', 'qos', 'format=Name,MaxSubmitPU', '-P']) |
| if qos_output: |
| for line in qos_output.splitlines(): |
| if not line.strip() or '|' not in line: |
| continue |
| name, max_submit = line.split('|', 1) |
| name = name.strip() |
| max_submit = max_submit.strip() |
| if name in partitions and max_submit: |
| try: |
| qos_limit_by_part[name] = int(max_submit) |
| except ValueError: |
| pass |
|
|
| rows: list[dict[str, object]] = [] |
| for partition in partitions: |
| free_gpus = 0 |
| nodes_output = run_command(['sinfo', '-h', '-N', '-p', partition, '-o', '%N']) |
| nodes = [line.strip() for line in nodes_output.splitlines() if line.strip()] |
| for node in nodes: |
| node_line = run_command(['scontrol', 'show', 'node', node, '-o']) |
| if not node_line: |
| continue |
| state_m = re.search(r'\bState=([^ ]+)', node_line) |
| state = state_m.group(1).lower() if state_m else '' |
| if any(flag in state for flag in ('drain', 'drained', 'down', 'fail', 'inval')): |
| continue |
| cfg_m = re.search(r'\bCfgTRES=.*?(?:,|^)gres/gpu=(\d+)', node_line) |
| alloc_m = re.search(r'\bAllocTRES=.*?(?:,|^)gres/gpu=(\d+)', node_line) |
| total = int(cfg_m.group(1)) if cfg_m else 0 |
| used = int(alloc_m.group(1)) if alloc_m else 0 |
| free = total - used |
| if free > 0: |
| free_gpus += free |
| active_tasks = int(active_tasks_by_partition.get(partition, 0)) |
| qos_limit = qos_limit_by_part.get(partition) |
| submit_slots = free_gpus |
| if qos_limit is not None: |
| submit_slots = min(submit_slots, max(0, qos_limit - active_tasks)) |
| rows.append({ |
| 'partition': partition, |
| 'free_gpus': free_gpus, |
| 'active_tasks': active_tasks, |
| 'qos_limit': qos_limit, |
| 'submit_slots': submit_slots, |
| }) |
| return rows |
|
|
|
|
| def filesystem_avail_bytes(path: Path) -> int: |
| try: |
| proc = subprocess.run(['df', '-B1', str(path)], check=False, capture_output=True, text=True) |
| lines = (proc.stdout or '').splitlines() |
| if len(lines) < 2: |
| return 0 |
| fields = lines[1].split() |
| if len(fields) < 4: |
| return 0 |
| return int(fields[3]) |
| except Exception: |
| return 0 |
|
|
|
|
| def human_bytes(num: int) -> str: |
| value = float(num) |
| for unit in ['B', 'KB', 'MB', 'GB', 'TB', 'PB']: |
| if value < 1024.0: |
| return f'{value:.1f}{unit}' |
| value /= 1024.0 |
| return f'{value:.1f}EB' |
|
|
|
|
| def read_source_manifest_count(path: Path) -> int: |
| if not path.exists(): |
| return 0 |
| count = 0 |
| with path.open('r', encoding='utf-8-sig', newline='') as f: |
| reader = csv.reader(f) |
| for row in reader: |
| if not row: |
| continue |
| if not (row[0] or '').strip(): |
| continue |
| count += 1 |
| return count |
|
|
|
|
| def read_processed_progress(path: Path) -> dict[str, object]: |
| result = { |
| 'csv_exists': path.exists(), |
| 'csv_ok': False, |
| 'csv_error': '', |
| 'processed_rows': 0, |
| 'download_ok_rows': 0, |
| 'download_skipped_rows': 0, |
| 'download_running_rows': 0, |
| 'download_pending_rows': 0, |
| 'process_ok_rows': 0, |
| 'process_running_rows': 0, |
| 'upload_uploaded_rows': 0, |
| } |
| if not path.exists(): |
| result['csv_error'] = 'missing' |
| return result |
| try: |
| with path.open('r', encoding='utf-8-sig', newline='') as f: |
| reader = csv.DictReader(f) |
| fieldnames = list(reader.fieldnames or []) |
| missing = sorted(PROCESSED_REQUIRED_COLUMNS - set(fieldnames)) |
| if missing: |
| result['csv_error'] = f'missing_columns:{",".join(missing)}' |
| return result |
| rows = list(reader) |
| result['processed_rows'] = len(rows) |
| for row in rows: |
| d = (row.get('download_status') or '').strip() |
| p = (row.get('process_status') or '').strip() |
| u = (row.get('upload_status') or '').strip() |
| if d == 'ok': |
| result['download_ok_rows'] += 1 |
| elif d == 'skipped': |
| result['download_skipped_rows'] += 1 |
| elif d == 'running': |
| result['download_running_rows'] += 1 |
| else: |
| result['download_pending_rows'] += 1 |
| if p == 'ok': |
| result['process_ok_rows'] += 1 |
| elif p == 'running': |
| result['process_running_rows'] += 1 |
| if u == 'uploaded': |
| result['upload_uploaded_rows'] += 1 |
| result['csv_ok'] = True |
| return result |
| except Exception as exc: |
| result['csv_error'] = str(exc) |
| return result |
|
|
|
|
| def run_sync(runtime_root: Path) -> str: |
| sync_script = Path('/cache/home/sf895/SignVerse-2M/scripts/sync_processed_csv_from_runtime.py') |
| if not sync_script.exists(): |
| return 'missing_sync_script' |
| cmd = [ |
| 'python3', str(sync_script), |
| '--source-metadata-csv', str(runtime_root / 'SignVerse-2M-metadata_ori.csv'), |
| '--output-metadata-csv', str(runtime_root / 'SignVerse-2M-metadata_processed.csv'), |
| '--raw-video-dir', str(runtime_root / 'raw_video'), |
| '--scratch-raw-video-dir', str(Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/raw_video')), |
| '--raw-caption-dir', str(runtime_root / 'raw_caption'), |
| '--raw-metadata-dir', str(runtime_root / 'raw_metadata'), |
| '--dataset-dir', str(runtime_root / 'dataset'), |
| '--scratch-dataset-dir', str(Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/dataset')), |
| '--progress-path', str(runtime_root / 'archive_upload_progress.json'), |
| '--status-journal-path', str(runtime_root / 'upload_status_journal.jsonl'), |
| ] |
| try: |
| proc = subprocess.run(cmd, check=False, capture_output=True, text=True) |
| except OSError as exc: |
| return f'error:{exc}' |
| if proc.returncode == 0: |
| return (proc.stdout or '').strip() or 'ok' |
| err = (proc.stderr or proc.stdout or '').strip() |
| return f'failed:{err}' |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description='Report SignVerse runtime status.') |
| parser.add_argument('--runtime-root', default='/home/sf895/SignVerse-2M-runtime') |
| parser.add_argument('--username', default='sf895') |
| parser.add_argument('--no-sync', action='store_true') |
| parser.add_argument('--json', action='store_true') |
| parser.add_argument('--include-partitions', action='store_true') |
| parser.add_argument('--scan-complete', action='store_true') |
| parser.add_argument('--scan-runtime-size', action='store_true') |
| args = parser.parse_args() |
|
|
| runtime_root = Path(args.runtime_root) |
| root_dir = Path('/cache/home/sf895/SignVerse-2M') |
| raw_dir = runtime_root / 'raw_video' |
| scratch_raw_dir = Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/raw_video') |
| dataset_dir = runtime_root / 'dataset' |
| scratch_dataset_dir = Path(f'/scratch/{os.environ.get("USER", "sf895")}/SignVerse-2M-runtime/dataset') |
| claims_dir = runtime_root / 'slurm' / 'state' / 'claims' |
| download_claims_dir = runtime_root / 'slurm' / 'state' / 'download_claims' |
| progress_path = runtime_root / 'archive_upload_progress.json' |
| source_csv = runtime_root / 'SignVerse-2M-metadata_ori.csv' |
| processed_csv = runtime_root / 'SignVerse-2M-metadata_processed.csv' |
|
|
| sync_result = 'skipped' |
| if not args.no_sync: |
| sync_result = run_sync(runtime_root) |
|
|
| raw_complete: dict[str, Path] = {} |
| raw_temp: list[Path] = [] |
| for current_raw_dir in [raw_dir, scratch_raw_dir]: |
| if not current_raw_dir.exists(): |
| continue |
| for path in current_raw_dir.iterdir(): |
| if not path.is_file(): |
| continue |
| if path.suffix.lower() in VIDEO_EXTS: |
| raw_complete.setdefault(path.stem, path) |
| else: |
| raw_temp.append(path) |
|
|
| raw_size = sum_file_sizes(list(raw_complete.values())) |
| runtime_size = 0 |
| if runtime_root.exists(): |
| proc = subprocess.run(['du', '-sb', str(runtime_root)], check=False, capture_output=True, text=True) |
| if proc.returncode == 0 and proc.stdout.strip(): |
| try: |
| runtime_size = int(proc.stdout.split()[0]) |
| except Exception: |
| runtime_size = 0 |
|
|
| source_rows = read_source_manifest_count(source_csv) |
| progress = read_processed_progress(processed_csv) |
| videos_per_dwpose_job = read_videos_per_dwpose_job(root_dir) |
|
|
| payload = { |
| 'sync_result': sync_result, |
| 'download_normal': len(raw_temp) == 0, |
| 'raw_videos': len(raw_complete), |
| 'raw_temp_files': len(raw_temp), |
| 'sent_to_gpu': count_claims(claims_dir), |
| 'processed_complete': count_complete(dataset_dir, scratch_dataset_dir), |
| 'active_downloads': count_claims(download_claims_dir), |
| 'uploaded_archives': 0, |
| 'uploaded_folders': 0, |
| 'raw_size_bytes': raw_size, |
| 'runtime_size_bytes': runtime_size, |
| 'filesystem_avail_bytes': filesystem_avail_bytes(runtime_root), |
| 'source_rows': source_rows, |
| 'csv_exists': progress['csv_exists'], |
| 'csv_ok': progress['csv_ok'], |
| 'csv_error': progress['csv_error'], |
| 'processed_rows': progress['processed_rows'], |
| 'download_ok_rows': progress['download_ok_rows'], |
| 'download_skipped_rows': progress['download_skipped_rows'], |
| 'download_running_rows': progress['download_running_rows'], |
| 'download_pending_rows': progress['download_pending_rows'], |
| 'process_ok_rows': progress['process_ok_rows'], |
| 'process_running_rows': progress['process_running_rows'], |
| 'upload_uploaded_rows': progress['upload_uploaded_rows'], |
| } |
| uploaded_archives, uploaded_folders = count_uploaded(progress_path) |
| payload['uploaded_archives'] = uploaded_archives |
| payload['uploaded_folders'] = uploaded_folders |
| payload.update(queue_status(args.username)) |
| process_claims_by_job = aggregate_claims_by_job_key(claims_dir) |
| payload['videos_per_dwpose_job'] = videos_per_dwpose_job |
| payload['process_claim_job_keys'] = len(process_claims_by_job) |
| payload['process_claim_videos_actual'] = sum(process_claims_by_job.values()) |
| payload['process_claim_videos_max_per_job'] = max(process_claims_by_job.values(), default=0) |
| payload['running_dwpose_jobs'] = payload['running_dwpose'] |
| payload['running_dwpose_videos_estimated'] = payload['running_dwpose'] * videos_per_dwpose_job |
| payload['pending_dwpose_videos_estimated'] = payload['pending_dwpose_jobs'] * videos_per_dwpose_job |
| payload['total_dwpose_jobs'] = payload['running_dwpose'] + payload['pending_dwpose_jobs'] |
| payload['total_dwpose_videos_estimated'] = payload['running_dwpose_videos_estimated'] + payload['pending_dwpose_videos_estimated'] |
| if args.include_partitions: |
| payload['gpu_partition_capacity'] = gpu_partition_capacity(GPU_PARTITIONS, payload.get('active_tasks_by_partition', {})) |
| else: |
| payload['gpu_partition_capacity'] = [] |
| payload['job_partition_state_counts'] = {} |
| payload['active_tasks_by_partition'] = {} |
| payload['csv_row_match'] = (payload['processed_rows'] == payload['source_rows']) if payload['csv_ok'] else False |
|
|
| if args.json: |
| print(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True)) |
| return |
|
|
| print(f"sync_result={payload['sync_result']}") |
| print(f"download_normal={payload['download_normal']}") |
| print(f"raw_videos={payload['raw_videos']}") |
| print(f"raw_temp_files={payload['raw_temp_files']}") |
| print(f"sent_to_gpu={payload['sent_to_gpu']}") |
| print(f"running_dwpose={payload['running_dwpose']}") |
| print(f"running_dwpose_jobs={payload['running_dwpose_jobs']}") |
| print(f"pending_dwpose_jobs={payload['pending_dwpose_jobs']}") |
| print(f"total_dwpose_jobs={payload['total_dwpose_jobs']}") |
| print(f"videos_per_dwpose_job={payload['videos_per_dwpose_job']}") |
| print(f"process_claim_job_keys={payload['process_claim_job_keys']}") |
| print(f"process_claim_videos_actual={payload['process_claim_videos_actual']}") |
| print(f"process_claim_videos_max_per_job={payload['process_claim_videos_max_per_job']}") |
| print(f"running_dwpose_videos_estimated={payload['running_dwpose_videos_estimated']}") |
| print(f"pending_dwpose_videos_estimated={payload['pending_dwpose_videos_estimated']}") |
| print(f"total_dwpose_videos_estimated={payload['total_dwpose_videos_estimated']}") |
| print(f"processed_complete={payload['processed_complete']}") |
| print(f"active_downloads={payload['active_downloads']}") |
| print(f"running_download_jobs={payload['running_download']}") |
| print(f"pending_download_jobs={payload['pending_download_jobs']}") |
| print(f"total_download_jobs={payload['total_download_jobs']}") |
| print(f"uploaded_archives={payload['uploaded_archives']}") |
| print(f"uploaded_folders={payload['uploaded_folders']}") |
| print(f"source_rows={payload['source_rows']}") |
| print(f"processed_rows={payload['processed_rows']}") |
| print(f"csv_ok={payload['csv_ok']}") |
| print(f"csv_row_match={payload['csv_row_match']}") |
| print(f"csv_error={payload['csv_error']}") |
| print(f"download_ok_rows={payload['download_ok_rows']}") |
| print(f"download_skipped_rows={payload['download_skipped_rows']}") |
| print(f"download_running_rows={payload['download_running_rows']}") |
| print(f"download_pending_rows={payload['download_pending_rows']}") |
| print(f"process_ok_rows={payload['process_ok_rows']}") |
| print(f"process_running_rows={payload['process_running_rows']}") |
| print(f"upload_uploaded_rows={payload['upload_uploaded_rows']}") |
| for key in sorted(payload.get('job_partition_state_counts', {})): |
| print(f"job_partition_state[{key}]={payload['job_partition_state_counts'][key]}") |
| for row in payload.get('gpu_partition_capacity', []): |
| qos_limit = row['qos_limit'] if row['qos_limit'] is not None else 'na' |
| print( |
| f"gpu_partition[{row['partition']}]=free_gpus={row['free_gpus']}," |
| f"active_tasks={row['active_tasks']},qos_limit={qos_limit},submit_slots={row['submit_slots']}" |
| ) |
| print(f"raw_size={human_bytes(payload['raw_size_bytes'])}") |
| print(f"runtime_size={human_bytes(payload['runtime_size_bytes'])}") |
| print(f"filesystem_avail={human_bytes(payload['filesystem_avail_bytes'])}") |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
