Add Dawn perf test harness

This patch adds a perf test harness for Dawn and a simple test of
buffer upload performance. The test harness is based off of ANGLE's
perf tests.

Because perf tests are parameterized to support multiple test
variants, this patch also adds DawnTestWithParams and ParamGenerator
to support instantiating tests with additional parameters.

Bug: dawn:208
Change-Id: I60df730e9f9f21a4c29fc21ea1a8315e4fff1aa6
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/10340
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Austin Eng <enga@chromium.org>

src/utils/OSXTimer.cpp

@@ -0,0 +1,77 @@
+// Copyright 2019 The Dawn Authors
+//
+// 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.
+
+#include "utils/Timer.h"
+
+#include <CoreServices/CoreServices.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+
+namespace utils {
+
+    class OSXTimer : public Timer {
+      public:
+        OSXTimer() : Timer(), mRunning(false), mSecondCoeff(0) {
+        }
+
+        ~OSXTimer() override = default;
+
+        void Start() override {
+            mStartTime = mach_absolute_time();
+            // Cache secondCoeff
+            GetSecondCoeff();
+            mRunning = true;
+        }
+
+        void Stop() override {
+            mStopTime = mach_absolute_time();
+            mRunning = false;
+        }
+
+        double GetElapsedTime() const override {
+            if (mRunning) {
+                return mSecondCoeff * (mach_absolute_time() - mStartTime);
+            } else {
+                return mSecondCoeff * (mStopTime - mStartTime);
+            }
+        }
+
+        double GetAbsoluteTime() override {
+            return GetSecondCoeff() * mach_absolute_time();
+        }
+
+      private:
+        double GetSecondCoeff() {
+            // If this is the first time we've run, get the timebase.
+            if (mSecondCoeff == 0.0) {
+                mach_timebase_info_data_t timebaseInfo;
+                mach_timebase_info(&timebaseInfo);
+
+                mSecondCoeff = timebaseInfo.numer * (1.0 / 1000000000) / timebaseInfo.denom;
+            }
+
+            return mSecondCoeff;
+        }
+
+        bool mRunning;
+        uint64_t mStartTime;
+        uint64_t mStopTime;
+        double mSecondCoeff;
+    };
+
+    Timer* CreateTimer() {
+        return new OSXTimer();
+    }
+
+}  // namespace utils

src/utils/PosixTimer.cpp

@@ -0,0 +1,74 @@
+// Copyright 2019 The Dawn Authors
+//
+// 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.
+
+#include "utils/Timer.h"
+
+#include <stdint.h>
+#include <time.h>
+
+namespace utils {
+
+    namespace {
+
+        uint64_t GetCurrentTimeNs() {
+            struct timespec currentTime;
+            clock_gettime(CLOCK_MONOTONIC, &currentTime);
+            return currentTime.tv_sec * 1'000'000'000llu + currentTime.tv_nsec;
+        }
+
+    }  // anonymous namespace
+
+    class PosixTimer : public Timer {
+      public:
+        PosixTimer() : Timer(), mRunning(false) {
+        }
+
+        ~PosixTimer() override = default;
+
+        void Start() override {
+            mStartTimeNs = GetCurrentTimeNs();
+            mRunning = true;
+        }
+
+        void Stop() override {
+            mStopTimeNs = GetCurrentTimeNs();
+            mRunning = false;
+        }
+
+        double GetElapsedTime() const override {
+            uint64_t endTimeNs;
+            if (mRunning) {
+                endTimeNs = GetCurrentTimeNs();
+            } else {
+                endTimeNs = mStopTimeNs;
+            }
+
+            return (endTimeNs - mStartTimeNs) * 1e-9;
+        }
+
+        double GetAbsoluteTime() override {
+            return GetCurrentTimeNs() * 1e-9;
+        }
+
+      private:
+        bool mRunning;
+        uint64_t mStartTimeNs;
+        uint64_t mStopTimeNs;
+    };
+
+    Timer* CreateTimer() {
+        return new PosixTimer();
+    }
+
+}  // namespace utils

src/utils/Timer.h

@@ -0,0 +1,41 @@
+// Copyright 2019 The Dawn Authors
+//
+// 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.
+
+#ifndef UTILS_TIMER_H_
+#define UTILS_TIMER_H_
+
+namespace utils {
+
+    class Timer {
+      public:
+        virtual ~Timer() {
+        }
+
+        // Timer functionality: Use start() and stop() to record the duration and use
+        // getElapsedTime() to query that duration.  If getElapsedTime() is called in between, it
+        // will report the elapsed time since start().
+        virtual void Start() = 0;
+        virtual void Stop() = 0;
+        virtual double GetElapsedTime() const = 0;
+
+        // Timestamp functionality: Use getAbsoluteTime() to get an absolute time with an unknown
+        // origin. This time moves forward regardless of start()/stop().
+        virtual double GetAbsoluteTime() = 0;
+    };
+
+    Timer* CreateTimer();
+
+}  // namespace utils
+
+#endif  // UTILS_TIMER_H_

src/utils/WindowsTimer.cpp

@@ -0,0 +1,89 @@
+// Copyright 2019 The Dawn Authors
+//
+// 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.
+
+#include "utils/Timer.h"
+
+#include <windows.h>
+
+namespace utils {
+
+    class WindowsTimer : public Timer {
+      public:
+        WindowsTimer() : Timer(), mRunning(false), mFrequency(0) {
+        }
+
+        ~WindowsTimer() override = default;
+
+        void Start() override {
+            LARGE_INTEGER curTime;
+            QueryPerformanceCounter(&curTime);
+            mStartTime = curTime.QuadPart;
+
+            // Cache the frequency
+            GetFrequency();
+
+            mRunning = true;
+        }
+
+        void Stop() override {
+            LARGE_INTEGER curTime;
+            QueryPerformanceCounter(&curTime);
+            mStopTime = curTime.QuadPart;
+
+            mRunning = false;
+        }
+
+        double GetElapsedTime() const override {
+            LONGLONG endTime;
+            if (mRunning) {
+                LARGE_INTEGER curTime;
+                QueryPerformanceCounter(&curTime);
+                endTime = curTime.QuadPart;
+            } else {
+                endTime = mStopTime;
+            }
+
+            return static_cast<double>(endTime - mStartTime) / mFrequency;
+        }
+
+        double GetAbsoluteTime() override {
+            LARGE_INTEGER curTime;
+            QueryPerformanceCounter(&curTime);
+
+            return static_cast<double>(curTime.QuadPart) / GetFrequency();
+        }
+
+      private:
+        LONGLONG GetFrequency() {
+            if (mFrequency == 0) {
+                LARGE_INTEGER frequency = {};
+                QueryPerformanceFrequency(&frequency);
+
+                mFrequency = frequency.QuadPart;
+            }
+
+            return mFrequency;
+        }
+
+        bool mRunning;
+        LONGLONG mStartTime;
+        LONGLONG mStopTime;
+        LONGLONG mFrequency;
+    };
+
+    Timer* CreateTimer() {
+        return new WindowsTimer();
+    }
+
+}  // namespace utils