Consider consolidating conda solves in CI tests

[charlesbluca]

Currently (using cuML as an example here), the conda test environment initialization for most CI jobs looks something like creating the test environment:

rapids-dependency-file-generator \
  --output conda \
  --file_key test_python \
  --matrix "cuda=${RAPIDS_CUDA_VERSION%.*};arch=$(arch);py=${RAPIDS_PY_VERSION}" | tee env.yaml

rapids-mamba-retry env create --force -f env.yaml -n test

And then downloading and installing build artifacts from previous jobs on top of this environment:

CPP_CHANNEL=$(rapids-download-conda-from-s3 cpp)
PYTHON_CHANNEL=$(rapids-download-conda-from-s3 python)

...

rapids-mamba-retry install \
  --channel "${CPP_CHANNEL}" \
  --channel "${PYTHON_CHANNEL}" \
  libcuml cuml

In addition to forcing us to eat the cost of a second conda environment solve, in many cases this can cause some pretty drastic changes to the environment which can be blocking - for example, consider this cuML run which fails because conda is unable to solve a downgrade from Arrow 15.0.0 (build 5) to 14.0.1.

Our current workaround for this is to manually add pinnings to the testing dependencies initially solved such that the artifact installation can be solved, but this can introduce a lot of burden in needing to:

• identify what packages/changes are blocking artifact installation
• open PR(s) modifying the impacted repos
• follow up on each impacted repo to potentially remove the pinning later on

Would it be possible to consolidate some (or all) of these conda environment solves by instead:

1. downloading the conda artifacts before creating the environment
2. updating the dependencies.yaml (or, if this isn't possible, the generated conda environment file) to include the desired packages, making sure to explicitly specify source channel to ensure we're picking up the build artifacts
3. creating the environment with this patched file

In my mind, the main blocker I could see to this working would be if rapids-download-conda-from-s3 requires some conda packages contained in the testing environment to work.

EDIT: Updating to capture state of other projects:

• rmm(https://github.com/rapidsai/rmm/pull/<YOUR_PR_HERE>)
• raft(https://github.com/rapidsai/raft/pull/<YOUR_PR_HERE>)
• cudf(https://github.com/rapidsai/cudf/pull/<YOUR_PR_HERE>)
• kvikio(https://github.com/rapidsai/kvikio/pull/<YOUR_PR_HERE>)
• cuml(Install test dependencies at the same time as cuml packages. cuml#5781)
• cucim (https://github.com/rapidsai/cucim/pull/<YOUR_PR_HERE>)
• cugraph(https://github.com/rapidsai/cugraph/pull/<YOUR_PR_HERE>)
• cugraph-ops(https://github.com/rapidsai/cugraph-ops/pull/<YOUR_PR_HERE>)
• cumlprims_mg(https://github.com/rapidsai/cumlprims_mg/pull/<YOUR_PR_HERE>)
• cuspatial(create conda ci test env in one step cuspatial#1387)
• cuvs(https://github.com/rapidsai/cuvs/pull/<YOUR_PR_HERE>)
• cuxfilter(https://github.com/rapidsai/cuxfilter/pull/<YOUR_PR_HERE>)
• dask-cuda(https://github.com/rapidsai/dask-cuda/pull/<YOUR_PR_HERE>)
• rapids-cmake(https://github.com/rapidsai/rapids-cmake/pull/<YOUR_PR_HERE>)
• rapids-dask-dependency(https://github.com/rapidsai/rapids-dask-dependency/pull/<YOUR_PR_HERE>)
• ucx-py(https://github.com/rapidsai/ucx-py/pull/<YOUR_PR_HERE>)
• ucxx(https://github.com/rapidsai/ucxx/pull/<YOUR_PR_HERE>)
• wholegraph(https://github.com/rapidsai/wholegraph/pull/<YOUR_PR_HERE>)

[msarahan]

I don't fully understand how much you need to be rebuilding, but if the answer is "not much" then maybe you could use https://conda.github.io/conda-pack/ or consider building a docker image instead of re-creating the environment each time?

[bdice]

I am proposing a flag --prepend-channels for rapids-dependency-file-generator that will enable a one-step conda environment creation. This would let us use local channels with CI artifacts and would eliminate the second conda solve used to install CI artifacts. rapidsai/dependency-file-generator#67

[bdice]

consider building a docker image instead of re-creating the environment each time?

This is a possible solution, but we'd need to maintain a separate Docker image for every repository and every test matrix configuration (e.g. a container containing the cuDF Python test environment on ARM using Python 3.9 and CUDA 12.2). I don't think we have the infrastructure to manage that while also ensuring that the conda environments are regularly updated (every night?) for all the possible containers so that we are aware of upstream changes that affect us. The workflows we have today would require an explosively large number of large containers (many of the containers would need to contain an entire CTK installed by conda).

This would also still require us to have a conda environment in that container that is compatible with the CI artifacts that we are installing. This doesn't avoid the "can't downgrade Arrow 15" problem because we must install the CI artifacts (conda packages built from the current PR) into the container.

[raydouglass]

The docker repo suffers from a similar problem and it was (partly) mitigated by dynamically editing the environment file: https://github.com/rapidsai/docker/blob/branch-24.04/context/notebooks.sh#L31, so just throwing that out there.

[vyasr]

Once rapidsai/cuml#5781 is merged, do we plan to roll out the same changes to the rest of RAPIDS? IIUC that's what it would take to close this issue.

[jakirkham]

Seems reasonable

We may want ensure that we are always getting cached CI packages too, which would close out issue: #14

[bdice]

@vyasr Yes, my plan is to convert all of RAPIDS to this single-solve approach.

@jakirkham The approach I'm taking in rapidsai/cuml#5781 will pin the major.minor versions of the packages as shown below. That isn't a full solution for #14 because nightlies of the same major.minor could still be selected, but it should help constrain the solver and reduce the likelihood of problems. If you have further suggestions please weigh in on #14 or on that cuML PR (if the code suggestions are small) and I'll adopt your proposals in a follow-up change.

  test_libcuml:
    common:
      - output_types: conda
        packages:
          - libcuml==24.4.*
          - libcuml-tests==24.4.*
  test_cuml:
    common:
      - output_types: conda
        packages:
          - libcuml==24.4.*
          - cuml==24.4.*

[jakirkham]

Ok it sounds like that is mostly an issue when we are getting close to (or in the midst of) a release. Is that right?

Agree that could be an issue, but that is a much smaller issue than picking up the prior release (especially well after it went out)

[bdice]

Yeah, I think the problematic case would be something like changing the dependencies of a package in a way that the conda packages from CI artifacts are not compatible with the rest of the testing environment, and the solver chooses recent nightlies instead of the PR artifacts. @charlesbluca proposed we could pin the exact channels like ${CPP_CHANNEL}::libcuml but we'd have to find a way to insert that channel information into the package's data in dependencies.yaml since the channel (a local filepath) isn't known ahead of time.

[vyasr]

An additional minor benefit is that this will speed up CI by reducing the number of solves.

[bdice]

An additional minor benefit is that this will speed up CI by reducing the number of solves.

This might not have a large impact on CI runtime. See rapidsai/cudf#15201 (comment). tl;dr, test startup time is dominated by network activity (downloading multiple GB of packages from RAPIDS and CTK dependencies) and the potential conda solve time savings are comparatively small.

[msarahan]

Taking this on with high priority because cuspatial CI is blocked, and this might help there.

[bdice]

@msarahan Is there a plan to continue on this work? We have implemented it for cuml and cuspatial but nothing else. It would be good to have alignment across RAPIDS to prevent future issues.

[msarahan]

Added task list to parent issue. We'll work on this as time allows.