function(caffe_get_items_with_prefix prefix list_variable output_variable)

set(__result "")

foreach(__e ${${list_variable}})

if(__e MATCHES "^${prefix}.*")

list(APPEND __result ${__e})

endif()

endforeach()

set(${output_variable} ${__result} PARENT_SCOPE)

endfunction()

function(caffe_generate_export_configs)

set(install_cmake_suffix "share/Caffe")

if(NOT HAVE_CUDA)

set(HAVE_CUDA FALSE)

endif()

if(NOT HAVE_CUDNN)

set(HAVE_CUDNN FALSE)

endif()

# ---[ Configure build-tree CaffeConfig.cmake file ]---

configure_file("cmake/Templates/CaffeConfig.cmake.in" "${PROJECT_BINARY_DIR}/CaffeConfig.cmake" @ONLY)

# Add targets to the build-tree export set

export(TARGETS caffe caffeproto FILE "${PROJECT_BINARY_DIR}/CaffeTargets.cmake")

export(PACKAGE Caffe)

# ---[ Configure install-tree CaffeConfig.cmake file ]---

configure_file("cmake/Templates/CaffeConfig.cmake.in" "${PROJECT_BINARY_DIR}/cmake/CaffeConfig.cmake" @ONLY)

# Install the CaffeConfig.cmake and export set to use with install-tree

install(FILES "${PROJECT_BINARY_DIR}/cmake/CaffeConfig.cmake" DESTINATION ${install_cmake_suffix})

install(EXPORT CaffeTargets DESTINATION ${install_cmake_suffix})

# ---[ Configure and install version file ]---

# TODO: Lines below are commented because Caffe doesn't declare its version in headers.

# When the declarations are added, modify `caffe_extract_caffe_version()` macro and uncomment

# configure_file(cmake/Templates/CaffeConfigVersion.cmake.in "${PROJECT_BINARY_DIR}/CaffeConfigVersion.cmake" @ONLY)

# install(FILES "${PROJECT_BINARY_DIR}/CaffeConfigVersion.cmake" DESTINATION ${install_cmake_suffix})

endfunction()

if(CPU_ONLY)

return()

endif()

set(Caffe_known_gpu_archs "20 21(20) 30 35 50 60 61")

function(caffe_detect_installed_gpus out_variable)

if(NOT CUDA_gpu_detect_output)

set(__cufile ${PROJECT_BINARY_DIR}/detect_cuda_archs.cu)

file(WRITE ${__cufile} ""

"#include <cstdio>\n"

"int main()\n"

"{\n"

" int count = 0;\n"

" if (cudaSuccess != cudaGetDeviceCount(&count)) return -1;\n"

" if (count == 0) return -1;\n"

" for (int device = 0; device < count; ++device)\n"

" {\n"

" cudaDeviceProp prop;\n"

" if (cudaSuccess == cudaGetDeviceProperties(&prop, device))\n"

" std::printf(\"%d.%d \", prop.major, prop.minor);\n"

" }\n"

" return 0;\n"

"}\n")

execute_process(COMMAND "${CUDA_NVCC_EXECUTABLE}" "--run" "${__cufile}"

WORKING_DIRECTORY "${PROJECT_BINARY_DIR}/CMakeFiles/"

RESULT_VARIABLE __nvcc_res OUTPUT_VARIABLE __nvcc_out

ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

if(__nvcc_res EQUAL 0)

string(REPLACE "2.1" "2.1(2.0)" __nvcc_out "${__nvcc_out}")

set(CUDA_gpu_detect_output ${__nvcc_out} CACHE INTERNAL "Returned GPU architetures from caffe_detect_gpus tool" FORCE)

endif()

endif()

if(NOT CUDA_gpu_detect_output)

message(STATUS "Automatic GPU detection failed. Building for all known architectures.")

set(${out_variable} ${Caffe_known_gpu_archs} PARENT_SCOPE)

else()

set(${out_variable} ${CUDA_gpu_detect_output} PARENT_SCOPE)

endif()

endfunction()

function(caffe_select_nvcc_arch_flags out_variable)

# List of arch names

set(__archs_names "Fermi" "Kepler" "Maxwell" "Pascal" "All" "Manual")

set(__archs_name_default "All")

if(NOT CMAKE_CROSSCOMPILING)

list(APPEND __archs_names "Auto")

set(__archs_name_default "Auto")

endif()

# set CUDA_ARCH_NAME strings (so it will be seen as dropbox in CMake-Gui)

set(CUDA_ARCH_NAME ${__archs_name_default} CACHE STRING "Select target NVIDIA GPU achitecture.")

set_property( CACHE CUDA_ARCH_NAME PROPERTY STRINGS "" ${__archs_names} )

mark_as_advanced(CUDA_ARCH_NAME)

# verify CUDA_ARCH_NAME value

if(NOT ";${__archs_names};" MATCHES ";${CUDA_ARCH_NAME};")

string(REPLACE ";" ", " __archs_names "${__archs_names}")

message(FATAL_ERROR "Only ${__archs_names} architeture names are supported.")

endif()

if(${CUDA_ARCH_NAME} STREQUAL "Manual")

set(CUDA_ARCH_BIN ${Caffe_known_gpu_archs} CACHE STRING "Specify 'real' GPU architectures to build binaries for, BIN(PTX) format is supported")

set(CUDA_ARCH_PTX "50" CACHE STRING "Specify 'virtual' PTX architectures to build PTX intermediate code for")

mark_as_advanced(CUDA_ARCH_BIN CUDA_ARCH_PTX)

else()

unset(CUDA_ARCH_BIN CACHE)

unset(CUDA_ARCH_PTX CACHE)

endif()

if(${CUDA_ARCH_NAME} STREQUAL "Fermi")

set(__cuda_arch_bin "20 21(20)")

elseif(${CUDA_ARCH_NAME} STREQUAL "Kepler")

set(__cuda_arch_bin "30 35")

elseif(${CUDA_ARCH_NAME} STREQUAL "Maxwell")

set(__cuda_arch_bin "50")

elseif(${CUDA_ARCH_NAME} STREQUAL "Pascal")

set(__cuda_arch_bin "60 61")

elseif(${CUDA_ARCH_NAME} STREQUAL "All")

set(__cuda_arch_bin ${Caffe_known_gpu_archs})

elseif(${CUDA_ARCH_NAME} STREQUAL "Auto")

caffe_detect_installed_gpus(__cuda_arch_bin)

else() # (${CUDA_ARCH_NAME} STREQUAL "Manual")

set(__cuda_arch_bin ${CUDA_ARCH_BIN})

endif()

# remove dots and convert to lists

string(REGEX REPLACE "\\." "" __cuda_arch_bin "${__cuda_arch_bin}")

string(REGEX REPLACE "\\." "" __cuda_arch_ptx "${CUDA_ARCH_PTX}")

string(REGEX MATCHALL "[0-9()]+" __cuda_arch_bin "${__cuda_arch_bin}")

string(REGEX MATCHALL "[0-9]+" __cuda_arch_ptx "${__cuda_arch_ptx}")

caffe_list_unique(__cuda_arch_bin __cuda_arch_ptx)

set(__nvcc_flags "")

set(__nvcc_archs_readable "")

# Tell NVCC to add binaries for the specified GPUs

foreach(__arch ${__cuda_arch_bin})

if(__arch MATCHES "([0-9]+)\\(([0-9]+)\\)")

# User explicitly specified PTX for the concrete BIN

list(APPEND __nvcc_flags -gencode arch=compute_${CMAKE_MATCH_2},code=sm_${CMAKE_MATCH_1})

list(APPEND __nvcc_archs_readable sm_${CMAKE_MATCH_1})

else()

# User didn't explicitly specify PTX for the concrete BIN, we assume PTX=BIN

list(APPEND __nvcc_flags -gencode arch=compute_${__arch},code=sm_${__arch})

list(APPEND __nvcc_archs_readable sm_${__arch})

endif()

endforeach()

# Tell NVCC to add PTX intermediate code for the specified architectures

foreach(__arch ${__cuda_arch_ptx})

list(APPEND __nvcc_flags -gencode arch=compute_${__arch},code=compute_${__arch})

list(APPEND __nvcc_archs_readable compute_${__arch})

endforeach()

string(REPLACE ";" " " __nvcc_archs_readable "${__nvcc_archs_readable}")

set(${out_variable} ${__nvcc_flags} PARENT_SCOPE)

set(${out_variable}_readable ${__nvcc_archs_readable} PARENT_SCOPE)

endfunction()

macro(caffe_cuda_compile objlist_variable)

foreach(var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)

set(${var}_backup_in_cuda_compile_ "${${var}}")

# we remove /EHa as it generates warnings under windows

string(REPLACE "/EHa" "" ${var} "${${var}}")

endforeach()

if(UNIX OR APPLE)

list(APPEND CUDA_NVCC_FLAGS -Xcompiler -fPIC)

endif()

if(APPLE)

list(APPEND CUDA_NVCC_FLAGS -Xcompiler -Wno-unused-function)

endif()

cuda_compile(cuda_objcs ${ARGN})

foreach(var CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_RELEASE CMAKE_CXX_FLAGS_DEBUG)

set(${var} "${${var}_backup_in_cuda_compile_}")

unset(${var}_backup_in_cuda_compile_)

endforeach()

set(${objlist_variable} ${cuda_objcs})

endmacro()

function(detect_cuDNN)

set(CUDNN_ROOT "" CACHE PATH "CUDNN root folder")

find_path(CUDNN_INCLUDE cudnn.h

PATHS ${CUDNN_ROOT} $ENV{CUDNN_ROOT} ${CUDA_TOOLKIT_INCLUDE}

DOC "Path to cuDNN include directory." )

# dynamic libs have different suffix in mac and linux

if(APPLE)

set(CUDNN_LIB_NAME "libcudnn.dylib")

else()

set(CUDNN_LIB_NAME "libcudnn.so")

endif()

get_filename_component(__libpath_hist ${CUDA_CUDART_LIBRARY} PATH)

find_library(CUDNN_LIBRARY NAMES ${CUDNN_LIB_NAME}

PATHS ${CUDNN_ROOT} $ENV{CUDNN_ROOT} ${CUDNN_INCLUDE} ${__libpath_hist} ${__libpath_hist}/../lib

DOC "Path to cuDNN library.")

if(CUDNN_INCLUDE AND CUDNN_LIBRARY)

set(HAVE_CUDNN TRUE PARENT_SCOPE)

set(CUDNN_FOUND TRUE PARENT_SCOPE)

file(READ ${CUDNN_INCLUDE}/cudnn.h CUDNN_VERSION_FILE_CONTENTS)

# cuDNN v3 and beyond

string(REGEX MATCH "define CUDNN_MAJOR * +([0-9]+)"

CUDNN_VERSION_MAJOR "${CUDNN_VERSION_FILE_CONTENTS}")

string(REGEX REPLACE "define CUDNN_MAJOR * +([0-9]+)" "\\1"

CUDNN_VERSION_MAJOR "${CUDNN_VERSION_MAJOR}")

string(REGEX MATCH "define CUDNN_MINOR * +([0-9]+)"

CUDNN_VERSION_MINOR "${CUDNN_VERSION_FILE_CONTENTS}")

string(REGEX REPLACE "define CUDNN_MINOR * +([0-9]+)" "\\1"

CUDNN_VERSION_MINOR "${CUDNN_VERSION_MINOR}")

string(REGEX MATCH "define CUDNN_PATCHLEVEL * +([0-9]+)"

CUDNN_VERSION_PATCH "${CUDNN_VERSION_FILE_CONTENTS}")

string(REGEX REPLACE "define CUDNN_PATCHLEVEL * +([0-9]+)" "\\1"

CUDNN_VERSION_PATCH "${CUDNN_VERSION_PATCH}")

if(NOT CUDNN_VERSION_MAJOR)

set(CUDNN_VERSION "???")

else()

set(CUDNN_VERSION "${CUDNN_VERSION_MAJOR}.${CUDNN_VERSION_MINOR}.${CUDNN_VERSION_PATCH}")

endif()

message(STATUS "Found cuDNN: ver. ${CUDNN_VERSION} found (include: ${CUDNN_INCLUDE}, library: ${CUDNN_LIBRARY})")

string(COMPARE LESS "${CUDNN_VERSION_MAJOR}" 3 cuDNNVersionIncompatible)

if(cuDNNVersionIncompatible)

message(FATAL_ERROR "cuDNN version >3 is required.")

endif()

set(CUDNN_VERSION "${CUDNN_VERSION}" PARENT_SCOPE)

mark_as_advanced(CUDNN_INCLUDE CUDNN_LIBRARY CUDNN_ROOT)

endif()

endfunction()

find_package(CUDA 5.5 QUIET)

find_cuda_helper_libs(curand) # cmake 2.8.7 compartibility which doesn't search for curand

if(NOT CUDA_FOUND)

return()

endif()

set(HAVE_CUDA TRUE)

message(STATUS "CUDA detected: " ${CUDA_VERSION})

list(APPEND Caffe_INCLUDE_DIRS PUBLIC ${CUDA_INCLUDE_DIRS})

list(APPEND Caffe_LINKER_LIBS PUBLIC ${CUDA_CUDART_LIBRARY}

${CUDA_curand_LIBRARY} ${CUDA_CUBLAS_LIBRARIES})

if(USE_CUDNN)

detect_cuDNN()

if(HAVE_CUDNN)

list(APPEND Caffe_DEFINITIONS PUBLIC -DUSE_CUDNN)

list(APPEND Caffe_INCLUDE_DIRS PUBLIC ${CUDNN_INCLUDE})

list(APPEND Caffe_LINKER_LIBS PUBLIC ${CUDNN_LIBRARY})

endif()

endif()

caffe_select_nvcc_arch_flags(NVCC_FLAGS_EXTRA)

list(APPEND CUDA_NVCC_FLAGS ${NVCC_FLAGS_EXTRA})

message(STATUS "Added CUDA NVCC flags for: ${NVCC_FLAGS_EXTRA_readable}")

if(Boost_VERSION EQUAL 105500)

message(STATUS "Cuda + Boost 1.55: Applying noinline work around")

# avoid warning for CMake >= 2.8.12

set(CUDA_NVCC_FLAGS "${CUDA_NVCC_FLAGS} \"-DBOOST_NOINLINE=__attribute__((noinline))\" ")

endif()

foreach(diag cc_clobber_ignored integer_sign_change useless_using_declaration set_but_not_used)

list(APPEND CUDA_NVCC_FLAGS -Xcudafe --diag_suppress=${diag})

endforeach()

if(NOT CUDA_TEST_DEVICE)

set(CUDA_TEST_DEVICE -1)

endif()

mark_as_advanced(CUDA_BUILD_CUBIN CUDA_BUILD_EMULATION CUDA_VERBOSE_BUILD)

mark_as_advanced(CUDA_SDK_ROOT_DIR CUDA_SEPARABLE_COMPILATION)

if(APPLE)

caffe_detect_darwin_version(OSX_VERSION)

# OSX 10.9 and higher uses clang/libc++ by default which is incompatible with old CUDA toolkits

if(OSX_VERSION VERSION_GREATER 10.8)

# enabled by default if and only if CUDA version is less than 7.0

caffe_option(USE_libstdcpp "Use libstdc++ instead of libc++" (CUDA_VERSION VERSION_LESS 7.0))

endif()

endif()