reactos/CMake
1
0
Fork 0
mirror of https://github.com/reactos/CMake.git synced 2024-11-26 21:10:29 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
b8a6300e6e
CMake/Modules/ProcessorCount.cmake

238 lines
8.4 KiB
CMake
Raw Normal View History

Simplify CMake per-source license notices Per-source copyright/license notice headers that spell out copyright holder names and years are hard to maintain and often out-of-date or plain wrong. Precise contributor information is already maintained automatically by the version control tool. Ultimately it is the receiver of a file who is responsible for determining its licensing status, and per-source notices are merely a convenience. Therefore it is simpler and more accurate for each source to have a generic notice of the license name and references to more detailed information on copyright holders and full license terms. Our `Copyright.txt` file now contains a list of Contributors whose names appeared source-level copyright notices. It also references version control history for more precise information. Therefore we no longer need to spell out the list of Contributors in each source file notice. Replace CMake per-source copyright/license notice headers with a short description of the license and links to `Copyright.txt` and online information available from "https://cmake.org/licensing". The online URL also handles cases of modules being copied out of our source into other projects, so we can drop our notices about replacing links with full license text. Run the `Utilities/Scripts/filter-notices.bash` script to perform the majority of the replacements mechanically. Manually fix up shebang lines and trailing newlines in a few files. Manually update the notices in a few files that the script does not handle.
2016-09-27 19:01:08 +00:00
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
#[=======================================================================[.rst:
ProcessorCount
--------------
ProcessorCount(var)
Determine the number of processors/cores and save value in ${var}
Sets the variable named ${var} to the number of physical cores
available on the machine if the information can be determined.
Otherwise it is set to 0. Currently this functionality is implemented
Remove now-unused code once used on IRIX We dropped support for IRIX as a host platform long ago. Remove some leftover code.
2019-01-11 18:50:46 +00:00
for AIX, cygwin, FreeBSD, HPUX, Linux, macOS, QNX, Sun and
Help: Convert remaining modules to block-style comments
2018-10-22 14:31:08 +00:00
Windows.
This function is guaranteed to return a positive integer (>=1) if it
succeeds. It returns 0 if there's a problem determining the processor
count.
Example use, in a ctest -S dashboard script:
::
include(ProcessorCount)
ProcessorCount(N)
if(NOT N EQUAL 0)
set(CTEST_BUILD_FLAGS -j${N})
set(ctest_test_args ${ctest_test_args} PARALLEL_LEVEL ${N})
endif()
This function is intended to offer an approximation of the value of
the number of compute cores available on the current machine, such
that you may use that value for parallel building and parallel
testing. It is meant to help utilize as much of the machine as seems
reasonable. Of course, knowledge of what else might be running on the
machine simultaneously should be used when deciding whether to request
a machine's full capacity all for yourself.
#]=======================================================================]
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
# A more reliable way might be to compile a small C program that uses the CPUID
# instruction, but that again requires compiler support or compiling assembler
# code.
function(ProcessorCount var)
# Unknown:
set(count 0)
if(WIN32)
# Windows:
set(count "$ENV{NUMBER_OF_PROCESSORS}")
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: WIN32, trying environment variable")
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
if(NOT count)
# Mac, FreeBSD, OpenBSD (systems with sysctl):
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
find_program(ProcessorCount_cmd_sysctl sysctl
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
PATHS /usr/sbin /sbin)
ProcessorCount: Mark find_program vars as advanced (#13236) After each find_program call, mark_as_advanced each find result variable to avoid polluting the cache with non-advanced variables
2012-08-17 14:53:37 +00:00
mark_as_advanced(ProcessorCount_cmd_sysctl)
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
if(ProcessorCount_cmd_sysctl)
execute_process(COMMAND ${ProcessorCount_cmd_sysctl} -n hw.ncpu
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
ERROR_QUIET
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE count)
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: trying sysctl '${ProcessorCount_cmd_sysctl}'")
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
endif()
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
ProcessorCount: Return the container CPU count instead of the host count On Linux containers (tested with LXC and Docker) getconf returns the host CPU count. Use nproc with a higher priority if available to get the container's allocated CPUs instead of the non-accessible host count.
2019-02-27 11:47:07 +00:00
if(NOT count)
# Linux (systems with nproc):
# Prefer nproc to getconf if available as getconf may return the host CPU count in Linux containers
find_program(ProcessorCount_cmd_nproc nproc)
mark_as_advanced(ProcessorCount_cmd_nproc)
if(ProcessorCount_cmd_nproc)
execute_process(COMMAND ${ProcessorCount_cmd_nproc}
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE count)
#message("ProcessorCount: trying nproc '${ProcessorCount_cmd_nproc}'")
endif()
endif()
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
if(NOT count)
Add ProcessorCount support for QNX via pidin. (#11302) Thanks to Rolf Eike Beer <eike@sf-mail.de> for the code snippet parsing the pidin output.
2010-11-08 14:37:04 +00:00
# Linux (systems with getconf):
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
find_program(ProcessorCount_cmd_getconf getconf)
ProcessorCount: Mark find_program vars as advanced (#13236) After each find_program call, mark_as_advanced each find result variable to avoid polluting the cache with non-advanced variables
2012-08-17 14:53:37 +00:00
mark_as_advanced(ProcessorCount_cmd_getconf)
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
if(ProcessorCount_cmd_getconf)
execute_process(COMMAND ${ProcessorCount_cmd_getconf} _NPROCESSORS_ONLN
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
ERROR_QUIET
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE count)
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: trying getconf '${ProcessorCount_cmd_getconf}'")
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
endif()
if(NOT count)
# HPUX (systems with machinfo):
find_program(ProcessorCount_cmd_machinfo machinfo
PATHS /usr/contrib/bin)
ProcessorCount: Mark find_program vars as advanced (#13236) After each find_program call, mark_as_advanced each find result variable to avoid polluting the cache with non-advanced variables
2012-08-17 14:53:37 +00:00
mark_as_advanced(ProcessorCount_cmd_machinfo)
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
if(ProcessorCount_cmd_machinfo)
execute_process(COMMAND ${ProcessorCount_cmd_machinfo}
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
ERROR_QUIET
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE machinfo_output)
string(REGEX MATCHALL "Number of CPUs = ([0-9]+)" procs "${machinfo_output}")
set(count "${CMAKE_MATCH_1}")
ProcessorCount: Update for HPUX 11iv3
2014-06-10 15:26:24 +00:00
if(NOT count)
string(REGEX MATCHALL "([0-9]+) logical processors" procs "${machinfo_output}")
set(count "${CMAKE_MATCH_1}")
endif()
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: trying machinfo '${ProcessorCount_cmd_machinfo}'")
ProcessorCount: use mpsched on HPUX if machinfo is not present Co-Author: Gerhard Grimm <gerhard.grimm@detec.com>
2014-03-28 16:59:31 +00:00
else()
find_program(ProcessorCount_cmd_mpsched mpsched)
mark_as_advanced(ProcessorCount_cmd_mpsched)
if(ProcessorCount_cmd_mpsched)
execute_process(COMMAND ${ProcessorCount_cmd_mpsched} -s
OUTPUT_QUIET
ERROR_STRIP_TRAILING_WHITESPACE
ERROR_VARIABLE mpsched_output)
string(REGEX MATCHALL "Processor Count *: *([0-9]+)" procs "${mpsched_output}")
set(count "${CMAKE_MATCH_1}")
#message("ProcessorCount: trying mpsched -s '${ProcessorCount_cmd_mpsched}'")
endif()
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
endif()
if(NOT count)
# AIX (systems with lsconf):
find_program(ProcessorCount_cmd_lsconf lsconf
PATHS /usr/sbin)
ProcessorCount: Mark find_program vars as advanced (#13236) After each find_program call, mark_as_advanced each find result variable to avoid polluting the cache with non-advanced variables
2012-08-17 14:53:37 +00:00
mark_as_advanced(ProcessorCount_cmd_lsconf)
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
if(ProcessorCount_cmd_lsconf)
execute_process(COMMAND ${ProcessorCount_cmd_lsconf}
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
ERROR_QUIET
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE lsconf_output)
string(REGEX MATCHALL "Number Of Processors: ([0-9]+)" procs "${lsconf_output}")
set(count "${CMAKE_MATCH_1}")
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: trying lsconf '${ProcessorCount_cmd_lsconf}'")
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
endif()
if(NOT count)
# QNX (systems with pidin):
find_program(ProcessorCount_cmd_pidin pidin)
ProcessorCount: Mark find_program vars as advanced (#13236) After each find_program call, mark_as_advanced each find result variable to avoid polluting the cache with non-advanced variables
2012-08-17 14:53:37 +00:00
mark_as_advanced(ProcessorCount_cmd_pidin)
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
if(ProcessorCount_cmd_pidin)
execute_process(COMMAND ${ProcessorCount_cmd_pidin} info
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
ERROR_QUIET
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE pidin_output)
string(REGEX MATCHALL "Processor[0-9]+: " procs "${pidin_output}")
list(LENGTH procs count)
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: trying pidin '${ProcessorCount_cmd_pidin}'")
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
endif()
Add ProcessorCount support for QNX via pidin. (#11302) Thanks to Rolf Eike Beer <eike@sf-mail.de> for the code snippet parsing the pidin output.
2010-11-08 14:37:04 +00:00
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
if(NOT count)
ProcessorCount: Implement with psrinfo tool on recent SunOS versions
2015-09-25 14:09:25 +00:00
# Sun (systems where psrinfo tool is available)
find_program(ProcessorCount_cmd_psrinfo psrinfo PATHS /usr/sbin /sbin)
mark_as_advanced(ProcessorCount_cmd_psrinfo)
if (ProcessorCount_cmd_psrinfo)
execute_process(COMMAND ${ProcessorCount_cmd_psrinfo} -p -v
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
ERROR_QUIET
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
OUTPUT_STRIP_TRAILING_WHITESPACE
ProcessorCount: Implement with psrinfo tool on recent SunOS versions
2015-09-25 14:09:25 +00:00
OUTPUT_VARIABLE psrinfo_output)
ProcessorCount: Fix virtual processor count on Solaris The previous code did not count the number of virtual processors across physical processors on SunOS. Can handle the following situations: ``` $ uname -a SunOS solaris 5.11 11.4.0.15.0 i86pc i386 i86pc $ psrinfo -p -v The physical processor has 1 virtual processor (0) x86 (GenuineIntel 306D2 family 6 model 61 step 2 clock 3492 MHz) Intel Core Processor (Broadwell) The physical processor has 1 virtual processor (1) x86 (GenuineIntel 306D2 family 6 model 61 step 2 clock 3492 MHz) Intel Core Processor (Broadwell) The physical processor has 1 virtual processor (2) x86 (GenuineIntel 306D2 family 6 model 61 step 2 clock 3492 MHz) Intel Core Processor (Broadwell) The physical processor has 1 virtual processor (3) x86 (GenuineIntel 306D2 family 6 model 61 step 2 clock 3492 MHz) Intel Core Processor (Broadwell) ``` ``` $ uname -a SunOS sol11x86 5.11 11.0 i86pc i386 i86pc $ psrinfo -p -v The physical processor has 2 virtual processors (0 1) x86 (GenuineIntel 50650 family 6 model 85 step 0 clock 2000 MHz) Intel(r) Xeon(r) Gold 6138 CPU @ 2.00GHz ``` ``` $ uname -a SunOS sol11 5.11 11.0 sun4v sparc sun4v $ psrinfo -p -v The physical processor has 2 cores and 16 virtual processors (0-15) The core has 8 virtual processors (0-7) The core has 8 virtual processors (8-15) SPARC-T4 (chipid 0, clock 2848 MHz) ```
2019-08-11 09:11:32 +00:00
string(REGEX MATCHALL "has [0-9]+ virtual processor" procs "${psrinfo_output}")
set(count "")
foreach(proc ${procs})
string(REGEX MATCH "has ([0-9]+) virtual" res ${proc})
math(EXPR count "${count} + ${CMAKE_MATCH_1}")
endforeach()
#message("ProcessorCount: trying '${ProcessorCount_cmd_psrinfo}' -p -v")
ProcessorCount: Implement with psrinfo tool on recent SunOS versions
2015-09-25 14:09:25 +00:00
else()
# Sun (systems where uname -X emits "NumCPU" in its output):
find_program(ProcessorCount_cmd_uname uname)
mark_as_advanced(ProcessorCount_cmd_uname)
if(ProcessorCount_cmd_uname)
execute_process(COMMAND ${ProcessorCount_cmd_uname} -X
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE uname_X_output)
string(REGEX MATCHALL "NumCPU = ([0-9]+)" procs "${uname_X_output}")
set(count "${CMAKE_MATCH_1}")
#message("ProcessorCount: trying uname -X '${ProcessorCount_cmd_uname}'")
endif()
Add ProcessorCount support for QNX via pidin. (#11302) Thanks to Rolf Eike Beer <eike@sf-mail.de> for the code snippet parsing the pidin output.
2010-11-08 14:37:04 +00:00
endif()
If getconf returns empty output, try cpuinfo. (#11302) Also, add message output (temporarily) for gathering data on all the dashboard machines. After the test runs on the overnight dashboards tonight, I'll comment out the message output and commit/push again.
2010-11-05 19:57:21 +00:00
endif()
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
# Execute this code when all previously attempted methods return empty
# output:
If getconf returns empty output, try cpuinfo. (#11302) Also, add message output (temporarily) for gathering data on all the dashboard machines. After the test runs on the overnight dashboards tonight, I'll comment out the message output and commit/push again.
2010-11-05 19:57:21 +00:00
#
if(NOT count)
# Systems with /proc/cpuinfo:
set(cpuinfo_file /proc/cpuinfo)
if(EXISTS "${cpuinfo_file}")
file(STRINGS "${cpuinfo_file}" procs REGEX "^processor.: [0-9]+$")
list(LENGTH procs count)
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: trying cpuinfo '${cpuinfo_file}'")
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
endif()
endif()
ProcessorCount: make it work on Haiku
2013-12-01 15:53:46 +00:00
if(NOT count)
# Haiku
find_program(ProcessorCount_cmd_sysinfo sysinfo)
if(ProcessorCount_cmd_sysinfo)
execute_process(COMMAND ${ProcessorCount_cmd_sysinfo}
ERROR_QUIET
OUTPUT_STRIP_TRAILING_WHITESPACE
OUTPUT_VARIABLE sysinfo_X_output)
string(REGEX MATCHALL "\nCPU #[0-9]+:" procs "\n${sysinfo_X_output}")
list(LENGTH procs count)
#message("ProcessorCount: trying sysinfo '${ProcessorCount_cmd_sysinfo}'")
endif()
endif()
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
# Since cygwin builds of CMake do not define WIN32 anymore, but they still
# run on Windows, and will still have this env var defined:
#
if(NOT count)
set(count "$ENV{NUMBER_OF_PROCESSORS}")
ProcessorCount: Use ERROR_QUIET with execute_process (#11302) Also, comment out all "debugging" calls to message() that helped us interpret the output on other platforms when running on the dashboard clients. Using ERROR_QUIET avoids unnecessary stderr output while calling external tools to determine the processor count. If there's an error parsing the output, we set the count to 0 anyhow. Also, the test will fail on a CMake dashboard run if the count comes back equal to 0. Now that the code is "done"-ish, remove the debugging output. Expect no output on stdout or stderr when calling the ProcessorCount function from now on.
2011-03-18 18:28:24 +00:00
#message("ProcessorCount: last fallback, trying environment variable")
ProcessorCount: Add support for remaining platforms (#11302) Including AIX, cygwin, FreeBSD, HPUX, IRIX, OpenBSD and Sun.
2011-03-09 19:06:58 +00:00
endif()
Add ProcessorCount support for QNX via pidin. (#11302) Thanks to Rolf Eike Beer <eike@sf-mail.de> for the code snippet parsing the pidin output.
2010-11-08 14:37:04 +00:00
# Ensure an integer return (avoid inadvertently returning an empty string
# or an error string)... If it's not a decimal integer, return 0:
#
if(NOT count MATCHES "^[0-9]+$")
set(count 0)
endif()
Add module ProcessorCount.cmake (#11302) Credit goes to David Cole ( http://www.kitware.com/blog/home/post/63 ). Also add a script-based test of the new module. Signed-off-by: Michael Wild <themiwi@users.sourceforge.net>
2010-10-08 07:16:04 +00:00
set(${var} ${count} PARENT_SCOPE)
endfunction()
Reference in New Issue Copy Permalink