Some VisualStudio compatibility hacks.

Author: lemire

include/util.h

@@ -1,13 +1,80 @@
 #ifndef FRAMEOFREFERENCE_INCLUDE_UTIL_H
 #define FRAMEOFREFERENCE_INCLUDE_UTIL_H
-#include <iso646.h> // mostly for Microsoft compilers
+#include <iso646.h> // mostly for Microsoft 
+#ifdef _MSC_VER
+/* Microsoft C/C++-compatible compiler */
+#include <intrin.h>
+
+#ifndef __clang__ // if one compiles with MSVC *with* clang, then these intrinsics are defined!!!
+// sadly there is no way to check whether we are missing these intrinsics specifically.
+
+/* wrappers for Visual Studio built-ins that look like gcc built-ins */
+/* result might be undefined when input_num is zero */
+static inline int __builtin_ctzll(unsigned long long input_num) {
+	unsigned long index;
+#ifdef _WIN64 // highly recommended!!!
+	_BitScanForward64(&index, input_num);
+#else // if we must support 32-bit Windows
+	if ((uint32_t)input_num != 0) {
+		_BitScanForward(&index, (uint32_t)input_num);
+	}
+	else {
+		_BitScanForward(&index, (uint32_t)(input_num >> 32));
+		index += 32;
+	}
+#endif
+	return index;
+}
+
+/* result might be undefined when input_num is zero */
+static inline int __builtin_clzll(unsigned long long input_num) {
+	unsigned long index;
+#ifdef _WIN64 // highly recommended!!!
+	_BitScanReverse64(&index, input_num);
+#else // if we must support 32-bit Windows
+	if (input_num > 0xFFFFFFF) {
+		_BitScanReverse(&index, (uint32_t)(input_num >> 32));
+	}
+	else {
+		_BitScanReverse(&index, (uint32_t)(input_num));
+		index += 32;
+	}
+#endif
+	return 63 - index;
+}
+
+/* result might be undefined when input_num is zero */
+static inline int __builtin_clz(int input_num) {
+	unsigned long index;
+	_BitScanReverse(&index, input_num);
+	return 31 - index;
+}
+
+/* result might be undefined when input_num is zero */
+static inline int __builtin_popcountll(unsigned long long input_num) {
+#ifdef _WIN64 // highly recommended!!!
+	return (int)__popcnt64(input_num);
+#else // if we must support 32-bit Windows
+	return (int)(__popcnt((uint32_t)input_num) + __popcnt((uint32_t)(input_num >> 32)));
+#endif
+}
+
+static inline void __builtin_unreachable() {
+	__assume(0);
+}
+#endif
+#endif
+
+
 #include <stdint.h> // part of Visual Studio 2010 and better
 
 // integer logarithm function
 static inline uint32_t bits(const uint32_t v) {
     return v == 0 ? 0 : 32 - __builtin_clz(v); // todo: make portable (Visual studio)
 }
 
+
+
 // integer logarithm function
 static inline uint32_t bits64(const uint64_t v) {
     return v == 0 ? 0 : 64 - __builtin_clzll(v); // todo: make portable (Visual studio)

src/test.cpp

@@ -4,9 +4,8 @@
 * Apache License Version 2.0 http://www.apache.org/licenses/.
 * (c) Daniel Lemire 2013
 */
-
+#include <chrono>
 #include <sys/stat.h>
-#include <sys/time.h>
 #include <sys/types.h>
 #ifdef _OPENMP
 #include <omp.h>
@@ -20,29 +19,116 @@
 
 using namespace std;
 
+
+//
+// VS2012 bug: high_precision_clock is defined as system_clock and precision is
+// about 15 MS!!
+// See: https://connect.microsoft.com/VisualStudio/feedback/details/719443
+//
+// Implementation has been taken from a post on stackoverflow and adapted here
+// http://stackoverflow.com/questions/13263277/difference-between-stdsystem-clock-and-stdsteady-clock
+//
+#ifdef _WIN32
+#define NOMINMAX
+#define WINDOWS_LEAN_AND_MEAN
+#include <windows.h>
+
+struct qpc_clock {
+	typedef std::chrono::nanoseconds duration;
+	typedef duration::rep rep;
+	typedef duration::period period;
+	typedef std::chrono::time_point<qpc_clock, duration> time_point;
+	static time_point now() {
+		static bool isInited = false;
+		static LARGE_INTEGER frequency = { 0, 0 };
+		if (!isInited) {
+			if (QueryPerformanceFrequency(&frequency) == 0) {
+				throw std::logic_error("QueryPerformanceCounter not supported: " +
+					std::to_string(GetLastError()));
+			}
+			isInited = true;
+		}
+		LARGE_INTEGER counter;
+		QueryPerformanceCounter(&counter);
+		return time_point(duration(static_cast<rep>((double)counter.QuadPart /
+			frequency.QuadPart *
+			period::den / period::num)));
+	}
+};
+
+#endif
+
+/**
+*  author: Preston Bannister
+*/
 class WallClockTimer {
 public:
-  struct timeval t1, t2;
+#ifdef _WIN32
+	typedef qpc_clock clock;
+#else
+	typedef std::chrono::high_resolution_clock clock;
+#endif
 
+	std::chrono::time_point<clock> t1, t2;
+	WallClockTimer() : t1(), t2() {
+		t1 = clock::now();
+		t2 = t1;
+	}
+	void reset() {
+		t1 = clock::now();
+		t2 = t1;
+	}
+	uint64_t elapsed() {
+		std::chrono::microseconds delta =
+			std::chrono::duration_cast<std::chrono::microseconds>(t2 - t1);
+		return delta.count();
+	}
+	uint64_t split() {
+		t2 = clock::now();
+		return elapsed();
+	}
+};
+
+#ifndef _WIN32
+
+class CPUTimer {
 public:
-  WallClockTimer() : t1(), t2() {
-    gettimeofday(&t1, 0);
-    t2 = t1;
-  }
-  void reset() {
-    gettimeofday(&t1, 0);
-    t2 = t1;
-  }
-  int elapsed() {
-    return ((t2.tv_sec - t1.tv_sec) * 1000) +
-           ((t2.tv_usec - t1.tv_usec) / 1000);
-  }
-  int split() {
-    gettimeofday(&t2, 0);
-    return elapsed();
-  }
+	// clock_t t1, t2;
+	struct rusage t1, t2;
+
+	CPUTimer() : t1(), t2() {
+		getrusage(RUSAGE_SELF, &t1);
+		// t1 = clock();
+		t2 = t1;
+	}
+	void reset() {
+		getrusage(RUSAGE_SELF, &t1);
+		t2 = t1;
+	}
+	// proxy for userelapsed
+	uint64_t elapsed() { return totalelapsed(); }
+
+	uint64_t totalelapsed() { return userelapsed() + systemelapsed(); }
+	// returns the *user* CPU time in micro seconds (mu s)
+	uint64_t userelapsed() {
+		return ((t2.ru_utime.tv_sec - t1.ru_utime.tv_sec) * 1000ULL * 1000ULL) +
+			((t2.ru_utime.tv_usec - t1.ru_utime.tv_usec));
+	}
+
+	// returns the *system* CPU time in micro seconds (mu s)
+	uint64_t systemelapsed() {
+		return ((t2.ru_stime.tv_sec - t1.ru_stime.tv_sec) * 1000ULL * 1000ULL) +
+			((t2.ru_stime.tv_usec - t1.ru_stime.tv_usec));
+	}
+
+	uint64_t split() {
+		getrusage(RUSAGE_SELF, &t2);
+		return elapsed();
+	}
 };
 
+#endif
+
 void displayUsage() { cout << "run as test nameoffile" << endl; }
 
 vector<uint32_t> loadVector(string filename) {