1 files changed, 78 insertions, 5 deletions

diff --git a/libs/hwui/tests/macrobench/main.cpp b/libs/hwui/tests/macrobench/main.cpp
index 02a39501e647..ebc1dd7516c2 100644
--- a/libs/hwui/tests/macrobench/main.cpp
+++ b/libs/hwui/tests/macrobench/main.cpp
@@ -14,11 +14,14 @@
  * limitations under the License.
  */
 
+#include "tests/common/LeakChecker.h"
 #include "tests/common/TestScene.h"
 
 #include "protos/hwui.pb.h"
 #include "Properties.h"
 
+#include <benchmark/benchmark.h>
+#include <../src/sysinfo.h>
 #include <getopt.h>
 #include <stdio.h>
 #include <string>
@@ -39,12 +42,14 @@ using namespace android::uirenderer::test;
 static int gRepeatCount = 1;
 static std::vector<TestScene::Info> gRunTests;
 static TestScene::Options gOpts;
+std::unique_ptr<benchmark::BenchmarkReporter> gBenchmarkReporter;
 
-void run(const TestScene::Info& info, const TestScene::Options& opts);
+void run(const TestScene::Info& info, const TestScene::Options& opts,
+        benchmark::BenchmarkReporter* reporter);
 
 static void printHelp() {
     printf(R"(
-USAGE: hwuitest [OPTIONS] <TESTNAME>
+USAGE: hwuimacro [OPTIONS] <TESTNAME>
 
 OPTIONS:
   -c, --count=NUM      NUM loops a test should run (example, number of frames)
@@ -58,6 +63,10 @@ OPTIONS:
                        moving average frametime. Weight is optional, default is 10
   --cpuset=name        Adds the test to the specified cpuset before running
                        Not supported on all devices and needs root
+  --offscreen          Render tests off device screen. This option is on by default
+  --onscreen           Render tests on device screen. By default tests
+                       are offscreen rendered
+  --benchmark_format   Set output format. Possible values are tabular, json, csv
 )");
 }
 
@@ -121,6 +130,20 @@ static void moveToCpuSet(const char* cpusetName) {
     close(fd);
 }
 
+static bool setBenchmarkFormat(const char* format) {
+    if (!strcmp(format, "tabular")) {
+        gBenchmarkReporter.reset(new benchmark::ConsoleReporter());
+    } else if (!strcmp(format, "json")) {
+        gBenchmarkReporter.reset(new benchmark::JSONReporter());
+    } else if (!strcmp(format, "csv")) {
+        gBenchmarkReporter.reset(new benchmark::CSVReporter());
+    } else {
+        fprintf(stderr, "Unknown format '%s'", format);
+        return false;
+    }
+    return true;
+}
+
 // For options that only exist in long-form. Anything in the
 // 0-255 range is reserved for short options (which just use their ASCII value)
 namespace LongOpts {
@@ -130,6 +153,9 @@ enum {
     WaitForGpu,
     ReportFrametime,
     CpuSet,
+    BenchmarkFormat,
+    Onscreen,
+    Offscreen,
 };
 }
 
@@ -141,6 +167,9 @@ static const struct option LONG_OPTIONS[] = {
     { "wait-for-gpu", no_argument, nullptr, LongOpts::WaitForGpu },
     { "report-frametime", optional_argument, nullptr, LongOpts::ReportFrametime },
     { "cpuset", required_argument, nullptr, LongOpts::CpuSet },
+    { "benchmark_format", required_argument, nullptr, LongOpts::BenchmarkFormat },
+    { "onscreen", no_argument, nullptr, LongOpts::Onscreen },
+    { "offscreen", no_argument, nullptr, LongOpts::Offscreen },
     { 0, 0, 0, 0 }
 };
 
@@ -214,6 +243,24 @@ void parseOptions(int argc, char* argv[]) {
             moveToCpuSet(optarg);
             break;
 
+        case LongOpts::BenchmarkFormat:
+            if (!optarg) {
+                error = true;
+                break;
+            }
+            if (!setBenchmarkFormat(optarg)) {
+                error = true;
+            }
+            break;
+
+        case LongOpts::Onscreen:
+            gOpts.renderOffscreen = false;
+            break;
+
+        case LongOpts::Offscreen:
+            gOpts.renderOffscreen = true;
+            break;
+
         case 'h':
             printHelp();
             exit(EXIT_SUCCESS);
@@ -246,7 +293,9 @@ void parseOptions(int argc, char* argv[]) {
             }
         } while (optind < argc);
     } else {
-        gRunTests.push_back(TestScene::testMap()["shadowgrid"]);
+        for (auto& iter : TestScene::testMap()) {
+            gRunTests.push_back(iter.second);
+        }
     }
 }
 
@@ -255,12 +304,36 @@ int main(int argc, char* argv[]) {
     gOpts.count = 150;
 
     parseOptions(argc, argv);
+    if (!gBenchmarkReporter && gOpts.renderOffscreen) {
+        gBenchmarkReporter.reset(new benchmark::ConsoleReporter());
+    }
+
+    if (gBenchmarkReporter) {
+        size_t name_field_width = 10;
+        for (auto&& test : gRunTests) {
+            name_field_width = std::max<size_t>(name_field_width, test.name.size());
+        }
+        // _50th, _90th, etc...
+        name_field_width += 5;
+
+        benchmark::BenchmarkReporter::Context context;
+        context.num_cpus = benchmark::NumCPUs();
+        context.mhz_per_cpu = benchmark::CyclesPerSecond() / 1000000.0f;
+        context.cpu_scaling_enabled = benchmark::CpuScalingEnabled();
+        context.name_field_width = name_field_width;
+        gBenchmarkReporter->ReportContext(context);
+    }
 
     for (int i = 0; i < gRepeatCount; i++) {
         for (auto&& test : gRunTests) {
-            run(test, gOpts);
+            run(test, gOpts, gBenchmarkReporter.get());
         }
     }
-    printf("Success!\n");
+
+    if (gBenchmarkReporter) {
+        gBenchmarkReporter->Finalize();
+    }
+
+    LeakChecker::checkForLeaks();
     return 0;
 }