Improve onnx app portability

Author: alexreinking

apps/onnx/model.cpp

@@ -6,9 +6,9 @@
 #include "common_types.h"
 #include "denormal_disabler.h"
 #include "onnx_converter.h"
+#include <chrono>
 #include <fstream>
 #include <random>
-#include <sys/time.h>
 #include <unordered_set>
 
 namespace py = pybind11;
@@ -469,29 +469,28 @@ double benchmark(
     pipeline.rep->realize(real, tgt);
 
     // Now benchmark by computing the value of the outputs num_iter times
-    struct timespec start;
-    struct timespec end;
-    clock_gettime(CLOCK_REALTIME, &start);
+    using clock = std::chrono::high_resolution_clock;
+    auto start = clock::now();
     for (int i = 0; i < num_iters; ++i) {
         // Increment the coefficients store in the cache evictor: this ensures that
         // all the data left in caches from the previous iteration is flushed out.
         cache_evictor.flush_caches();
         pipeline.rep->realize(real, tgt);
     }
-    clock_gettime(CLOCK_REALTIME, &end);
+    auto end = clock::now();
 
     double total_runtime =
-        (end.tv_sec - start.tv_sec) * 1e9 + end.tv_nsec - start.tv_nsec;
+        std::chrono::duration<double, std::nano>(end - start).count();
 
     // Figure out how long it took to generate new inputs at every iteration
     // and adjust the runtime accordingly.
-    clock_gettime(CLOCK_REALTIME, &start);
+    start = clock::now();
     for (int i = 0; i < num_iters; ++i) {
         cache_evictor.flush_caches();
     }
-    clock_gettime(CLOCK_REALTIME, &end);
+    end = clock::now();
     double input_gen_time =
-        (end.tv_sec - start.tv_sec) * 1e9 + end.tv_nsec - start.tv_nsec;
+        std::chrono::duration<double, std::nano>(end - start).count();
 
     total_runtime -= input_gen_time;
 

apps/onnx/onnx_converter.cc

@@ -1,9 +1,11 @@
 #include "onnx_converter.h"
 #include <climits>
-#include <exception>
-#include <math.h>
+#include <numeric>
 #include <unordered_set>
 
+#define _USE_MATH_DEFINES
+#include <math.h>
+
 static Halide::Expr div_up(Halide::Expr num, int denom) {
     return Halide::Internal::simplify((num + denom - 1) / denom);
 }