From 1d640d0521c7b266bb4b44726305ba2b9971f01d Mon Sep 17 00:00:00 2001 From: Jakub Kotur Date: Wed, 6 Jan 2021 12:40:43 +0100 Subject: [PATCH] Add rust_benchmark module to soong. This commit adds rust_benchmark and rust_benchmark_host commands to soong. Respectively running rust benchmarks on device and host. Currently only criterion based benchmarks are supported and criterion library is automatically linked. Test: atest Bug: 155309706 Change-Id: I6edfc2b4bf30b1163fe59b8c2ecdcd4e7125e7b9 --- rust/Android.bp | 2 + rust/benchmark.go | 89 ++++++++++++++++++++++++++++++++++++++++++ rust/benchmark_test.go | 54 +++++++++++++++++++++++++ rust/rust.go | 1 + rust/testing.go | 8 ++++ 5 files changed, 154 insertions(+) create mode 100644 rust/benchmark.go create mode 100644 rust/benchmark_test.go diff --git a/rust/Android.bp b/rust/Android.bp index a29c474b1..a6c4e0787 100644 --- a/rust/Android.bp +++ b/rust/Android.bp @@ -14,6 +14,7 @@ bootstrap_go_package { ], srcs: [ "androidmk.go", + "benchmark.go", "binary.go", "bindgen.go", "builder.go", @@ -35,6 +36,7 @@ bootstrap_go_package { "testing.go", ], testSrcs: [ + "benchmark_test.go", "binary_test.go", "bindgen_test.go", "builder_test.go", diff --git a/rust/benchmark.go b/rust/benchmark.go new file mode 100644 index 000000000..6e4fb85c1 --- /dev/null +++ b/rust/benchmark.go @@ -0,0 +1,89 @@ +// Copyright 2020 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rust + +import ( + "android/soong/android" +) + +type BenchmarkProperties struct { +} + +type benchmarkDecorator struct { + *binaryDecorator + Properties BenchmarkProperties + testConfig android.Path +} + +func NewRustBenchmark(hod android.HostOrDeviceSupported) (*Module, *benchmarkDecorator) { + // Build both 32 and 64 targets for device benchmarks. + // Cannot build both for host benchmarks yet if the benchmark depends on + // something like proc-macro2 that cannot be built for both. + multilib := android.MultilibBoth + if hod != android.DeviceSupported && hod != android.HostAndDeviceSupported { + multilib = android.MultilibFirst + } + module := newModule(hod, multilib) + + benchmark := &benchmarkDecorator{ + binaryDecorator: &binaryDecorator{ + baseCompiler: NewBaseCompiler("nativebench", "nativebench64", InstallInData), + }, + } + + module.compiler = benchmark + module.AddProperties(&benchmark.Properties) + return module, benchmark +} + +func init() { + android.RegisterModuleType("rust_benchmark", RustBenchmarkFactory) + android.RegisterModuleType("rust_benchmark_host", RustBenchmarkHostFactory) +} + +func RustBenchmarkFactory() android.Module { + module, _ := NewRustBenchmark(android.HostAndDeviceSupported) + return module.Init() +} + +func RustBenchmarkHostFactory() android.Module { + module, _ := NewRustBenchmark(android.HostSupported) + return module.Init() +} + +func (benchmark *benchmarkDecorator) autoDep(ctx android.BottomUpMutatorContext) autoDep { + return rlibAutoDep +} + +func (benchmark *benchmarkDecorator) stdLinkage(ctx *depsContext) RustLinkage { + return RlibLinkage +} + +func (benchmark *benchmarkDecorator) compilerFlags(ctx ModuleContext, flags Flags) Flags { + flags = benchmark.binaryDecorator.compilerFlags(ctx, flags) + return flags +} + +func (benchmark *benchmarkDecorator) compilerDeps(ctx DepsContext, deps Deps) Deps { + deps = benchmark.binaryDecorator.compilerDeps(ctx, deps) + + deps.Rustlibs = append(deps.Rustlibs, "libcriterion") + + return deps +} + +func (benchmark *benchmarkDecorator) compilerProps() []interface{} { + return append(benchmark.binaryDecorator.compilerProps(), &benchmark.Properties) +} diff --git a/rust/benchmark_test.go b/rust/benchmark_test.go new file mode 100644 index 000000000..734dda71d --- /dev/null +++ b/rust/benchmark_test.go @@ -0,0 +1,54 @@ +// Copyright 2021 The Android Open Source Project +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package rust + +import ( + "strings" + "testing" + + "android/soong/android" +) + +func TestRustBenchmark(t *testing.T) { + ctx := testRust(t, ` + rust_benchmark_host { + name: "my_bench", + srcs: ["foo.rs"], + }`) + + testingModule := ctx.ModuleForTests("my_bench", "linux_glibc_x86_64") + expectedOut := "my_bench/linux_glibc_x86_64/my_bench" + outPath := testingModule.Output("my_bench").Output.String() + if !strings.Contains(outPath, expectedOut) { + t.Errorf("wrong output path: %v; expected: %v", outPath, expectedOut) + } +} + +func TestRustBenchmarkLinkage(t *testing.T) { + ctx := testRust(t, ` + rust_benchmark { + name: "my_bench", + srcs: ["foo.rs"], + }`) + + testingModule := ctx.ModuleForTests("my_bench", "android_arm64_armv8-a").Module().(*Module) + + if !android.InList("libcriterion.rlib-std", testingModule.Properties.AndroidMkRlibs) { + t.Errorf("rlib-std variant for libcriterion not detected as a rustlib-defined rlib dependency for device rust_benchmark module") + } + if !android.InList("libstd", testingModule.Properties.AndroidMkRlibs) { + t.Errorf("Device rust_benchmark module 'my_bench' does not link libstd as an rlib") + } +} diff --git a/rust/rust.go b/rust/rust.go index f0d0e361c..fa54b1b32 100644 --- a/rust/rust.go +++ b/rust/rust.go @@ -429,6 +429,7 @@ func DefaultsFactory(props ...interface{}) android.Module { module.AddProperties( &BaseProperties{}, &cc.VendorProperties{}, + &BenchmarkProperties{}, &BindgenProperties{}, &BaseCompilerProperties{}, &BinaryCompilerProperties{}, diff --git a/rust/testing.go b/rust/testing.go index 75adcfce9..1e01cc0c5 100644 --- a/rust/testing.go +++ b/rust/testing.go @@ -192,11 +192,19 @@ func GatherRequiredDepsForTest() string { srcs:["foo.rs"], host_supported: true, } + rust_library { + name: "libcriterion", + crate_name: "criterion", + srcs:["foo.rs"], + host_supported: true, + } ` return bp } func registerRequiredBuildComponentsForTest(ctx android.RegistrationContext) { + ctx.RegisterModuleType("rust_benchmark", RustBenchmarkFactory) + ctx.RegisterModuleType("rust_benchmark_host", RustBenchmarkHostFactory) ctx.RegisterModuleType("rust_binary", RustBinaryFactory) ctx.RegisterModuleType("rust_binary_host", RustBinaryHostFactory) ctx.RegisterModuleType("rust_bindgen", RustBindgenFactory)