Leveraging F16C x86 instruction set architecture extension for half datatype (#330)

rahul003 · piiswrong · commit 0b4cedd7015c · 2018-04-09T14:40:54.000-07:00
* f16c changes

* cast double to float for conversion to uint6_t

* undo line break removal

* whitespace changes

* lint fix

* detect f16c support on system

* remove earlier setting of var

* comment

* cmake support for linux and mac

* cmake support

* lint fixes
diff --git a/cmake/mshadow.cmake b/cmake/mshadow.cmake
@@ -48,6 +48,31 @@ else()
 	add_definitions(-DMSHADOW_USE_SSE=0)
 endif()
 
+if(NOT DEFINED SUPPORT_MF16C AND NOT MSVC)
+    check_cxx_compiler_flag("-mf16c"     COMPILER_SUPPORT_MF16C)
+    if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+        execute_process(COMMAND cat /proc/cpuinfo
+                COMMAND grep flags
+                COMMAND grep f16c
+                OUTPUT_VARIABLE CPU_SUPPORT_F16C)
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "Darwin")
+        execute_process(COMMAND sysctl -a
+                COMMAND grep machdep.cpu.features
+                COMMAND grep F16C
+                OUTPUT_VARIABLE CPU_SUPPORT_F16C)
+    endif()
+    if(CPU_SUPPORT_F16C AND COMPILER_SUPPORT_MF16C)
+        set(SUPPORT_MF16C TRUE)
+    endif()
+endif()
+
+if(SUPPORT_MF16C)
+    add_definitions(-DMSHADOW_USE_F16C=1)
+    set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -mf16c")
+else()
+    add_definitions(-DMSHADOW_USE_F16C=0)
+endif()
+
 if(USE_CUDA)
 	find_package(CUDA 5.5 QUIET)
 	find_cuda_helper_libs(curand)
diff --git a/make/mshadow.mk b/make/mshadow.mk
@@ -31,6 +31,32 @@ else
 	MSHADOW_CFLAGS += -DMSHADOW_USE_SSE=0
 endif
 
+ifndef USE_F16C
+    ifneq ($(OS),Windows_NT)
+        detected_OS := $(shell uname -s)
+        ifeq ($(detected_OS),Darwin)
+            F16C_SUPP = $(shell sysctl -a | grep machdep.cpu.features | grep F16C)
+        endif
+        ifeq ($(detected_OS),Linux)
+            F16C_SUPP = $(shell cat /proc/cpuinfo | grep flags | grep f16c)
+        endif
+	ifneq ($(F16C_SUPP), NONE)
+                USE_F16C=1
+        else
+                USE_F16C=0
+        endif
+    endif
+    # if OS is Windows, check if your processor supports F16C architecture.
+    # One way to do that is to download the tool https://docs.microsoft.com/en-us/sysinternals/downloads/coreinfo.
+    # If coreinfo -c shows F16C then you can set USE_F16C=1 explicitly to leverage that capability"
+endif
+
+ifeq ($(USE_F16C), 1)
+        MSHADOW_CFLAGS += -mf16c
+else
+        MSHADOW_CFLAGS += -DMSHADOW_USE_F16C=0
+endif
+
 ifeq ($(USE_CUDA), 0)
 	MSHADOW_CFLAGS += -DMSHADOW_USE_CUDA=0
 else
diff --git a/mshadow/base.h b/mshadow/base.h
@@ -134,6 +134,12 @@ typedef unsigned __int64 uint64_t;
 #ifndef MSHADOW_USE_SSE
   #define MSHADOW_USE_SSE 1
 #endif
+
+/*! \brief whether use F16C instruction set architecture extension */
+#ifndef MSHADOW_USE_F16C
+#define MSHADOW_USE_F16C 1
+#endif
+
 /*! \brief whether use NVML to get dynamic info */
 #ifndef MSHADOW_USE_NVML
   #define MSHADOW_USE_NVML 0
diff --git a/mshadow/half.h b/mshadow/half.h
@@ -9,6 +9,10 @@
 #define MSHADOW_HALF_H_
 #include "./base.h"
 
+#if MSHADOW_USE_F16C
+  #include <x86intrin.h>
+#endif  // MSHADOW_USE_F16C
+
 #if (MSHADOW_USE_CUDA && CUDA_VERSION >= 7050)
   #define MSHADOW_CUDA_HALF 1
   #include <cuda_fp16.h>
@@ -61,7 +65,15 @@ namespace half {
     return T(__half2float(cuhalf_));  /* NOLINT(*)*/                      \
   }                                                                       \
   MSHADOW_XINLINE operator T() const volatile {                           \
-    return T(__half2float_warp(cuhalf_));  /* NOLINT(*)*/                      \
+    return T(__half2float_warp(cuhalf_));  /* NOLINT(*)*/                 \
+  }
+#elif(MSHADOW_USE_F16C)
+#define MSHADOW_HALF_CONVERSIONOP(T)                                      \
+  MSHADOW_XINLINE operator T() const {                                    \
+    return T(_cvtsh_ss(half_));   /* NOLINT(*)*/                          \
+  }                                                                       \
+  MSHADOW_XINLINE operator T() const volatile {                           \
+    return T(_cvtsh_ss(half_));   /* NOLINT(*)*/                          \
   }
 #else
 #define MSHADOW_HALF_CONVERSIONOP(T)                                      \
@@ -244,9 +256,11 @@ class MSHADOW_ALIGNED(2) half_t {
   MSHADOW_XINLINE void constructor(const T& value) {
 #if (MSHADOW_CUDA_HALF && defined(__CUDA_ARCH__))
     cuhalf_ = __float2half(float(value));  // NOLINT(*)
-#else
+#elif(MSHADOW_USE_F16C)
+    half_ = _cvtss_sh(static_cast<float>(value), 0);
+#else /* !MSHADOW_CUDA_HALF && !MSHADOW_USE_F16C */
     half_ = float2half(float(value));  // NOLINT(*)
-#endif  // (MSHADOW_CUDA_HALF && defined(__CUDA_ARCH__))
+#endif /* !MSHADOW_CUDA_HALF && !MSHADOW_USE_F16C */
   }
 };
 
