Skip to content

Use static linking for fuzz coverage CI targets#39612

Merged
yanavlasov merged 1 commit intoenvoyproxy:mainfrom
krinkinmu:use-static-linking-for-fuzz
May 23, 2025
Merged

Use static linking for fuzz coverage CI targets#39612
yanavlasov merged 1 commit intoenvoyproxy:mainfrom
krinkinmu:use-static-linking-for-fuzz

Conversation

@krinkinmu
Copy link
Copy Markdown
Contributor

Commit Message:

Static linking helps to work around the issue with LLVM/Clang source-based coverage (see llvm/llvm-project#32849). On the flip side, the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed the switch for the fuzz coverage because fuzz coverage hit RBE backend resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

  1. We switched coverage runs from Google RBE backend to EngFlow which allows for somewhat larger workers
  2. We started building fuzz targets without WASM - there are not fuzz targets that actually need a full WASM runtime and elimnating it speeds things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to static linking for all coverage tests. It also has a benefit of better cache re-use since we will be linking both coverage and fuzz coverage targets statically.

Additional Description:

#39030 provides some context for EngFlow migration and #39248 is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
   allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
   targets that actually need a full WASM runtime and elimnating it
   speeds things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch
to static linking for all coverage tests. It also has a benefit of
better cache re-use since we will be linking both coverage and fuzz
coverage targets statically.

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
@repokitteh-read-only
Copy link
Copy Markdown

As a reminder, PRs marked as draft will not be automatically assigned reviewers,
or be handled by maintainer-oncall triage.

Please mark your PR as ready when you want it to be reviewed!

🐱

Caused by: #39612 was opened by krinkinmu.

see: more, trace.

@krinkinmu krinkinmu marked this pull request as ready for review May 23, 2025 17:34
@yanavlasov yanavlasov merged commit db9a6f2 into envoyproxy:main May 23, 2025
24 checks passed
phlax pushed a commit to phlax/envoy that referenced this pull request Jun 11, 2025
Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
targets that actually need a full WASM runtime and elimnating it speeds
things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to
static linking for all coverage tests. It also has a benefit of better
cache re-use since we will be linking both coverage and fuzz coverage
targets statically.

Additional Description:

envoyproxy#39030 provides some context for
EngFlow migration and envoyproxy#39248
is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
phlax pushed a commit to phlax/envoy that referenced this pull request Jun 11, 2025
Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
targets that actually need a full WASM runtime and elimnating it speeds
things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to
static linking for all coverage tests. It also has a benefit of better
cache re-use since we will be linking both coverage and fuzz coverage
targets statically.

Additional Description:

envoyproxy#39030 provides some context for
EngFlow migration and envoyproxy#39248
is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
Signed-off-by: Ryan Northey <ryan@synca.io>
phlax pushed a commit to phlax/envoy that referenced this pull request Jun 11, 2025
Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
targets that actually need a full WASM runtime and elimnating it speeds
things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to
static linking for all coverage tests. It also has a benefit of better
cache re-use since we will be linking both coverage and fuzz coverage
targets statically.

Additional Description:

envoyproxy#39030 provides some context for
EngFlow migration and envoyproxy#39248
is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
Signed-off-by: Ryan Northey <ryan@synca.io>
phlax pushed a commit that referenced this pull request Jun 11, 2025
Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
targets that actually need a full WASM runtime and elimnating it speeds
things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to
static linking for all coverage tests. It also has a benefit of better
cache re-use since we will be linking both coverage and fuzz coverage
targets statically.

Additional Description:

#39030 provides some context for
EngFlow migration and #39248
is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
Signed-off-by: Ryan Northey <ryan@synca.io>
phlax pushed a commit to phlax/envoy that referenced this pull request Jun 11, 2025
Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
targets that actually need a full WASM runtime and elimnating it speeds
things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to
static linking for all coverage tests. It also has a benefit of better
cache re-use since we will be linking both coverage and fuzz coverage
targets statically.

Additional Description:

envoyproxy#39030 provides some context for
EngFlow migration and envoyproxy#39248
is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
phlax pushed a commit to phlax/envoy that referenced this pull request Jun 11, 2025
Static linking helps to work around the issue with LLVM/Clang
source-based coverage (see llvm/llvm-project#32849). On the flip side,
the coverage build and test run will take a bit longer with this change.

We already did this change for the regular test coverage, but we delayed
the switch for the fuzz coverage because fuzz coverage hit RBE backend
resource constraints and was OOMing during linking.

Since then we did a few things to mitigate the issue with resources:

1. We switched coverage runs from Google RBE backend to EngFlow which
allows for somewhat larger workers
2. We started building fuzz targets without WASM - there are not fuzz
targets that actually need a full WASM runtime and elimnating it speeds
things up and reduces the footprint noticably.

With the above two changes I think we are ready to completely switch to
static linking for all coverage tests. It also has a benefit of better
cache re-use since we will be linking both coverage and fuzz coverage
targets statically.

Additional Description:

envoyproxy#39030 provides some context for
EngFlow migration and envoyproxy#39248
is a tracking bug.

Risk Level: low
Testing: regular CI tests
Docs Changes: n/a
Release Notes: n/a
Platform Specific Features: n/a

Signed-off-by: Mikhail Krinkin <mkrinkin@microsoft.com>
Signed-off-by: Ryan Northey <ryan@synca.io>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants