[CT] Add ability to run unlanded benchmarks on Chromium Perf

ct/go/worker_scripts/run_chromium_perf/main.go

 // run_chromium_perf is an application that runs the specified benchmark over CT's
 // webpage archives.
 package main
 
 import (
         "encoding/csv"
         "flag"
         "fmt"
+        "io"
         "io/ioutil"
         "os"
         "path/filepath"
         "runtime"
         "sync"
         "time"
 
         "github.com/skia-dev/glog"
 
         "strings"
 
         "go.skia.org/infra/ct/go/adb"
         "go.skia.org/infra/ct/go/util"
         "go.skia.org/infra/ct/go/worker_scripts/worker_common"
         "go.skia.org/infra/go/common"
         skutil "go.skia.org/infra/go/util"
 )
 
 const (
         // The number of goroutines that will run in parallel to run benchmarks.
         WORKER_POOL_SIZE = 10
 )
 
 var (
         workerNum                 = flag.Int("worker_num", 1, "The number of this CT worker. It will be in the {1..100} range.")
         pagesetType               = flag.String("pageset_type", util.PAGESET_TYPE_MOBILE_10k, "The type of pagesets to create from the Alexa CSV list. Eg: 10k, Mobile10k, All.")
         chromiumBuildNoPatch      = flag.String("chromium_build_nopatch", "", "The chromium build to use for the nopatch run.")
         chromiumBuildWithPatch    = flag.String("chromium_build_withpatch", "", "The chromium build to use for the withpatch run.")
+        runID                     = flag.String("run_id", "", "The unique run id (typically requester + timestamp).")
         runIDNoPatch              = flag.String("run_id_nopatch", "", "The unique run id (typically requester + timestamp) for the nopatch run.")
         runIDWithPatch            = flag.String("run_id_withpatch", "", "The unique run id (typically requester + timestamp) for the withpatch run.")
         benchmarkName             = flag.String("benchmark_name", "", "The telemetry benchmark to run on this worker.")
         benchmarkExtraArgs        = flag.String("benchmark_extra_args", "", "The extra arguments that are passed to the specified benchmark.")
         browserExtraArgsNoPatch   = flag.String("browser_extra_args_nopatch", "", "The extra arguments that are passed to the browser while running the benchmark during the nopatch run.")
         browserExtraArgsWithPatch = flag.String("browser_extra_args_withpatch", "", "The extra arguments that are passed to the browser while running the benchmark during the withpatch run.")
         repeatBenchmark           = flag.Int("repeat_benchmark", 3, "The number of times the benchmark should be repeated. For skpicture_printer benchmark this value is always 1.")
         runInParallel             = flag.Bool("run_in_parallel", false, "Run the benchmark by bringing up multiple chrome instances in parallel.")
         targetPlatform            = flag.String("target_platform", util.PLATFORM_ANDROID, "The platform the benchmark will run on (Android / Linux).")
         chromeCleanerTimer        = flag.Duration("cleaner_timer", 15*time.Minute, "How often all chrome processes will be killed on this slave.")
@@ skipping 59 matching lines @@
                         util.ADB_ROOT_TIMEOUT, nil, nil))
         }
 
         // Instantiate GsUtil object.
         gs, err := util.NewGsUtil(nil)
         if err != nil {
                 glog.Error(err)
                 return
         }
 
+        // Download the benchmark patch for this run from Google storage.
+        benchmarkPatchName := *runID + ".benchmark.patch"
+        benchmarkPatchLocalPath := filepath.Join(os.TempDir(), benchmarkPatchName)
+        remoteDir := filepath.Join(util.ChromiumPerfRunsDir, *runID)
+        benchmarkPatchRemotePath := filepath.Join(remoteDir, benchmarkPatchName)
+        respBody, err := gs.GetRemoteFileContents(benchmarkPatchRemotePath)
+        if err != nil {
+                glog.Errorf("Could not fetch %s: %s", benchmarkPatchRemotePath, err)
+                return
+        }
+        defer skutil.Close(respBody)
+        out, err := os.Create(benchmarkPatchLocalPath)

[dogben, 2015/10/20 15:17:26]

Seems like you could use os.WriteFile.
https://golang.org/pkg/io/ioutil/#WriteFile

[rmistry, 2015/10/20 17:47:48]

Done.

+        if err != nil {
+                glog.Errorf("Unable to create file %s: %s", benchmarkPatchLocalPath, err)
+                return
+        }
+        defer skutil.Close(out)
+        defer skutil.Remove(benchmarkPatchLocalPath)
+        if _, err = io.Copy(out, respBody); err != nil {
+                glog.Error(err)
+                return
+        }
+        // Apply benchmark patch to the local chromium checkout.
+        benchmarkPatchFile, _ := os.Open(benchmarkPatchLocalPath)

[dogben, 2015/10/20 15:17:26]

Use os.Stat. https://golang.org/pkg/os/#Stat
(Or defer skutil.Close(benchmarkPatchFile))

[rmistry, 2015/10/20 17:47:48]

Done.

[dogben, 2015/10/20 18:14:08]

Nit: You actually have the size from buf above, so Stat is not really needed.

[rmistry, 2015/10/21 12:32:47]

Done.

+        benchmarkPatchFileInfo, _ := benchmarkPatchFile.Stat()
+        if benchmarkPatchFileInfo.Size() > 10 {
+                if err := util.ApplyPatch(benchmarkPatchLocalPath, util.ChromiumSrcDir); err != nil {
+                        glog.Errorf("Could not apply Telemetry's patch in %s: %s", util.ChromiumSrcDir, err)
+                        return
+                }
+        }
+
         // Download the specified chromium builds.
         for _, chromiumBuild := range []string{*chromiumBuildNoPatch, *chromiumBuildWithPatch} {
                 if err := gs.DownloadChromiumBuild(chromiumBuild); err != nil {
                         glog.Error(err)
                         return
                 }
                 //Delete the chromium build to save space when we are done.
                 defer skutil.RemoveAll(filepath.Join(util.ChromiumBuildsDir, chromiumBuild))
         }
 
@@ skipping 120 matching lines @@
 
         // Read the pageset.
         pagesetName := strings.TrimSuffix(pagesetBaseName, filepath.Ext(pagesetBaseName))
         pagesetPath := filepath.Join(pathToPagesets, fileInfoName)
         decodedPageset, err := util.ReadPageset(pagesetPath)
         if err != nil {
                 return fmt.Errorf("Could not read %s: %s", pagesetPath, err)
         }
 
         glog.Infof("===== Processing %s for %s =====", pagesetPath, runID)
+        pagesetName, present := util.BenchmarksToPagesetName[*benchmarkName]
+        if !present {
+                // If it is custom benchmark use the entered benchmark name.
+                pagesetName = *benchmarkName
+        }
         args := []string{
                 filepath.Join(util.TelemetryBinariesDir, util.BINARY_RUN_BENCHMARK),
-                util.BenchmarksToPagesetName[*benchmarkName],
+                pagesetName,
                 "--also-run-disabled-tests",
                 "--user-agent=" + decodedPageset.UserAgent,
                 "--urls-list=" + decodedPageset.UrlsList,
                 "--archive-data-file=" + decodedPageset.ArchiveDataFile,
         }
 
         // Need to capture output for all benchmarks.
         outputDirArgValue := filepath.Join(localOutputDir, pagesetName)
         args = append(args, "--output-dir="+outputDirArgValue)
         // Figure out which browser should be used.
@@ skipping 116 matching lines @@
                 return fmt.Errorf("Could not write to %s: %s", csvPath, err)
         }
         // Write all values.
         for _, row := range values {
                 if err := writer.Write(row); err != nil {
                         return fmt.Errorf("Could not write to %s: %s", csvPath, err)
                 }
         }
         return nil
 }