Installation Guide

This guide provides step-by-step installation instructions for AADC on Windows and Linux platforms.

System Requirements

Hardware Requirements

• CPU: x86-64 architecture with AVX2 or AVX512 support (Intel Haswell+ or AMD Zen+)
• Memory: Minimum 4GB RAM (8GB+ recommended for large models)
• Storage: 500MB available disk space

Operating Systems

• Windows: Windows 10/11 with Visual Studio 2019 or 2022
• Linux: Ubuntu 18.04+, CentOS 7+, RHEL 7+, or equivalent distributions

C++ Installation

Windows (Visual Studio)

Prerequisites: - Visual Studio 2019 or 2022 (Community, Professional, or Enterprise) - Windows SDK 10.0 or later

Installation Steps:

1. Download AADC Package

   Download the AADC demo package and extract to your preferred location
   Example: C:\AADC\

2. Folder Structure Overview

   include/                - core AADC library header files
   lib/                    - core AADC library lib files
   aadc-getting-started/   - examples from the manual. START HERE.
   python/                 - AADC Python examples
   visualstudio/           - Visual Studio solution files
   docs/                   - documentation files

3. Build with Visual Studio

   Option 1: Use Solution File

   Open visualstudio/20XX/AADC.sln in Visual Studio
   Select Debug or Release configuration
   Build → Build Solution

   Option 2: CMake Integration

   Visual Studio can use CMake integration to build and run examples

4. Build Configurations

   • Debug: Full debugging information, slower execution
   • Release: Optimized for performance, recommended for production

5. Verify Installation

   • run Ex1HelloWorld.exe to verify the installation
   • run tests.exe to confirm your system and AADC work as expected

Linux (GCC/Clang)

Prerequisites:

• Compatible C++ compiler (GCC 7.0+, Clang 6.0+, Intel C++)
• CMake 3.10+
• Git (optional, for version control)

Supported Compilers:

• GCC 7.0+
• Clang 6.0+

Installation Steps:

1. Extract AADC Package

   unzip aadc-demo-package.zip
   cd AADC-Demo

2. Build with CMake

   Standard Release Build:

   mkdir build
   cd build
   cmake ..
   make -j

   Debug Build:

   mkdir build_debug
   cd build_debug
   cmake -DCMAKE_BUILD_TYPE=Debug ..
   make -j

   AVX512 Optimized Build:

   mkdir build_avx512
   cd build_avx512
   cmake -DAADC_512=1 ..
   make -j

3. Verify Installation

   # Run getting started example
   AADC-Demo/build$ ./aadc-getting-started/Ex1HelloWorld 
   
   # Expected output:
   # z:1.39121
   # avx[0] f(4,2,0.4)=11.0232
   # avx[1] f(3,2,0.3)=6.04965
   # avx[2] f(2,2,0.2)=3.32012
   # avx[3] f(1,2,0.1)=1.82212
   # avx[0] df/dx=5.51159,df/dy=-11.0232,df/dz=11.0232
   # ... (additional output)
   # Example 1 is done

4. Check Compiler Options (optional)

   # View exact compiler flags used
   cat compile_commands.json

Performance Optimization

AVX Support

• AVX2: Standard build (supported on Intel Haswell+ and AMD Zen+)
• AVX512: Use -DAADC_512=1 for modern processors (Skylake-X+)

Build Types

• Debug: Full debugging symbols, assertions enabled
• Release: Optimized for maximum performance

Troubleshooting

Common Issues

Missing AVX Support:

# Check CPU features on Linux
lscpu | grep -i avx

# Check CPU features on Windows (PowerShell)
Get-WmiObject -Class Win32_Processor | Select-Object -ExpandProperty Name

# Ensure your CPU supports AVX2 or AVX512

Library Linking Issues:

Windows:

# Verify library exists
dir C:\path\to\aadc\lib\aadc-avx2-*.lib

# Check runtime library mismatch
# Ensure your project uses the same runtime library as AADC:
# - MD libraries require /MD or /MDd
# - MT libraries require /MT or /MTd

Linux:

# Add library path for dynamic libraries
export LD_LIBRARY_PATH=/path/to/aadc/lib:$LD_LIBRARY_PATH

# Check library dependencies
ldd your_program

# Verify library exists
ls -la /path/to/aadc/lib/libaadc-*.{a,so}

Library Selection Decision Tree

Step 1: Choose CPU Architecture

- Use AVX2 for broader compatibility (Intel Haswell+, AMD Zen+)
- Use AVX512 for maximum performance on modern Intel CPUs (Skylake-X+)

Step 2: Choose Linking Type

Use Static Linking When:

- Single executable application
- Recording happens within one module
- Kernel execution only (no recording phase)
- Easier deployment (no external dependencies)

Use Dynamic Linking When:

- Multi-module application (multiple DLLs/SOs)
- Recording can cross module boundaries
- Need to update AADC without recompiling application

Step 3: Choose Runtime Library (Windows Only)

- **MD/MDd**: Use with applications that use dynamic C runtime
- **MT/MTd**: Use with applications that use static C runtime
- Must match your application's runtime library setting