hero-z-7045-builder

#! /bin/bash
# Copyright (C) 2018 ETH Zurich and University of Bologna
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

# Error handler
set -e
trap 'previous_command=$this_command; this_command=$BASH_COMMAND' DEBUG
trap 'echo FAILED COMMAND: $previous_command' ERR

if [[ ! -f "${0##*/}" ]]; then
    echo "Error: ${0##*/} should be launched from the directory that contains it"
    exit 1
fi

update_env() {
    source scripts/hero-z-7045-env.sh
}

prepare_linux() {
    cd ${HERO_SDK_DIR}
    update_env

    # Does the kernel directory already exist? It may be external.
    if [ ! -d "${HERO_LINUX_KERNEL_DIR}" ]; then

        # Prepare Linux workspace and get sources
        mkdir -p ${HERO_LINUX_WORKSPACE_DIR}
        cp -r ${HERO_SUPPORT_DIR}/linux/zynqlinux/* ${HERO_LINUX_WORKSPACE_DIR}/.
        cd ${HERO_LINUX_WORKSPACE_DIR}
        ./setup.sh
    fi
}

get_sources() {
    cd ${HERO_SDK_DIR}
    git submodule update --init
    update_env

    cd ${HERO_TOOLCHAIN_DIR}
    git submodule update --init --recursive

    cd ${HERO_PULP_SDK_DIR}
    git submodule update --init --recursive

    cd ${HERO_SUPPORT_DIR}
    git submodule update --init --recursive

    cd ${HERO_OMP_EXAMPLES_DIR}
    git submodule update --init --recursive
}

build_riscv32_toolchain() {
    cd ${HERO_SDK_DIR}
    update_env

    cd ${HERO_TOOLCHAIN_DIR}
    ./hero_riscv32_toolchain_builder -dPj

    if [ $? -ne 0 ]; then
        echo "ERROR: build_riscv32_toolchain failed, aborting now."
        exit 1
    fi
}

build_pulp_sdk() {
    cd ${HERO_SDK_DIR}
    update_env

    cd ${HERO_PULP_SDK_DIR}
    source scripts/hero/setup.sh
    
    if [ $? -ne 0 ]; then
        echo "ERROR: build_pulp_sdk failed, aborting now."
        exit 1
    fi
}

build_arm_toolchain() {
    cd ${HERO_SDK_DIR}
    update_env

    # requires Linux kernel headers
    prepare_linux

    cd ${HERO_TOOLCHAIN_DIR}
    ./hero_arm_toolchain_builder -dPj

    if [ $? -ne 0 ]; then
        echo "ERROR: build_arm_toolchain failed, aborting now."
        exit 1
    fi
}

build_linux() {
    cd ${HERO_SDK_DIR}
    update_env

    prepare_linux

    # Build Linux (kernel, root filesystem, boot files, etc.)
    cd ${HERO_LINUX_WORKSPACE_DIR}
    ./build.sh

    if [ $? -ne 0 ]; then
        echo "ERROR: build_linux failed, aborting now."
        exit 1
    fi
}

build_offload() {
    cd ${HERO_SDK_DIR}
    update_env

    # Build the Linux kernel-level PULP driver
    cd ${HERO_SUPPORT_DIR}/drivers/pulp
    make clean build

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the Linux PULP driver failed, aborting now."
        exit 1
    fi

    # Build the PULP offload library
    cd ${HERO_SUPPORT_DIR}/libpulp
    make clean build

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the PULP library failed, aborting now."
        exit 1
    fi

    # Build the PULP UART reader
    cd ${HERO_SUPPORT_DIR}/apps/uart
    make clean build

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the PULP UART reader failed, aborting now."
        exit 1
    fi
}

build_hero_toolchain() {
    cd ${HERO_SDK_DIR}
    update_env

    cd ${HERO_TOOLCHAIN_DIR}
    ./hero_riscv32_toolchain_builder -gj
    if [ $? -ne 0 ]; then
        echo "ERROR: build_hero_toolchain failed for PULP, aborting now."
        exit 1
    fi

    ./hero_arm_toolchain_builder -gj
    if [ $? -ne 0 ]; then
        echo "ERROR: build_hero_toolchain failed for host, aborting now."
        exit 1
    fi

    # Build the HERO target library
    cd ${HERO_SDK_DIR}/libhero-target
    make clean header build
    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the HERO target library failed, aborting now."
        exit 1
    fi
}

install() {
    cd ${HERO_SDK_DIR}
    update_env

    if [[ -z "${HERO_TARGET_HOST}" ]]; then
        echo "ERROR: HERO target platform not defined, aborting now."
    fi

    TARGET=`echo ${HERO_TARGET_HOST} | rev | cut -d@ -f-1 | rev`
    ping ${TARGET} -c 1 > /dev/null
    if [ $? -ne 0 ]; then
        echo "ERROR: HERO target platform not online, aborting now."
    fi

    # Build and install the Linux kernel-level PULP driver
    cd ${HERO_SUPPORT_DIR}/drivers/pulp
    make clean all

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the Linux PULP driver failed, aborting now."
        exit 1
    fi

    # Build and install the PULP offload library
    cd ${HERO_SUPPORT_DIR}/libpulp
    make clean all

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the PULP library failed, aborting now."
        exit 1
    fi

    # Build and install the PULP UART reader
    cd ${HERO_SUPPORT_DIR}/apps/uart
    make clean all

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the PULP UART reader failed, aborting now."
        exit 1
    fi

    # Install the HERO toolchain
    cd ${HERO_TOOLCHAIN_DIR}
    scripts/./install_toolchain.sh

    if [ $? -ne 0 ]; then
        echo "ERROR: HERO toolchain installation failed, aborting now."
        exit 1
    fi

    # Build and install the HERO target library
    cd ${HERO_SDK_DIR}/libhero-target
    make clean all

    if [ $? -ne 0 ]; then
        echo "ERROR: Build of the HERO target library failed, aborting now."
        exit 1
    fi
}

# Usage info
show_help() {
cat << EOF
Usage: ${0##*/} [-hAsrpaloti]
HERO SDK builder
----------------------------------------------------

HERO toolchain commands
----------------------------------------------------

  -A : build whole HERO toolchain and its dependecies:
    > get sources
    > RISCV GCC standalone toolchain
    > PULP SDK
    > ARM GCC standalone toolchain
    > Linux
    > offload framework
    > HERO toolchain


Commands for building individual components
----------------------------------------------------

  -s : get sources
  -r : RISCV GCC standalone toolchain
  -p : PULP SDK
  -a : ARM GCC standalone toolchain
  -l : Linux
  -o : offload framework
  -t : HERO toolchain
  -i : install

EOF
}

# Setup the environment variables
update_env

do_get_sources=false
do_build_riscv32_toolchain=false
do_build_pulp_sdk=false
do_build_arm_toolchain=false
do_build_linux=false
do_build_offload=false
do_build_hero_toolchain=false
do_install=false

while getopts hAsrpaloti opt; do
    case $opt in

        A)
            do_get_sources=true
            do_build_riscv32_toolchain=true
            do_build_pulp_sdk=true
            do_build_arm_toolchain=true
            do_build_linux=true
            do_build_offload=true
            do_build_hero_toolchain=true
            ;;
        s)
            do_get_sources=true
            ;;
        r)
            do_build_riscv32_toolchain=true
            ;;
        p)
            do_build_pulp_sdk=true
            ;;
        a)
            do_build_arm_toolchain=true
            ;;
        l)
            do_build_linux=true
            ;;
        o)
            do_build_offload=true
            ;;
        t)
            do_build_hero_toolchain=true
            ;;
        i)
            do_install=true
            ;;
        h)
            show_help
            exit 0
            ;;
        *)
            show_help >&2
            exit 1
            ;;
    esac
done

if [ "$do_get_sources" = true ] ; then
    get_sources
fi

if [ "$do_build_riscv32_toolchain" = true ] ; then
    build_riscv32_toolchain
fi

if [ "$do_build_pulp_sdk" = true ] ; then
    build_pulp_sdk
fi

if [ "$do_build_arm_toolchain" = true ] ; then
    build_arm_toolchain
fi

if [ "$do_build_linux" = true ] ; then
    build_linux
fi

if [ "$do_build_offload" = true ] ; then
    build_offload
fi

if [ "$do_build_hero_toolchain" = true ] ; then
    build_hero_toolchain
fi

if [ "$do_install" = true ] ; then
    install
fi

# That's all folks!!