script addition

Signed-off-by: Akshay Tondak <aktondak@amd.com>

Author: aktondak

archive/README.md

@@ -1,54 +1,103 @@
-# Runner Directory Archive Creation Guide
+# Archive Directory - NPU Platform Test Archives
 
-This directory contains test runners and benchmarks for different NPU platforms: `npu3`, `phx`, and `strx`. Each platform has its own subdirectory with specific test configurations and binaries.
+This directory contains test runners and benchmarks for different NPU platforms: `npu3`, `phx`, `strx`, and `ve2`. Each platform has its own subdirectory with specific test configurations and binaries.
 
 ## Directory Structure
 
 ```
-runner/
-├── npu3/           # NPU3 platform tests
-├── phx/            # Phoenix platform tests
-├── Strx/           # Strix platform tests
-└── ve2/            # Telluride platform tests
+archive/
+├── npu3/                    # NPU3 platform tests
+│   └── xrt_smi_npu3.a      # Generated archive
+├── phx/                     # Phoenix platform tests  
+│   └── xrt_smi_phx.a       # Generated archive
+├── strx/                    # Strix platform tests
+│   └── xrt_smi_strx.a      # Generated archive
+├── ve2/                     # Telluride platform tests
+│   └── xrt_smi_ve2.a       # Generated archive
+└── build_archives.py       # Archive creation script
 ```
 
-## Creating Archives
+## Creating Archives (Recommended)
 
-Use the `ar` utility to create archives. **Note**: The `ar` utility preserves directory paths by default and does NOT automatically flatten file structure.
+Use the provided Python script for automated archive creation:
 
-### Platform Archives
+### Basic Usage
 
 ```bash
-# Archive all NPU3 subdirectories
-(cd npu3 && find . -type f -print0 | xargs -0 ar -cr xrt_smi_npu3.a)
+# Create archives for all platforms
+python build_archives.py
 
-# Archive all PHX subdirectories  
-(cd phx && find . -type f -print0 | xargs -0 ar -cr xrt_smi_phx.a)
+# Create archive for specific platform
+python build_archives.py strx
 
-# Archive all STRX subdirectories
-(cd strx && find . -type f -print0 | xargs -0 ar -cr xrt_smi_strx.a)
+# Create archives for multiple platforms
+python build_archives.py phx ve2 strx
+```
+
+### Script Features
+
+- **Recursive file collection**: Automatically includes files from subdirectories
+- **Flattened structure**: Creates archives with all files at root level
+- **Smart updates**: Only updates files newer than existing archive
+- **Change tracking**: Shows added, removed, and updated files
+- **Automatic exclusion**: Skips `.a` files to prevent self-inclusion
+
+### Example Output
 
-# Archive all VE2 subdirectories
-(cd ve2 && find . -type f -print0 | xargs -0 ar -cr xrt_smi_ve2.a)
+```
+Processing 1 folder(s)...
+Updating xrt_smi_strx.a from 25 files...
+✓ Updated: strx/xrt_smi_strx.a
+  ➕ New files added (2):
+    + firmware_log.json
+    + trace_events.json
+  🔄 Files updated (3):
+    ~ config.json
+    ~ nop.elf
+    ~ validate.xclbin
+
+SUMMARY:
+Archives processed: 1/1
+Total new files: 2
+Total updated files: 3
+```
+
+## Manual Archive Creation (Alternative)
+
+If you need to create archives manually without the script:
+
+```bash
+# Archive all STRX subdirectories manually
+(cd strx && find . -type f ! -name "*.a" -print0 | xargs -0 ar -cr xrt_smi_strx.a)
+
+# Archive all PHX subdirectories manually  
+(cd phx && find . -type f ! -name "*.a" -print0 | xargs -0 ar -cr xrt_smi_phx.a)
 ```
 
 ## File Types in Archives
 
-Each test category typically contains:
+Each platform directory typically contains:
 - **ELF files** (`.elf`): Executable binaries for the NPU
-- **JSON files** (`.json`): Configuration profiles and recipes
+- **JSON files** (`.json`): Configuration profiles, recipes, and firmware logs
 - **XCLBIN files** (`.xclbin`): FPGA bitstream files
-- **Archive files** (`.a`): Static library files (XRT SMI)
+- **Other test files**: Various test configurations and data
 
-## Archive Command Options
+## Archive Management
 
-- `c`: Create archive
-- `r`: Insert files (replace if already exists)
-- The `ar` utility creates archives with all files flattened at the root level
+```bash
+# List contents of an archive
+ar -t strx/xrt_smi_strx.a
+
+# Extract all files from an archive
+ar -x strx/xrt_smi_strx.a
+
+# Get help for the Python script
+python build_archives.py --help
+```
 
 ## Notes
 
-- Archives are created in the current working directory
-- Use `ar -t archive_name.a` to list contents of an archive
-- Use `ar -x archive_name.a` to extract all files from an archive
-- All files will be extracted to the current directory without preserving subdirectory structure
+- Archives are stored in their respective platform directories (e.g., `strx/xrt_smi_strx.a`)
+- All files are flattened to root level in archives (no directory structure preserved)
+- The Python script automatically excludes existing `.a` files to prevent circular inclusion
+- Use the Python script for consistent and automated archive management

archive/build_archives.py

@@ -0,0 +1,147 @@
+#!/usr/bin/env python3
+
+import subprocess
+import argparse
+import shutil
+from pathlib import Path
+
+def check_ar_utility():
+    if not shutil.which('ar'):
+        print("Error: 'ar' utility not found. Please install binutils package.")
+        exit(1)
+
+def get_archive_contents(archive_path):
+    if not archive_path.exists():
+        return set()
+    result = subprocess.run(['ar', 't', str(archive_path)], capture_output=True, text=True)
+    return set(f.strip() for f in result.stdout.strip().split('\n') if f.strip()) if result.returncode == 0 else set()
+
+def create_archive(folder_path):
+    if not folder_path.exists():
+        print(f"Error: Folder {folder_path} does not exist")
+        return False, [], []
+    
+    # Get all files recursively from the folder and its subdirectories, excluding .a files
+    files = list(folder_path.rglob('*'))
+    files = [f for f in files if f.is_file() and f.suffix != '.a']
+    
+    if not files:
+        print(f"Error: Folder {folder_path} has no files")
+        return False, [], []
+    
+    output_name = f"xrt_smi_{folder_path.name}.a"
+    output_path = folder_path / output_name  # Store archive inside the folder itself
+    old_files, archive_existed = get_archive_contents(output_path), output_path.exists()
+    
+    print(f"{'Updating' if archive_existed else 'Creating'} {output_name} from {len(files)} files...")
+    
+    file_paths = [str(f.absolute()) for f in files]
+    
+    if archive_existed:
+        # Check which files are newer than the archive before updating
+        archive_mtime = output_path.stat().st_mtime
+        updated_files = [f.name for f in files if f.name in old_files and f.stat().st_mtime > archive_mtime]
+        
+        # Use 'ar u' (update) to only add files newer than those in archive
+        result = subprocess.run(['ar', 'rus', str(output_path)] + file_paths, 
+                              capture_output=True, text=True)
+        action = "Updated"
+    else:
+        updated_files = []
+        # Create new archive
+        result = subprocess.run(['ar', 'rcs', str(output_path)] + file_paths, 
+                              capture_output=True, text=True)
+        action = "Created"
+    
+    if result.returncode != 0:
+        print(f"✗ Failed: {result.stderr}")
+        return False, [], []
+    
+    print(f"✓ {action}: {output_path}")
+    
+    # Show what actually changed by comparing before/after
+    new_files_set = get_archive_contents(output_path)
+    added = new_files_set - old_files
+    removed = old_files - new_files_set
+    
+    if archive_existed:
+        for files_list, symbol, label, emoji in [
+            (added, "+", "New files added", "➕"),
+            (removed, "-", "Files removed", "➖"), 
+            (updated_files, "~", "Files updated", "🔄")
+        ]:
+            if files_list:
+                print(f"  {emoji} {label} ({len(files_list)}):")
+                [print(f"    {symbol} {file}") for file in sorted(files_list)]
+        
+        if not added and not removed and not updated_files:
+            print(f"  📄 No changes detected")
+        
+        return True, list(added), updated_files
+    else:
+        print(f"  📦 Files added to new archive ({len(new_files_set)}):")
+        [print(f"    + {file}") for file in sorted(new_files_set)]
+        return True, list(new_files_set), []
+
+def print_help():
+    print("""Archive Builder - Create .a archives from folders
+
+USAGE: python build_archives.py [folders...]
+ARGUMENTS: folders - List of folder names (default: all folders in current directory)
+
+EXAMPLES:
+    python build_archives.py          # Create archives for all folders
+    python build_archives.py phx      # Create archive for specific folder
+    python build_archives.py phx ve2  # Create archives for multiple folders
+
+OUTPUT: Archives created as xrt_smi_<foldername>.a""")
+
+def main():
+    check_ar_utility()
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument('-h', '--help', action='store_true')
+    parser.add_argument('folders', nargs='*', help='Folder names to create archives for')
+    args = parser.parse_args()
+    
+    if args.help:
+        print_help()
+        return 0
+    
+    current_dir = Path(".")
+    folder_names = args.folders or [d.name for d in current_dir.iterdir() if d.is_dir()]
+    if not args.folders:
+        print(f"No folders specified, processing all: {', '.join(folder_names)}")
+    
+    folders = [current_dir / name for name in folder_names if (current_dir / name).exists()]
+    [print(f"Warning: Folder {name} not found, skipping") for name in folder_names if not (current_dir / name).exists()]
+    
+    if not folders:
+        print("No valid folders found")
+        return 1
+    
+    print(f"Processing {len(folders)} folder(s)...")
+    success, total_new, total_updated, archives_info = 0, 0, 0, []
+    
+    for folder in folders:
+        success_status, new_files, updated_files = create_archive(folder)
+        if success_status:
+            success += 1
+            total_new += len(new_files)
+            total_updated += len(updated_files)
+            archives_info.append((f"xrt_smi_{folder.name}.a", new_files, updated_files))
+        print()
+    
+    print("=" * 60)
+    print(f"SUMMARY:\nArchives processed: {success}/{len(folders)}\nTotal new files: {total_new}\nTotal updated files: {total_updated}")
+    
+    if archives_info:
+        print("\nArchive changes:")
+        for archive_name, new_files, updated_files in archives_info:
+            status = [f"{len(new_files)} new"] if new_files else []
+            status += [f"{len(updated_files)} updated"] if updated_files else []
+            print(f"  {archive_name}: {', '.join(status) or 'no changes'}")
+    
+    return 0 if success == len(folders) else 1
+
+if __name__ == "__main__":
+    exit(main())