Move sharding functions for reuse (0a2f719b) · Commits · e / os / android_build_soong

Android.bp

+0 −1

Original line number	Diff line number	Diff line
		@@ -304,7 +304,6 @@ bootstrap_go_package {
		"java/jdeps_test.go",
		"java/kotlin_test.go",
		"java/plugin_test.go",
		"java/robolectric_test.go",
		"java/sdk_test.go",
		],
		pluginFor: ["soong_build"],

android/util.go

+33 −0

Original line number	Diff line number	Diff line
		@@ -319,3 +319,36 @@ func SplitFileExt(name string) (string, string, string) {

		return root, suffix, ext
		}

		// ShardPaths takes a Paths, and returns a slice of Paths where each one has at most shardSize paths.
		func ShardPaths(paths Paths, shardSize int) []Paths {
		if len(paths) == 0 {
		return nil
		}
		ret := make([]Paths, 0, (len(paths)+shardSize-1)/shardSize)
		for len(paths) > shardSize {
		ret = append(ret, paths[0:shardSize])
		paths = paths[shardSize:]
		}
		if len(paths) > 0 {
		ret = append(ret, paths)
		}
		return ret
		}

		// ShardStrings takes a slice of strings, and returns a slice of slices of strings where each one has at most shardSize
		// elements.
		func ShardStrings(s []string, shardSize int) [][]string {
		if len(s) == 0 {
		return nil
		}
		ret := make([][]string, 0, (len(s)+shardSize-1)/shardSize)
		for len(s) > shardSize {
		ret = append(ret, s[0:shardSize])
		s = s[shardSize:]
		}
		if len(s) > 0 {
		ret = append(ret, s)
		}
		return ret
		}

android/util_test.go

+99 −0

Original line number	Diff line number	Diff line
		@@ -469,3 +469,102 @@ func TestSplitFileExt(t *testing.T) {
		}
		})
		}

		func Test_Shard(t *testing.T) {
		type args struct {
		strings []string
		shardSize int
		}
		tests := []struct {
		name string
		args args
		want [][]string
		}{
		{
		name: "empty",
		args: args{
		strings: nil,
		shardSize: 1,
		},
		want: [][]string(nil),
		},
		{
		name: "single shard",
		args: args{
		strings: []string{"a", "b"},
		shardSize: 2,
		},
		want: [][]string{{"a", "b"}},
		},
		{
		name: "single short shard",
		args: args{
		strings: []string{"a", "b"},
		shardSize: 3,
		},
		want: [][]string{{"a", "b"}},
		},
		{
		name: "shard per input",
		args: args{
		strings: []string{"a", "b", "c"},
		shardSize: 1,
		},
		want: [][]string{{"a"}, {"b"}, {"c"}},
		},
		{
		name: "balanced shards",
		args: args{
		strings: []string{"a", "b", "c", "d"},
		shardSize: 2,
		},
		want: [][]string{{"a", "b"}, {"c", "d"}},
		},
		{
		name: "unbalanced shards",
		args: args{
		strings: []string{"a", "b", "c"},
		shardSize: 2,
		},
		want: [][]string{{"a", "b"}, {"c"}},
		},
		}
		for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
		t.Run("strings", func(t *testing.T) {
		if got := ShardStrings(tt.args.strings, tt.args.shardSize); !reflect.DeepEqual(got, tt.want) {
		t.Errorf("ShardStrings(%v, %v) = %v, want %v",
		tt.args.strings, tt.args.shardSize, got, tt.want)
		}
		})

		t.Run("paths", func(t *testing.T) {
		stringsToPaths := func(strings []string) Paths {
		if strings == nil {
		return nil
		}
		paths := make(Paths, len(strings))
		for i, s := range strings {
		paths[i] = PathForTesting(s)
		}
		return paths
		}

		paths := stringsToPaths(tt.args.strings)

		var want []Paths
		if sWant := tt.want; sWant != nil {
		want = make([]Paths, len(sWant))
		for i, w := range sWant {
		want[i] = stringsToPaths(w)
		}
		}

		if got := ShardPaths(paths, tt.args.shardSize); !reflect.DeepEqual(got, want) {
		t.Errorf("ShardPaths(%v, %v) = %v, want %v",
		paths, tt.args.shardSize, got, want)
		}
		})
		})
		}
		}

java/aapt2.go

+1 −1

Original line number	Diff line number	Diff line
		@@ -63,7 +63,7 @@ var aapt2CompileRule = pctx.AndroidStaticRule("aapt2Compile",
		func aapt2Compile(ctx android.ModuleContext, dir android.Path, paths android.Paths,
		flags []string) android.WritablePaths {

		shards := shardPaths(paths, AAPT2_SHARD_SIZE)
		shards := android.ShardPaths(paths, AAPT2_SHARD_SIZE)

		ret := make(android.WritablePaths, 0, len(paths))

java/java.go

+1 −13

Original line number	Diff line number	Diff line
		@@ -580,18 +580,6 @@ func hasSrcExt(srcs []string, ext string) bool {
		return false
		}

		func shardPaths(paths android.Paths, shardSize int) []android.Paths {
		ret := make([]android.Paths, 0, (len(paths)+shardSize-1)/shardSize)
		for len(paths) > shardSize {
		ret = append(ret, paths[0:shardSize])
		paths = paths[shardSize:]
		}
		if len(paths) > 0 {
		ret = append(ret, paths)
		}
		return ret
		}

		func (j *Module) hasSrcExt(ext string) bool {
		return hasSrcExt(j.properties.Srcs, ext)
		}
		@@ -1156,7 +1144,7 @@ func (j *Module) compile(ctx android.ModuleContext, aaptSrcJar android.Path) {
		shardSize := int(*(j.properties.Javac_shard_size))
		var shardSrcs []android.Paths
		if len(uniqueSrcFiles) > 0 {
		shardSrcs = shardPaths(uniqueSrcFiles, shardSize)
		shardSrcs = android.ShardPaths(uniqueSrcFiles, shardSize)
		for idx, shardSrc := range shardSrcs {
		classes := j.compileJavaClasses(ctx, jarName, idx, shardSrc,
		nil, flags, extraJarDeps)