Skipping CI for Draft Pull Request.
If you want CI signal for your change, please convert it to an actual PR.
You can still manually trigger a test run with /test all

Does this have a significant benefit?
Do you have a benchmark result?

I don't have benchmarks for this case (and it may depend where these packages are used); I know both @kolyshkin and @tonistiigi have looked at use of regexp.MustCompile in library code in various projects, as they tended to bring additional overhead even when not used; some related discussions with some examples;

• link: do not use regexp pkg cilium/ebpf#642 (comment)
• Remove regexp use docker/go-units#40 (comment)
• use sync.OnceValue for various regular expressions distribution/reference#15 (comment)
• use sync.OnceValue for various regular expressions distribution/reference#15 (comment)

@AkihiroSuda OK; did some rudimentary comparisons based on just the github.com/containerd/containerd/v2 packages (I didn't compare (clock) time, as it fluctuated too much);

• ctr; -16576 bytes (-9.85%), -202 allocations (-34.47%)
• containerd; -18616 bytes (-10.98%), -154 allocations (-6.15%)
• containerd-shim-runc-v2; -5040 bytes (-77.68%), -70 allocations (-76.92%)

For those, I ran (e.g.);

Before:

GODEBUG=inittrace=1 containerd-shim-runc-v2 --version 2>&1 | grep github.com/containerd/containerd/v2
init github.com/containerd/containerd/v2/version @0.48 ms, 0.043 ms clock, 0 bytes, 0 allocs
init github.com/containerd/containerd/v2/pkg/identifiers @3.6 ms, 0.063 ms clock, 5184 bytes, 73 allocs
init github.com/containerd/containerd/v2/pkg/protobuf @4.2 ms, 0.007 ms clock, 128 bytes, 3 allocs
init github.com/containerd/containerd/v2/core/mount @4.7 ms, 0.001 ms clock, 0 bytes, 0 allocs
init github.com/containerd/containerd/v2/pkg/sys/reaper @4.7 ms, 0 ms clock, 48 bytes, 1 allocs
init github.com/containerd/containerd/v2/core/runtime @4.8 ms, 0.007 ms clock, 992 bytes, 11 allocs
init github.com/containerd/containerd/v2/cmd/containerd-shim-runc-v2/task/plugin @4.8 ms, 0.001 ms clock, 136 bytes, 3 allocs

After:

GODEBUG=inittrace=1 containerd-shim-runc-v2 --version 2>&1 | grep github.com/containerd/containerd/v2
init github.com/containerd/containerd/v2/version @0.30 ms, 0.004 ms clock, 0 bytes, 0 allocs
init github.com/containerd/containerd/v2/internal/lazyregexp @2.1 ms, 0 ms clock, 0 bytes, 0 allocs
init github.com/containerd/containerd/v2/pkg/identifiers @2.1 ms, 0.001 ms clock, 144 bytes, 3 allocs
init github.com/containerd/containerd/v2/pkg/protobuf @2.8 ms, 0.006 ms clock, 128 bytes, 3 allocs
init github.com/containerd/containerd/v2/core/mount @3.3 ms, 0.001 ms clock, 0 bytes, 0 allocs
init github.com/containerd/containerd/v2/pkg/sys/reaper @3.3 ms, 0 ms clock, 48 bytes, 1 allocs
init github.com/containerd/containerd/v2/core/runtime @3.4 ms, 0.006 ms clock, 992 bytes, 11 allocs
init github.com/containerd/containerd/v2/cmd/containerd-shim-runc-v2/task/plugin @3.5 ms, 0.001 ms clock, 136 bytes, 3 allocs

It might make sense to drop the use of regexp altogether at least in some cases.

Regexp is good to have when the pattern can be different (for example, supplied from config). It can be useful when the parsing logic is very complex.

In other cases (relatively simple pattern which won't change) it's better to reimplement the logic.

For example, here is Validate from pkg/indentifiers which don't use regexp, mostly written by Claude. It's faster, cleaner, and the logic is easy to follow:

func Validate(s string) error {
	if len(s) == 0 {
		return fmt.Errorf("identifier must not be empty: %w", errdefs.ErrInvalidArgument)
	}

	if len(s) > maxLength {
		return fmt.Errorf("identifier %q greater than maximum length (%d characters): %w", s, maxLength, errdefs.ErrInvalidArgument)
	}

	// Must start with alphanumeric character.
	if !isAlphaNum(s[0]) {
		return fmt.Errorf("identifier %q must begin with alphanumeric character: %w", s, errdefs.ErrInvalidArgument)
	}

	// Now check the pattern: alphanumeric followed by optional (separator + alphanumeric).
	i := 0
	// Parse first alphanumeric segment.
	for i < len(s) && isAlphaNum(s[i]) {
		i++
	}

	// Now we should have alternating separator and alphanumeric segments.
	for i < len(s) {
		// Must be a separator.
		if !isSep(s[i]) {
			return fmt.Errorf("identifier %q must match pattern of alphanumeric segments separated by '.', '_', or '-': %w", s, errdefs.ErrInvalidArgument)
		}
		i++

		// Separator must be followed by at least one alphanumeric.
		if i >= len(s) || !isAlphaNum(s[i]) {
			return fmt.Errorf("identifier %q must have alphanumeric characters after each separator: %w", s, errdefs.ErrInvalidArgument)
		}

		// Parse alphanumeric segment.
		for i < len(s) && isAlphaNum(s[i]) {
			i++
		}
	}

	return nil
}

func isAlphaNum(c byte) bool {
	return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')
}

func isSep(c byte) bool {
	return c == '.' || c == '_' || c == '-'
}

Can you rebase to pick up the CI fixes

rebased 👍

@kolyshkin thanks! Yes, I think rewriting some of these could make sense. I did this one as I had done this approach in some of the other repositories, and it at least addresses the immediate issue, but yeah, sometimes regexes have been used a bit too early. I might spend some time on those on a rainy afternoon

Looks good, can you squash the package updates into a single commit

done; let me know if this is what you meant

/retest

all green again 👍