diff --git a/CMakeLists.txt b/CMakeLists.txt
index ba810db796..d37dbfc65c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -32,8 +32,8 @@ if(RELEASE_WITH_REGKEYS)
 endif(RELEASE_WITH_REGKEYS)
 
 if(NOT CMAKE_BUILD_TYPE)
-	message(STATUS "CMAKE_BUILD_TYPE not specified, using Release")
-	set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type: [Release, ReleaseInternal, Debug]" FORCE)
+  message(STATUS "CMAKE_BUILD_TYPE not specified, using Release")
+  set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type: [Release, ReleaseInternal, Debug]" FORCE)
 endif()
 
 add_definitions(-DCL_USE_DEPRECATED_OPENCL_1_1_APIS -DCL_USE_DEPRECATED_OPENCL_1_2_APIS -DCL_USE_DEPRECATED_OPENCL_2_0_APIS)
@@ -55,23 +55,23 @@ endif()
 
 string(TOLOWER "${CMAKE_BUILD_TYPE}" BUILD_TYPE_lower)
 if("${BUILD_TYPE_lower}" STREQUAL "releaseinternal")
-	add_definitions(-D_RELEASE_INTERNAL)
+  add_definitions(-D_RELEASE_INTERNAL)
 endif("${BUILD_TYPE_lower}" STREQUAL "releaseinternal")
 
 message(STATUS "${CMAKE_BUILD_TYPE} build configuration")
 
 # Set the runtime source directory
 if(NOT DEFINED IGDRCL_SOURCE_DIR)
-	set(IGDRCL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+  set(IGDRCL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 endif()
 
 # Set our build directory
 if(NOT DEFINED IGDRCL_BUILD_DIR)
-	set(IGDRCL_BUILD_DIR ${CMAKE_BINARY_DIR})
+  set(IGDRCL_BUILD_DIR ${CMAKE_BINARY_DIR})
 endif()
 
 if(NOT IGDRCL_BINARY_DIR)
-	set(IGDRCL_BINARY_DIR ${CMAKE_BINARY_DIR})
+  set(IGDRCL_BINARY_DIR ${CMAKE_BINARY_DIR})
 endif()
 
 # we use c++14
@@ -89,17 +89,17 @@ set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${IGDRCL_BINARY_DIR}/lib)
 # We want to build with the static, multithreaded runtime libraries (as opposed
 # to the multithreaded runtime DLLs)
 if(MSVC)
-	string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
-	string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
-	string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASEINTERNAL "${CMAKE_CXX_FLAGS_RELEASEINTERNAL}")
+  string(REPLACE "/MDd" "/MTd" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
+  string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
+  string(REPLACE "/MD" "/MT" CMAKE_CXX_FLAGS_RELEASEINTERNAL "${CMAKE_CXX_FLAGS_RELEASEINTERNAL}")
 endif(MSVC)
 
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
-	set(NEO_BITS "64")
-	set(NEO_ARCH "x64")
+  set(NEO_BITS "64")
+  set(NEO_ARCH "x64")
 else()
-	set(NEO_BITS "32")
-	set(NEO_ARCH "x86")
+  set(NEO_BITS "32")
+  set(NEO_ARCH "x86")
 endif()
 
 if(NOT KMDAF_HEADERS_DIR)
@@ -162,51 +162,51 @@ endif()
 message(STATUS "Khronos OpenGL headers dir: ${KHRONOS_GL_HEADERS_DIR}")
 
 if(NOT THIRD_PARTY_DIR)
-	get_filename_component(THIRD_PARTY_DIR "../third_party/" ABSOLUTE)
+  get_filename_component(THIRD_PARTY_DIR "../third_party/" ABSOLUTE)
 endif(NOT THIRD_PARTY_DIR)
 message(STATUS "Third party dir: ${THIRD_PARTY_DIR}")
 
 if(WIN32)
 # get WDK location and version to use
-	if(NOT WDK_DIR)
-		if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../wdk")
-			get_filename_component(WDK_DIR "../wdk" ABSOLUTE)
-		endif()
-	endif(NOT WDK_DIR)
-	if(WDK_DIR)
-		if(IS_DIRECTORY "${WDK_DIR}/Win15")
-			get_filename_component(WDK_DIR "${WDK_DIR}/Win15" ABSOLUTE)
-		endif()
-	endif()
-	message(STATUS "WDK Directory: ${WDK_DIR}")
+  if(NOT WDK_DIR)
+    if(IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../wdk")
+      get_filename_component(WDK_DIR "../wdk" ABSOLUTE)
+    endif()
+  endif(NOT WDK_DIR)
+  if(WDK_DIR)
+    if(IS_DIRECTORY "${WDK_DIR}/Win15")
+      get_filename_component(WDK_DIR "${WDK_DIR}/Win15" ABSOLUTE)
+    endif()
+  endif()
+  message(STATUS "WDK Directory: ${WDK_DIR}")
 
-	if(NOT WDK_VERSION)
-		# Get WDK version from ${WDK_DIR}/WDKVersion.txt
-		file(READ "${WDK_DIR}/WDKVersion.txt" WindowsTargetPlatformVersion)
-		string(REPLACE " " ";" WindowsTargetPlatformVersion ${WindowsTargetPlatformVersion})
-		list(LENGTH WindowsTargetPlatformVersion versionListLength)
-		if(NOT versionListLength EQUAL 3)
-			message(ERROR "Error reading content of WDKVersion.txt file")
-		endif(NOT versionListLength EQUAL 3)
-		list(GET WindowsTargetPlatformVersion 2 WindowsTargetPlatformVersion)
-	else()
-		set(WindowsTargetPlatformVersion ${WDK_VERSION})
-	endif()
-	message(STATUS "WDK Version is ${WindowsTargetPlatformVersion}")
+  if(NOT WDK_VERSION)
+    # Get WDK version from ${WDK_DIR}/WDKVersion.txt
+    file(READ "${WDK_DIR}/WDKVersion.txt" WindowsTargetPlatformVersion)
+    string(REPLACE " " ";" WindowsTargetPlatformVersion ${WindowsTargetPlatformVersion})
+    list(LENGTH WindowsTargetPlatformVersion versionListLength)
+    if(NOT versionListLength EQUAL 3)
+      message(ERROR "Error reading content of WDKVersion.txt file")
+    endif(NOT versionListLength EQUAL 3)
+    list(GET WindowsTargetPlatformVersion 2 WindowsTargetPlatformVersion)
+  else()
+    set(WindowsTargetPlatformVersion ${WDK_VERSION})
+  endif()
+  message(STATUS "WDK Version is ${WindowsTargetPlatformVersion}")
 
-	if(${WindowsTargetPlatformVersion} VERSION_LESS "10.0.18328.0")
-		set(CONST_FROM_WDK_10_0_18328_0)
-	else()
-		set(CONST_FROM_WDK_10_0_18328_0 "CONST")
-	endif()
-	add_compile_options(-DCONST_FROM_WDK_10_0_18328_0=${CONST_FROM_WDK_10_0_18328_0})
+  if(${WindowsTargetPlatformVersion} VERSION_LESS "10.0.18328.0")
+    set(CONST_FROM_WDK_10_0_18328_0)
+  else()
+    set(CONST_FROM_WDK_10_0_18328_0 "CONST")
+  endif()
+  add_compile_options(-DCONST_FROM_WDK_10_0_18328_0=${CONST_FROM_WDK_10_0_18328_0})
 
-	set(WDK_INCLUDE_PATHS
-		"${WDK_DIR}/Include/${WindowsTargetPlatformVersion}/um"
-		"${WDK_DIR}/Include/${WindowsTargetPlatformVersion}/shared"
-		"${WDK_DIR}/Include/${WindowsTargetPlatformVersion}/km"
-	)
-	message(STATUS "WDK include paths: ${WDK_INCLUDE_PATHS}")
+  set(WDK_INCLUDE_PATHS
+    "${WDK_DIR}/Include/${WindowsTargetPlatformVersion}/um"
+    "${WDK_DIR}/Include/${WindowsTargetPlatformVersion}/shared"
+    "${WDK_DIR}/Include/${WindowsTargetPlatformVersion}/km"
+  )
+  message(STATUS "WDK include paths: ${WDK_INCLUDE_PATHS}")
 endif()
 
 # Intel Graphics Compiler detection
@@ -251,7 +251,7 @@ if(NOT IGC__IGC_TARGETS)
 
         set(IGC_OPTION__OUTPUT_DIR "${IGDRCL_BUILD_DIR}/igc")
         set(IGC_OPTION__INCLUDE_IGC_COMPILER_TOOLS OFF)
-        add_subdirectory("${IGC_DIR}" "${IGDRCL_BUILD_DIR}/igc" EXCLUDE_FROM_ALL)
+        add_subdirectory_unique("${IGC_DIR}" "${IGDRCL_BUILD_DIR}/igc" EXCLUDE_FROM_ALL)
 
         set(IGDRCL__IGC_TARGETS "${IGC__IGC_TARGETS}")
         foreach(TARGET_tmp ${IGDRCL__IGC_TARGETS})
@@ -322,7 +322,7 @@ if(NOT DEFINED GMMUMD_LIB_NAME)
     else()
       if(EXISTS "${GMM_SOURCE_DIR}/CMakeLists.txt")
         message(STATUS "GmmLib source dir is: ${GMM_SOURCE_DIR}")
-        add_subdirectory("${GMM_SOURCE_DIR}" "${IGDRCL_BUILD_DIR}/gmmlib")
+        add_subdirectory_unique("${GMM_SOURCE_DIR}" "${IGDRCL_BUILD_DIR}/gmmlib")
 
         if(NOT DEFINED GMMUMD_LIB_NAME)
           set(GMMUMD_LIB_NAME "igfx_gmmumd_dll")
@@ -364,7 +364,7 @@ if(NOT INSTRUMENTATION_LIB_NAME)
     endif()
     if(IS_DIRECTORY "${INSTRUMENTATION_SOURCE_DIR}")
         message(STATUS "Instrumentation source dir is: ${INSTRUMENTATION_SOURCE_DIR}")
-        add_subdirectory("${INSTRUMENTATION_SOURCE_DIR}" "${IGDRCL_BUILD_DIR}/instrumentation")
+        add_subdirectory_unique("${INSTRUMENTATION_SOURCE_DIR}" "${IGDRCL_BUILD_DIR}/instrumentation")
         set(INSTRUMENTATION_LIB_NAME "instrumentation_umd")
         set(HAVE_INSTRUMENTATION TRUE)
     endif()
@@ -427,12 +427,12 @@ if(NEO_BITS STREQUAL "64")
 endif()
 
 
-add_subdirectory(third_party/gtest)
+add_subdirectory_unique(third_party/gtest)
 
 message(STATUS "AUB_STREAM_DIR = ${AUB_STREAM_DIR}" )
 if(DEFINED AUB_STREAM_DIR)
     set(AUB_STREAM_PROJECT_NAME "aub_stream")
-    add_subdirectory(${AUB_STREAM_DIR} ${CMAKE_BINARY_DIR}/aub_stream EXCLUDE_FROM_ALL)
+    add_subdirectory_unique(${AUB_STREAM_DIR} ${CMAKE_BINARY_DIR}/aub_stream EXCLUDE_FROM_ALL)
     set(ENGINE_NODE_DIR ${AUB_STREAM_DIR}/aub_mem_dump${BRANCH_DIR_SUFFIX}/includes)
 else()
     set(ENGINE_NODE_DIR ${AUB_STREAM_HEADERS_DIR})
@@ -466,9 +466,9 @@ option(APPVERIFIER_ALLOWED "allow use of AppVerifier" OFF)
 option(CCACHE_ALLOWED "allow use of ccache" TRUE)
 find_program(CCACHE_EXE_FOUND ccache)
 if(CCACHE_EXE_FOUND AND CCACHE_ALLOWED)
-	message(STATUS "Found ccache: ${CCACHE_EXE_FOUND}")
-	set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
-	set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
+  message(STATUS "Found ccache: ${CCACHE_EXE_FOUND}")
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
+  set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
 endif()
 
 # Miscs options
@@ -479,177 +479,177 @@ set(CL_CACHE_LOCATION "cl_cache" CACHE STRING "OpenCL program binary cache locat
 
 # Put profiling enable flag into define
 if(OCL_RUNTIME_PROFILING)
-	add_definitions(-DOCL_RUNTIME_PROFILING=${OCL_RUNTIME_PROFILING})
+  add_definitions(-DOCL_RUNTIME_PROFILING=${OCL_RUNTIME_PROFILING})
 endif()
 
 if(MSVC)
-	# Force to treat warnings as errors
-	if(NOT CMAKE_CXX_FLAGS MATCHES "/WX")
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
+  # Force to treat warnings as errors
+  if(NOT CMAKE_CXX_FLAGS MATCHES "/WX")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /WX")
         if("${CMAKE_BUILD_TYPE}" STREQUAL "Debug")
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /we4189")
         endif()
-	endif()
+  endif()
 
 # Disable generating manifest
-	set(LINKER_FLAGS "/MANIFEST:NO")
+  set(LINKER_FLAGS "/MANIFEST:NO")
 
 # Support for WUD
-	set(CMAKE_CXX_STANDARD_LIBRARIES "onecore.lib")
-	foreach(IT kernel32.lib;user32.lib;gdi32.lib;advapi32.lib;ole32.lib;)
-		set(LINKER_FLAGS "${LINKER_FLAGS} /NODEFAULTLIB:${IT}")
-	endforeach()
-	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
-	set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
-	set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
-	add_definitions(-DUNICODE -D_UNICODE)
-	link_directories("${WDK_DIR}/Lib/${WindowsTargetPlatformVersion}/um/${NEO_ARCH}/")
+  set(CMAKE_CXX_STANDARD_LIBRARIES "onecore.lib")
+  foreach(IT kernel32.lib;user32.lib;gdi32.lib;advapi32.lib;ole32.lib;)
+    set(LINKER_FLAGS "${LINKER_FLAGS} /NODEFAULTLIB:${IT}")
+  endforeach()
+  set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${LINKER_FLAGS}")
+  set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${LINKER_FLAGS}")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${LINKER_FLAGS}")
+  add_definitions(-DUNICODE -D_UNICODE)
+  link_directories("${WDK_DIR}/Lib/${WindowsTargetPlatformVersion}/um/${NEO_ARCH}/")
 else()
-	if(IGDRCL_GCOV)
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage --coverage")
-	endif()
-	option(USE_ASAN "Link with address sanitization support" OFF)
-	if(USE_ASAN)
-		if(CMAKE_COMPILER_IS_GNUCC)
-			set(ASAN_FLAGS " -fsanitize=address -fno-omit-frame-pointer -DSANITIZER_BUILD")
-			set(ASAN_LIBS "asan")
-		else()
-			message(STATUS "Address sanitization with clang not yet support")
-		endif()
-	endif()
-	if(USE_TSAN)
-		if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-			set(TSAN_FLAGS " -fsanitize=thread -DSANITIZER_BUILD")
-			set(TSAN_LIBS "tsan")
-		else()
-			message(STATUS "Thread sanitization with gcc is not fully supported")
-		endif()
-	endif()
+  if(IGDRCL_GCOV)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage --coverage")
+  endif()
+  option(USE_ASAN "Link with address sanitization support" OFF)
+  if(USE_ASAN)
+    if(CMAKE_COMPILER_IS_GNUCC)
+      set(ASAN_FLAGS " -fsanitize=address -fno-omit-frame-pointer -DSANITIZER_BUILD")
+      set(ASAN_LIBS "asan")
+    else()
+      message(STATUS "Address sanitization with clang not yet support")
+    endif()
+  endif()
+  if(USE_TSAN)
+    if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+      set(TSAN_FLAGS " -fsanitize=thread -DSANITIZER_BUILD")
+      set(TSAN_LIBS "tsan")
+    else()
+      message(STATUS "Thread sanitization with gcc is not fully supported")
+    endif()
+  endif()
 
 endif()
 
 # setup variables needed for custom configuration type
 # generate PDB files even for release build on MSVC
 if(MSVC)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
-	set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
-	set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /MP")
+  set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /Zi")
+  set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DEBUG /OPT:REF /OPT:ICF")
 
-	set(CMAKE_CXX_FLAGS_RELEASEINTERNAL "${CMAKE_CXX_FLAGS_RELEASEINTERNAL} /Zi")
-	set(CMAKE_SHARED_LINKER_FLAGS_RELEASEINTERNAL "${CMAKE_SHARED_LINKER_FLAGS_RELEASEINTERNAL} /DEBUG /OPT:REF /OPT:ICF")
+  set(CMAKE_CXX_FLAGS_RELEASEINTERNAL "${CMAKE_CXX_FLAGS_RELEASEINTERNAL} /Zi")
+  set(CMAKE_SHARED_LINKER_FLAGS_RELEASEINTERNAL "${CMAKE_SHARED_LINKER_FLAGS_RELEASEINTERNAL} /DEBUG /OPT:REF /OPT:ICF")
 endif()
 
 # spectre mitigation
 include(CheckCXXCompilerFlag)
 if(MSVC)
-	check_cxx_compiler_flag(/Qspectre COMPILER_SUPPORTS_QSPECTRE)
-	check_cxx_compiler_flag(/d2guardspecload COMPILER_SUPPORTS_D2GUARDSPECLOAD)
-	if(COMPILER_SUPPORTS_QSPECTRE)
-		SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qspectre")
-	elseif(COMPILER_SUPPORTS_D2GUARDSPECLOAD)
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /d2guardspecload")
-	else()
-		message(WARNING "Spectre mitigation is not supported by the compiler")
-	endif()
+  check_cxx_compiler_flag(/Qspectre COMPILER_SUPPORTS_QSPECTRE)
+  check_cxx_compiler_flag(/d2guardspecload COMPILER_SUPPORTS_D2GUARDSPECLOAD)
+  if(COMPILER_SUPPORTS_QSPECTRE)
+    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Qspectre")
+  elseif(COMPILER_SUPPORTS_D2GUARDSPECLOAD)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /d2guardspecload")
+  else()
+    message(WARNING "Spectre mitigation is not supported by the compiler")
+  endif()
 else()
-	if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-		check_cxx_compiler_flag(-mretpoline COMPILER_SUPPORTS_RETPOLINE)
-		if(COMPILER_SUPPORTS_RETPOLINE)
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mretpoline")
-		else()
-			message(WARNING "Spectre mitigation -mretpoline flag is not supported by the compiler")
-		endif()
-	else()
-		check_cxx_compiler_flag(-mindirect-branch=thunk COMPILER_SUPPORTS_INDIRECT_BRANCH_THUNK)
-		if(COMPILER_SUPPORTS_INDIRECT_BRANCH_THUNK)
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mindirect-branch=thunk")
-		else()
-			message(WARNING "Spectre mitigation -mindirect-branch=thunk flag is not supported by the compiler")
-		endif()
-		check_cxx_compiler_flag(-mfunction-return=thunk COMPILER_SUPPORTS_FUNCTION_RETURN_THUNK)
-		if(COMPILER_SUPPORTS_FUNCTION_RETURN_THUNK)
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfunction-return=thunk")
-		else()
-			message(WARNING "Spectre mitigation -mfunction-return=thunk flag is not supported by the compiler")
-		endif()
-		check_cxx_compiler_flag(-mindirect-branch-register COMPILER_SUPPORTS_INDIRECT_BRANCH_REGISTER)
-		if(COMPILER_SUPPORTS_INDIRECT_BRANCH_REGISTER)
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mindirect-branch-register")
-		else()
-			message(WARNING "Spectre mitigation -mindirect-branch-register flag is not supported by the compiler")
-		endif()
-	endif()
+  if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+    check_cxx_compiler_flag(-mretpoline COMPILER_SUPPORTS_RETPOLINE)
+    if(COMPILER_SUPPORTS_RETPOLINE)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mretpoline")
+    else()
+      message(WARNING "Spectre mitigation -mretpoline flag is not supported by the compiler")
+    endif()
+  else()
+    check_cxx_compiler_flag(-mindirect-branch=thunk COMPILER_SUPPORTS_INDIRECT_BRANCH_THUNK)
+    if(COMPILER_SUPPORTS_INDIRECT_BRANCH_THUNK)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mindirect-branch=thunk")
+    else()
+      message(WARNING "Spectre mitigation -mindirect-branch=thunk flag is not supported by the compiler")
+    endif()
+    check_cxx_compiler_flag(-mfunction-return=thunk COMPILER_SUPPORTS_FUNCTION_RETURN_THUNK)
+    if(COMPILER_SUPPORTS_FUNCTION_RETURN_THUNK)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfunction-return=thunk")
+    else()
+      message(WARNING "Spectre mitigation -mfunction-return=thunk flag is not supported by the compiler")
+    endif()
+    check_cxx_compiler_flag(-mindirect-branch-register COMPILER_SUPPORTS_INDIRECT_BRANCH_REGISTER)
+    if(COMPILER_SUPPORTS_INDIRECT_BRANCH_REGISTER)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mindirect-branch-register")
+    else()
+      message(WARNING "Spectre mitigation -mindirect-branch-register flag is not supported by the compiler")
+    endif()
+  endif()
 endif(MSVC)
 
 if(NOT MSVC)
-	SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=1024")
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ftemplate-depth=1024")
 endif(NOT MSVC)
 
 # Compiler warning flags
 if(NOT MSVC)
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wempty-body")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wignored-qualifiers")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wtype-limits")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wuninitialized")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra -Wno-unused-parameter -Wno-missing-field-initializers")
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Winvalid-pch")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wempty-body")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wignored-qualifiers")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wtype-limits")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wuninitialized")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wextra -Wno-unused-parameter -Wno-missing-field-initializers")
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Winvalid-pch")
 
-	if("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" )
-		# clang only
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshorten-64-to-32")
-		if(USE_SANITIZE_UB)
-			message(STATUS "Enabling undefined behavior sanitizer")
+  if("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" )
+    # clang only
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wshorten-64-to-32")
+    if(USE_SANITIZE_UB)
+      message(STATUS "Enabling undefined behavior sanitizer")
             set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=undefined -fno-sanitize-recover=undefined -fsanitize-recover=vptr -fno-rtti -DSANITIZER_BUILD")
-		endif(USE_SANITIZE_UB)
-		if (NOT (CMAKE_C_COMPILER_VERSION VERSION_LESS 3.6))
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-local-typedefs -DSANITIZER_BUILD")
-		endif()
-		if (NOT (CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0))
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-register") # Added for htons()
-		endif()
-	else()
-		# gcc only
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-local-typedefs -Wno-unused-but-set-variable")
-		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wclobbered")
-		if (CMAKE_C_COMPILER_VERSION VERSION_LESS 7.0)
-		else()
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wimplicit-fallthrough=4")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-noexcept-type")	# Added for gtest
-		endif()
-	endif()
-	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
+    endif(USE_SANITIZE_UB)
+    if (NOT (CMAKE_C_COMPILER_VERSION VERSION_LESS 3.6))
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-local-typedefs -DSANITIZER_BUILD")
+    endif()
+    if (NOT (CMAKE_C_COMPILER_VERSION VERSION_LESS 4.0))
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-deprecated-register") # Added for htons()
+    endif()
+  else()
+    # gcc only
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-local-typedefs -Wno-unused-but-set-variable")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wclobbered")
+    if (CMAKE_C_COMPILER_VERSION VERSION_LESS 7.0)
+    else()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wimplicit-fallthrough=4")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-noexcept-type")  # Added for gtest
+    endif()
+  endif()
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
 endif()
 
 # Compile code with defenses enabled (settings to be used for production release code)
 if("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
-	if(MSVC)
-		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GS")
-		set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /sdl")
-		set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /NXCompat")
-		set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DynamicBase")
-		if("${NEO_ARCH}" STREQUAL "x86")
-			set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SafeSEH")
-		endif()
-	else()
-		if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -D_FORTIFY_SOURCE=2")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security")
-		else()
-			# gcc, g++ only
-			if (CMAKE_C_COMPILER_VERSION VERSION_LESS 4.9)
-				set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
-			else()
-				set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
-			endif()
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -D_FORTIFY_SOURCE=2")
-			set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security")
-			set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,-z,noexecstack")
-			set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,-z,relro")
-			set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,-z,now")
-		endif()
-	endif()
+  if(MSVC)
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /GS")
+    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /sdl")
+    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /NXCompat")
+    set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /DynamicBase")
+    if("${NEO_ARCH}" STREQUAL "x86")
+      set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} /SafeSEH")
+    endif()
+  else()
+    if(${CMAKE_CXX_COMPILER_ID} STREQUAL "Clang")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -D_FORTIFY_SOURCE=2")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security")
+    else()
+      # gcc, g++ only
+      if (CMAKE_C_COMPILER_VERSION VERSION_LESS 4.9)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector")
+      else()
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fstack-protector-strong")
+      endif()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O2 -D_FORTIFY_SOURCE=2")
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat -Wformat-security")
+      set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,-z,noexecstack")
+      set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,-z,relro")
+      set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} -Wl,-z,now")
+    endif()
+  endif()
 endif()
 
 # Project-wide include paths
@@ -686,9 +686,9 @@ else()
 	set(TargetDir ${CMAKE_RUNTIME_OUTPUT_DIRECTORY})
 endif(MSVC)
 
-add_subdirectory(offline_compiler ${IGDRCL_BUILD_DIR}/offline_compiler)
+add_subdirectory_unique(offline_compiler ${IGDRCL_BUILD_DIR}/offline_compiler)
 target_compile_definitions(ocloc PRIVATE MOCKABLE_VIRTUAL=)
-add_subdirectory(core)
+add_subdirectory_unique(core)
 
 macro(generate_runtime_lib LIB_NAME MOCKABLE GENERATE_EXEC)
 	set(NEO_STATIC_LIB_NAME ${LIB_NAME})
@@ -719,7 +719,7 @@ set(BUILTINS_SOURCES_LIB_NAME "builtins_sources")
 set(BUILTINS_BINARIES_LIB_NAME "builtins_binaries")
 set(SCHEDULER_BINARY_LIB_NAME "scheduler_binary")
 
-add_subdirectory(elf)
+add_subdirectory_unique(elf)
 if(DONT_CARE_OF_VIRTUALS)
     message(STATUS "All targets will use virtuals")
 
@@ -736,16 +736,18 @@ else()
 endif()
 
 if(DEFAULT_TESTED_PLATFORM)
-  add_subdirectory(unit_tests ${IGDRCL_BUILD_DIR}/unit_tests)
+  add_subdirectory_unique(unit_tests ${IGDRCL_BUILD_DIR}/unit_tests)
+else() 
+  hide_subdir(unit_tests)
 endif()
 
 set(DONT_LINK_ELF_STATICALLY TRUE)
 if(EXISTS ${IGDRCL_SOURCE_DIR}/../internal)
-	add_subdirectory(${IGDRCL_SOURCE_DIR}/../internal ${IGDRCL_BUILD_DIR}/internal)
+  add_subdirectory_unique(${IGDRCL_SOURCE_DIR}/../internal ${IGDRCL_BUILD_DIR}/internal)
 endif(EXISTS ${IGDRCL_SOURCE_DIR}/../internal)
 
 include(package.cmake)
-add_subdirectory(scripts/lint)
+add_subdirectory_unique(scripts/lint)
 
 configure_file(config.h.in ${IGDRCL_BUILD_DIR}/config.h)
 if(WIN32 AND NOT IGDRCL__IGC_FOUND)
@@ -753,3 +755,6 @@ if(WIN32 AND NOT IGDRCL__IGC_FOUND)
 endif()
 configure_file(driver_version.h.in ${IGDRCL_BUILD_DIR}/driver_version.h) # Put Driver version into define
 configure_file(lib_names.h.in ${IGDRCL_BUILD_DIR}/lib_names.h)
+
+hide_subdir(runtime)
+add_subdirectories()
diff --git a/common_macros.cmake b/common_macros.cmake
index f514b185e2..997e15a066 100644
--- a/common_macros.cmake
+++ b/common_macros.cmake
@@ -1,5 +1,5 @@
 #
-# Copyright (C) 2018 Intel Corporation
+# Copyright (C) 2018-2019 Intel Corporation
 #
 # SPDX-License-Identifier: MIT
 #
@@ -9,6 +9,14 @@ macro(hide_subdir subdir)
   set(${subdir_relative}_hidden} TRUE)
 endmacro()
 
+macro(add_subdirectory_unique subdir)
+  file(RELATIVE_PATH subdir_relative ${IGDRCL_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/${subdir})
+  if(NOT ${subdir_relative}_hidden})
+    add_subdirectory(${subdir} ${ARGN})
+  endif()
+  hide_subdir(${subdir})
+endmacro()
+
 macro(add_subdirectories)
   file(GLOB subdirectories RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/*)
   foreach(subdir ${subdirectories})