Update re2

third_party/re2/util/benchmark.cc

 // Copyright 2009 The RE2 Authors.  All Rights Reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "util/util.h"
 #include "util/flags.h"
 #include "util/benchmark.h"
 #include "re2/re2.h"
 
 DEFINE_string(test_tmpdir, "/var/tmp", "temp directory");
 
 using testing::Benchmark;
 using namespace re2;
 
 static Benchmark* benchmarks[10000];
 static int nbenchmarks;
 
 void Benchmark::Register() {
         benchmarks[nbenchmarks] = this;
         if(lo < 1)
                 lo = 1;
         if(hi < lo)
                 hi = lo;
         nbenchmarks++;
 }
 
 static int64 nsec() {
+#if defined(__APPLE__)
         struct timeval tv;
         if(gettimeofday(&tv, 0) < 0)
                 return -1;
         return (int64)tv.tv_sec*1000*1000*1000 + tv.tv_usec*1000;
+#elif defined(_WIN32)
+        // https://msdn.microsoft.com/en-us/library/windows/desktop/dn553408.aspx
+        // describes how to query ticks and convert to microseconds. Of course,
+        // what we want in this case are nanoseconds. Also, note that .QuadPart
+        // is a signed 64-bit integer, so casting to int64 shouldn't be needed.
+        LARGE_INTEGER freq;
+        QueryPerformanceFrequency(&freq);
+        LARGE_INTEGER ticks;
+        QueryPerformanceCounter(&ticks);
+        ticks.QuadPart *= 1000*1000*1000;
+        ticks.QuadPart /= freq.QuadPart;
+        return ticks.QuadPart;
+#else
+        struct timespec tp;
+        if(clock_gettime(CLOCK_REALTIME, &tp) < 0)
+                return -1;
+        return (int64)tp.tv_sec*1000*1000*1000 + tp.tv_nsec;
+#endif
 }
 
 static int64 bytes;
 static int64 ns;
 static int64 t0;
 static int64 items;
 
 void SetBenchmarkBytesProcessed(long long x) {
         bytes = x;
 }
@@ skipping 56 matching lines @@
         // TODO(rsc): Threaded benchmarks.
         if(nthread != 1)
                 return;
         
         // run once in case it's expensive
         n = 1;
         runN(b, n, siz);
         while(ns < (int)1e9 && n < (int)1e9) {
                 last = n;
                 if(ns/n == 0)
-                        n = 1e9;
+                        n = (int)1e9;
                 else
-                        n = 1e9 / (ns/n);
+                        n = (int)1e9 / static_cast<int>(ns/n);
                 
                 n = max(last+1, min(n+n/2, 100*last));
                 n = round(n);
                 runN(b, n, siz);
         }
         
         char mb[100];
         char suf[100];
         mb[0] = '\0';
         suf[0] = '\0';
@@ skipping 23 matching lines @@
 int main(int argc, const char** argv) {
         for(int i = 0; i < nbenchmarks; i++) {
                 Benchmark* b = benchmarks[i];
                 if(match(b->name, argc, argv))
                         for(int j = b->threadlo; j <= b->threadhi; j++)
                                 for(int k = max(b->lo, 1); k <= max(b->hi, 1); k<<=1)
                                         RunBench(b, j, k);
         }
 }