Only use partial compile on eng builds (768b00f9) · Commits · e / os / android_build_soong

android/config.go

+24 −13

Original line number	Diff line number	Diff line
		@@ -413,18 +413,21 @@ type jsonConfigurable interface {
		// To add a new feature to the list, add the field in the struct
		// `partialCompileFlags` above, and then add the name of the field in the
		// switch statement below.
		func (c *config) parsePartialCompileFlags() (partialCompileFlags, error) {
		defaultFlags := partialCompileFlags{
		var defaultPartialCompileFlags = partialCompileFlags{
		// Set any opt-out flags here. Opt-in flags are off by default.
		enabled: false,
		}
		value := c.Getenv("SOONG_PARTIAL_COMPILE")

		func (c *config) parsePartialCompileFlags(isEngBuild bool) (partialCompileFlags, error) {
		value := c.Getenv("SOONG_PARTIAL_COMPILE")
		if !isEngBuild {
		return partialCompileFlags{}, nil
		}
		if value == "" {
		return defaultFlags, nil
		return defaultPartialCompileFlags, nil
		}

		ret := defaultFlags
		ret := defaultPartialCompileFlags
		tokens := strings.Split(strings.ToLower(value), ",")
		makeVal := func(state string, defaultValue bool) bool {
		switch state {
		@@ -455,17 +458,17 @@ func (c *config) parsePartialCompileFlags() (partialCompileFlags, error) {
		}
		switch tok {
		case "true":
		ret = defaultFlags
		ret = defaultPartialCompileFlags
		ret.enabled = true
		case "false":
		// Set everything to false.
		ret = partialCompileFlags{}
		case "enabled":
		ret.enabled = makeVal(state, defaultFlags.enabled)
		ret.enabled = makeVal(state, defaultPartialCompileFlags.enabled)
		case "use_d8":
		ret.use_d8 = makeVal(state, defaultFlags.use_d8)
		ret.use_d8 = makeVal(state, defaultPartialCompileFlags.use_d8)
		default:
		return partialCompileFlags{}, fmt.Errorf("Unknown SOONG_PARTIAL_COMPILE value: %v", value)
		return partialCompileFlags{}, fmt.Errorf("Unknown SOONG_PARTIAL_COMPILE value: %v", tok)
		}
		}
		return ret, nil
		@@ -616,6 +619,14 @@ func NewConfig(cmdArgs CmdArgs, availableEnv map[string]string) (Config, error)

		buildFromSourceStub: cmdArgs.BuildFromSourceStub,
		}
		variant, ok := os.LookupEnv("TARGET_BUILD_VARIANT")
		isEngBuild := !ok \|\| variant == "eng"

		if isEngBuild {
		// Partial Compile is only supported on eng builds.
		config.env["SOONG_PARTIAL_COMPILE"] = "false"
		config.env["SOONG_USE_PARTIAL_COMPILE"] = ""
		}

		config.deviceConfig = &deviceConfig{
		config: config,
		@@ -657,7 +668,7 @@ func NewConfig(cmdArgs CmdArgs, availableEnv map[string]string) (Config, error)
		return Config{}, err
		}

		config.partialCompileFlags, err = config.parsePartialCompileFlags()
		config.partialCompileFlags, err = config.parsePartialCompileFlags(isEngBuild)
		if err != nil {
		return Config{}, err
		}

android/config_test.go

+45 −0

Original line number	Diff line number	Diff line
		@@ -212,3 +212,48 @@ func TestConfiguredJarList(t *testing.T) {
		assertStringEquals(t, "apex1:jarA", list5.String())
		})
		}

		func (p partialCompileFlags) updateEnabled(value bool) partialCompileFlags {
		p.enabled = value
		return p
		}

		func (p partialCompileFlags) updateUseD8(value bool) partialCompileFlags {
		p.use_d8 = value
		return p
		}

		func TestPartialCompile(t *testing.T) {
		mockConfig := func(value string) *config {
		c := &config{
		env: map[string]string{
		"SOONG_PARTIAL_COMPILE": value,
		},
		}
		return c
		}
		tests := []struct {
		value string
		isEngBuild bool
		expected partialCompileFlags
		}{
		{"", true, defaultPartialCompileFlags},
		{"false", true, partialCompileFlags{}},
		{"true", true, defaultPartialCompileFlags.updateEnabled(true)},
		{"true", false, partialCompileFlags{}},
		{"true,use_d8", true, defaultPartialCompileFlags.updateEnabled(true).updateUseD8(true)},
		{"true,-use_d8", true, defaultPartialCompileFlags.updateEnabled(true).updateUseD8(false)},
		{"use_d8,false", true, partialCompileFlags{}},
		{"false,+use_d8", true, partialCompileFlags{}.updateUseD8(true)},
		}

		for _, test := range tests {
		t.Run(test.value, func(t *testing.T) {
		config := mockConfig(test.value)
		flags, _ := config.parsePartialCompileFlags(test.isEngBuild)
		if flags != test.expected {
		t.Errorf("expected %v found %v", test.expected, flags)
		}
		})
		}
		}