mongodb/etc/system_perf.yml

command_type: system
stepback: false
exec_timeout_secs: &exec_timeout_secs 21600
timeout_secs: &timeout_secs 7200

include:
  - filename: etc/evergreen_yml_components/definitions.yml
  - filename: etc/evergreen_yml_components/tasks/resmoke/server_divisions/durable_transactions_and_availability/tasks.yml
  - filename: etc/evergreen_yml_components/tasks/resmoke/server_divisions/query/tasks.yml
  - filename: etc/evergreen_yml_components/tasks/compile_tasks.yml
  - filename: etc/evergreen_yml_components/tasks/misc_tasks.yml
  - filename: etc/evergreen_yml_components/variants/misc/task_generation.yml
  - filename: etc/system_perf_yml_components/tasks.yml
  - filename: etc/system_perf_yml_components/variants.yml
  - filename: etc/system_perf_yml_components/variants_branching.yml

## Parameters for parameterized builds (see https://github.com/evergreen-ci/evergreen/wiki/Parameterized-Builds)
parameters:
  - key: patch_compile_flags
    description: "Additional SCons flags to be applied during scons compile invocations in this patch"
  # see https://github.com/10gen/performance-tooling-docs/blob/main/patch_testing.md#skipping-compilation-on-sys-perf-projects
  - key: reuse_compile_from
    description: "Version_id of the commit/patch to reuse the compile artifacts from, e.g., sys_perf_ef8504eefef4c9fe2062b8424e85053b3e1ad8d2"
  - key: exec_timeout_secs_override
    value: *exec_timeout_secs
    description: "Overrides the default exec_timeout_secs defined at the top of this file for the f_dsi_run_workload task"
  - key: timeout_secs_override
    value: *timeout_secs
    description: "Overrides the default timeout_secs defined at the top of this file for the f_dsi_run_workload task"

variables:
  _src_dir: &src_dir src/mongo
  _modules: &modules
    - dsi
    - genny
    - workloads
    - linkbench
    - linkbench2
    - tsbs
    - mongo-perf
    - YCSB
    - py-tpcc
    - PrivateWorkloads
    - flamegraph

  _schedule_variant_auto_tasks_task: &schedule_variant_auto_tasks_task
    name: schedule_variant_auto_tasks
    activate: false
    depends_on:
      - name: schedule_global_auto_tasks
        variant: task_generation

  _schedule_patch_auto_tasks_task: &schedule_patch_auto_tasks_task
    name: schedule_patch_auto_tasks
    activate: false
    depends_on:
      - name: schedule_global_auto_tasks
        variant: task_generation

  _shared_compile_expansions: &shared_compile_expansions
    platform: linux
    project_dir: dsi
    scons_cache_scope: shared
    scons_cache_mode: all
    has_packages: false

###
# Same in every DSI project. Ensure that this block is synchronized with
# evergreen-dsitest.yml, and src/dsi/onboarding.py (search update-repos-here)
# in the dsi repo, and etc/system_perf.yml in mongodb/mongo.
modules:
  - name: dsi
    owner: 10gen
    repo: dsi
    prefix: ${workdir}/src
    branch: master
  - name: genny
    owner: mongodb
    repo: genny
    prefix: ${workdir}/src
    branch: master
  - name: workloads
    owner: 10gen
    repo: workloads
    prefix: ${workdir}/src
    branch: master
  - name: linkbench
    owner: 10gen
    repo: linkbench
    prefix: ${workdir}/src
    branch: master
  - name: linkbench2
    owner: 10gen
    repo: linkbench2
    prefix: ${workdir}/src
    branch: master
  - name: tsbs
    owner: mongodb-forks
    repo: tsbs
    prefix: ${workdir}/src
    branch: main
  - name: mongo-perf
    owner: mongodb
    repo: mongo-perf
    prefix: ${workdir}/src
    branch: master
  - name: YCSB
    owner: mongodb-labs
    repo: YCSB
    prefix: ${workdir}/src
    branch: production
  - name: py-tpcc
    owner: mongodb-labs
    repo: py-tpcc
    prefix: ${workdir}/src
    branch: production
  - name: flamegraph
    owner: mongodb-forks
    repo: flamegraph
    prefix: ${workdir}/src
    branch: master
  - name: PrivateWorkloads
    owner: 10gen
    repo: PrivateWorkloads
    prefix: ${workdir}/src
    branch: production
###

###
# Same in every DSI project
pre:
  - func: "f_other_pre_ops"
  - func: "f_dsi_pre_run"
  - func: "get version expansions"
  - func: "apply version expansions"
post:
  - func: "f_dsi_post_run"
  - func: "f_other_post_ops"
timeout:
  - func: "f_dsi_timeout"
  - func: "f_other_timeout"
###

functions:
  ###
  # Same in every DSI project
  f_dsi_pre_run:
    - command: manifest.load
  f_dsi_post_run:
    - command: shell.exec
      params:
        script: ./src/dsi/run-dsi post_run
    - command: perf.send
      params:
        file: ./build/CedarReports/cedar_report.json
        aws_key: ${terraform_key}
        aws_secret: ${terraform_secret}
        bucket: genny-metrics
        region: us-east-1
        prefix: ${task_id}_${execution}
    - command: attach.results
      params:
        file_location: ./build/EvergreenResultsJson/results.json
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: ./build/Artifacts/DSIArtifacts.tgz
        remote_file: ${project_dir}/${build_variant}/${revision}/${task_id}/${version_id}/logs/dsi-artifacts-${task_name}-${build_id}-${execution}.tgz
        bucket: mciuploads
        permissions: public-read
        content_type: application/x-gzip
        display_name: DSI Artifacts - Execution ${execution}
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: ./build/Documentation/index.html
        remote_file: ${project_dir}/${build_variant}/${revision}/${task_id}/${version_id}/logs/${task_name}-${build_id}-index.html
        bucket: mciuploads
        permissions: public-read
        content_type: text/html
        display_name: Documentation
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: bootstrap.yml
        remote_file: ${project_dir}/${build_variant}/${revision}/${task_id}/${version_id}/bootstrap-${task_name}-${build_id}-${execution}.yml
        bucket: mciuploads
        permissions: public-read
        content_type: text/plain
        display_name: Task Bootstrap Config
  f_dsi_timeout:
    - command: shell.exec
      params:
        script: ./src/dsi/run-dsi on_timeout
  ###

  f_other_post_ops:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          # removes files from the (local) scons cache when it's over a
          # threshold, to the $prune_ratio percentage. Ideally override
          # these default values in the distro config in evergreen.

          if [ -d "${scons_cache_path}" ]; then
              /opt/mongodbtoolchain/v4/bin/python3 buildscripts/scons_cache_prune.py --cache-dir ${scons_cache_path} --cache-size ${scons_cache_size|200} --prune-ratio ${scons_prune_ratio|0.8}
          fi          
  f_other_pre_ops:
    - &f_other_pre_ops
      command: shell.exec
      params:
        silent: true
        script: |
          for PS in mongo{,d,s,import,export,dump,restore,stat,files,top,bridge} resmoke.py python{,2} lldb _test; do
              pkill -9 "$PS"
          done          
  f_other_timeout:
    # Can't be empty so just `echo`.
    - command: shell.exec
      params: {script: "echo"}

  f_generate_all_variant_auto_tasks:
    - command: git.get_project
      params:
        directory: *src_dir
        revisions:
          dsi: ${dsi_rev}
          genny: ${genny_rev}
          linkbench: ${linkbench_rev}
          linkbench2: ${linkbench2_rev}
          tsbs: ${tsbs_rev}
          workloads: ${workloads_rev}
          mongo-perf: ${mongo-perf_rev}
          YCSB: ${YCSB_rev}
          py-tpcc: ${py-tpcc_rev}
          PrivateWorkloads: ${PrivateWorkloads_rev}
    - command: expansions.write
      params:
        file: ./expansions.yml
    - command: shell.exec
      params:
        # The script below makes sure that if we generate all tasks in a patch, we will only generate
        # them and not run all of them, since activating all tasks is the default behavior for task
        # generation in a patch.
        script: |
          pushd ./src/mongo
          ~/evergreen evaluate ./etc/system_perf.yml > evaluated_project_configuration.yml
          popd
          if [ "${is_patch|false}" = "true" ]; then
            ./src/genny/run-genny auto-tasks-all --project-file ./src/mongo/evaluated_project_configuration.yml --no-activate
          else
            ./src/genny/run-genny auto-tasks-all --project-file ./src/mongo/evaluated_project_configuration.yml
          fi          
    - command: generate.tasks
      params:
        files:
          - build/TaskJSON/Tasks.json

  ###
  # Prepares the environment before compiling the binaries
  compile prep:
    # We create a virtual environment with the Python dependencies for compiling the server
    # installed.
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          mkdir -p mongodb/bin

          # This is copied from evergreen/functions/venv_setup.sh
          # Consider consolidating this in the future
          /opt/mongodbtoolchain/v4/bin/python3 -m venv "${workdir}/compile_venv"
          source "${workdir}/compile_venv/bin/activate"

          poetry_dir="${workdir}/poetry_dir"
          mkdir -p $poetry_dir
          export POETRY_CONFIG_DIR="$poetry_dir/config"
          export POETRY_DATA_DIR="$poetry_dir/data"
          export POETRY_CACHE_DIR="$poetry_dir/cache"
          python -m pip install "poetry==1.8.3"
          # See BF-29897 / https://github.com/python-poetry/poetry/issues/7584
          poetry config installer.max-workers 10
          # Trying poetry install due to https://github.com/python-poetry/poetry/issues/7611
          python -m poetry install --no-root --sync || python -m poetry install --no-root --sync          
    - command: expansions.write
      params:
        file: expansions.yml
        redacted: true
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          source "${workdir}/compile_venv/bin/activate"

          # We get the raw version string (r1.2.3-45-gabcdef) from git
          # And append "-sys-perf" at the end
          export MONGO_VERSION=$(git describe --abbrev=7)
          MONGO_VERSION="$MONGO_VERSION-sys-perf"

          # If this is a patch build, we add the patch version id to the version string so we know
          # this build was a patch, and which evergreen task it came from
          if [ "${is_patch|false}" = "true" ]; then
            MONGO_VERSION="$MONGO_VERSION-patch-${version_id}"
          fi

          # This script handles sanitizing the version string for use during SCons build
          # and when pushing artifacts up to S3.
          IS_PATCH=${is_patch|false} IS_COMMIT_QUEUE=${is_commit_queue|false} \
            buildscripts/generate_version_expansions.py --out version_expansions.yml          
    - command: expansions.update
      params:
        file: src/version_expansions.yml
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          # This script handles whether the SCons cache should be used
          source "${workdir}/compile_venv/bin/activate"
          SCONS_CACHE_MODE=${scons_cache_mode|} USE_SCONS_CACHE=${use_scons_cache|false} \
            IS_PATCH=${is_patch|false} IS_COMMIT_QUEUE=${is_commit_queue|false} \
            python buildscripts/generate_compile_expansions.py --out compile_expansions.yml          
    - command: expansions.update
      params:
        file: src/compile_expansions.yml
  get engflow creds perf:
    - command: s3.get
      display_name: "get engflow key"
      params:
        aws_key: ${engflow_key}
        aws_secret: ${engflow_secret}
        remote_file: engflow/engflow.key
        bucket: serverengflow
        local_file: "src/engflow.key"
        # Mark as optional to allow local-mode execution to succeed.
        optional: true
    - command: s3.get
      display_name: "get engflow cert"
      params:
        aws_key: ${engflow_key}
        aws_secret: ${engflow_secret}
        remote_file: engflow/engflow.cert
        bucket: serverengflow
        local_file: "src/engflow.cert"
        # Mark as optional to allow local-mode execution to succeed.
        optional: true
    - command: shell.exec
      params:
        display_name: "generate evergreen engflow bazelrc"
        shell: bash
        working_dir: src
        script: |
          set -o errexit
          set -o verbose

          # Pulled from evergreen/generate_evergreen_engflow_bazelrc.sh consider
          # consolidating once prelude.sh is runnable in the perf project.

          source ./evergreen/bazel_RBE_supported.sh

          # Use the Evergreen temp directory to avoid filling up the disk.
          mkdir -p $TMPDIR
          if [[ "$OSTYPE" == "cygwin" ]] || [[ "$OSTYPE" == "win32" ]]; then
            abs_path=$(cygpath -w "$TMPDIR" | tr '\\' '/')
            echo "startup --output_user_root=$abs_path/bazel-output-root" > .bazelrc.evergreen
            echo "BAZELISK_HOME=$abs_path/bazelisk_home" >> .bazeliskrc
          else
            echo "startup --output_user_root=$TMPDIR/bazel-output-root" > .bazelrc.evergreen
            echo "BAZELISK_HOME=$TMPDIR/bazelisk_home" >> .bazeliskrc
          fi

          if bazel_rbe_supported; then

            uri="https://spruce.mongodb.com/task/${task_id}?execution=${execution}"

            echo "build --tls_client_certificate=./engflow.cert" >> .bazelrc.evergreen
            echo "build --tls_client_key=./engflow.key" >> .bazelrc.evergreen
            echo "build --bes_keywords=engflow:CiCdPipelineName=${build_variant}" >> .bazelrc.evergreen
            echo "build --bes_keywords=engflow:CiCdJobName=${task_name}" >> .bazelrc.evergreen
            echo "build --bes_keywords=engflow:CiCdUri=$uri" >> .bazelrc.evergreen
            echo "build --bes_keywords=evg:project=${project}" >> .bazelrc.evergreen
            echo "build --workspace_status_command=./evergreen/engflow_workspace_status.sh" >> .bazelrc.evergreen
          fi          
    - command: expansions.write
      params:
        file: expansions.yml
        redacted: true
    - command: shell.exec
      params:
        working_dir: src
        script: |
          if [ -z "${reuse_compile_from}" ] || [ "${is_patch|false}" = "false" ]; then
            set -o errexit
            set -o verbose

            source "${workdir}/compile_venv/bin/activate"

            # We get the raw version string (r1.2.3-45-gabcdef) from git
            # And append "-sys-perf" at the end
            export MONGO_VERSION=$(git describe --abbrev=7)
            MONGO_VERSION="$MONGO_VERSION-sys-perf"

            # If this is a patch build, we add the patch version id to the version string so we know
            # this build was a patch, and which evergreen task it came from
            if [ "${is_patch|false}" = "true" ]; then
              MONGO_VERSION="$MONGO_VERSION-patch-${version_id}"
            fi

            # This script handles sanitizing the version string for use during SCons build
            # and when pushing artifacts up to S3.
            IS_PATCH=${is_patch|false} IS_COMMIT_QUEUE=${is_commit_queue|false} \
              buildscripts/generate_version_expansions.py --out version_expansions.yml
          else
            touch version_expansions.yml
          fi          
    - command: expansions.update
      params:
        file: src/version_expansions.yml
    - command: shell.exec
      params:
        working_dir: src
        script: |
          if [ -z "${reuse_compile_from}" ] || [ "${is_patch|false}" = "false" ]; then
            set -o errexit
            set -o verbose

            # This script handles whether the SCons cache should be used
            source "${workdir}/compile_venv/bin/activate"
            SCONS_CACHE_MODE=${scons_cache_mode|} USE_SCONS_CACHE=${use_scons_cache|false} \
              IS_PATCH=${is_patch|false} IS_COMMIT_QUEUE=${is_commit_queue|false} \
              python buildscripts/generate_compile_expansions.py --out compile_expansions.yml
          else
            touch compile_expansions.yml
          fi          
    - command: expansions.update
      params:
        file: src/compile_expansions.yml
  ###

  ###
  # Compile mongodb
  download mongo tools:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o verbose
          set -o errexit

          arch=$(uname -m)
          case $arch in
            "x86_64")
              if [ -f /etc/os-release ]; then
                . /etc/os-release
                if [ "$ID" == "amzn" ]; then
                  case $VERSION_ID in
                    "2")
                      binary_url="https://fastdl.mongodb.org/tools/db/mongodb-database-tools-amazon2-x86_64-100.9.4.tgz"
                      ;;
                    "2023")
                      binary_url="https://fastdl.mongodb.org/tools/db/mongodb-database-tools-amazon2023-x86_64-100.9.4.tgz"
                      ;;
                    *)
                      echo "Unsupported Amazon Linux version: $VERSION_ID"
                      exit 1
                      ;;
                  esac
                else
                  echo "Unsupported Linux distribution: $ID"
                  exit 1
                fi
              else
                echo "Unable to determine Linux distribution"
                exit 1
              fi
              ;;
            "aarch64")
              if [ -f /etc/os-release ]; then
                . /etc/os-release
                if [ "$ID" == "amzn" ]; then
                  case $VERSION_ID in
                    "2")
                      binary_url="https://fastdl.mongodb.org/tools/db/mongodb-database-tools-amazon2-aarch64-100.9.4.tgz"
                      ;;
                    "2023")
                      binary_url="https://fastdl.mongodb.org/tools/db/mongodb-database-tools-amazon2023-aarch64-100.9.4.tgz"
                      ;;
                    *)
                      echo "Unsupported Amazon Linux version: $VERSION_ID"
                      exit 1
                      ;;
                  esac
                else
                  echo "Unsupported Linux distribution: $ID"
                  exit 1
                fi
              else
                echo "Unable to determine Linux distribution"
                exit 1
              fi
              ;;
            *)
              echo "Unsupported architecture: $arch"
              exit 1
              ;;
          esac

          echo "Downloading and installing MongoDB tools..."
          sudo mkdir -p mongodb/
          wget "$binary_url" -O mongo-tools.tar.gz
          sudo tar -xzvf mongo-tools.tar.gz -C mongodb/ --strip-components=1 "mong*/bin"
          echo "MongoDB tools installed successfully!"          
  generate feature flag list:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose
          source "${workdir}/compile_venv/bin/activate"
          python ./buildscripts/idl/gen_all_feature_flag_list.py
          mkdir -p mongodb/feature_flags
          cp ./all_feature_flags.txt mongodb/feature_flags          
  generate server params list:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose
          source "${workdir}/compile_venv/bin/activate"
          python ./buildscripts/idl/gen_all_server_params_list.py
          mkdir -p mongodb/server_params
          cp ./all_server_params.txt mongodb/server_params          
  compile mongodb:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          if [ -z "${reuse_compile_from}" ] || [ "${is_patch|false}" = "false" ]; then
            set -o errexit
            set -o verbose
            source "${workdir}/compile_venv/bin/activate"
            python ./buildscripts/scons.py ${compile_flags|} ${scons_cache_args|} $extra_args install-core install-jstestshell SPLIT_DWARF=0 MONGO_VERSION=${version} DESTDIR=$(pwd)/mongodb ${patch_compile_flags|}
          fi          
  download mongodb:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose
          wget --quiet https://s3.amazonaws.com/mciuploads/${project}/${compile_variant}/${version_id}/binaries/mongo-${revision_order_id}.${ext|tgz}
          tar -xvf mongo-${revision_order_id}.${ext|tgz}
          mv ./dist-test/bin/mongo mongodb/bin
          mv ./dist-test/bin/mongos mongodb/bin
          mv ./dist-test/bin/mongod mongodb/bin
          mv ./dist-test/bin/mongocryptd mongodb/bin
          # Copy libs folder if it exists
          [ ! -d ./dist-test/lib ] || mv ./dist-test/lib mongodb          
  download jstests:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose
          mkdir -p mongodb/jstests/hooks
          if [ -d jstests/hooks ]
          then
            echo "Fetching JS test DB correctness checks from directory jstests"
            cp -a jstests/* mongodb/jstests

            echo "Now adding our own special run_validate_collections.js wrapper"
            mv mongodb/jstests/hooks/run_validate_collections.js mongodb/jstests/hooks/run_validate_collections.actual.js

            cat << EOF > mongodb/jstests/hooks/run_validate_collections.js
            print("NOTE: run_validate_collections.js will skip the oplog!");
            TestData = { skipValidationNamespaces: ['local.oplog.rs'] };
            await import("jstests/hooks/run_validate_collections.actual.js");
          EOF
          fi          
  download buildscripts:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          set -o errexit
          set -o verbose
          mkdir -p mongodb/buildscripts
          cp -a buildscripts/* mongodb/buildscripts          
  package binary:
    - command: shell.exec
      params:
        working_dir: src
        script: |
          tar czf mongodb${compile_variant|}.tar.gz mongodb          
  upload binary:
    - command: s3.put
      params:
        aws_key: ${aws_key}
        aws_secret: ${aws_secret}
        local_file: src/mongodb${compile_variant|}.tar.gz
        remote_file: ${project_dir}/${version_id}/${revision}/${platform}/mongodb${compile_variant|}-${version_id}.tar.gz
        bucket: mciuploads
        permissions: public-read
        content_type: ${content_type|application/x-gzip}
        display_name: mongodb${compile_variant|}.tar.gz

tasks:
  - name: package_new_compile
    commands:
      - command: manifest.load
      - command: git.get_project
        params:
          directory: src
      - func: "compile prep"
      - func: "get engflow creds perf"
      - func: "download mongo tools"
      - func: "generate feature flag list"
      - func: "generate server params list"
      - func: "download mongodb"
      - func: "download jstests"
      - func: "download buildscripts"
      - func: "package binary"
      - func: "upload binary"

buildvariants:
  - name: task_generation
    display_name: " * Task Generation"
    cron: "0 0 1 1 *" # Every year starting 1/1 at 00:00
    modules: *modules
    run_on:
      - amazon2-build
    tasks:
      - name: generate_all_variant_auto_tasks
        activate: true
      - name: schedule_global_auto_tasks

  - name: amazon2-x86-compile
    display_name: "* Compile for Amazon Linux 2 x86"
    expansions:
      <<: *shared_compile_expansions
      compile_variant: amazon2-x86-compile
      compile_flags: >-
        --ssl
        MONGO_DISTMOD=amazon2
        -j$(grep -c ^processor /proc/cpuinfo)
        --release
        --variables-files=etc/scons/mongodbtoolchain_stable_gcc.vars        
    run_on:
      - amazon2-xlarge
    tasks:
      - name: compile_and_package_serial_no_unittests_TG
      - name: package_new_compile
        depends_on:
          - name: archive_dist_test
            variant: amazon2-x86-compile

  - name: amazon2-arm64-compile
    display_name: "* Compile for Amazon Linux 2 arm64"
    expansions:
      <<: *shared_compile_expansions
      compile_variant: amazon2-arm64-compile
      compile_flags: >-
        --ssl
        MONGO_DISTMOD=amazon2
        -j$(grep -c ^processor /proc/cpuinfo)
        --release
        --variables-files=etc/scons/mongodbtoolchain_stable_gcc.vars        
    run_on:
      - amazon2-arm64-xlarge
    tasks:
      - name: compile_and_package_serial_no_unittests_TG
      - name: package_new_compile
        depends_on:
          - name: archive_dist_test
            variant: amazon2-arm64-compile

  - name: amazon2-arm64-mongocrypt-shlib-compile
    display_name: "* Compile mongo_crypt_v1.so for Amazon Linux 2 arm64"
    modules: *modules
    cron: "0 0 * * 4" # 00:00 on Thursday
    tags: ["bazel_check"]
    expansions:
      <<: *shared_compile_expansions
      compile_variant: amazon2-arm64-compile
      use_scons_cache: true
      compile_flags: >-
        --separate-debug
        MONGO_DISTMOD=amazon2
        -j$(grep -c ^processor /proc/cpuinfo)
        --release
        --variables-files=etc/scons/mongodbtoolchain_stable_gcc.vars
        --use-diagnostic-latches=off
        --allocator=system
        --enterprise-features=fle
        --js-engine=none
        --link-model=dynamic-sdk
        --enable-http-client=off
        --ssl=off
        SHLINKFLAGS_EXTRA="-Wl,-Bsymbolic -Wl,--no-gnu-unique"
        CCFLAGS="-fno-gnu-unique"        
    run_on:
      - amazon2-arm64-xlarge
    tasks:
      - name: .crypt

  - name: amazon2-x86-streams-compile
    display_name: "* Compile Streams for Amazon Linux 2 x86"
    expansions:
      <<: *shared_compile_expansions
      compile_variant: amazon2-x86-streams-compile
      compile_flags: >-
        --ssl
        MONGO_DISTMOD=amazon2
        -j$(grep -c ^processor /proc/cpuinfo)
        --release
        --variables-files=etc/scons/mongodbtoolchain_stable_gcc.vars
        --streams-release-build        
    run_on:
      - amazon2-xlarge
    tasks:
      - name: compile_and_package_serial_no_unittests_TG
      - name: package_new_compile
        depends_on:
          - name: archive_dist_test
            variant: amazon2-x86-streams-compile

  # This variant tests the reuse_compile_from feature
  # by reusing compile artifacts from another compile
  # in the same patch.
  - name: test-reuse-compile-from
    display_name: "~ Test reuse_compile_from"
    cron: "0 0 * * *" # Every day at 00:00
    expansions:
      <<: *shared_compile_expansions
      compile_variant: amazon2-arm64-compile
      reuse_compile_from: ${version_id}
      compile_flags: >-
        --ssl
        MONGO_DISTMOD=amazon2
        -j$(grep -c ^processor /proc/cpuinfo)
        --release
        --variables-files=etc/scons/mongodbtoolchain_stable_gcc.vars        
    run_on:
      - amazon2-arm64-xlarge
    tasks:
      - name: compile_and_package_serial_no_unittests_TG
        depends_on:
          - name: archive_dist_test
            variant: amazon2-arm64-compile
          - name: archive_dist_test_debug
            variant: amazon2-arm64-compile