wehub-resource-sync
529 lines
20 KiB
YAML
529 lines
20 KiB
YAML
# GitHub Actions Workflow for android-x86_64
|
|
|
|
on:
|
|
workflow_dispatch:
|
|
inputs:
|
|
buildThreads:
|
|
description: 'Build threads for libnd4j. Used to control memory usage of builds.'
|
|
required: true
|
|
default: 2
|
|
|
|
deployToReleaseStaging:
|
|
description: 'Whether to deploy to release staging or not.'
|
|
required: false
|
|
default: 0
|
|
|
|
releaseVersion:
|
|
description: 'Release version target'
|
|
required: false
|
|
default: 1.0.0-M3
|
|
|
|
snapshotVersion:
|
|
description: 'Snapshot version target'
|
|
required: false
|
|
default: 1.0.0-SNAPSHOT
|
|
|
|
releaseRepoId:
|
|
description: 'Release repository id'
|
|
required: false
|
|
default: ""
|
|
|
|
serverId:
|
|
description: 'Server id to publish to'
|
|
required: false
|
|
default: central
|
|
|
|
mvnFlags:
|
|
description: "Extra maven flags (must escape input yourself if used)"
|
|
required: false
|
|
default: ""
|
|
|
|
libnd4jUrl:
|
|
description: 'Sets a libnd4j download url for this build. LIBND4J_HOME will automatically be set. Should be used when only needing to build other modules.'
|
|
required: false
|
|
default: ""
|
|
|
|
runsOn:
|
|
description: 'System to run on'
|
|
required: false
|
|
default: ubuntu-latest
|
|
|
|
debug_enabled:
|
|
description: 'Run the build with tmate debugging enabled (https://github.com/marketplace/actions/debugging-with-tmate)'
|
|
required: false
|
|
default: false
|
|
|
|
jobs:
|
|
android-x86_64:
|
|
strategy:
|
|
fail-fast: false
|
|
matrix:
|
|
helper: [onednn, ""]
|
|
include:
|
|
- mvn_ext: ${{ github.event.inputs.mvnFlags }}
|
|
experimental: true
|
|
name: Extra maven flags
|
|
- debug_enabled: ${{ github.event.inputs.debug_enabled }}
|
|
experimental: true
|
|
name: Debug enabled
|
|
- deploy_to_release_staging: ${{ github.event.inputs.deployToReleaseStaging }}
|
|
experimental: true
|
|
name: Whether to deploy to release staging or not
|
|
- release_version: ${{ github.event.inputs.releaseVersion }}
|
|
experimental: true
|
|
name: Release version
|
|
- snapshot_version: ${{ github.event.inputs.snapshotVersion }}
|
|
experimental: true
|
|
name: Snapshot version
|
|
- server_id: ${{ github.event.inputs.serverId }}
|
|
experimental: true
|
|
name: Server id
|
|
- release_repo_id: ${{ github.event.inputs.releaseRepoId }}
|
|
experimental: true
|
|
name: The release repository to run on
|
|
- build_threads: ${{ github.event.inputs.buildThreads }}
|
|
experimental: true
|
|
name: The number of threads to build libnd4j with
|
|
runs-on: ${{ github.event.inputs.runsOn }}
|
|
steps:
|
|
- uses: AutoModality/action-clean@v1
|
|
|
|
- name: Cancel Previous Runs
|
|
uses: styfle/cancel-workflow-action@0.8.0
|
|
with:
|
|
access_token: ${{ github.token }}
|
|
|
|
- uses: actions/checkout@v4
|
|
|
|
- name: Free Disk Space
|
|
uses: jlumbroso/free-disk-space@main
|
|
with:
|
|
tool-cache: false
|
|
android: true
|
|
dotnet: true
|
|
haskell: true
|
|
large-packages: true
|
|
docker-images: true
|
|
swap-storage: true
|
|
|
|
- name: Configure swap space
|
|
shell: bash
|
|
run: |
|
|
echo "=== Initial system status ==="
|
|
free -h
|
|
df -h
|
|
echo "Available disk space on root:"
|
|
df -h /
|
|
|
|
# Check if swap is already enabled
|
|
if swapon --show | grep -q "/"; then
|
|
echo "Swap already configured:"
|
|
swapon --show
|
|
else
|
|
echo "Configuring swap space..."
|
|
|
|
# Use fixed 4GB swap size
|
|
SWAP_SIZE="12G"
|
|
echo "Creating ${SWAP_SIZE} swap file..."
|
|
|
|
# Create swap file
|
|
sudo fallocate -l ${SWAP_SIZE} /swapfile || {
|
|
echo "fallocate failed, trying dd..."
|
|
sudo dd if=/dev/zero of=/swapfile bs=1G count=12 status=progress
|
|
}
|
|
|
|
# Set up swap
|
|
sudo chmod 600 /swapfile
|
|
sudo mkswap /swapfile
|
|
sudo swapon /swapfile
|
|
|
|
# Verify swap is active
|
|
echo "=== Swap configuration completed ==="
|
|
free -h
|
|
swapon --show
|
|
fi
|
|
|
|
# Tune swappiness for build workloads
|
|
# Lower values (10-20) prefer RAM, higher values (60+) use swap more aggressively
|
|
echo "Current swappiness: $(cat /proc/sys/vm/swappiness)"
|
|
sudo sysctl vm.swappiness=80
|
|
echo "Adjusted swappiness: $(cat /proc/sys/vm/swappiness)"
|
|
sudo sysctl vm.overcommit_memory=2 # Allow overcommit
|
|
sudo sysctl vm.overcommit_ratio=80
|
|
# Show final memory status
|
|
echo "=== Final memory status ==="
|
|
free -h
|
|
|
|
- uses: ./.github/actions/set-linux-distro-version
|
|
- uses: ./.github/actions/update-deps-linux
|
|
|
|
- name: Cache cmake install
|
|
uses: actions/cache@v4
|
|
id: cache-cmake-install
|
|
with:
|
|
path: /opt/cmake
|
|
key: ${{ runner.os }}-cmake-${{ github.run_id }}
|
|
restore-keys: |
|
|
${{ runner.os }}-cmake-
|
|
|
|
- name: Cache protobuf install
|
|
uses: actions/cache@v4
|
|
id: cache-protobuf
|
|
with:
|
|
path: /opt/protobuf
|
|
key: ${{ runner.os }}-protobuf-${{ github.run_id }}
|
|
restore-keys: |
|
|
${{ runner.os }}-protobuf-
|
|
|
|
- uses: ./.github/actions/install-protobuf-linux
|
|
if: steps.cache-protobuf.outputs.cache-hit != 'true'
|
|
|
|
- uses: ./.github/actions/install-cmake-linux
|
|
if: steps.cache-cmake-install.outputs.cache-hit != 'true'
|
|
|
|
- name: Set up Java for publishing to OSSRH
|
|
uses: actions/setup-java@v4
|
|
with:
|
|
java-version: 11
|
|
distribution: 'temurin'
|
|
server-id: ${{ github.event.inputs.serverId }}
|
|
server-username: MAVEN_USERNAME
|
|
server-password: MAVEN_PASSWORD
|
|
gpg-private-key: ${{ secrets.SONATYPE_GPG_KEY }}
|
|
gpg-passphrase: MAVEN_GPG_PASSPHRASE
|
|
cache: 'maven'
|
|
|
|
- uses: nttld/setup-ndk@v1
|
|
id: setup-ndk
|
|
with:
|
|
ndk-version: r26d
|
|
|
|
- name: Set mvn build command and environment variables
|
|
shell: bash
|
|
run: |
|
|
# Set constants for Android X86_64
|
|
LIBND4J_CLASSIFIER="android-x86_64"
|
|
|
|
# Define the specific OpenBLAS JAR for android-x86_64
|
|
OPENBLAS_VERSION="0.3.28-1.5.11"
|
|
OPENBLAS_JAR="openblas-${OPENBLAS_VERSION}-${LIBND4J_CLASSIFIER}.jar"
|
|
OPENBLAS_INSTALL_DIR="${GITHUB_WORKSPACE}/openblas_home"
|
|
|
|
NDK_VERSION_ENV="r26d"
|
|
|
|
echo "LIBND4J_CLASSIFIER=${LIBND4J_CLASSIFIER}" >> $GITHUB_ENV
|
|
echo "OPENBLAS_VERSION=${OPENBLAS_VERSION}" >> $GITHUB_ENV
|
|
echo "OPENBLAS_JAR=${OPENBLAS_JAR}" >> $GITHUB_ENV
|
|
echo "OPENBLAS_INSTALL_DIR=${OPENBLAS_INSTALL_DIR}" >> $GITHUB_ENV
|
|
echo "CURRENT_TARGET=android-x86_64" >> $GITHUB_ENV
|
|
echo "NDK_VERSION=${NDK_VERSION_ENV}" >> $GITHUB_ENV
|
|
echo "ANDROID_VERSION=21" >> $GITHUB_ENV
|
|
|
|
if [ "${{ github.event.inputs.libnd4jUrl }}" != '' ]; then
|
|
modules=':nd4j-native,:nd4j-native-preset'
|
|
else
|
|
echo "Building libnd4j from source"
|
|
modules=':nd4j-native,:nd4j-native-preset,:libnd4j'
|
|
fi
|
|
|
|
# Base Maven command
|
|
command="mvn ${{ matrix.mvn_ext }} -Dlibnd4j.generate.flatc=ON --no-transfer-progress -pl $modules -Pcpu -Dlibnd4j.buildthreads=${{ github.event.inputs.buildThreads }} -Dhttp.keepAlive=false -Dmaven.wagon.http.pool=false -Dmaven.wagon.http.retryHandler.count=3 -Possrh -DskipTestResourceEnforcement=true -Dmaven.javadoc.failOnError=false -Djavacpp.platform=${LIBND4J_CLASSIFIER} -Pcpu --also-make --batch-mode deploy -DskipTests"
|
|
|
|
# Updated conditional flags for the helper library
|
|
if [ "${{ matrix.helper }}" != '' ]; then
|
|
if [ "${{ matrix.helper }}" == "onednn" ]; then
|
|
mvn_ext=" -Dlibnd4j.helper=onednn -Djavacpp.platform.extension=-onednn -Dlibnd4j.classifier=${LIBND4J_CLASSIFIER}-onednn"
|
|
else
|
|
echo "Warning: Unsupported helper '${{ matrix.helper }}' defined in matrix. Only 'onednn' or empty is handled for Maven flags."
|
|
mvn_ext=""
|
|
fi
|
|
else
|
|
mvn_ext=""
|
|
fi
|
|
|
|
command="${command} ${mvn_ext}"
|
|
echo "Setting command for helper ${{ matrix.helper }} to ${command}"
|
|
echo "COMMAND=${command}" >> $GITHUB_ENV
|
|
|
|
- name: Setup OpenBLAS Library
|
|
shell: bash
|
|
env:
|
|
OPENBLAS_INSTALL_DIR: ${{ env.OPENBLAS_INSTALL_DIR }}
|
|
OPENBLAS_JAR: ${{ env.OPENBLAS_JAR }}
|
|
OPENBLAS_VERSION: ${{ env.OPENBLAS_VERSION }}
|
|
LIBND4J_CLASSIFIER: ${{ env.LIBND4J_CLASSIFIER }}
|
|
run: |
|
|
echo "=== Setting up OpenBLAS ${OPENBLAS_VERSION} for ${LIBND4J_CLASSIFIER} ==="
|
|
|
|
# Create and navigate to install directory
|
|
mkdir -p "${OPENBLAS_INSTALL_DIR}"
|
|
cd "${OPENBLAS_INSTALL_DIR}"
|
|
|
|
# Download OpenBLAS JAR
|
|
OPENBLAS_URL="https://repo1.maven.org/maven2/org/bytedeco/openblas/${OPENBLAS_VERSION}/${OPENBLAS_JAR}"
|
|
echo "Downloading ${OPENBLAS_JAR} from ${OPENBLAS_URL}..."
|
|
wget --quiet ${OPENBLAS_URL} || {
|
|
echo "❌ Failed to download OpenBLAS JAR"
|
|
exit 1
|
|
}
|
|
|
|
# Extract JAR
|
|
echo "Extracting ${OPENBLAS_JAR}..."
|
|
unzip -q ${OPENBLAS_JAR} || {
|
|
echo "❌ Failed to extract OpenBLAS JAR"
|
|
exit 1
|
|
}
|
|
|
|
echo "=== OpenBLAS JAR extraction completed ==="
|
|
|
|
# The JAR contains: lib/x86_64/include/ and lib/x86_64/
|
|
OPENBLAS_PLATFORM_PATH="lib/x86_64"
|
|
|
|
if [[ -d "$OPENBLAS_PLATFORM_PATH" ]]; then
|
|
echo "✅ Found OpenBLAS platform directory: $OPENBLAS_PLATFORM_PATH"
|
|
|
|
# Verify the expected structure
|
|
if [[ -d "$OPENBLAS_PLATFORM_PATH/include" && -f "$OPENBLAS_PLATFORM_PATH/include/cblas.h" ]]; then
|
|
echo "✅ Found headers at: $OPENBLAS_PLATFORM_PATH/include/"
|
|
else
|
|
echo "❌ Headers not found at expected location: $OPENBLAS_PLATFORM_PATH/include/"
|
|
exit 1
|
|
fi
|
|
|
|
if [[ -d "$OPENBLAS_PLATFORM_PATH/lib" ]] || [[ -f "$OPENBLAS_PLATFORM_PATH/libopenblas.so" ]]; then
|
|
echo "✅ Found libraries in: $OPENBLAS_PLATFORM_PATH/"
|
|
else
|
|
echo "❌ Libraries not found in: $OPENBLAS_PLATFORM_PATH/"
|
|
exit 1
|
|
fi
|
|
|
|
# Set the correct path - this should be the full path to lib/x86_64
|
|
OPENBLAS_FINAL_PATH="$(realpath "$OPENBLAS_PLATFORM_PATH")"
|
|
|
|
else
|
|
echo "❌ Could not find OpenBLAS platform directory: $OPENBLAS_PLATFORM_PATH"
|
|
echo "Available directories:"
|
|
find . -type d -maxdepth 3 | head -20
|
|
exit 1
|
|
fi
|
|
|
|
# Set final environment variables - this is the key fix
|
|
echo "=== Setting final environment variables ==="
|
|
echo "OPENBLAS_PATH=${OPENBLAS_FINAL_PATH}" >> $GITHUB_ENV
|
|
echo "OPENBLAS_INCLUDE_PATH=${OPENBLAS_FINAL_PATH}/include" >> $GITHUB_ENV
|
|
echo "OPENBLAS_LIB_PATH=${OPENBLAS_FINAL_PATH}/" >> $GITHUB_ENV
|
|
|
|
echo "=== OpenBLAS setup completed ==="
|
|
echo "Final OpenBLAS path: ${OPENBLAS_FINAL_PATH}"
|
|
echo "Include path: ${OPENBLAS_FINAL_PATH}/include"
|
|
echo "Library path: ${OPENBLAS_FINAL_PATH}/"
|
|
|
|
# Verify the final setup
|
|
echo "=== Final verification ==="
|
|
ls -la "${OPENBLAS_FINAL_PATH}/include/" | head -10
|
|
ls -la "${OPENBLAS_FINAL_PATH}/" | grep -E "\.(so|a)$" | head -5
|
|
|
|
- name: OpenBLAS Configuration Verification
|
|
shell: bash
|
|
run: |
|
|
echo "=== OpenBLAS Configuration Verification ==="
|
|
echo "OPENBLAS_PATH: ${OPENBLAS_PATH}"
|
|
echo "OPENBLAS_INCLUDE_PATH: ${OPENBLAS_INCLUDE_PATH}"
|
|
echo "OPENBLAS_LIB_PATH: ${OPENBLAS_LIB_PATH}"
|
|
echo
|
|
|
|
# Test that paths are accessible
|
|
if [[ -d "$OPENBLAS_PATH" ]]; then
|
|
echo "✅ OPENBLAS_PATH is accessible"
|
|
else
|
|
echo "❌ OPENBLAS_PATH is not accessible: $OPENBLAS_PATH"
|
|
exit 1
|
|
fi
|
|
|
|
if [[ -d "$OPENBLAS_INCLUDE_PATH" ]]; then
|
|
echo "✅ OPENBLAS_INCLUDE_PATH is accessible"
|
|
else
|
|
echo "❌ OPENBLAS_INCLUDE_PATH is not accessible: $OPENBLAS_INCLUDE_PATH"
|
|
exit 1
|
|
fi
|
|
|
|
# Test header file accessibility
|
|
if [[ -f "$OPENBLAS_INCLUDE_PATH/cblas.h" ]]; then
|
|
echo "✅ cblas.h is accessible"
|
|
echo "First few lines of cblas.h:"
|
|
head -5 "$OPENBLAS_INCLUDE_PATH/cblas.h"
|
|
else
|
|
echo "❌ cblas.h is not accessible"
|
|
echo "Contents of include directory:"
|
|
ls -la "$OPENBLAS_INCLUDE_PATH"
|
|
exit 1
|
|
fi
|
|
|
|
if [[ -f "$OPENBLAS_INCLUDE_PATH/openblas_config.h" ]]; then
|
|
echo "✅ openblas_config.h is accessible"
|
|
else
|
|
echo "❌ openblas_config.h is not accessible"
|
|
exit 1
|
|
fi
|
|
|
|
echo "=== Verification completed successfully ==="
|
|
|
|
- name: Debug Info
|
|
shell: bash
|
|
run: |
|
|
echo "--- Workflow Inputs ---"
|
|
echo "buildThreads: ${{ github.event.inputs.buildThreads }}"
|
|
echo "deployToReleaseStaging: ${{ github.event.inputs.deployToReleaseStaging }}"
|
|
echo "releaseVersion: ${{ github.event.inputs.releaseVersion }}"
|
|
echo "snapshotVersion: ${{ github.event.inputs.snapshotVersion }}"
|
|
echo "releaseRepoId: ${{ github.event.inputs.releaseRepoId }}"
|
|
echo "serverId: ${{ github.event.inputs.serverId }}"
|
|
echo "mvnFlags: ${{ github.event.inputs.mvnFlags }}"
|
|
echo "libnd4jUrl: ${{ github.event.inputs.libnd4jUrl }}"
|
|
echo "runsOn: ${{ github.event.inputs.runsOn }}"
|
|
echo "debug_enabled: ${{ github.event.inputs.debug_enabled }}"
|
|
echo "--- Matrix Values ---"
|
|
echo "Helper: ${{ matrix.helper }}"
|
|
echo "--- Environment Variables ---"
|
|
echo "LIBND4J_CLASSIFIER: $LIBND4J_CLASSIFIER"
|
|
echo "OPENBLAS_VERSION: $OPENBLAS_VERSION"
|
|
echo "OPENBLAS_JAR: $OPENBLAS_JAR"
|
|
echo "OPENBLAS_INSTALL_DIR: $OPENBLAS_INSTALL_DIR"
|
|
echo "OPENBLAS_PATH: $OPENBLAS_PATH"
|
|
echo "OPENBLAS_INCLUDE_PATH: $OPENBLAS_INCLUDE_PATH"
|
|
echo "OPENBLAS_LIB_PATH: $OPENBLAS_LIB_PATH"
|
|
echo "CURRENT_TARGET: $CURRENT_TARGET"
|
|
echo "NDK_VERSION: $NDK_VERSION"
|
|
echo "ANDROID_VERSION: $ANDROID_VERSION"
|
|
echo "NDK Path (from step): ${{ steps.setup-ndk.outputs.ndk-path }}"
|
|
echo "COMMAND: $COMMAND"
|
|
echo "--- System Info ---"
|
|
export PATH=/opt/protobuf/bin:/opt/cmake/bin:$PATH
|
|
mvn --version
|
|
cmake --version
|
|
protoc --version
|
|
|
|
- name: Monitor memory during build
|
|
shell: bash
|
|
run: |
|
|
# Start background memory monitoring
|
|
(while true; do
|
|
echo "$(date '+%H:%M:%S'): $(free -h | head -n 2 | tail -n 1)"
|
|
if swapon --show | grep -q "/"; then
|
|
echo "$(date '+%H:%M:%S'): Swap: $(swapon --show --noheadings)"
|
|
fi
|
|
sleep 120 # Check every 2 minutes
|
|
done) > memory_monitor.log 2>&1 &
|
|
MONITOR_PID=$!
|
|
echo "MONITOR_PID=${MONITOR_PID}" >> $GITHUB_ENV
|
|
echo "Started memory monitoring (PID: ${MONITOR_PID})"
|
|
|
|
- name: Build with Maven
|
|
shell: bash
|
|
env:
|
|
MAVEN_GPG_KEY: ${{ secrets.SONATYPE_GPG_KEY }}
|
|
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
|
|
MAVEN_USERNAME: ${{ secrets.CENTRAL_SONATYPE_TOKEN_USERNAME }}
|
|
MAVEN_PASSWORD: ${{ secrets.CENTRAL_SONATYPE_TOKEN_PASSWORD }}
|
|
MAVEN_GPG_PASSPHRASE: ${{ secrets.PACKAGES_GPG_PASS }}
|
|
PERFORM_RELEASE: ${{ github.event.inputs.deployToReleaseStaging }}
|
|
RELEASE_VERSION: ${{ github.event.inputs.releaseVersion }}
|
|
SNAPSHOT_VERSION: ${{ github.event.inputs.snapshotVersion }}
|
|
RELEASE_REPO_ID: ${{ github.event.inputs.releaseRepoId }}
|
|
HELPER: ${{ matrix.helper }}
|
|
LIBND4J_BUILD_THREADS: ${{ github.event.inputs.buildThreads }}
|
|
ANDROID_NDK: ${{ steps.setup-ndk.outputs.ndk-path }}
|
|
OPENBLAS_PATH: ${{ env.OPENBLAS_PATH }}
|
|
ANDROID_VERSION: ${{ env.ANDROID_VERSION }}
|
|
NDK_VERSION: ${{ env.NDK_VERSION }}
|
|
PROTO_EXEC: /opt/protobuf/bin/protoc
|
|
LD_LIBRARY_PATH: $LD_LIBRARY_PATH:${{ env.OPENBLAS_LIB_PATH }}
|
|
DEBIAN_FRONTEND: noninteractive
|
|
DEPLOY: 1
|
|
BUILD_USING_MAVEN: 1
|
|
TARGET_OS: android
|
|
PUBLISH_TO: central
|
|
DEPLOY_TO: central
|
|
MAVEN_OPTS: -Xmx2g
|
|
RLIMIT_AS: 6442450944 # 6GB virtual memory limit
|
|
RLIMIT_DATA: 4294967296 # 4GB data segment limit
|
|
run: |
|
|
echo "=== Build Environment Summary ==="
|
|
echo "NDK Path: ${ANDROID_NDK}"
|
|
echo "OpenBLAS Path: ${OPENBLAS_PATH}"
|
|
echo "OpenBLAS Include Path: ${OPENBLAS_INCLUDE_PATH}"
|
|
echo "OpenBLAS Lib Path: ${OPENBLAS_LIB_PATH}"
|
|
echo "LD_LIBRARY_PATH: ${LD_LIBRARY_PATH}"
|
|
echo "Build Threads: ${LIBND4J_BUILD_THREADS}"
|
|
echo "Helper: ${HELPER}"
|
|
echo "================================="
|
|
|
|
# Show memory status before build
|
|
echo "=== Memory status before build ==="
|
|
free -h
|
|
|
|
# Pre-build verification
|
|
echo "=== Pre-build OpenBLAS verification ==="
|
|
if [[ -f "$OPENBLAS_PATH/include/cblas.h" ]]; then
|
|
echo "✅ cblas.h found and accessible"
|
|
else
|
|
echo "❌ cblas.h not found at $OPENBLAS_PATH/include/cblas.h"
|
|
echo "Attempting to locate cblas.h..."
|
|
find "$OPENBLAS_PATH" -name "cblas.h" 2>/dev/null | head -5
|
|
exit 1
|
|
fi
|
|
|
|
# Execute build
|
|
if [ "$PERFORM_RELEASE" == 1 ] || [ "$PERFORM_RELEASE" == "true" ]; then
|
|
echo "=== Executing release build ==="
|
|
bash ${GITHUB_WORKSPACE}/release-specified-component.sh "${RELEASE_VERSION}" "${SNAPSHOT_VERSION}" "${RELEASE_REPO_ID}" "${COMMAND}"
|
|
else
|
|
echo "=== Executing snapshot build ==="
|
|
echo "Command: ${COMMAND}"
|
|
eval "${COMMAND}"
|
|
fi
|
|
|
|
- name: Show memory usage summary
|
|
if: always()
|
|
shell: bash
|
|
run: |
|
|
# Stop memory monitoring
|
|
if [ -n "$MONITOR_PID" ]; then
|
|
kill $MONITOR_PID 2>/dev/null || true
|
|
fi
|
|
|
|
echo "=== Final memory status ==="
|
|
free -h
|
|
if swapon --show | grep -q "/"; then
|
|
echo "=== Swap usage ==="
|
|
swapon --show
|
|
fi
|
|
|
|
echo "=== Memory usage during build ==="
|
|
if [ -f memory_monitor.log ]; then
|
|
cat memory_monitor.log
|
|
else
|
|
echo "No memory monitoring log found"
|
|
fi
|
|
|
|
- name: Cleanup swap
|
|
if: always()
|
|
shell: bash
|
|
run: |
|
|
echo "Cleaning up swap configuration..."
|
|
sudo swapoff /swapfile 2>/dev/null || true
|
|
sudo rm -f /swapfile 2>/dev/null || true
|
|
echo "Swap cleanup completed"
|
|
|
|
- name: Upload build artifacts on failure
|
|
if: failure()
|
|
uses: actions/upload-artifact@v4
|
|
with:
|
|
name: build-logs-${{ matrix.helper }}-${{ github.run_id }}
|
|
path: |
|
|
memory_monitor.log
|
|
**/cmake_install.log
|
|
**/build.log
|
|
**/CMakeFiles/CMakeError.log
|
|
**/CMakeFiles/CMakeOutput.log
|
|
retention-days: 3 |