blob: de6f10d84e87168f584f33d611379767453ee4a6 [file] [log] [blame]
// Copyright 2019 Google Inc. All rights reserved.
//
// 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.
// This executable runs a series of build commands to test and benchmark some critical user journeys.
package main
import (
"context"
"fmt"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"android/soong/ui/build"
"android/soong/ui/logger"
"android/soong/ui/metrics"
"android/soong/ui/signal"
"android/soong/ui/status"
"android/soong/ui/terminal"
"android/soong/ui/tracer"
)
type Test struct {
name string
args []string
before func() error
results TestResults
}
type TestResults struct {
metrics *metrics.Metrics
err error
}
// Run runs a single build command. It emulates the "m" command line by calling into Soong UI directly.
func (t *Test) Run(logsDir string) {
output := terminal.NewStatusOutput(os.Stdout, "", false, false, false)
log := logger.New(output)
defer log.Cleanup()
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
trace := tracer.New(log)
defer trace.Close()
met := metrics.New()
stat := &status.Status{}
defer stat.Finish()
stat.AddOutput(output)
stat.AddOutput(trace.StatusTracer())
signal.SetupSignals(log, cancel, func() {
trace.Close()
log.Cleanup()
stat.Finish()
})
buildCtx := build.Context{ContextImpl: &build.ContextImpl{
Context: ctx,
Logger: log,
Metrics: met,
Tracer: trace,
Writer: output,
Status: stat,
}}
defer logger.Recover(func(err error) {
t.results.err = err
})
config := build.NewConfig(buildCtx, t.args...)
build.SetupOutDir(buildCtx, config)
os.MkdirAll(logsDir, 0777)
log.SetOutput(filepath.Join(logsDir, "soong.log"))
trace.SetOutput(filepath.Join(logsDir, "build.trace"))
stat.AddOutput(status.NewVerboseLog(log, filepath.Join(logsDir, "verbose.log")))
stat.AddOutput(status.NewErrorLog(log, filepath.Join(logsDir, "error.log")))
stat.AddOutput(status.NewProtoErrorLog(log, filepath.Join(logsDir, "build_error")))
stat.AddOutput(status.NewCriticalPathLogger(log, nil))
defer met.Dump(filepath.Join(logsDir, "soong_metrics"))
if start, ok := os.LookupEnv("TRACE_BEGIN_SOONG"); ok {
if !strings.HasSuffix(start, "N") {
if start_time, err := strconv.ParseUint(start, 10, 64); err == nil {
log.Verbosef("Took %dms to start up.",
time.Since(time.Unix(0, int64(start_time))).Nanoseconds()/time.Millisecond.Nanoseconds())
buildCtx.CompleteTrace(metrics.RunSetupTool, "startup", start_time, uint64(time.Now().UnixNano()))
}
}
if executable, err := os.Executable(); err == nil {
trace.ImportMicrofactoryLog(filepath.Join(filepath.Dir(executable), "."+filepath.Base(executable)+".trace"))
}
}
f := build.NewSourceFinder(buildCtx, config)
defer f.Shutdown()
build.FindSources(buildCtx, config, f)
build.Build(buildCtx, config)
t.results.metrics = met
}
// Touch the Intent.java file to cause a rebuild of the frameworks to monitor the
// incremental build speed as mentioned b/152046247. Intent.java file was chosen
// as it is a key component of the framework and is often modified.
func touchIntentFile() error {
const intentFileName = "frameworks/base/core/java/android/content/Intent.java"
currentTime := time.Now().Local()
return os.Chtimes(intentFileName, currentTime, currentTime)
}
func main() {
outDir := os.Getenv("OUT_DIR")
if outDir == "" {
outDir = "out"
}
cujDir := filepath.Join(outDir, "cuj_tests")
wd, _ := os.Getwd()
os.Setenv("TOP", wd)
// Use a subdirectory for the out directory for the tests to keep them isolated.
os.Setenv("OUT_DIR", filepath.Join(cujDir, "out"))
// Each of these tests is run in sequence without resetting the output tree. The state of the output tree will
// affect each successive test. To maintain the validity of the benchmarks across changes, care must be taken
// to avoid changing the state of the tree when a test is run. This is most easily accomplished by adding tests
// at the end.
tests := []Test{
{
// Reset the out directory to get reproducible results.
name: "clean",
args: []string{"clean"},
},
{
// Parse the build files.
name: "nothing",
args: []string{"nothing"},
},
{
// Parse the build files again to monitor issues like globs rerunning.
name: "nothing_rebuild",
args: []string{"nothing"},
},
{
// Parse the build files again, this should always be very short.
name: "nothing_rebuild_twice",
args: []string{"nothing"},
},
{
// Build the framework as a common developer task and one that keeps getting longer.
name: "framework",
args: []string{"framework"},
},
{
// Build the framework again to make sure it doesn't rebuild anything.
name: "framework_rebuild",
args: []string{"framework"},
},
{
// Build the framework again to make sure it doesn't rebuild anything even if it did the second time.
name: "framework_rebuild_twice",
args: []string{"framework"},
},
{
// Scenario major_inc_build (b/152046247): tracking build speed of major incremental build.
name: "major_inc_build_droid",
args: []string{"droid"},
},
{
name: "major_inc_build_framework_minus_apex_after_droid_build",
args: []string{"framework-minus-apex"},
before: touchIntentFile,
},
{
name: "major_inc_build_framework_after_droid_build",
args: []string{"framework"},
before: touchIntentFile,
},
{
name: "major_inc_build_sync_after_droid_build",
args: []string{"sync"},
before: touchIntentFile,
},
{
name: "major_inc_build_droid_rebuild",
args: []string{"droid"},
before: touchIntentFile,
},
{
name: "major_inc_build_update_api_after_droid_rebuild",
args: []string{"update-api"},
before: touchIntentFile,
},
}
cujMetrics := metrics.NewCriticalUserJourneysMetrics()
defer cujMetrics.Dump(filepath.Join(cujDir, "logs", "cuj_metrics.pb"))
for i, t := range tests {
logsSubDir := fmt.Sprintf("%02d_%s", i, t.name)
logsDir := filepath.Join(cujDir, "logs", logsSubDir)
if t.before != nil {
if err := t.before(); err != nil {
fmt.Printf("error running before function on test %q: %v\n", t.name, err)
break
}
}
t.Run(logsDir)
if t.results.err != nil {
fmt.Printf("error running test %q: %s\n", t.name, t.results.err)
break
}
if t.results.metrics != nil {
cujMetrics.Add(t.name, t.results.metrics)
}
}
}