android/phony.go

// Copyright 2020 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.

package android

import (
	"io"
	"runtime"
	"sort"
	"strings"
	"sync"

	"github.com/google/blueprint"
)

//go:generate go run ../../blueprint/gobtools/codegen

type phonyMap map[string]Paths

// @auto-generate: gob
type PhonyInfo struct {
	Phonies phonyMap
}

var SingletonPhonyProvider = blueprint.NewSingletonProvider[PhonyInfo]()

type phonySingleton struct {
	phonyMap  phonyMap
	phonyList []string

	soongDist
}

var _ SingletonMakeVarsProvider = (*phonySingleton)(nil)

func (p *phonySingleton) GenerateBuildActions(ctx SingletonContext) {
	p.phonyMap = make(phonyMap)
	ctx.VisitAllModuleProxies(func(m ModuleProxy) {
		if info, ok := OtherModuleProvider(ctx, m, CommonModuleInfoProvider); ok && info.Phonies != nil {
			for k, v := range info.Phonies.Phonies {
				p.phonyMap[k] = append(p.phonyMap[k], v...)
			}
		}
	})

	ctx.VisitAllSingletons(func(s blueprint.SingletonProxy) {
		if info, ok := OtherSingletonProvider(ctx, s, SingletonPhonyProvider); ok {
			for k, v := range info.Phonies {
				p.phonyMap[k] = append(p.phonyMap[k], v...)
			}
		}
	})

	if !ctx.Config().KatiEnabled() {
		p.soongDist.collectDists(ctx)
		// Every dist goal gets an extra dependency on an extra phony with a __dist suffix.  On builds without dist
		// enabled the phony will have no dependencies, on builds with dist enabled the phony will depend on all
		// the copy rules for that goal.
		p.soongDist.addDistsToPhonyMap(ctx, p.phonyMap)

		// Define well-known goals and their dependency graph that they've
		// traditionally had in make builds.
		addPhony := func(target string, deps ...Path) {
			p.phonyMap[target] = append(p.phonyMap[target], deps...)
		}
		addPhony("droid", PathForPhony(ctx, "droid_targets"))
		addPhony("droid_targets", PathForPhony(ctx, "droidcore"), PathForPhony(ctx, "dist_files"))
		addPhony("droidcore", PathForPhony(ctx, "droidcore-unbundled"))
		addPhony("dist_files")
		addPhony("droidcore-unbundled")
	}

	// We will sort phonyList in parallel with other stuff later, but for now copy it into
	// a slice in series so that we don't read and write to phonyMap concurrently.
	p.phonyList = make([]string, 0, len(p.phonyMap))
	for phony := range p.phonyMap {
		p.phonyList = append(p.phonyList, phony)
	}

	type phonyDef struct {
		name string
		deps Paths
	}

	sortChan := make(chan phonyDef, len(p.phonyMap))
	resultsChan := make(chan phonyDef)
	var wg sync.WaitGroup

	// Sorting the phony deps in parallel saves about 2 seconds. Nothing runs in parallel with
	// the phony singleton so it's time off of wall clock.
	for i := 0; i < 2*runtime.NumCPU(); i++ {
		wg.Add(1)
		go func() {
			for toSort := range sortChan {
				toSort.deps = SortedUniquePaths(toSort.deps)
				resultsChan <- toSort
			}
			wg.Done()
		}()
	}

	go func() {
		sort.Strings(p.phonyList)
		wg.Wait()
		close(resultsChan)
	}()

	for phony, deps := range p.phonyMap {
		sortChan <- phonyDef{
			name: phony,
			deps: deps,
		}
	}
	close(sortChan)

	for result := range resultsChan {
		p.phonyMap[result.name] = result.deps
	}

	if !ctx.Config().KatiEnabled() {
		// The filename suffix style used by soong (".$TARGET_PRODUCT") is not available here, fake it
		// using katiSuffix ("-$TARGET_PRODUCT").
		suffix := "." + strings.TrimPrefix(ctx.Config().katiSuffix, "-")
		soongPhonyNinja := PathForOutput(ctx, "build"+suffix+".phony.ninja")
		soongDistFile := PathForOutput(ctx, "build"+suffix+".dist.ninja")
		soongNoDistFile := PathForOutput(ctx, "build"+suffix+".nodist.ninja")
		ctx.addSubninja(soongPhonyNinja.String())
		ctx.addSubninja(PathForOutput(ctx).String() + "/build" + suffix + ".$dist.ninja")

		wg := WaitGroupWithErrorCollector{}

		wg.Go(func() error {
			f, err := openBufferedFile(absolutePath(soongPhonyNinja.String()))
			if err != nil {
				return err
			}
			defer f.Close()
			return p.writeSoongPhonyNinja(f)
		})

		wg.GoWithMultipleErrors(func() []error {
			return p.soongDist.writeNinjaFiles(soongDistFile, soongNoDistFile, ctx.Config().REWrapperRemoteBuild())
		})

		wg.Wait()

		for _, err := range wg.Errors() {
			ctx.Errorf("%s", err)
		}
	}
}

func (p phonySingleton) MakeVars(ctx MakeVarsContext) {
	for _, phony := range p.phonyList {
		ctx.Phony(phony, p.phonyMap[phony]...)
	}
}

func phonySingletonFactory() Singleton {
	return &phonySingleton{}
}

func (p *phonySingleton) IncrementalSupported() bool {
	return true
}

// writeSoongPhonyNinja writes a ninja file containing phony rules for each phony target requested in Soong-only builds.
func (p *phonySingleton) writeSoongPhonyNinja(w io.StringWriter) error {
	var err error
	write := func(s string) {
		if err == nil {
			_, err = w.WriteString(s)
		}
	}
	for _, phony := range p.phonyList {
		write("build ")
		write(phony)
		write(": phony")
		for _, dep := range p.phonyMap[phony] {
			write(" ")
			write(dep.String())
		}
		write("\n")
		write(" phony_output = true\n")
	}

	write("default droid\n")

	return err
}