From cc6e72a5f011edc06dee3bfcf8a2c06f6bab44de Mon Sep 17 00:00:00 2001
From: Ryan Beltran <ryanbeltran@chromium.org>
Date: Tue, 20 Apr 2021 16:10:49 +0000
Subject: compiler_wrapper: disable rusage when goma enabled

This disables rusage logging when Goma is enabled as goma makes the
resulting logs meaningless.

BUG=None
TEST=Updated and ran go tests

Change-Id: If55a820676faa6b40d471db48749d384b7e2c671
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/third_party/toolchain-utils/+/2840684
Reviewed-by: George Burgess <gbiv@chromium.org>
Tested-by: Ryan Beltran <ryanbeltran@chromium.org>
---
 compiler_wrapper/compiler_wrapper.go | 49 ++++++++++++++++++++----------------
 1 file changed, 28 insertions(+), 21 deletions(-)

(limited to 'compiler_wrapper/compiler_wrapper.go')

diff --git a/compiler_wrapper/compiler_wrapper.go b/compiler_wrapper/compiler_wrapper.go
index 8538fd49..9d7b76e5 100644
--- a/compiler_wrapper/compiler_wrapper.go
+++ b/compiler_wrapper/compiler_wrapper.go
@@ -81,6 +81,7 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 	// Disable CCache for rusage logs
 	// Note: Disabling Goma causes timeout related INFRA_FAILUREs in builders
 	allowCCache := !rusageEnabled
+	gomaUsed := false
 
 	workAroundKernelBugWithRetries := false
 	if cfg.isAndroidWrapper {
@@ -90,7 +91,7 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 			mainBuilder.addPreUserArgs(mainBuilder.cfg.clangFlags...)
 			mainBuilder.addPreUserArgs(mainBuilder.cfg.commonFlags...)
 			mainBuilder.addPostUserArgs(mainBuilder.cfg.clangPostFlags...)
-			if _, err := processGomaCccFlags(mainBuilder); err != nil {
+			if gomaUsed, err = processGomaCccFlags(mainBuilder); err != nil {
 				return 0, err
 			}
 			compilerCmd = mainBuilder.build()
@@ -126,24 +127,24 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 					return 0, err
 				}
 			}
-			if err := processGomaCCacheFlags(allowCCache, mainBuilder); err != nil {
+			if gomaUsed, err = processGomaCCacheFlags(allowCCache, mainBuilder); err != nil {
 				return 0, err
 			}
 			compilerCmd = mainBuilder.build()
 		} else {
 			if clangSyntax {
 				allowCCache = false
-				clangCmd, err := calcClangCommand(allowCCache, mainBuilder.clone())
+				_, clangCmd, err := calcClangCommand(allowCCache, mainBuilder.clone())
 				if err != nil {
 					return 0, err
 				}
-				gccCmd, err := calcGccCommand(rusageEnabled, mainBuilder)
+				_, gccCmd, err := calcGccCommand(rusageEnabled, mainBuilder)
 				if err != nil {
 					return 0, err
 				}
 				return checkClangSyntax(env, clangCmd, gccCmd)
 			}
-			compilerCmd, err = calcGccCommand(rusageEnabled, mainBuilder)
+			gomaUsed, compilerCmd, err = calcGccCommand(rusageEnabled, mainBuilder)
 			if err != nil {
 				return 0, err
 			}
@@ -244,10 +245,11 @@ func callCompilerInternal(env env, cfg *config, inputCmd *command) (exitCode int
 		case err != nil:
 			return exitCode, err
 		default:
-			if err := commitRusage(exitCode); err != nil {
-				return exitCode, fmt.Errorf("commiting rusage: %v", err)
+			if !gomaUsed {
+				if err := commitRusage(exitCode); err != nil {
+					return exitCode, fmt.Errorf("commiting rusage: %v", err)
+				}
 			}
-
 			return exitCode, err
 		}
 	}
@@ -266,30 +268,34 @@ func prepareClangCommand(builder *commandBuilder) (err error) {
 	return processClangFlags(builder)
 }
 
-func calcClangCommand(allowCCache bool, builder *commandBuilder) (*command, error) {
+func calcClangCommand(allowCCache bool, builder *commandBuilder) (bool, *command, error) {
 	err := prepareClangCommand(builder)
 	if err != nil {
-		return nil, err
+		return false, nil, err
 	}
-	if err := processGomaCCacheFlags(allowCCache, builder); err != nil {
-		return nil, err
+	gomaUsed, err := processGomaCCacheFlags(allowCCache, builder)
+	if err != nil {
+		return gomaUsed, nil, err
 	}
-	return builder.build(), nil
+	return gomaUsed, builder.build(), nil
 }
 
-func calcGccCommand(enableRusage bool, builder *commandBuilder) (*command, error) {
+func calcGccCommand(enableRusage bool, builder *commandBuilder) (bool, *command, error) {
 	if !builder.cfg.isHostWrapper {
 		processSysrootFlag(builder)
 	}
 	builder.addPreUserArgs(builder.cfg.gccFlags...)
 	calcCommonPreUserArgs(builder)
 	processGccFlags(builder)
+
+	gomaUsed := false
 	if !builder.cfg.isHostWrapper {
-		if err := processGomaCCacheFlags(!enableRusage, builder); err != nil {
-			return nil, err
+		var err error
+		if gomaUsed, err = processGomaCCacheFlags(!enableRusage, builder); err != nil {
+			return gomaUsed, nil, err
 		}
 	}
-	return builder.build(), nil
+	return gomaUsed, builder.build(), nil
 }
 
 func calcCommonPreUserArgs(builder *commandBuilder) {
@@ -303,18 +309,19 @@ func calcCommonPreUserArgs(builder *commandBuilder) {
 	processSanitizerFlags(builder)
 }
 
-func processGomaCCacheFlags(allowCCache bool, builder *commandBuilder) (err error) {
-	gomaccUsed := false
+func processGomaCCacheFlags(allowCCache bool, builder *commandBuilder) (gomaccUsed bool, err error) {
+
+	gomaccUsed = false
 	if !builder.cfg.isHostWrapper {
 		gomaccUsed, err = processGomaCccFlags(builder)
 		if err != nil {
-			return err
+			return gomaccUsed, err
 		}
 	}
 	if !gomaccUsed && allowCCache {
 		processCCacheFlag(builder)
 	}
-	return nil
+	return gomaccUsed, nil
 }
 
 func getAbsWrapperPath(env env, wrapperCmd *command) (string, error) {
-- 
cgit v1.2.3