cmd/go: remote build cache #42785
Comments
cagedmantis
added
the
NeedsInvestigation
|
Some prior art: Bazel supports remote caching over both HTTP and gRPC based protocols. Some of the folks that worked on Bazel RBE prototyped this in the Implementing remote caching and execution adds a lot of complexity to the |
|
I'd love to get the speed up for caching tests since were we spend alot of time. Is there a way to identify test cache results so we could slurp them up GOCACHE and then lay them back down before the next clean build? (maybe storing/retrieviing at git commit). Having a seperate GO_TEST_CACHE might also make this pretty feasible. |
|
@jayconrod - is there a public reference to the design and the attempt done by the RBE people? I wonder if we can still utilize remote cache for CI builds done on ephemeral machines. For organizations working in monorepo and cloud-based CI this could be a real game-changer (given that the org does not want to adopt Bazel). Is there a way to plugin to go cache so we can replace its implementation with some custom code? That would allow us to offer remote caching implementation while keeping the code of go slim and lean. |
|
I'd also be interested in plugging into Go's caching. https://github.com/firebuild/firebuild implements a generic process cache working with a many compilers and reproducible commands, but not Go, because Go's build insists on using its internal caching. |
|
See the proposal at #59719, which pulls most of the work out of cmd/go. |
What version of Go are you using (
go version)?What are you suggesting?
Go's build cache (GOCACHE) provides a hash-driven mechanism for storing intermediate compilation results. This hash takes into consideration a number of different variables (including Go versions, architecture, flags, paths, etc). As such, it should be possible to share the cache across different concurrent build jobs (both for developers and CI jobs).
There are a lot of different ways to share thousands of small files across machines, but for most people this will involve NFS (AWS EFS, GCP Filestore, etc). NFS is suboptimal for this use case (provisioning IO throughput across many machines is problematic, builds should not be punished for NFS outages, file interactions need to be atomic, metadata (stat) lookups are rarely cached, etc, etc).
Instead, this is a proposal to support URLs in GOCACHE. This would allow CI servers to have a simple, central HTTP server which would accept GETs for cache lookups and PUT/POST for cache writes. For distributed systems, local proxies off the central HTTP server would provide an additional speedup.
Why would it be valuable?
As anyone who has had to interact with NFS in their career would agree, this is a much simpler configuration than trying to mount a shared filesystem.
This would also lead to the possibility of using memcache/etc URLs in the future.
What are you looking for?
What is the process to officially propose this idea and have it accepted? If it was accepted, I would like some design constraints. I could take it from there and put together a prototype.
The text was updated successfully, but these errors were encountered: