Merge pull request #3119 from SChernykh/dev

RandomX: optimized CFROUND elimination

.gitignore

@@ -1,4 +1,6 @@
 /build
+scripts/build
+scripts/deps
 /CMakeLists.txt.user
 /.idea
 /src/backend/opencl/cl/cn/cryptonight_gen.cl

CHANGELOG.md

@@ -1,3 +1,232 @@
+# v6.18.0
+- [#3067](https://github.com/xmrig/xmrig/pull/3067) Monero v15 network upgrade support and more house keeping.
+  - Removed deprecated AstroBWTv1 and v2.
+  - Fixed debug GhostRider build.
+  - Monero v15 network upgrade support.
+  - Fixed ZMQ debug log.
+  - Improved daemon ZMQ mining stability.
+- [#3054](https://github.com/xmrig/xmrig/pull/3054) Fixes for 32-bit ARM.
+- [#3042](https://github.com/xmrig/xmrig/pull/3042) Fixed being unable to resume from `pause-on-battery`.
+- [#3031](https://github.com/xmrig/xmrig/pull/3031) Fixed `--cpu-priority` not working sometimes.
+- [#3020](https://github.com/xmrig/xmrig/pull/3020) Removed old AstroBWT algorithm.
+
+# v6.17.0
+- [#2954](https://github.com/xmrig/xmrig/pull/2954) **Dero HE fork support (`astrobwt/v2` algorithm).**
+  - [#2961](https://github.com/xmrig/xmrig/pull/2961) Dero HE (`astrobwt/v2`) CUDA config generator.
+  - [#2969](https://github.com/xmrig/xmrig/pull/2969) Dero HE (`astrobwt/v2`) OpenCL support.
+- Fixed displayed DMI memory information for empty slots.
+- [#2932](https://github.com/xmrig/xmrig/pull/2932) Fixed GhostRider with hwloc disabled.
+
+# v6.16.4
+- [#2904](https://github.com/xmrig/xmrig/pull/2904) Fixed unaligned memory accesses.
+- [#2908](https://github.com/xmrig/xmrig/pull/2908) Added MSVC/2022 to `version.h`.
+- [#2910](https://github.com/xmrig/xmrig/issues/2910) Fixed donation for GhostRider/RTM.
+
+# v6.16.3
+- [#2778](https://github.com/xmrig/xmrig/pull/2778) Fixed `READY threads X/X` display after algorithm switching.
+- [#2782](https://github.com/xmrig/xmrig/pull/2782) Updated GhostRider documentation.
+- [#2815](https://github.com/xmrig/xmrig/pull/2815) Fixed `cn-heavy` in 32-bit builds.
+- [#2827](https://github.com/xmrig/xmrig/pull/2827) GhostRider: set correct priority for helper threads.
+- [#2837](https://github.com/xmrig/xmrig/pull/2837) RandomX: don't restart mining threads when the seed changes.
+- [#2848](https://github.com/xmrig/xmrig/pull/2848) GhostRider: added support for `client.reconnect` method.
+- [#2856](https://github.com/xmrig/xmrig/pull/2856) Fix for short responses from some Raptoreum pools.
+- [#2873](https://github.com/xmrig/xmrig/pull/2873) Fixed GhostRider benchmark on single-core systems.
+- [#2882](https://github.com/xmrig/xmrig/pull/2882) Fixed ARMv7 compilation.
+- [#2893](https://github.com/xmrig/xmrig/pull/2893) KawPow OpenCL: use separate UV loop for building programs.
+
+# v6.16.2
+- [#2751](https://github.com/xmrig/xmrig/pull/2751) Fixed crash on CPUs supporting VAES and running GCC-compiled xmrig.
+- [#2761](https://github.com/xmrig/xmrig/pull/2761) Fixed broken auto-tuning in GCC Windows build.
+- [#2771](https://github.com/xmrig/xmrig/issues/2771) Fixed environment variables support for GhostRider and KawPow. 
+- [#2769](https://github.com/xmrig/xmrig/pull/2769) Performance fixes:
+  - Fixed several performance bottlenecks introduced in v6.16.1.
+  - Fixed overall GCC-compiled build performance, it's the same speed as MSVC build now.
+  - **Linux builds are up to 10% faster now compared to v6.16.0 GCC build.**
+  - **Windows builds are up to 5% faster now compared to v6.16.0 MSVC build.**
+
+# v6.16.1
+- [#2729](https://github.com/xmrig/xmrig/pull/2729) GhostRider fixes:
+  - Added average hashrate display.
+  - Fixed the number of threads shown at startup.
+  - Fixed `--threads` or `-t` command line option (but `--cpu-max-threads-hint` is recommended to use).
+- [#2738](https://github.com/xmrig/xmrig/pull/2738) GhostRider fixes:
+  - Fixed "difficulty is not a number" error when diff is high on some pools.
+  - Fixed GhostRider compilation when `WITH_KAWPOW=OFF`.
+- [#2740](https://github.com/xmrig/xmrig/pull/2740) Added VAES support for Cryptonight variants **+4% speedup on Zen3**.
+  - VAES instructions are available on Intel Ice Lake/AMD Zen3 and newer CPUs.
+  - +4% speedup on Ryzen 5 5600X.
+
+# v6.16.0
+- [#2712](https://github.com/xmrig/xmrig/pull/2712) **GhostRider algorithm (Raptoreum) support**: read the [RELEASE NOTES](src/crypto/ghostrider/README.md) for quick start guide and performance comparisons.
+- [#2682](https://github.com/xmrig/xmrig/pull/2682) Fixed: use cn-heavy optimization only for Vermeer CPUs.
+- [#2684](https://github.com/xmrig/xmrig/pull/2684) MSR mod: fix for error 183.
+
+# v6.15.3
+- [#2614](https://github.com/xmrig/xmrig/pull/2614) OpenCL fixes for non-AMD platforms.
+- [#2623](https://github.com/xmrig/xmrig/pull/2623) Fixed compiling without kawpow.
+- [#2636](https://github.com/xmrig/xmrig/pull/2636) [#2639](https://github.com/xmrig/xmrig/pull/2639) AstroBWT speedup (up to +35%).
+- [#2646](https://github.com/xmrig/xmrig/pull/2646) Fixed MSVC compilation error.
+
+# v6.15.2
+- [#2606](https://github.com/xmrig/xmrig/pull/2606) Fixed: AstroBWT auto-config ignored `max-threads-hint`.
+- Fixed possible crash on Windows (regression in v6.15.1).
+
+# v6.15.1
+- [#2586](https://github.com/xmrig/xmrig/pull/2586) Fixed Windows 7 compatibility.
+- [#2594](https://github.com/xmrig/xmrig/pull/2594) Added Windows taskbar icon colors.
+
+# v6.15.0
+- [#2548](https://github.com/xmrig/xmrig/pull/2548) Added automatic coin detection for daemon mining.
+- [#2563](https://github.com/xmrig/xmrig/pull/2563) Added new algorithm RandomX Graft (`rx/graft`).
+- [#2565](https://github.com/xmrig/xmrig/pull/2565) AstroBWT: added AVX2 Salsa20 implementation.
+- Added support for new CUDA plugin API (previous API still supported).
+
+# v6.14.1
+- [#2532](https://github.com/xmrig/xmrig/pull/2532) Refactoring: stable (persistent) algorithms IDs.
+- [#2537](https://github.com/xmrig/xmrig/pull/2537) Fixed Termux build.
+
+# v6.14.0
+- [#2484](https://github.com/xmrig/xmrig/pull/2484) Added ZeroMQ support for solo mining.
+- [#2476](https://github.com/xmrig/xmrig/issues/2476) Fixed crash in DMI memory reader.
+- [#2492](https://github.com/xmrig/xmrig/issues/2492) Added missing `--huge-pages-jit` command line option.
+- [#2512](https://github.com/xmrig/xmrig/pull/2512) Added show the number of transactions in pool job.
+
+# v6.13.1
+- [#2468](https://github.com/xmrig/xmrig/pull/2468) Fixed regression in previous version: don't send miner signature during regular mining.
+
+# v6.13.0
+- [#2445](https://github.com/xmrig/xmrig/pull/2445) Added support for solo mining with miner signatures for the upcoming Wownero fork.
+
+# v6.12.2
+- [#2280](https://github.com/xmrig/xmrig/issues/2280) GPU backends are now disabled in benchmark mode.
+- [#2322](https://github.com/xmrig/xmrig/pull/2322) Improved MSR compatibility with recent Linux kernels and updated `randomx_boost.sh`.
+- [#2340](https://github.com/xmrig/xmrig/pull/2340) Fixed AES detection on FreeBSD on ARM.
+- [#2341](https://github.com/xmrig/xmrig/pull/2341) `sse2neon` updated to the latest version.
+- [#2351](https://github.com/xmrig/xmrig/issues/2351) Fixed help output for `--cpu-priority` and `--cpu-affinity` option.
+- [#2375](https://github.com/xmrig/xmrig/pull/2375) Fixed macOS CUDA backend default loader name.
+- [#2378](https://github.com/xmrig/xmrig/pull/2378) Fixed broken light mode mining on x86.
+- [#2379](https://github.com/xmrig/xmrig/pull/2379) Fixed CL code for KawPow where it assumes everything is AMD.
+- [#2386](https://github.com/xmrig/xmrig/pull/2386) RandomX: enabled `IMUL_RCP` optimization for light mode mining.
+- [#2393](https://github.com/xmrig/xmrig/pull/2393) RandomX: added BMI2 version for scratchpad prefetch.
+- [#2395](https://github.com/xmrig/xmrig/pull/2395) RandomX: rewrote dataset read code.
+- [#2398](https://github.com/xmrig/xmrig/pull/2398) RandomX: optimized ARMv8 dataset read.
+- Added `argon2/ninja` alias for `argon2/wrkz` algorithm.
+
+# v6.12.1
+- [#2296](https://github.com/xmrig/xmrig/pull/2296) Fixed Zen3 assembly code for `cn/upx2` algorithm.
+
+# v6.12.0
+- [#2276](https://github.com/xmrig/xmrig/pull/2276) Added support for Uplexa (`cn/upx2` algorithm).
+- [#2261](https://github.com/xmrig/xmrig/pull/2261) Show total hashrate if compiled without OpenCL.
+- [#2289](https://github.com/xmrig/xmrig/pull/2289) RandomX: optimized `IMUL_RCP` instruction.
+- Added support for `--user` command line option for online benchmark.
+
+# v6.11.2
+- [#2207](https://github.com/xmrig/xmrig/issues/2207) Fixed regression in HTTP parser and llhttp updated to v5.1.0.
+
+# v6.11.1
+- [#2239](https://github.com/xmrig/xmrig/pull/2239) Fixed broken `coin` setting functionality.
+
+# v6.11.0
+- [#2196](https://github.com/xmrig/xmrig/pull/2196) Improved DNS subsystem and added new DNS specific options.
+- [#2172](https://github.com/xmrig/xmrig/pull/2172) Fixed build on Alpine 3.13.
+- [#2177](https://github.com/xmrig/xmrig/pull/2177) Fixed ARM specific compilation error with GCC 10.2.
+- [#2214](https://github.com/xmrig/xmrig/pull/2214) [#2216](https://github.com/xmrig/xmrig/pull/2216) [#2235](https://github.com/xmrig/xmrig/pull/2235) Optimized `cn-heavy` algorithm.
+- [#2217](https://github.com/xmrig/xmrig/pull/2217) Fixed mining job creation sequence.
+- [#2225](https://github.com/xmrig/xmrig/pull/2225) Fixed build without OpenCL support on some systems.
+- [#2229](https://github.com/xmrig/xmrig/pull/2229) Don't use RandomX JIT if `WITH_ASM=OFF`.
+- [#2228](https://github.com/xmrig/xmrig/pull/2228) Removed useless code for cryptonight algorithms.
+- [#2234](https://github.com/xmrig/xmrig/pull/2234) Fixed build error on gcc 4.8.
+
+# v6.10.0
+- [#2122](https://github.com/xmrig/xmrig/pull/2122) Fixed pause logic when both pause on battery and user activity are enabled.
+- [#2123](https://github.com/xmrig/xmrig/issues/2123) Fixed compatibility with gcc 4.8.
+- [#2147](https://github.com/xmrig/xmrig/pull/2147) Fixed many `new job` messages when solo mining.
+- [#2150](https://github.com/xmrig/xmrig/pull/2150) Updated `sse2neon.h` to the latest master, fixes build on ARMv7.
+- [#2157](https://github.com/xmrig/xmrig/pull/2157) Fixed crash in `cn-heavy` on Zen3 with manual thread count.
+- Fixed possible out of order write to log file.
+- [http-parser](https://github.com/nodejs/http-parser) replaced to [llhttp](https://github.com/nodejs/llhttp).
+- For official builds: libuv, hwloc and OpenSSL updated to latest versions.
+
+# v6.9.0
+- [#2104](https://github.com/xmrig/xmrig/pull/2104) Added [pause-on-active](https://xmrig.com/docs/miner/config/misc#pause-on-active) config option and `--pause-on-active=N` command line option.
+- [#2112](https://github.com/xmrig/xmrig/pull/2112) Added support for [Tari merge mining](https://github.com/tari-project/tari/blob/development/README.md#tari-merge-mining).
+- [#2117](https://github.com/xmrig/xmrig/pull/2117) Fixed crash when GPU mining `cn-heavy` on Zen3 system.
+
+# v6.8.2
+- [#2080](https://github.com/xmrig/xmrig/pull/2080) Fixed compile error in Termux.
+- [#2089](https://github.com/xmrig/xmrig/pull/2089) Optimized CryptoNight-Heavy for Zen3, 7-8% speedup.
+
+# v6.8.1
+- [#2064](https://github.com/xmrig/xmrig/pull/2064) Added documentation for config.json CPU options.
+- [#2066](https://github.com/xmrig/xmrig/issues/2066) Fixed AMD GPUs health data readings on Linux.
+- [#2067](https://github.com/xmrig/xmrig/pull/2067) Fixed compilation error when RandomX and Argon2 are disabled.
+- [#2076](https://github.com/xmrig/xmrig/pull/2076) Added support for flexible huge page sizes on Linux.
+- [#2077](https://github.com/xmrig/xmrig/pull/2077) Fixed `illegal instruction` crash on ARM.
+
+# v6.8.0
+- [#2052](https://github.com/xmrig/xmrig/pull/2052) Added DMI/SMBIOS reader.
+  - Added information about memory modules on the miner startup and for online benchmark.
+  - Added new HTTP API endpoint: `GET /2/dmi`.
+  - Added new command line option `--no-dmi` or config option `"dmi"`.
+  - Added new CMake option `-DWITH_DMI=OFF`.
+- [#2057](https://github.com/xmrig/xmrig/pull/2057) Improved MSR subsystem code quality.
+- [#2058](https://github.com/xmrig/xmrig/pull/2058) RandomX JIT x86: removed unnecessary instructions.
+
+# v6.7.2
+- [#2039](https://github.com/xmrig/xmrig/pull/2039) Fixed solo mining.
+
+# v6.7.1
+- [#1995](https://github.com/xmrig/xmrig/issues/1995) Fixed log initialization.
+- [#1998](https://github.com/xmrig/xmrig/pull/1998) Added hashrate in the benchmark finished message.
+- [#2009](https://github.com/xmrig/xmrig/pull/2009) AstroBWT OpenCL fixes.
+- [#2028](https://github.com/xmrig/xmrig/pull/2028) RandomX x86 JIT: removed redundant `CFROUND`.
+
+# v6.7.0
+- **[#1991](https://github.com/xmrig/xmrig/issues/1991) Added Apple M1 processor support.**
+- **[#1986](https://github.com/xmrig/xmrig/pull/1986) Up to 20-30% faster RandomX dataset initialization with AVX2 on some CPUs.**
+- [#1964](https://github.com/xmrig/xmrig/pull/1964) Cleanup and refactoring.
+- [#1966](https://github.com/xmrig/xmrig/pull/1966) Removed libcpuid support.
+- [#1968](https://github.com/xmrig/xmrig/pull/1968) Added virtual machine detection.
+- [#1969](https://github.com/xmrig/xmrig/pull/1969) [#1970](https://github.com/xmrig/xmrig/pull/1970) Fixed errors found by static analysis.
+- [#1977](https://github.com/xmrig/xmrig/pull/1977) Fixed: secure JIT and huge pages are incompatible on Windows.
+- [#1979](https://github.com/xmrig/xmrig/pull/1979) Term `x64` replaced to `64-bit`.
+- [#1980](https://github.com/xmrig/xmrig/pull/1980) Fixed build on gcc 11.
+- [#1989](https://github.com/xmrig/xmrig/pull/1989) Fixed broken Dero solo mining.
+
+# v6.6.2
+- [#1958](https://github.com/xmrig/xmrig/pull/1958) Added example mining scripts to help new miners.
+- [#1959](https://github.com/xmrig/xmrig/pull/1959) Optimized JIT compiler.
+- [#1960](https://github.com/xmrig/xmrig/pull/1960) Fixed RandomX init when switching to other algo and back.
+
+# v6.6.1
+- Fixed, benchmark validation on NUMA hardware produced incorrect results in some conditions.
+
+# v6.6.0
+- Online benchmark protocol upgraded to v2, validation not compatible with previous versions.
+  - Single thread benchmark now is cheat-resistant, not possible speedup it with multiple threads.
+  - RandomX dataset is now always initialized with static seed, to prevent time cheat by report slow dataset initialization.
+  - Zero delay online submission, to make time validation much more precise and strict.
+  - DNS cache for online benchmark to prevent unexpected delays.
+
+# v6.5.3
+- [#1946](https://github.com/xmrig/xmrig/pull/1946) Fixed MSR mod names in JSON API (v6.5.2 affected).
+
+# v6.5.2
+- [#1935](https://github.com/xmrig/xmrig/pull/1935) Separate MSR mod for Zen/Zen2 and Zen3.
+- [#1937](https://github.com/xmrig/xmrig/issues/1937) Print path to existing WinRing0 service without verbose option.
+- [#1939](https://github.com/xmrig/xmrig/pull/1939) Fixed build with gcc 4.8.
+- [#1941](https://github.com/xmrig/xmrig/pull/1941) Added CPUID info to JSON report.
+- [#1941](https://github.com/xmrig/xmrig/pull/1942) Fixed alignment modification in memory pool.
+- [#1944](https://github.com/xmrig/xmrig/pull/1944) Updated `randomx_boost.sh` with new MSR mod.
+- Added `250K` and `500K` offline benchmarks.
+
+# v6.5.1
+- [#1932](https://github.com/xmrig/xmrig/pull/1932) New MSR mod for Ryzen, up to +3.5% on Zen2 and +1-2% on Zen3.
+- [#1918](https://github.com/xmrig/xmrig/issues/1918) Fixed 1GB huge pages support on ARMv8.
+- [#1926](https://github.com/xmrig/xmrig/pull/1926) Fixed compilation on ARMv8 with GCC 9.3.0.
+- [#1929](https://github.com/xmrig/xmrig/issues/1929) Fixed build without HTTP.
+
 # v6.5.0
 - **Added [online benchmark](https://xmrig.com/benchmark) mode for sharing results.**
   - Added new command line options: `--submit`, `	--verify=ID`, `	--seed=SEED`, `--hash=HASH`.

CMakeLists.txt

@@ -1,15 +1,15 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 2.8.12)
 project(xmrig)
 
-option(WITH_LIBCPUID        "Enable libcpuid support" ON)
 option(WITH_HWLOC           "Enable hwloc support" ON)
 option(WITH_CN_LITE         "Enable CryptoNight-Lite algorithms family" ON)
 option(WITH_CN_HEAVY        "Enable CryptoNight-Heavy algorithms family" ON)
 option(WITH_CN_PICO         "Enable CryptoNight-Pico algorithm" ON)
+option(WITH_CN_FEMTO        "Enable CryptoNight-UPX2 algorithm" ON)
 option(WITH_RANDOMX         "Enable RandomX algorithms family" ON)
 option(WITH_ARGON2          "Enable Argon2 algorithms family" ON)
-option(WITH_ASTROBWT        "Enable AstroBWT algorithms family" ON)
 option(WITH_KAWPOW          "Enable KawPow algorithms family" ON)
+option(WITH_GHOSTRIDER      "Enable GhostRider algorithm" ON)
 option(WITH_HTTP            "Enable HTTP protocol support (client/server)" ON)
 option(WITH_DEBUG_LOG       "Enable debug log output" OFF)
 option(WITH_TLS             "Enable OpenSSL support" ON)
@@ -18,6 +18,8 @@ option(WITH_MSR             "Enable MSR mod & 1st-gen Ryzen fix" ON)
 option(WITH_ENV_VARS        "Enable environment variables support in config file" ON)
 option(WITH_EMBEDDED_CONFIG "Enable internal embedded JSON config" OFF)
 option(WITH_OPENCL          "Enable OpenCL backend" ON)
+set(WITH_OPENCL_VERSION 200 CACHE STRING "Target OpenCL version")
+set_property(CACHE WITH_OPENCL_VERSION PROPERTY STRINGS 120 200 210 220)
 option(WITH_CUDA            "Enable CUDA backend" ON)
 option(WITH_NVML            "Enable NVML (NVIDIA Management Library) support (only if CUDA backend enabled)" ON)
 option(WITH_ADL             "Enable ADL (AMD Display Library) or sysfs support (only if OpenCL backend enabled)" ON)
@@ -25,7 +27,11 @@ option(WITH_STRICT_CACHE    "Enable strict checks for OpenCL cache" ON)
 option(WITH_INTERLEAVE_DEBUG_LOG "Enable debug log for threads interleave" OFF)
 option(WITH_PROFILING       "Enable profiling for developers" OFF)
 option(WITH_SSE4_1          "Enable SSE 4.1 for Blake2" ON)
+option(WITH_AVX2            "Enable AVX2 for Blake2" ON)
+option(WITH_VAES            "Enable VAES instructions for Cryptonight" ON)
 option(WITH_BENCHMARK       "Enable builtin RandomX benchmark and stress test" ON)
+option(WITH_SECURE_JIT      "Enable secure access to JIT memory" OFF)
+option(WITH_DMI             "Enable DMI/SMBIOS reader" ON)
 
 option(BUILD_STATIC         "Build static binary" OFF)
 option(ARM_TARGET           "Force use specific ARM target 8 or 7" 0)
@@ -54,6 +60,7 @@ set(HEADERS
     src/core/config/usage.h
     src/core/Controller.h
     src/core/Miner.h
+    src/core/Taskbar.h
     src/net/interfaces/IJobResultListener.h
     src/net/JobResult.h
     src/net/JobResults.h
@@ -102,6 +109,7 @@ set(SOURCES
     src/core/config/ConfigTransform.cpp
     src/core/Controller.cpp
     src/core/Miner.cpp
+    src/core/Taskbar.cpp
     src/net/JobResults.cpp
     src/net/Network.cpp
     src/net/strategies/DonateStrategy.cpp
@@ -122,6 +130,19 @@ set(SOURCES_CRYPTO
     src/crypto/common/VirtualMemory.cpp
    )
 
+if (CMAKE_C_COMPILER_ID MATCHES GNU)
+    set_source_files_properties(src/crypto/cn/CnHash.cpp PROPERTIES COMPILE_FLAGS "-Ofast -fno-tree-vectorize")
+endif()
+
+if (WITH_VAES)
+    add_definitions(-DXMRIG_VAES)
+    set(HEADERS_CRYPTO "${HEADERS_CRYPTO}" src/crypto/cn/CryptoNight_x86_vaes.h)
+    set(SOURCES_CRYPTO "${SOURCES_CRYPTO}" src/crypto/cn/CryptoNight_x86_vaes.cpp)
+    if (CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES Clang)
+        set_source_files_properties(src/crypto/cn/CryptoNight_x86_vaes.cpp PROPERTIES COMPILE_FLAGS "-Ofast -fno-tree-vectorize -mavx2 -mvaes")
+    endif()
+endif()
+
 if (WITH_HWLOC)
     list(APPEND HEADERS_CRYPTO
         src/crypto/common/NUMAMemoryPool.h
@@ -146,8 +167,10 @@ elseif (XMRIG_OS_APPLE)
         src/App_unix.cpp
         src/crypto/common/VirtualMemory_unix.cpp
         )
+
     find_library(IOKIT_LIBRARY IOKit)
-    set(EXTRA_LIBS ${IOKIT_LIBRARY})
+    find_library(CORESERVICES_LIBRARY CoreServices)
+    set(EXTRA_LIBS ${IOKIT_LIBRARY} ${CORESERVICES_LIBRARY})
 else()
     list(APPEND SOURCES_OS
         src/App_unix.cpp
@@ -168,16 +191,16 @@ else()
     endif()
 endif()
 
-add_definitions(-DXMRIG_MINER_PROJECT)
-add_definitions(-D__STDC_FORMAT_MACROS -DUNICODE)
+add_definitions(-DXMRIG_MINER_PROJECT -DXMRIG_JSON_SINGLE_LINE_ARRAY)
+add_definitions(-D__STDC_FORMAT_MACROS -DUNICODE -D_FILE_OFFSET_BITS=64)
 
 find_package(UV REQUIRED)
 
 include(cmake/flags.cmake)
 include(cmake/randomx.cmake)
 include(cmake/argon2.cmake)
-include(cmake/astrobwt.cmake)
 include(cmake/kawpow.cmake)
+include(cmake/ghostrider.cmake)
 include(cmake/OpenSSL.cmake)
 include(cmake/asm.cmake)
 
@@ -193,10 +216,17 @@ if (WITH_CN_PICO)
     add_definitions(/DXMRIG_ALGO_CN_PICO)
 endif()
 
+if (WITH_CN_FEMTO)
+    add_definitions(/DXMRIG_ALGO_CN_FEMTO)
+endif()
+
 if (WITH_EMBEDDED_CONFIG)
     add_definitions(/DXMRIG_FEATURE_EMBEDDED_CONFIG)
 endif()
 
+include(src/hw/api/api.cmake)
+include(src/hw/dmi/dmi.cmake)
+
 include_directories(src)
 include_directories(src/3rdparty)
 include_directories(${UV_INCLUDE_DIR})
@@ -205,15 +235,18 @@ if (WITH_DEBUG_LOG)
     add_definitions(/DAPP_DEBUG)
 endif()
 
-add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES} ${SOURCES_OS} ${SOURCES_CPUID} ${HEADERS_CRYPTO} ${SOURCES_CRYPTO} ${SOURCES_SYSLOG} ${TLS_SOURCES} ${XMRIG_ASM_SOURCES})
-target_link_libraries(${CMAKE_PROJECT_NAME} ${XMRIG_ASM_LIBRARY} ${OPENSSL_LIBRARIES} ${UV_LIBRARIES} ${EXTRA_LIBS} ${CPUID_LIB} ${ARGON2_LIBRARY} ${ETHASH_LIBRARY})
+add_executable(${CMAKE_PROJECT_NAME} ${HEADERS} ${SOURCES} ${SOURCES_OS} ${HEADERS_CRYPTO} ${SOURCES_CRYPTO} ${SOURCES_SYSLOG} ${TLS_SOURCES} ${XMRIG_ASM_SOURCES})
+target_link_libraries(${CMAKE_PROJECT_NAME} ${XMRIG_ASM_LIBRARY} ${OPENSSL_LIBRARIES} ${UV_LIBRARIES} ${EXTRA_LIBS} ${CPUID_LIB} ${ARGON2_LIBRARY} ${ETHASH_LIBRARY} ${GHOSTRIDER_LIBRARY})
 
 if (WIN32)
     add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/bin/WinRing0/WinRing0x64.sys" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
     add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/scripts/benchmark_1M.cmd" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
     add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/scripts/benchmark_10M.cmd" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
+    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/scripts/pool_mine_example.cmd" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
+    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/scripts/solo_mine_example.cmd" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
+    add_custom_command(TARGET ${CMAKE_PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "${CMAKE_SOURCE_DIR}/scripts/rtm_ghostrider_example.cmd" $<TARGET_FILE_DIR:${CMAKE_PROJECT_NAME}>)
 endif()
 
-if (CMAKE_CXX_COMPILER_ID MATCHES Clang AND CMAKE_BUILD_TYPE STREQUAL Release)
+if (CMAKE_CXX_COMPILER_ID MATCHES Clang AND CMAKE_BUILD_TYPE STREQUAL Release AND NOT CMAKE_GENERATOR STREQUAL Xcode)
     add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_STRIP} ${CMAKE_PROJECT_NAME})
 endif()

README.md

@@ -7,10 +7,10 @@
 [![GitHub stars](https://img.shields.io/github/stars/xmrig/xmrig.svg)](https://github.com/xmrig/xmrig/stargazers)
 [![GitHub forks](https://img.shields.io/github/forks/xmrig/xmrig.svg)](https://github.com/xmrig/xmrig/network)
 
-XMRig is a high performance, open source, cross platform RandomX, KawPow, CryptoNight and AstroBWT unified CPU/GPU miner. Official binaries are available for Windows, Linux, macOS and FreeBSD.
+XMRig is a high performance, open source, cross platform RandomX, KawPow, CryptoNight and [GhostRider](https://github.com/xmrig/xmrig/tree/master/src/crypto/ghostrider#readme) unified CPU/GPU miner and [RandomX benchmark](https://xmrig.com/benchmark). Official binaries are available for Windows, Linux, macOS and FreeBSD.
 
 ## Mining backends
-- **CPU** (x64/ARMv8)
+- **CPU** (x64/ARMv7/ARMv8)
 - **OpenCL** for AMD GPUs.
 - **CUDA** for NVIDIA GPUs via external [CUDA plugin](https://github.com/xmrig/xmrig-cuda).
 
@@ -19,7 +19,7 @@ XMRig is a high performance, open source, cross platform RandomX, KawPow, Crypto
 * **[Build from source](https://xmrig.com/docs/miner/build)**
 
 ## Usage
-The preferred way to configure the miner is the [JSON config file](src/config.json) as it is more flexible and human friendly. The [command line interface](https://xmrig.com/docs/miner/command-line-options) does not cover all features, such as mining profiles for different algorithms. Important options can be changed during runtime without miner restart by editing the config file or executing API calls.
+The preferred way to configure the miner is the [JSON config file](https://xmrig.com/docs/miner/config) as it is more flexible and human friendly. The [command line interface](https://xmrig.com/docs/miner/command-line-options) does not cover all features, such as mining profiles for different algorithms. Important options can be changed during runtime without miner restart by editing the config file or executing [API](https://xmrig.com/docs/miner/api) calls.
 
 * **[Wizard](https://xmrig.com/wizard)** helps you create initial configuration for the miner.
 * **[Workers](http://workers.xmrig.info)** helps manage your miners via HTTP API.

cmake/astrobwt.cmake

@@ -1,45 +0,0 @@
-if (WITH_ASTROBWT)
-    add_definitions(/DXMRIG_ALGO_ASTROBWT)
-
-    list(APPEND HEADERS_CRYPTO
-        src/crypto/astrobwt/AstroBWT.h
-    )
-
-    list(APPEND SOURCES_CRYPTO
-        src/crypto/astrobwt/AstroBWT.cpp
-    )
-
-    if (XMRIG_ARM)
-        list(APPEND HEADERS_CRYPTO
-            src/crypto/astrobwt/salsa20_ref/ecrypt-config.h
-            src/crypto/astrobwt/salsa20_ref/ecrypt-machine.h
-            src/crypto/astrobwt/salsa20_ref/ecrypt-portable.h
-            src/crypto/astrobwt/salsa20_ref/ecrypt-sync.h
-        )
-
-        list(APPEND SOURCES_CRYPTO
-            src/crypto/astrobwt/salsa20_ref/salsa20.c
-        )
-    else()
-        if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-            add_definitions(/DASTROBWT_AVX2)
-            if (CMAKE_C_COMPILER_ID MATCHES MSVC)
-                enable_language(ASM_MASM)
-                list(APPEND SOURCES_CRYPTO src/crypto/astrobwt/sha3_256_avx2.asm)
-            else()
-                enable_language(ASM)
-                list(APPEND SOURCES_CRYPTO src/crypto/astrobwt/sha3_256_avx2.S)
-            endif()
-        endif()
-
-        list(APPEND HEADERS_CRYPTO
-            src/crypto/astrobwt/Salsa20.hpp
-        )
-
-        list(APPEND SOURCES_CRYPTO
-            src/crypto/astrobwt/Salsa20.cpp
-        )
-    endif()
-else()
-    remove_definitions(/DXMRIG_ALGO_ASTROBWT)
-endif()

cmake/cpu.cmake

@@ -1,48 +1,64 @@
+if (CMAKE_SIZEOF_VOID_P EQUAL 8)
+    set(XMRIG_64_BIT ON)
+    add_definitions(-DXMRIG_64_BIT)
+else()
+    set(XMRIG_64_BIT OFF)
+endif()
+
 if (NOT CMAKE_SYSTEM_PROCESSOR)
     message(WARNING "CMAKE_SYSTEM_PROCESSOR not defined")
 endif()
 
-if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$" AND CMAKE_SIZEOF_VOID_P EQUAL 8)
-    add_definitions(/DRAPIDJSON_SSE2)
+include(CheckCXXCompilerFlag)
+
+if (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
+    set(VAES_SUPPORTED ON)
+else()
+    CHECK_CXX_COMPILER_FLAG("-mavx2 -mvaes" VAES_SUPPORTED)
+endif()
+
+if (NOT VAES_SUPPORTED)
+    set(WITH_VAES OFF)
+endif()
+
+if (XMRIG_64_BIT AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")
+    add_definitions(-DRAPIDJSON_SSE2)
 else()
     set(WITH_SSE4_1 OFF)
+    set(WITH_AVX2 OFF)
+    set(WITH_VAES OFF)
 endif()
 
 if (NOT ARM_TARGET)
     if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64|arm64|armv8-a)$")
         set(ARM_TARGET 8)
-    elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7|armv7f|armv7s|armv7k|armv7-a|armv7l)$")
+    elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(armv7|armv7f|armv7s|armv7k|armv7-a|armv7l|armv7ve)$")
         set(ARM_TARGET 7)
     endif()
 endif()
 
 if (ARM_TARGET AND ARM_TARGET GREATER 6)
     set(XMRIG_ARM ON)
-    set(WITH_LIBCPUID OFF)
-    add_definitions(/DXMRIG_ARM)
+    add_definitions(-DXMRIG_ARM=${ARM_TARGET})
 
     message(STATUS "Use ARM_TARGET=${ARM_TARGET} (${CMAKE_SYSTEM_PROCESSOR})")
 
-    include(CheckCXXCompilerFlag)
-
     if (ARM_TARGET EQUAL 8)
-        set(XMRIG_ARMv8 ON)
-        add_definitions(/DXMRIG_ARMv8)
-
         CHECK_CXX_COMPILER_FLAG(-march=armv8-a+crypto XMRIG_ARM_CRYPTO)
 
         if (XMRIG_ARM_CRYPTO)
-            add_definitions(/DXMRIG_ARM_CRYPTO)
+            add_definitions(-DXMRIG_ARM_CRYPTO)
             set(ARM8_CXX_FLAGS "-march=armv8-a+crypto")
         else()
             set(ARM8_CXX_FLAGS "-march=armv8-a")
         endif()
-    elseif (ARM_TARGET EQUAL 7)
-        set(XMRIG_ARMv7 ON)
-        add_definitions(/DXMRIG_ARMv7)
     endif()
 endif()
 
 if (WITH_SSE4_1)
-    add_definitions(/DXMRIG_FEATURE_SSE4_1)
+    add_definitions(-DXMRIG_FEATURE_SSE4_1)
+endif()
+
+if (WITH_AVX2)
+    add_definitions(-DXMRIG_FEATURE_AVX2)
 endif()

cmake/flags.cmake

@@ -22,12 +22,12 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fexceptions -fno-rtti -Wno-strict-aliasing -Wno-class-memaccess")
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Ofast -s")
 
-    if (XMRIG_ARMv8)
+    if (ARM_TARGET EQUAL 8)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARM8_CXX_FLAGS}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARM8_CXX_FLAGS} -flax-vector-conversions")
-    elseif (XMRIG_ARMv7)
-        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon -flax-vector-conversions")
+    elseif (ARM_TARGET EQUAL 7)
+        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfpu=neon")
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv7-a -mfpu=neon -flax-vector-conversions")
     else()
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
@@ -80,10 +80,10 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fexceptions -fno-rtti -Wno-missing-braces")
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -Ofast -funroll-loops -fmerge-all-constants")
 
-    if (XMRIG_ARMv8)
+    if (ARM_TARGET EQUAL 8)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARM8_CXX_FLAGS}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARM8_CXX_FLAGS}")
-    elseif (XMRIG_ARMv7)
+    elseif (ARM_TARGET EQUAL 7)
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon -march=${CMAKE_SYSTEM_PROCESSOR}")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon -march=${CMAKE_SYSTEM_PROCESSOR}")
     else()

cmake/ghostrider.cmake

@@ -0,0 +1,8 @@
+if (WITH_GHOSTRIDER)
+    add_definitions(/DXMRIG_ALGO_GHOSTRIDER)
+    add_subdirectory(src/crypto/ghostrider)
+    set(GHOSTRIDER_LIBRARY ghostrider)
+else()
+    remove_definitions(/DXMRIG_ALGO_GHOSTRIDER)
+    set(GHOSTRIDER_LIBRARY "")
+endif()

cmake/os.cmake

@@ -22,24 +22,31 @@ endif()
 
 
 if (XMRIG_OS_WIN)
-    add_definitions(/DWIN32)
-    add_definitions(/DXMRIG_OS_WIN)
+    add_definitions(-DWIN32 -DXMRIG_OS_WIN)
 elseif(XMRIG_OS_APPLE)
-    add_definitions(/DXMRIG_OS_APPLE)
+    add_definitions(-DXMRIG_OS_APPLE)
 
     if (XMRIG_OS_IOS)
-        add_definitions(/DXMRIG_OS_IOS)
+        add_definitions(-DXMRIG_OS_IOS)
     else()
-        add_definitions(/DXMRIG_OS_MACOS)
+        add_definitions(-DXMRIG_OS_MACOS)
+    endif()
+
+    if (XMRIG_ARM)
+        set(WITH_SECURE_JIT ON)
     endif()
 elseif(XMRIG_OS_UNIX)
-    add_definitions(/DXMRIG_OS_UNIX)
+    add_definitions(-DXMRIG_OS_UNIX)
 
     if (XMRIG_OS_ANDROID)
-        add_definitions(/DXMRIG_OS_ANDROID)
+        add_definitions(-DXMRIG_OS_ANDROID)
     elseif (XMRIG_OS_LINUX)
-        add_definitions(/DXMRIG_OS_LINUX)
+        add_definitions(-DXMRIG_OS_LINUX)
     elseif (XMRIG_OS_FREEBSD)
-        add_definitions(/DXMRIG_OS_FREEBSD)
+        add_definitions(-DXMRIG_OS_FREEBSD)
     endif()
 endif()
+
+if (WITH_SECURE_JIT)
+    add_definitions(-DXMRIG_SECURE_JIT)
+endif()

cmake/randomx.cmake

@@ -42,13 +42,13 @@ if (WITH_RANDOMX)
         src/crypto/rx/RxVm.cpp
     )
 
-    if (CMAKE_C_COMPILER_ID MATCHES MSVC)
+    if (WITH_ASM AND CMAKE_C_COMPILER_ID MATCHES MSVC)
         enable_language(ASM_MASM)
         list(APPEND SOURCES_CRYPTO
              src/crypto/randomx/jit_compiler_x86_static.asm
              src/crypto/randomx/jit_compiler_x86.cpp
             )
-    elseif (NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+    elseif (WITH_ASM AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
         list(APPEND SOURCES_CRYPTO
              src/crypto/randomx/jit_compiler_x86_static.S
              src/crypto/randomx/jit_compiler_x86.cpp
@@ -61,7 +61,11 @@ if (WITH_RANDOMX)
              src/crypto/randomx/jit_compiler_a64.cpp
             )
         # cheat because cmake and ccache hate each other
+        if (CMAKE_GENERATOR STREQUAL Xcode)
+            set_property(SOURCE src/crypto/randomx/jit_compiler_a64_static.S PROPERTY LANGUAGE ASM)
+        else()
             set_property(SOURCE src/crypto/randomx/jit_compiler_a64_static.S PROPERTY LANGUAGE C)
+        endif()
     else()
         list(APPEND SOURCES_CRYPTO
              src/crypto/randomx/jit_compiler_fallback.cpp
@@ -72,7 +76,15 @@ if (WITH_RANDOMX)
         list(APPEND SOURCES_CRYPTO src/crypto/randomx/blake2/blake2b_sse41.c)
 
         if (CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES Clang)
-            set_source_files_properties(src/crypto/randomx/blake2/blake2b_sse41.c PROPERTIES COMPILE_FLAGS -msse4.1)
+            set_source_files_properties(src/crypto/randomx/blake2/blake2b_sse41.c PROPERTIES COMPILE_FLAGS "-Ofast -msse4.1")
+        endif()
+    endif()
+
+    if (WITH_AVX2)
+        list(APPEND SOURCES_CRYPTO src/crypto/randomx/blake2/avx2/blake2b_avx2.c)
+
+        if (CMAKE_C_COMPILER_ID MATCHES GNU OR CMAKE_C_COMPILER_ID MATCHES Clang)
+            set_source_files_properties(src/crypto/randomx/blake2/avx2/blake2b_avx2.c PROPERTIES COMPILE_FLAGS "-Ofast -mavx2")
         endif()
     endif()
 
@@ -96,18 +108,41 @@ if (WITH_RANDOMX)
         message("-- WITH_MSR=ON")
 
         if (XMRIG_OS_WIN)
-            list(APPEND SOURCES_CRYPTO src/crypto/rx/Rx_win.cpp)
+            list(APPEND SOURCES_CRYPTO
+                src/crypto/rx/RxFix_win.cpp
+                src/hw/msr/Msr_win.cpp
+                )
         elseif (XMRIG_OS_LINUX)
-            list(APPEND SOURCES_CRYPTO src/crypto/rx/Rx_linux.cpp)
+            list(APPEND SOURCES_CRYPTO
+                src/crypto/rx/RxFix_linux.cpp
+                src/hw/msr/Msr_linux.cpp
+                )
         endif()
 
-        list(APPEND HEADERS_CRYPTO src/crypto/rx/msr/MsrItem.h)
-        list(APPEND SOURCES_CRYPTO src/crypto/rx/msr/MsrItem.cpp)
+        list(APPEND HEADERS_CRYPTO
+            src/crypto/rx/RxFix.h
+            src/crypto/rx/RxMsr.h
+            src/hw/msr/Msr.h
+            src/hw/msr/MsrItem.h
+            )
+
+        list(APPEND SOURCES_CRYPTO
+            src/crypto/rx/RxMsr.cpp
+            src/hw/msr/Msr.cpp
+            src/hw/msr/MsrItem.cpp
+            )
     else()
         remove_definitions(/DXMRIG_FEATURE_MSR)
         remove_definitions(/DXMRIG_FIX_RYZEN)
         message("-- WITH_MSR=OFF")
     endif()
+
+    if (WITH_PROFILING)
+        add_definitions(/DXMRIG_FEATURE_PROFILING)
+
+        list(APPEND HEADERS_CRYPTO src/crypto/rx/Profiler.h)
+        list(APPEND SOURCES_CRYPTO src/crypto/rx/Profiler.cpp)
+    endif()
 else()
     remove_definitions(/DXMRIG_ALGO_RANDOMX)
 endif()

doc/CPU.md

@@ -1,3 +1,5 @@
+**:warning: Recent version of this page https://xmrig.com/docs/miner/config/cpu.**
+
 # CPU backend
 
 All CPU related settings contains in one `cpu` object in config file, CPU backend allow specify multiple profiles and allow switch between them without restrictions by pool request or config change. Default auto-configuration create reasonable minimum of profiles which cover all supported algorithms.
@@ -75,6 +77,35 @@ Each number represent one thread and means CPU affinity, this is default format
 ```
 Internal format, but can be user defined.
 
+## RandomX options
+
+#### `init`
+Thread count to initialize RandomX dataset. Auto-detect (`-1`) or any number greater than 0 to use that many threads.
+
+#### `init-avx2`
+Use AVX2 for dataset initialization. Faster on some CPUs. Auto-detect (`-1`), disabled (`0`), always enabled on CPUs that support AVX2 (`1`).
+
+#### `mode`
+RandomX mining mode: `auto`, `fast` (2 GB memory), `light` (256 MB memory).
+
+#### `1gb-pages`
+Use 1GB hugepages for RandomX dataset (Linux only). Enabled (`true`) or disabled (`false`). It gives 1-3% speedup.
+
+#### `wrmsr`
+[MSR mod](https://xmrig.com/docs/miner/randomx-optimization-guide/msr). Enabled (`true`) or disabled (`false`). It gives up to 15% speedup depending on your system. _(**Note**: Userspace MSR writes are no longer enabled by default; the flag `msr.allow_writes=on` must be set for Linux Kernels 5.9 and after.)_
+
+#### `rdmsr`
+Restore MSR register values to their original values on exit. Used together with `wrmsr`. Enabled (`true`) or disabled (`false`).
+
+#### `cache_qos`
+[Cache QoS](https://xmrig.com/docs/miner/randomx-optimization-guide/qos). Enabled (`true`) or disabled (`false`). It's useful when you can't or don't want to mine on all CPU cores to make mining hashrate more stable.
+
+#### `numa`
+NUMA support (better hashrate on multi-CPU servers and Ryzen Threadripper 1xxx/2xxx). Enabled (`true`) or disabled (`false`).
+
+#### `scratchpad_prefetch_mode`
+Which instruction to use in RandomX loop to prefetch data from scratchpad. `1` is default and fastest in most cases. Can be off (`0`), `prefetcht0` instruction (`1`), `prefetchnta` instruction (`2`, a bit faster on Coffee Lake and a few other CPUs), `mov` instruction (`3`).
+
 ## Shared options
 
 #### `enabled`
@@ -83,23 +114,32 @@ Enable (`true`) or disable (`false`) CPU backend, by default `true`.
 #### `huge-pages`
 Enable (`true`) or disable (`false`) huge pages support, by default `true`.
 
+#### `huge-pages-jit`
+Enable (`true`) or disable (`false`) huge pages support for RandomX JIT code, by default `false`. It gives a very small boost on Ryzen CPUs, but hashrate is unstable between launches. Use with caution.
+
 #### `hw-aes`
 Force enable (`true`) or disable (`false`) hardware AES support. Default value `null` means miner autodetect this feature. Usually don't need change this option, this option useful for some rare cases when miner can't detect hardware AES, but it available. If you force enable this option, but your hardware not support it, miner will crash.
 
 #### `priority`
-Mining threads priority, value from `1` (lowest priority) to `5` (highest possible priority). Default value `null` means miner don't change threads priority at all.
+Mining threads priority, value from `1` (lowest priority) to `5` (highest possible priority). Default value `null` means miner don't change threads priority at all. Setting priority higher than 2 can make your PC unresponsive.
+
+#### `memory-pool` (since v4.3.0)
+Use continuous, persistent memory block for mining threads, useful for preserve huge pages allocation while algorithm switching. Possible values `false` (feature disabled, by default) or `true` or specific count of 2 MB huge pages. It helps to avoid loosing huge pages for scratchpads when RandomX dataset is updated and mining threads restart after a 2-3 days of mining.
+
+#### `yield` (since v5.1.1)
+Prefer system better system response/stability `true` (default value) or maximum hashrate `false`.
 
 #### `asm`
 Enable/configure or disable ASM optimizations. Possible values: `true`, `false`, `"intel"`, `"ryzen"`, `"bulldozer"`.
 
 #### `argon2-impl` (since v3.1.0)
-Allow override automatically detected Argon2 implementation, this option added mostly for debug purposes, default value `null` means autodetect. Other possible values: `"x86_64"`, `"SSE2"`, `"SSSE3"`, `"XOP"`, `"AVX2"`, `"AVX-512F"`. Manual selection has no safe guards, if you CPU not support required instuctions, miner will crash.
+Allow override automatically detected Argon2 implementation, this option added mostly for debug purposes, default value `null` means autodetect. This is used in RandomX dataset initialization and also in some other mining algorithms. Other possible values: `"x86_64"`, `"SSE2"`, `"SSSE3"`, `"XOP"`, `"AVX2"`, `"AVX-512F"`. Manual selection has no safe guards - if your CPU doesn't support required instuctions, miner will crash.
+
+#### `astrobwt-max-size`
+AstroBWT algorithm: skip hashes with large stage 2 size, default: `550`, min: `400`, max: `1200`. Optimal value depends on your CPU/GPU
+
+#### `astrobwt-avx2`
+AstroBWT algorithm: use AVX2 code. It's faster on some CPUs and slower on other
 
 #### `max-threads-hint` (since v4.2.0)
 Maximum CPU threads count (in percentage) hint for autoconfig. [CPU_MAX_USAGE.md](CPU_MAX_USAGE.md)
-
-#### `memory-pool` (since v4.3.0)
-Use continuous, persistent memory block for mining threads, useful for preserve huge pages allocation while algorithm swithing. Possible values `false` (feature disabled, by default) or `true` or specific count of 2 MB huge pages.
-
-#### `yield` (since v5.1.1)
-Prefer system better system response/stability `true` (default value) or maximum hashrate `false`.

doc/releases/5_0_1/SHA256SUMS

@@ -1,5 +0,0 @@
-6bb1a2e3a0fbca5195be6022f2a9fbff8a353c37c7542e7ab89420cb45b64505  xmrig-5.0.1-gcc-win32.zip
-24dba9ec281acfb2ea2c401ebd0e4e2d1f1ee5fd557da5ff3c7049020c1f78b6  xmrig-5.0.1-gcc-win64.zip
-86d65c6693ec9e35cd7547329580638b85c9eb0cf8383892a1c15199de5b556f  xmrig-5.0.1-msvc-cuda10_1-win64.zip
-0fbfe518b1c4b6993b0f66ff01302626375b15620ccf8f64d6fb97845068ffca  xmrig-5.0.1-msvc-win64.zip
-aa34890738a3494de2fa0e44db346937fea7339852f5f10b5d4655f95e2d8f1f  xmrig-5.0.1-xenial-x64.tar.gz

doc/releases/5_0_1/SHA256SUMS.sig

@@ -1,11 +0,0 @@
------BEGIN PGP SIGNATURE-----
-
-iQEzBAABCgAdFiEEmsTOqOZuNaXHzdwbRGpTY4vpRAkFAl3VcsoACgkQRGpTY4vp
-RAm9vQgA1MyTUU2jley2TCYLUzQy2Fffc8fbXYv64r44jbWOjC/6qo2iIlRgPhIc
-oVyPKr5TYS3QjDzCEm8IvozS0YudS6soESbPzqDonboK8pd0K4bsML9TQY2feV7A
-NL5vln0rfVHp1wxLLrQpfBqAgvJUXEyaHece6gFQN79JOGhEo2bHL2NyrOl+FViS
-b2BaMtXq410Fh+XT6ShnOaG/2EuO8ZqSGdCO6A/2LHQw1UY+mZiCvue6P6B06HmB
-WD/urOv38V389v+V+Sp4UlEW6VpBOOjvtChoVWtLt+tKzydrnt2EmoWWWg475pka
-4G6whHuMWS8CTt5/PDhJpvVXNQTIOw==
-=C764
------END PGP SIGNATURE-----

scripts/benchmark_10M.cmd

@@ -1,3 +1,4 @@
 @echo off
+cd %~dp0
 xmrig.exe --bench=10M --submit
 pause

scripts/benchmark_1M.cmd

@@ -1,3 +1,4 @@
 @echo off
+cd %~dp0
 xmrig.exe --bench=1M --submit
 pause

scripts/build.hwloc.sh

@@ -1,6 +1,10 @@
 #!/bin/bash -e
 
-HWLOC_VERSION="2.2.0"
+HWLOC_VERSION_MAJOR="2"
+HWLOC_VERSION_MINOR="7"
+HWLOC_VERSION_PATCH="1"
+
+HWLOC_VERSION="${HWLOC_VERSION_MAJOR}.${HWLOC_VERSION_MINOR}.${HWLOC_VERSION_PATCH}"
 
 mkdir -p deps
 mkdir -p deps/include
@@ -8,7 +12,7 @@ mkdir -p deps/lib
 
 mkdir -p build && cd build
 
-wget https://download.open-mpi.org/release/hwloc/v2.2/hwloc-${HWLOC_VERSION}.tar.gz -O hwloc-${HWLOC_VERSION}.tar.gz
+wget https://download.open-mpi.org/release/hwloc/v${HWLOC_VERSION_MAJOR}.${HWLOC_VERSION_MINOR}/hwloc-${HWLOC_VERSION}.tar.gz -O hwloc-${HWLOC_VERSION}.tar.gz
 tar -xzf hwloc-${HWLOC_VERSION}.tar.gz
 
 cd hwloc-${HWLOC_VERSION}

scripts/build.libressl.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -e
 
-LIBRESSL_VERSION="3.0.2"
+LIBRESSL_VERSION="3.5.2"
 
 mkdir -p deps
 mkdir -p deps/include

scripts/build.openssl.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -e
 
-OPENSSL_VERSION="1.1.1h"
+OPENSSL_VERSION="1.1.1o"
 
 mkdir -p deps
 mkdir -p deps/include

scripts/build.openssl3.sh

@@ -0,0 +1,20 @@
+#!/bin/bash -e
+
+OPENSSL_VERSION="3.0.3"
+
+mkdir -p deps
+mkdir -p deps/include
+mkdir -p deps/lib
+
+mkdir -p build && cd build
+
+wget https://www.openssl.org/source/openssl-${OPENSSL_VERSION}.tar.gz -O openssl-${OPENSSL_VERSION}.tar.gz
+tar -xzf openssl-${OPENSSL_VERSION}.tar.gz
+
+cd openssl-${OPENSSL_VERSION}
+./config -no-shared -no-asm -no-zlib -no-comp -no-dgram -no-filenames -no-cms
+make -j$(nproc || sysctl -n hw.ncpu || sysctl -n hw.logicalcpu)
+cp -fr include ../../deps
+cp libcrypto.a ../../deps/lib
+cp libssl.a ../../deps/lib
+cd ..

scripts/build.uv.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -e
 
-UV_VERSION="1.40.0"
+UV_VERSION="1.44.1"
 
 mkdir -p deps
 mkdir -p deps/include

scripts/generate_cl.js

@@ -51,6 +51,7 @@ function rx()
         'randomx_constants_wow.h',
         'randomx_constants_arqma.h',
         'randomx_constants_keva.h',
+        'randomx_constants_graft.h',
         'aes.cl',
         'blake2b.cl',
         'randomx_vm.cl',
@@ -66,15 +67,6 @@ function rx()
 }
 
 
-function astrobwt()
-{
-    const astrobwt = opencl_minify(addIncludes('astrobwt.cl', [ 'BWT.cl', 'salsa20.cl', 'sha3.cl' ]));
-
-    // fs.writeFileSync('astrobwt_gen.cl', astrobwt);
-    fs.writeFileSync('astrobwt_cl.h', text2h(astrobwt, 'xmrig', 'astrobwt_cl'));
-}
-
-
 function kawpow()
 {
     const kawpow = opencl_minify(addIncludes('kawpow.cl', [ 'defs.h' ]));
@@ -96,11 +88,6 @@ process.chdir(path.resolve('src/backend/opencl/cl/rx'));
 
 rx();
 
-process.chdir(cwd);
-process.chdir(path.resolve('src/backend/opencl/cl/astrobwt'));
-
-astrobwt();
-
 process.chdir(cwd);
 process.chdir(path.resolve('src/backend/opencl/cl/kawpow'));
 

scripts/pool_mine_example.cmd

@@ -0,0 +1,20 @@
+:: Example batch file for mining Monero at a pool
+::
+:: Format:
+::	xmrig.exe -o <pool address>:<pool port> -u <pool username/wallet> -p <pool password>
+::
+:: Fields:
+::	pool address		The host name of the pool stratum or its IP address, for example pool.hashvault.pro
+::	pool port 		The port of the pool's stratum to connect to, for example 3333. Check your pool's getting started page.
+::	pool username/wallet 	For most pools, this is the wallet address you want to mine to. Some pools require a username
+::	pool password 		For most pools this can be just 'x'. For pools using usernames, you may need to provide a password as configured on the pool.
+::
+:: List of Monero mining pools:
+::	https://miningpoolstats.stream/monero
+::
+:: Choose pools outside of top 5 to help Monero network be more decentralized!
+:: Smaller pools also often have smaller fees/payout limits.
+
+cd %~dp0
+xmrig.exe -o pool.hashvault.pro:3333 -u 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD -p x
+pause

scripts/randomx_boost.sh

@@ -1,18 +1,34 @@
-#!/bin/bash
+#!/bin/sh -e
 
-modprobe msr
+MSR_FILE=/sys/module/msr/parameters/allow_writes
 
-if cat /proc/cpuinfo | grep "AMD Ryzen" > /dev/null;
+if test -e "$MSR_FILE"; then
+	echo on > $MSR_FILE
+else
+	modprobe msr allow_writes=on
+fi
+
+if grep -E 'AMD Ryzen|AMD EPYC' /proc/cpuinfo > /dev/null;
 	then
-		echo "Detected Ryzen"
-		wrmsr -a 0xc0011022 0x510000
-		wrmsr -a 0xc001102b 0x1808cc16
+	if grep "cpu family[[:space:]]:[[:space:]]25" /proc/cpuinfo > /dev/null;
+		then
+			echo "Detected Zen3 CPU"
+			wrmsr -a 0xc0011020 0x4480000000000
+			wrmsr -a 0xc0011021 0x1c000200000040
+			wrmsr -a 0xc0011022 0xc000000401500000
+			wrmsr -a 0xc001102b 0x2000cc14
+			echo "MSR register values for Zen3 applied"
+		else
+			echo "Detected Zen1/Zen2 CPU"
 			wrmsr -a 0xc0011020 0
 			wrmsr -a 0xc0011021 0x40
-		echo "MSR register values for Ryzen applied"
-elif cat /proc/cpuinfo | grep "Intel" > /dev/null;
+			wrmsr -a 0xc0011022 0x1510000
+			wrmsr -a 0xc001102b 0x2000cc16
+			echo "MSR register values for Zen1/Zen2 applied"
+		fi
+elif grep "Intel" /proc/cpuinfo > /dev/null;
 	then
-		echo "Detected Intel"
+		echo "Detected Intel CPU"
 		wrmsr -a 0x1a4 0xf
 		echo "MSR register values for Intel applied"
 else

scripts/rtm_ghostrider_example.cmd

@@ -0,0 +1,23 @@
+:: Example batch file for mining Raptoreum at a pool
+::
+:: Format:
+::      xmrig.exe -a gr -o <pool address>:<pool port> -u <pool username/wallet> -p <pool password>
+::
+:: Fields:
+::      pool address            The host name of the pool stratum or its IP address, for example raptoreumemporium.com
+::      pool port               The port of the pool's stratum to connect to, for example 3333. Check your pool's getting started page.
+::      pool username/wallet    For most pools, this is the wallet address you want to mine to. Some pools require a username
+::      pool password           For most pools this can be just 'x'. For pools using usernames, you may need to provide a password as configured on the pool.
+::
+:: List of Raptoreum mining pools:
+::      https://miningpoolstats.stream/raptoreum
+::
+:: Choose pools outside of top 5 to help Raptoreum network be more decentralized!
+:: Smaller pools also often have smaller fees/payout limits.
+
+cd %~dp0
+:: Use this command line to connect to non-SSL port
+xmrig.exe -a gr -o raptoreumemporium.com:3008 -u WALLET_ADDRESS -p x
+:: Or use this command line to connect to an SSL port
+:: xmrig.exe -a gr -o rtm.suprnova.cc:4273 --tls -u WALLET_ADDRESS -p x
+pause

scripts/solo_mine_example.cmd

@@ -0,0 +1,16 @@
+:: Example batch file for mining Monero solo
+::
+:: Format:
+::	xmrig.exe -o <node address>:<node port> -a rx/0 -u <wallet address> --daemon
+::
+:: Fields:
+::	node address		The host name of your monerod node or its IP address. It can also be a public node with RPC enabled, for example node.xmr.to
+::	node port 		The RPC port of your monerod node to connect to, usually 18081.
+::	wallet address		Check your Monero CLI or GUI wallet to see your wallet's address.
+::
+:: Mining solo is the best way to help Monero network be more decentralized!
+:: But you will only get a payout when you find a block which can take more than a year for a single low-end PC.
+
+cd %~dp0
+xmrig.exe -o node.xmr.to:18081 -a rx/0 -u 48edfHu7V9Z84YzzMa6fUueoELZ9ZRXq9VetWzYGzKt52XU5xvqgzYnDK9URnRoJMk1j8nLwEVsaSWJ4fhdUyZijBGUicoD --daemon
+pause

src/3rdparty/argon2/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 2.8)
+cmake_minimum_required(VERSION 2.8.12)
 
 project(argon2 C)
 set(CMAKE_C_STANDARD 99)

src/3rdparty/epee/LICENSE.txt

@@ -0,0 +1,25 @@
+Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Andrey N. Sabelnikov nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL Andrey N. Sabelnikov BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

src/3rdparty/epee/README.md

@@ -0,0 +1 @@
+epee -  is a small library of helpers, wrappers, tools and and so on, used to make my life easier.

src/3rdparty/epee/span.h

@@ -0,0 +1,176 @@
+// Copyright (c) 2017-2020, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+//    conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice, this list
+//    of conditions and the following disclaimer in the documentation and/or other
+//    materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+//    used to endorse or promote products derived from this software without specific
+//    prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+// THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+// THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#pragma once
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <type_traits>
+
+namespace epee
+{
+  /*!
+    \brief Non-owning sequence of data. Does not deep copy
+
+    Inspired by `gsl::span` and/or `boost::iterator_range`. This class is
+    intended to be used as a parameter type for functions that need to take a
+    writable or read-only sequence of data. Most common cases are `span<char>`
+    and `span<std::uint8_t>`. Using as a class member is only recommended if
+    clearly documented as not doing a deep-copy. C-arrays are easily convertible
+    to this type.
+
+    \note Conversion from C string literal to `span<const char>` will include
+      the NULL-terminator.
+    \note Never allows derived-to-base pointer conversion; an array of derived
+      types is not an array of base types.
+   */
+  template<typename T>
+  class span
+  {
+    template<typename U>
+    static constexpr bool safe_conversion() noexcept
+    {
+      // Allow exact matches or `T*` -> `const T*`.
+      using with_const = typename std::add_const<U>::type;
+      return std::is_same<T, U>() ||
+        (std::is_const<T>() && std::is_same<T, with_const>());
+    }
+
+  public:
+    using value_type = T;
+    using size_type = std::size_t;
+    using difference_type = std::ptrdiff_t;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using reference = T&;
+    using const_reference = const T&;
+    using iterator = pointer;
+    using const_iterator = const_pointer;
+
+    constexpr span() noexcept : ptr(nullptr), len(0) {}
+    constexpr span(std::nullptr_t) noexcept : span() {}
+
+    //! Prevent derived-to-base conversions; invalid in this context.
+    template<typename U, typename = typename std::enable_if<safe_conversion<U>()>::type>
+    constexpr span(U* const src_ptr, const std::size_t count) noexcept
+      : ptr(src_ptr), len(count) {}
+
+    //! Conversion from C-array. Prevents common bugs with sizeof + arrays.
+    template<std::size_t N>
+    constexpr span(T (&src)[N]) noexcept : span(src, N) {}
+
+    constexpr span(const span&) noexcept = default;
+    span& operator=(const span&) noexcept = default;
+
+    /*! Try to remove `amount` elements from beginning of span.
+    \return Number of elements removed. */
+    std::size_t remove_prefix(std::size_t amount) noexcept
+    {
+        amount = std::min(len, amount);
+        ptr += amount;
+        len -= amount;
+        return amount;
+    }
+
+    constexpr iterator begin() const noexcept { return ptr; }
+    constexpr const_iterator cbegin() const noexcept { return ptr; }
+
+    constexpr iterator end() const noexcept { return begin() + size(); }
+    constexpr const_iterator cend() const noexcept { return cbegin() + size(); }
+
+    constexpr bool empty() const noexcept { return size() == 0; }
+    constexpr pointer data() const noexcept { return ptr; }
+    constexpr std::size_t size() const noexcept { return len; }
+    constexpr std::size_t size_bytes() const noexcept { return size() * sizeof(value_type); }
+
+    T &operator[](size_t idx) noexcept { return ptr[idx]; }
+    const T &operator[](size_t idx) const noexcept { return ptr[idx]; }
+
+  private:
+    T* ptr;
+    std::size_t len;
+  };
+
+  //! \return `span<const T::value_type>` from a STL compatible `src`.
+  template<typename T>
+  constexpr span<const typename T::value_type> to_span(const T& src)
+  {
+    // compiler provides diagnostic if size() is not size_t.
+    return {src.data(), src.size()};
+  }
+
+  //! \return `span<T::value_type>` from a STL compatible `src`.
+  template<typename T>
+  constexpr span<typename T::value_type> to_mut_span(T& src)
+  {
+    // compiler provides diagnostic if size() is not size_t.
+    return {src.data(), src.size()};
+  }
+
+  template<typename T>
+  constexpr bool has_padding() noexcept
+  {
+    return !std::is_standard_layout<T>() || alignof(T) != 1;
+  }
+
+  //! \return Cast data from `src` as `span<const std::uint8_t>`.
+  template<typename T>
+  span<const std::uint8_t> to_byte_span(const span<const T> src) noexcept
+  {
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<const std::uint8_t*>(src.data()), src.size_bytes()};
+  }
+
+  //! \return `span<const std::uint8_t>` which represents the bytes at `&src`.
+  template<typename T>
+  span<const std::uint8_t> as_byte_span(const T& src) noexcept
+  {
+    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<const std::uint8_t*>(std::addressof(src)), sizeof(T)};
+  }
+
+  //! \return `span<std::uint8_t>` which represents the bytes at `&src`.
+  template<typename T>
+  span<std::uint8_t> as_mut_byte_span(T& src) noexcept
+  {
+    static_assert(!std::is_empty<T>(), "empty types will not work -> sizeof == 1");
+    static_assert(!has_padding<T>(), "source type may have padding");
+    return {reinterpret_cast<std::uint8_t*>(std::addressof(src)), sizeof(T)};
+  }
+
+  //! make a span from a std::string
+  template<typename T>
+  span<const T> strspan(const std::string &s) noexcept
+  {
+    static_assert(std::is_same<T, char>() || std::is_same<T, unsigned char>() || std::is_same<T, int8_t>() || std::is_same<T, uint8_t>(), "Unexpected type");
+    return {reinterpret_cast<const T*>(s.data()), s.size()};
+  }
+}

src/3rdparty/fmt/format-inl.h

@@ -1754,7 +1754,7 @@ inline bool divisible_by_power_of_2(uint64_t x, int exp) FMT_NOEXCEPT {
 #ifdef FMT_BUILTIN_CTZLL
   return FMT_BUILTIN_CTZLL(x) >= exp;
 #else
-  return exp < num_bits<uint64_t>()) && x == ((x >> exp) << exp);
+  return (exp < num_bits<uint64_t>()) && x == ((x >> exp) << exp);
 #endif
 }
 

src/3rdparty/getopt/getopt.h

@@ -109,11 +109,7 @@ char    *optarg;		/* argument associated with option */
 extern char __declspec(dllimport) *__progname;
 #endif
 
-#ifdef __CYGWIN__
 static char EMSG[] = "";
-#else
-#define	EMSG		""
-#endif
 
 static int getopt_internal(int, char * const *, const char *,
 			   const struct option *, int *, int);

src/3rdparty/http-parser/AUTHORS

@@ -1,68 +0,0 @@
-# Authors ordered by first contribution.
-Ryan Dahl <ry@tinyclouds.org>
-Jeremy Hinegardner <jeremy@hinegardner.org>
-Sergey Shepelev <temotor@gmail.com>
-Joe Damato <ice799@gmail.com>
-tomika <tomika_nospam@freemail.hu>
-Phoenix Sol <phoenix@burninglabs.com>
-Cliff Frey <cliff@meraki.com>
-Ewen Cheslack-Postava <ewencp@cs.stanford.edu>
-Santiago Gala <sgala@apache.org>
-Tim Becker <tim.becker@syngenio.de>
-Jeff Terrace <jterrace@gmail.com>
-Ben Noordhuis <info@bnoordhuis.nl>
-Nathan Rajlich <nathan@tootallnate.net>
-Mark Nottingham <mnot@mnot.net>
-Aman Gupta <aman@tmm1.net>
-Tim Becker <tim.becker@kuriositaet.de>
-Sean Cunningham <sean.cunningham@mandiant.com>
-Peter Griess <pg@std.in>
-Salman Haq <salman.haq@asti-usa.com>
-Cliff Frey <clifffrey@gmail.com>
-Jon Kolb <jon@b0g.us>
-Fouad Mardini <f.mardini@gmail.com>
-Paul Querna <pquerna@apache.org>
-Felix Geisendörfer <felix@debuggable.com>
-koichik <koichik@improvement.jp>
-Andre Caron <andre.l.caron@gmail.com>
-Ivo Raisr <ivosh@ivosh.net>
-James McLaughlin <jamie@lacewing-project.org>
-David Gwynne <loki@animata.net>
-Thomas LE ROUX <thomas@november-eleven.fr>
-Randy Rizun <rrizun@ortivawireless.com>
-Andre Louis Caron <andre.louis.caron@usherbrooke.ca>
-Simon Zimmermann <simonz05@gmail.com>
-Erik Dubbelboer <erik@dubbelboer.com>
-Martell Malone <martellmalone@gmail.com>
-Bertrand Paquet <bpaquet@octo.com>
-BogDan Vatra <bogdan@kde.org>
-Peter Faiman <peter@thepicard.org>
-Corey Richardson <corey@octayn.net>
-Tóth Tamás <tomika_nospam@freemail.hu>
-Cam Swords <cam.swords@gmail.com>
-Chris Dickinson <christopher.s.dickinson@gmail.com>
-Uli Köhler <ukoehler@btronik.de>
-Charlie Somerville <charlie@charliesomerville.com>
-Patrik Stutz <patrik.stutz@gmail.com>
-Fedor Indutny <fedor.indutny@gmail.com>
-runner <runner.mei@gmail.com>
-Alexis Campailla <alexis@janeasystems.com>
-David Wragg <david@wragg.org>
-Vinnie Falco <vinnie.falco@gmail.com>
-Alex Butum <alexbutum@linux.com>
-Rex Feng <rexfeng@gmail.com>
-Alex Kocharin <alex@kocharin.ru>
-Mark Koopman <markmontymark@yahoo.com>
-Helge Heß <me@helgehess.eu>
-Alexis La Goutte <alexis.lagoutte@gmail.com>
-George Miroshnykov <george.miroshnykov@gmail.com>
-Maciej Małecki <me@mmalecki.com>
-Marc O'Morain <github.com@marcomorain.com>
-Jeff Pinner <jpinner@twitter.com>
-Timothy J Fontaine <tjfontaine@gmail.com>
-Akagi201 <akagi201@gmail.com>
-Romain Giraud <giraud.romain@gmail.com>
-Jay Satiro <raysatiro@yahoo.com>
-Arne Steen <Arne.Steen@gmx.de>
-Kjell Schubert <kjell.schubert@gmail.com>
-Olivier Mengué <dolmen@cpan.org>

src/3rdparty/http-parser/LICENSE-MIT

@@ -1,19 +0,0 @@
-Copyright Joyent, Inc. and other Node contributors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to
-deal in the Software without restriction, including without limitation the
-rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
-sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
-IN THE SOFTWARE. 

src/3rdparty/http-parser/README.md

@@ -1,246 +0,0 @@
-HTTP Parser
-===========
-
-[![Build Status](https://api.travis-ci.org/nodejs/http-parser.svg?branch=master)](https://travis-ci.org/nodejs/http-parser)
-
-This is a parser for HTTP messages written in C. It parses both requests and
-responses. The parser is designed to be used in performance HTTP
-applications. It does not make any syscalls nor allocations, it does not
-buffer data, it can be interrupted at anytime. Depending on your
-architecture, it only requires about 40 bytes of data per message
-stream (in a web server that is per connection).
-
-Features:
-
-  * No dependencies
-  * Handles persistent streams (keep-alive).
-  * Decodes chunked encoding.
-  * Upgrade support
-  * Defends against buffer overflow attacks.
-
-The parser extracts the following information from HTTP messages:
-
-  * Header fields and values
-  * Content-Length
-  * Request method
-  * Response status code
-  * Transfer-Encoding
-  * HTTP version
-  * Request URL
-  * Message body
-
-
-Usage
------
-
-One `http_parser` object is used per TCP connection. Initialize the struct
-using `http_parser_init()` and set the callbacks. That might look something
-like this for a request parser:
-```c
-http_parser_settings settings;
-settings.on_url = my_url_callback;
-settings.on_header_field = my_header_field_callback;
-/* ... */
-
-http_parser *parser = malloc(sizeof(http_parser));
-http_parser_init(parser, HTTP_REQUEST);
-parser->data = my_socket;
-```
-
-When data is received on the socket execute the parser and check for errors.
-
-```c
-size_t len = 80*1024, nparsed;
-char buf[len];
-ssize_t recved;
-
-recved = recv(fd, buf, len, 0);
-
-if (recved < 0) {
-  /* Handle error. */
-}
-
-/* Start up / continue the parser.
- * Note we pass recved==0 to signal that EOF has been received.
- */
-nparsed = http_parser_execute(parser, &settings, buf, recved);
-
-if (parser->upgrade) {
-  /* handle new protocol */
-} else if (nparsed != recved) {
-  /* Handle error. Usually just close the connection. */
-}
-```
-
-`http_parser` needs to know where the end of the stream is. For example, sometimes
-servers send responses without Content-Length and expect the client to
-consume input (for the body) until EOF. To tell `http_parser` about EOF, give
-`0` as the fourth parameter to `http_parser_execute()`. Callbacks and errors
-can still be encountered during an EOF, so one must still be prepared
-to receive them.
-
-Scalar valued message information such as `status_code`, `method`, and the
-HTTP version are stored in the parser structure. This data is only
-temporally stored in `http_parser` and gets reset on each new message. If
-this information is needed later, copy it out of the structure during the
-`headers_complete` callback.
-
-The parser decodes the transfer-encoding for both requests and responses
-transparently. That is, a chunked encoding is decoded before being sent to
-the on_body callback.
-
-
-The Special Problem of Upgrade
-------------------------------
-
-`http_parser` supports upgrading the connection to a different protocol. An
-increasingly common example of this is the WebSocket protocol which sends
-a request like
-
-        GET /demo HTTP/1.1
-        Upgrade: WebSocket
-        Connection: Upgrade
-        Host: example.com
-        Origin: http://example.com
-        WebSocket-Protocol: sample
-
-followed by non-HTTP data.
-
-(See [RFC6455](https://tools.ietf.org/html/rfc6455) for more information the
-WebSocket protocol.)
-
-To support this, the parser will treat this as a normal HTTP message without a
-body, issuing both on_headers_complete and on_message_complete callbacks. However
-http_parser_execute() will stop parsing at the end of the headers and return.
-
-The user is expected to check if `parser->upgrade` has been set to 1 after
-`http_parser_execute()` returns. Non-HTTP data begins at the buffer supplied
-offset by the return value of `http_parser_execute()`.
-
-
-Callbacks
----------
-
-During the `http_parser_execute()` call, the callbacks set in
-`http_parser_settings` will be executed. The parser maintains state and
-never looks behind, so buffering the data is not necessary. If you need to
-save certain data for later usage, you can do that from the callbacks.
-
-There are two types of callbacks:
-
-* notification `typedef int (*http_cb) (http_parser*);`
-    Callbacks: on_message_begin, on_headers_complete, on_message_complete.
-* data `typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);`
-    Callbacks: (requests only) on_url,
-               (common) on_header_field, on_header_value, on_body;
-
-Callbacks must return 0 on success. Returning a non-zero value indicates
-error to the parser, making it exit immediately.
-
-For cases where it is necessary to pass local information to/from a callback,
-the `http_parser` object's `data` field can be used.
-An example of such a case is when using threads to handle a socket connection,
-parse a request, and then give a response over that socket. By instantiation
-of a thread-local struct containing relevant data (e.g. accepted socket,
-allocated memory for callbacks to write into, etc), a parser's callbacks are
-able to communicate data between the scope of the thread and the scope of the
-callback in a threadsafe manner. This allows `http_parser` to be used in
-multi-threaded contexts.
-
-Example:
-```c
- typedef struct {
-  socket_t sock;
-  void* buffer;
-  int buf_len;
- } custom_data_t;
-
-
-int my_url_callback(http_parser* parser, const char *at, size_t length) {
-  /* access to thread local custom_data_t struct.
-  Use this access save parsed data for later use into thread local
-  buffer, or communicate over socket
-  */
-  parser->data;
-  ...
-  return 0;
-}
-
-...
-
-void http_parser_thread(socket_t sock) {
- int nparsed = 0;
- /* allocate memory for user data */
- custom_data_t *my_data = malloc(sizeof(custom_data_t));
-
- /* some information for use by callbacks.
- * achieves thread -> callback information flow */
- my_data->sock = sock;
-
- /* instantiate a thread-local parser */
- http_parser *parser = malloc(sizeof(http_parser));
- http_parser_init(parser, HTTP_REQUEST); /* initialise parser */
- /* this custom data reference is accessible through the reference to the
- parser supplied to callback functions */
- parser->data = my_data;
-
- http_parser_settings settings; /* set up callbacks */
- settings.on_url = my_url_callback;
-
- /* execute parser */
- nparsed = http_parser_execute(parser, &settings, buf, recved);
-
- ...
- /* parsed information copied from callback.
- can now perform action on data copied into thread-local memory from callbacks.
- achieves callback -> thread information flow */
- my_data->buffer;
- ...
-}
-
-```
-
-In case you parse HTTP message in chunks (i.e. `read()` request line
-from socket, parse, read half headers, parse, etc) your data callbacks
-may be called more than once. `http_parser` guarantees that data pointer is only
-valid for the lifetime of callback. You can also `read()` into a heap allocated
-buffer to avoid copying memory around if this fits your application.
-
-Reading headers may be a tricky task if you read/parse headers partially.
-Basically, you need to remember whether last header callback was field or value
-and apply the following logic:
-
-    (on_header_field and on_header_value shortened to on_h_*)
-     ------------------------ ------------ --------------------------------------------
-    | State (prev. callback) | Callback   | Description/action                         |
-     ------------------------ ------------ --------------------------------------------
-    | nothing (first call)   | on_h_field | Allocate new buffer and copy callback data |
-    |                        |            | into it                                    |
-     ------------------------ ------------ --------------------------------------------
-    | value                  | on_h_field | New header started.                        |
-    |                        |            | Copy current name,value buffers to headers |
-    |                        |            | list and allocate new buffer for new name  |
-     ------------------------ ------------ --------------------------------------------
-    | field                  | on_h_field | Previous name continues. Reallocate name   |
-    |                        |            | buffer and append callback data to it      |
-     ------------------------ ------------ --------------------------------------------
-    | field                  | on_h_value | Value for current header started. Allocate |
-    |                        |            | new buffer and copy callback data to it    |
-     ------------------------ ------------ --------------------------------------------
-    | value                  | on_h_value | Value continues. Reallocate value buffer   |
-    |                        |            | and append callback data to it             |
-     ------------------------ ------------ --------------------------------------------
-
-
-Parsing URLs
-------------
-
-A simplistic zero-copy URL parser is provided as `http_parser_parse_url()`.
-Users of this library may wish to use it to parse URLs constructed from
-consecutive `on_url` callbacks.
-
-See examples of reading in headers:
-
-* [partial example](http://gist.github.com/155877) in C
-* [from http-parser tests](http://github.com/joyent/http-parser/blob/37a0ff8/test.c#L403) in C
-* [from Node library](http://github.com/joyent/node/blob/842eaf4/src/http.js#L284) in Javascript

src/3rdparty/http-parser/http_parser.h

@@ -1,442 +0,0 @@
-/* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to
- * deal in the Software without restriction, including without limitation the
- * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE.
- */
-#ifndef http_parser_h
-#define http_parser_h
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Also update SONAME in the Makefile whenever you change these. */
-#define HTTP_PARSER_VERSION_MAJOR 2
-#define HTTP_PARSER_VERSION_MINOR 9
-#define HTTP_PARSER_VERSION_PATCH 3
-
-#include <stddef.h>
-#if defined(_WIN32) && !defined(__MINGW32__) && \
-  (!defined(_MSC_VER) || _MSC_VER<1600) && !defined(__WINE__)
-#include <BaseTsd.h>
-typedef __int8 int8_t;
-typedef unsigned __int8 uint8_t;
-typedef __int16 int16_t;
-typedef unsigned __int16 uint16_t;
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef __int64 int64_t;
-typedef unsigned __int64 uint64_t;
-#else
-#include <stdint.h>
-#endif
-
-/* Compile with -DHTTP_PARSER_STRICT=0 to make less checks, but run
- * faster
- */
-#ifndef HTTP_PARSER_STRICT
-# define HTTP_PARSER_STRICT 1
-#endif
-
-/* Maximium header size allowed. If the macro is not defined
- * before including this header then the default is used. To
- * change the maximum header size, define the macro in the build
- * environment (e.g. -DHTTP_MAX_HEADER_SIZE=<value>). To remove
- * the effective limit on the size of the header, define the macro
- * to a very large number (e.g. -DHTTP_MAX_HEADER_SIZE=0x7fffffff)
- */
-#ifndef HTTP_MAX_HEADER_SIZE
-# define HTTP_MAX_HEADER_SIZE (80*1024)
-#endif
-
-typedef struct http_parser http_parser;
-typedef struct http_parser_settings http_parser_settings;
-
-
-/* Callbacks should return non-zero to indicate an error. The parser will
- * then halt execution.
- *
- * The one exception is on_headers_complete. In a HTTP_RESPONSE parser
- * returning '1' from on_headers_complete will tell the parser that it
- * should not expect a body. This is used when receiving a response to a
- * HEAD request which may contain 'Content-Length' or 'Transfer-Encoding:
- * chunked' headers that indicate the presence of a body.
- *
- * Returning `2` from on_headers_complete will tell parser that it should not
- * expect neither a body nor any futher responses on this connection. This is
- * useful for handling responses to a CONNECT request which may not contain
- * `Upgrade` or `Connection: upgrade` headers.
- *
- * http_data_cb does not return data chunks. It will be called arbitrarily
- * many times for each string. E.G. you might get 10 callbacks for "on_url"
- * each providing just a few characters more data.
- */
-typedef int (*http_data_cb) (http_parser*, const char *at, size_t length);
-typedef int (*http_cb) (http_parser*);
-
-
-/* Status Codes */
-#define HTTP_STATUS_MAP(XX)                                                 \
-  XX(100, CONTINUE,                        Continue)                        \
-  XX(101, SWITCHING_PROTOCOLS,             Switching Protocols)             \
-  XX(102, PROCESSING,                      Processing)                      \
-  XX(200, OK,                              OK)                              \
-  XX(201, CREATED,                         Created)                         \
-  XX(202, ACCEPTED,                        Accepted)                        \
-  XX(203, NON_AUTHORITATIVE_INFORMATION,   Non-Authoritative Information)   \
-  XX(204, NO_CONTENT,                      No Content)                      \
-  XX(205, RESET_CONTENT,                   Reset Content)                   \
-  XX(206, PARTIAL_CONTENT,                 Partial Content)                 \
-  XX(207, MULTI_STATUS,                    Multi-Status)                    \
-  XX(208, ALREADY_REPORTED,                Already Reported)                \
-  XX(226, IM_USED,                         IM Used)                         \
-  XX(300, MULTIPLE_CHOICES,                Multiple Choices)                \
-  XX(301, MOVED_PERMANENTLY,               Moved Permanently)               \
-  XX(302, FOUND,                           Found)                           \
-  XX(303, SEE_OTHER,                       See Other)                       \
-  XX(304, NOT_MODIFIED,                    Not Modified)                    \
-  XX(305, USE_PROXY,                       Use Proxy)                       \
-  XX(307, TEMPORARY_REDIRECT,              Temporary Redirect)              \
-  XX(308, PERMANENT_REDIRECT,              Permanent Redirect)              \
-  XX(400, BAD_REQUEST,                     Bad Request)                     \
-  XX(401, UNAUTHORIZED,                    Unauthorized)                    \
-  XX(402, PAYMENT_REQUIRED,                Payment Required)                \
-  XX(403, FORBIDDEN,                       Forbidden)                       \
-  XX(404, NOT_FOUND,                       Not Found)                       \
-  XX(405, METHOD_NOT_ALLOWED,              Method Not Allowed)              \
-  XX(406, NOT_ACCEPTABLE,                  Not Acceptable)                  \
-  XX(407, PROXY_AUTHENTICATION_REQUIRED,   Proxy Authentication Required)   \
-  XX(408, REQUEST_TIMEOUT,                 Request Timeout)                 \
-  XX(409, CONFLICT,                        Conflict)                        \
-  XX(410, GONE,                            Gone)                            \
-  XX(411, LENGTH_REQUIRED,                 Length Required)                 \
-  XX(412, PRECONDITION_FAILED,             Precondition Failed)             \
-  XX(413, PAYLOAD_TOO_LARGE,               Payload Too Large)               \
-  XX(414, URI_TOO_LONG,                    URI Too Long)                    \
-  XX(415, UNSUPPORTED_MEDIA_TYPE,          Unsupported Media Type)          \
-  XX(416, RANGE_NOT_SATISFIABLE,           Range Not Satisfiable)           \
-  XX(417, EXPECTATION_FAILED,              Expectation Failed)              \
-  XX(421, MISDIRECTED_REQUEST,             Misdirected Request)             \
-  XX(422, UNPROCESSABLE_ENTITY,            Unprocessable Entity)            \
-  XX(423, LOCKED,                          Locked)                          \
-  XX(424, FAILED_DEPENDENCY,               Failed Dependency)               \
-  XX(426, UPGRADE_REQUIRED,                Upgrade Required)                \
-  XX(428, PRECONDITION_REQUIRED,           Precondition Required)           \
-  XX(429, TOO_MANY_REQUESTS,               Too Many Requests)               \
-  XX(431, REQUEST_HEADER_FIELDS_TOO_LARGE, Request Header Fields Too Large) \
-  XX(451, UNAVAILABLE_FOR_LEGAL_REASONS,   Unavailable For Legal Reasons)   \
-  XX(500, INTERNAL_SERVER_ERROR,           Internal Server Error)           \
-  XX(501, NOT_IMPLEMENTED,                 Not Implemented)                 \
-  XX(502, BAD_GATEWAY,                     Bad Gateway)                     \
-  XX(503, SERVICE_UNAVAILABLE,             Service Unavailable)             \
-  XX(504, GATEWAY_TIMEOUT,                 Gateway Timeout)                 \
-  XX(505, HTTP_VERSION_NOT_SUPPORTED,      HTTP Version Not Supported)      \
-  XX(506, VARIANT_ALSO_NEGOTIATES,         Variant Also Negotiates)         \
-  XX(507, INSUFFICIENT_STORAGE,            Insufficient Storage)            \
-  XX(508, LOOP_DETECTED,                   Loop Detected)                   \
-  XX(510, NOT_EXTENDED,                    Not Extended)                    \
-  XX(511, NETWORK_AUTHENTICATION_REQUIRED, Network Authentication Required) \
-
-enum http_status
-  {
-#define XX(num, name, string) HTTP_STATUS_##name = num,
-  HTTP_STATUS_MAP(XX)
-#undef XX
-  };
-
-
-/* Request Methods */
-#define HTTP_METHOD_MAP(XX)         \
-  XX(0,  DELETE,      DELETE)       \
-  XX(1,  GET,         GET)          \
-  XX(2,  HEAD,        HEAD)         \
-  XX(3,  POST,        POST)         \
-  XX(4,  PUT,         PUT)          \
-  /* pathological */                \
-  XX(5,  CONNECT,     CONNECT)      \
-  XX(6,  OPTIONS,     OPTIONS)      \
-  XX(7,  TRACE,       TRACE)        \
-  /* WebDAV */                      \
-  XX(8,  COPY,        COPY)         \
-  XX(9,  LOCK,        LOCK)         \
-  XX(10, MKCOL,       MKCOL)        \
-  XX(11, MOVE,        MOVE)         \
-  XX(12, PROPFIND,    PROPFIND)     \
-  XX(13, PROPPATCH,   PROPPATCH)    \
-  XX(14, SEARCH,      SEARCH)       \
-  XX(15, UNLOCK,      UNLOCK)       \
-  XX(16, BIND,        BIND)         \
-  XX(17, REBIND,      REBIND)       \
-  XX(18, UNBIND,      UNBIND)       \
-  XX(19, ACL,         ACL)          \
-  /* subversion */                  \
-  XX(20, REPORT,      REPORT)       \
-  XX(21, MKACTIVITY,  MKACTIVITY)   \
-  XX(22, CHECKOUT,    CHECKOUT)     \
-  XX(23, MERGE,       MERGE)        \
-  /* upnp */                        \
-  XX(24, MSEARCH,     M-SEARCH)     \
-  XX(25, NOTIFY,      NOTIFY)       \
-  XX(26, SUBSCRIBE,   SUBSCRIBE)    \
-  XX(27, UNSUBSCRIBE, UNSUBSCRIBE)  \
-  /* RFC-5789 */                    \
-  XX(28, PATCH,       PATCH)        \
-  XX(29, PURGE,       PURGE)        \
-  /* CalDAV */                      \
-  XX(30, MKCALENDAR,  MKCALENDAR)   \
-  /* RFC-2068, section 19.6.1.2 */  \
-  XX(31, LINK,        LINK)         \
-  XX(32, UNLINK,      UNLINK)       \
-  /* icecast */                     \
-  XX(33, SOURCE,      SOURCE)       \
-
-enum http_method
-  {
-#define XX(num, name, string) HTTP_##name = num,
-  HTTP_METHOD_MAP(XX)
-#undef XX
-  };
-
-
-enum http_parser_type { HTTP_REQUEST, HTTP_RESPONSE, HTTP_BOTH };
-
-
-/* Flag values for http_parser.flags field */
-enum flags
-  { F_CHUNKED               = 1 << 0
-  , F_CONNECTION_KEEP_ALIVE = 1 << 1
-  , F_CONNECTION_CLOSE      = 1 << 2
-  , F_CONNECTION_UPGRADE    = 1 << 3
-  , F_TRAILING              = 1 << 4
-  , F_UPGRADE               = 1 << 5
-  , F_SKIPBODY              = 1 << 6
-  , F_CONTENTLENGTH         = 1 << 7
-  , F_TRANSFER_ENCODING     = 1 << 8
-  };
-
-
-/* Map for errno-related constants
- *
- * The provided argument should be a macro that takes 2 arguments.
- */
-#define HTTP_ERRNO_MAP(XX)                                           \
-  /* No error */                                                     \
-  XX(OK, "success")                                                  \
-                                                                     \
-  /* Callback-related errors */                                      \
-  XX(CB_message_begin, "the on_message_begin callback failed")       \
-  XX(CB_url, "the on_url callback failed")                           \
-  XX(CB_header_field, "the on_header_field callback failed")         \
-  XX(CB_header_value, "the on_header_value callback failed")         \
-  XX(CB_headers_complete, "the on_headers_complete callback failed") \
-  XX(CB_body, "the on_body callback failed")                         \
-  XX(CB_message_complete, "the on_message_complete callback failed") \
-  XX(CB_status, "the on_status callback failed")                     \
-  XX(CB_chunk_header, "the on_chunk_header callback failed")         \
-  XX(CB_chunk_complete, "the on_chunk_complete callback failed")     \
-                                                                     \
-  /* Parsing-related errors */                                       \
-  XX(INVALID_EOF_STATE, "stream ended at an unexpected time")        \
-  XX(HEADER_OVERFLOW,                                                \
-     "too many header bytes seen; overflow detected")                \
-  XX(CLOSED_CONNECTION,                                              \
-     "data received after completed connection: close message")      \
-  XX(INVALID_VERSION, "invalid HTTP version")                        \
-  XX(INVALID_STATUS, "invalid HTTP status code")                     \
-  XX(INVALID_METHOD, "invalid HTTP method")                          \
-  XX(INVALID_URL, "invalid URL")                                     \
-  XX(INVALID_HOST, "invalid host")                                   \
-  XX(INVALID_PORT, "invalid port")                                   \
-  XX(INVALID_PATH, "invalid path")                                   \
-  XX(INVALID_QUERY_STRING, "invalid query string")                   \
-  XX(INVALID_FRAGMENT, "invalid fragment")                           \
-  XX(LF_EXPECTED, "LF character expected")                           \
-  XX(INVALID_HEADER_TOKEN, "invalid character in header")            \
-  XX(INVALID_CONTENT_LENGTH,                                         \
-     "invalid character in content-length header")                   \
-  XX(UNEXPECTED_CONTENT_LENGTH,                                      \
-     "unexpected content-length header")                             \
-  XX(INVALID_CHUNK_SIZE,                                             \
-     "invalid character in chunk size header")                       \
-  XX(INVALID_TRANSFER_ENCODING,                                      \
-     "request has invalid transfer-encoding")                        \
-  XX(INVALID_CONSTANT, "invalid constant string")                    \
-  XX(INVALID_INTERNAL_STATE, "encountered unexpected internal state")\
-  XX(STRICT, "strict mode assertion failed")                         \
-  XX(PAUSED, "parser is paused")                                     \
-  XX(UNKNOWN, "an unknown error occurred")
-
-
-/* Define HPE_* values for each errno value above */
-#define HTTP_ERRNO_GEN(n, s) HPE_##n,
-enum http_errno {
-  HTTP_ERRNO_MAP(HTTP_ERRNO_GEN)
-};
-#undef HTTP_ERRNO_GEN
-
-
-/* Get an http_errno value from an http_parser */
-#define HTTP_PARSER_ERRNO(p)            ((enum http_errno) (p)->http_errno)
-
-
-struct http_parser {
-  /** PRIVATE **/
-  unsigned int type : 2;         /* enum http_parser_type */
-  unsigned int state : 7;        /* enum state from http_parser.c */
-  unsigned int header_state : 7; /* enum header_state from http_parser.c */
-  unsigned int index : 7;        /* index into current matcher */
-  unsigned int lenient_http_headers : 1;
-  unsigned int flags : 16;       /* F_* values from 'flags' enum; semi-public */
-
-  uint32_t nread;          /* # bytes read in various scenarios */
-  uint64_t content_length; /* # bytes in body (0 if no Content-Length header) */
-
-  /** READ-ONLY **/
-  unsigned short http_major;
-  unsigned short http_minor;
-  unsigned int status_code : 16; /* responses only */
-  unsigned int method : 8;       /* requests only */
-  unsigned int http_errno : 7;
-
-  /* 1 = Upgrade header was present and the parser has exited because of that.
-   * 0 = No upgrade header present.
-   * Should be checked when http_parser_execute() returns in addition to
-   * error checking.
-   */
-  unsigned int upgrade : 1;
-
-  /** PUBLIC **/
-  void *data; /* A pointer to get hook to the "connection" or "socket" object */
-};
-
-
-struct http_parser_settings {
-  http_cb      on_message_begin;
-  http_data_cb on_url;
-  http_data_cb on_status;
-  http_data_cb on_header_field;
-  http_data_cb on_header_value;
-  http_cb      on_headers_complete;
-  http_data_cb on_body;
-  http_cb      on_message_complete;
-  /* When on_chunk_header is called, the current chunk length is stored
-   * in parser->content_length.
-   */
-  http_cb      on_chunk_header;
-  http_cb      on_chunk_complete;
-};
-
-
-enum http_parser_url_fields
-  { UF_SCHEMA           = 0
-  , UF_HOST             = 1
-  , UF_PORT             = 2
-  , UF_PATH             = 3
-  , UF_QUERY            = 4
-  , UF_FRAGMENT         = 5
-  , UF_USERINFO         = 6
-  , UF_MAX              = 7
-  };
-
-
-/* Result structure for http_parser_parse_url().
- *
- * Callers should index into field_data[] with UF_* values iff field_set
- * has the relevant (1 << UF_*) bit set. As a courtesy to clients (and
- * because we probably have padding left over), we convert any port to
- * a uint16_t.
- */
-struct http_parser_url {
-  uint16_t field_set;           /* Bitmask of (1 << UF_*) values */
-  uint16_t port;                /* Converted UF_PORT string */
-
-  struct {
-    uint16_t off;               /* Offset into buffer in which field starts */
-    uint16_t len;               /* Length of run in buffer */
-  } field_data[UF_MAX];
-};
-
-
-/* Returns the library version. Bits 16-23 contain the major version number,
- * bits 8-15 the minor version number and bits 0-7 the patch level.
- * Usage example:
- *
- *   unsigned long version = http_parser_version();
- *   unsigned major = (version >> 16) & 255;
- *   unsigned minor = (version >> 8) & 255;
- *   unsigned patch = version & 255;
- *   printf("http_parser v%u.%u.%u\n", major, minor, patch);
- */
-unsigned long http_parser_version(void);
-
-void http_parser_init(http_parser *parser, enum http_parser_type type);
-
-
-/* Initialize http_parser_settings members to 0
- */
-void http_parser_settings_init(http_parser_settings *settings);
-
-
-/* Executes the parser. Returns number of parsed bytes. Sets
- * `parser->http_errno` on error. */
-size_t http_parser_execute(http_parser *parser,
-                           const http_parser_settings *settings,
-                           const char *data,
-                           size_t len);
-
-
-/* If http_should_keep_alive() in the on_headers_complete or
- * on_message_complete callback returns 0, then this should be
- * the last message on the connection.
- * If you are the server, respond with the "Connection: close" header.
- * If you are the client, close the connection.
- */
-int http_should_keep_alive(const http_parser *parser);
-
-/* Returns a string version of the HTTP method. */
-const char *http_method_str(enum http_method m);
-
-/* Returns a string version of the HTTP status code. */
-const char *http_status_str(enum http_status s);
-
-/* Return a string name of the given error */
-const char *http_errno_name(enum http_errno err);
-
-/* Return a string description of the given error */
-const char *http_errno_description(enum http_errno err);
-
-/* Initialize all http_parser_url members to 0 */
-void http_parser_url_init(struct http_parser_url *u);
-
-/* Parse a URL; return nonzero on failure */
-int http_parser_parse_url(const char *buf, size_t buflen,
-                          int is_connect,
-                          struct http_parser_url *u);
-
-/* Pause or un-pause the parser; a nonzero value pauses */
-void http_parser_pause(http_parser *parser, int paused);
-
-/* Checks if this is the final chunk of the body. */
-int http_body_is_final(const http_parser *parser);
-
-/* Change the maximum header size provided at compile time. */
-void http_parser_set_max_header_size(uint32_t size);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

src/3rdparty/hwloc/CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required (VERSION 2.8)
+cmake_minimum_required (VERSION  2.8.12)
 project (hwloc C)
 
 include_directories(include)
@@ -30,6 +30,8 @@ set(SOURCES
     src/topology-xml.c
     src/topology-xml-nolibxml.c
     src/traversal.c
+    src/memattrs.c
+    src/cpukinds.c
    )
 
 add_library(hwloc STATIC

src/3rdparty/hwloc/NEWS

@@ -1,7 +1,8 @@
 Copyright © 2009 CNRS
-Copyright © 2009-2020 Inria.  All rights reserved.
+Copyright © 2009-2022 Inria.  All rights reserved.
 Copyright © 2009-2013 Université Bordeaux
 Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
+Copyright © 2020 Hewlett Packard Enterprise.  All rights reserved.
 
 $COPYRIGHT$
 
@@ -16,6 +17,228 @@ bug fixes (and other actions) for each version of hwloc since version
 0.9.
 
 
+Version 2.7.1
+-------------
+* Workaround crashes when virtual machines report incoherent x86 CPUID
+  information about numbers of cores and threads.
+  Thanks to Peter Bense for the report.
+* Use setenv() instead of putenv() when trying to force enable oneAPI L0
+  support, to avoid issues with applications that touch the environment,
+  thanks to Josh Hursey for the patch.
+* Add some warnings at the end of configure when GPU libraries are
+  missing on the system or their path is missing in the environment.
+
+
+Version 2.7.0
+-------------
+* Backends
+  + Add support for NUMA nodes and caches with more than 64 PUs across
+    multiple processor groups on Windows 11 and Windows Server 2022.
+  + Group objects are not created for Windows processor groups anymore,
+    except if HWLOC_WINDOWS_PROCESSOR_GROUP_OBJS=1 in the environment.
+  + Expose "Cluster" group objects on Linux kernel 5.16+ for CPUs
+    that share some internal cache or bus. This can be equivalent
+    to the L2 Cache level on some platforms (e.g. x86) or a specific
+    level between L2 and L3 on others (e.g. ARM Kungpeng 920).
+    Thanks to Jonathan Cameron for the help.
+    - HWLOC_DONT_MERGE_CLUSTER_GROUPS=1 may be set in the environment
+      to prevent these groups from being merged with identical caches, etc.
+  + Improve the oneAPI LevelZero backend:
+    - Expose subdevices such as "ze0.1" inside root OS devices ("ze0")
+      when the hardware contains multiple subdevices.
+    - Add many new attributes to describe device type, and the
+      numbers of slices, subslices, execution units and threads.
+    - Expose the memory information as LevelZeroHBM/DDR/MemorySize infos.
+  + Ignore the max frequencies of cores in Linux cpukinds when the
+    base frequencies are available (to avoid exposing hybrid CPUs
+    when Intel Turbo Boost Max 3.0 gives slightly different max
+    frequencies to CPU cores).
+    - May be reverted by setting HWLOC_CPUKINDS_MAXFREQ=1 in the environment.
+* Tools
+  + Add --grey and --palette options to switch lstopo to greyscale or
+    white-background-only graphics, or to tune individual colors.
+* Build
+  + Windows CMake builds now support non-MSVC compilers, detect several
+    features at build time, can build/run tests, etc.
+    Thanks to Michael Hirsch and Alexander Neumann .
+
+
+Version 2.6.0
+-------------
+* Backends
+  + Expose two cpukinds for energy-efficient cores (icestorm) and
+    high-performance cores (firestorm) on Apple M1 on Mac OS X.
+  + Use sysfs CPU "capacity" to rank hybrid cores by efficiency
+    on Linux when available (mostly on recent ARM platforms for now).
+  + Improve HWLOC_MEMBIND_BIND (without the STRICT flag) on Linux kernel
+    >= 5.15: If more than one node is given, the kernel may now use all
+    of them instead of only the first one before falling back to others.
+  + Expose cache os_index when available on Linux, it may be needed
+    when using resctrl to configure cache partitioning, memory bandwidth
+    monitoring, etc.
+  + Add a "XGMIHops" distances matrix in the RSMI backend for AMD GPU
+    interconnected through XGMI links.
+  + Expose AMD GPU memory information (VRAM and GTT) in the RSMI backend.
+  + Add OS devices such as "bxi0" for Atos/Bull BXI HCAs on Linux.
+* Tools
+  + lstopo has a better placement algorithm with respect to I/O
+    objects, see --children-order in the manpage for details.
+  + hwloc-annotate may now change object subtypes and cache or memory
+    sizes.
+* Build
+  + Allow to specify the ROCm installation for building the RSMI backend:
+    - Use a custom installation path if specified with --with-rocm=<dir>.
+    - Use /opt/rocm-<version> if specified with --with-rocm-version=<version>
+      or the ROCM_VERSION environment variable.
+    - Try /opt/rocm if it exists.
+    - See "How do I enable ROCm SMI and select which version to use?"
+      in the FAQ for details.
+  + Add a CMakeLists for Windows under contrib/windows-cmake/ .
+* Documentation
+  + Add FAQ entry "How do I create a custom heterogeneous and
+     asymmetric topology?"
+
+
+Version 2.5.0
+-------------
+* API
+  + Add hwloc/windows.h to query Windows processor groups.
+  + Add hwloc_get_obj_with_same_locality() to convert between objects
+    with same locality, for instance NUMA nodes and Packages,
+    or OS devices within a PCI device.
+  + Add hwloc_distances_transform() to modify distances structures.
+    - hwloc-annotate and lstopo have new distances-transform options.
+  + hwloc_distances_add() is replaced with _add_create() followed by
+    _add_values() and _add_commit(). See hwloc/distances.h for details.
+  + Add topology flags to mitigate binding modifications during
+    hwloc discovery, especially on Windows:
+    - HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING and _MEMBINDING
+      restrict discovery to PUs and NUMA nodes inside the binding.
+    - HWLOC_TOPOLOGY_FLAG_DONT_CHANGE_BINDING prevents from ever
+      changing the binding during discovery.
+* Backends
+  + Add a levelzero backend for oneAPI L0 devices, exposed as OS devices
+    of subtype "LevelZero" and name such as "ze0".
+    - Add hwloc/levelzero.h for interoperability between converting
+      between L0 API devices and hwloc cpusets or OS devices.
+  + Expose NEC Vector Engine cards on Linux as OS devices of subtype
+    "VectorEngine" and name "ve0", etc.
+    Thanks to Anara Kozhokanova, Tim Cramer and Erich Focht for the help.
+  + Add a NVLinkBandwidth distances structure between NVIDIA GPUs
+    (and POWER processor or NVSwitches) in the NVML backend,
+    and a XGMIBandwidth distances structure between AMD GPUs
+    in the RSMI backends.
+    - See "Topology Attributes: Distances, Memory Attributes and CPU Kinds"
+      in the documentation for details about these new distances.
+  + Add support for NUMA node 0 being offline in Linux, thanks to Jirka Hladky.
+* Build
+  + Add --with-cuda-version=<version> or look at the CUDA_VERSION
+    environment variable to find the appropriate CUDA pkg-config files.
+    Thanks to Stephen Herbein for the suggestion.
+    - Also add --with-cuda=<dir> to specify the CUDA installation path
+      manually (and its NVML and OpenCL components).
+      Thanks to Andrea Bocci for the suggestion.
+    - See "How do I enable CUDA and select which CUDA version to use?"
+      in the FAQ for details.
+* Tools
+  + lstopo now has a --windows-processor-groups option on Windows.
+  + hwloc-ps now has a --short-name option to avoid long/truncated
+    command path.
+  + hwloc-ps now has a --single-ancestor option to return a single
+    (possibly too large) object where a process is bound.
+  + hwloc-ps --pid-cmd may now query environment variables,
+    including MPI-specific variables to find out process ranks.
+
+
+Version 2.4.1
+-------------
+* Fix AMD OpenCL device locality when PCI bus or device number >= 128.
+  Thanks to Edgar Leon for reporting the issue.
+  + Applications using any of the following inline functions must
+    be recompiled to get the fix: hwloc_opencl_get_device_pci_busid()
+    hwloc_opencl_get_device_cpuset(), hwloc_opencl_get_device_osdev().
+* Fix the ranking of cpukinds on non-Windows systems,
+  thanks to Ivan Kochin for the report.
+* Fix the insertion of custom Groups after loading the topology,
+  thanks to Scott Hicks.
+* Add support for CPU0 being offline in Linux, thanks to Garrett Clay.
+* Fix missing x86 Package and Core objects FreeBSD/NetBSD.
+  Thanks to Thibault Payet and Yuri Victorovich for the report.
+* Fix the import of very large distances with heterogeneous object types.
+* Fix a memory leak in the Linux backend,
+  thanks to Perceval Anichini.
+
+
+Version 2.4.0
+-------------
+* API
+  + Add hwloc/cpukinds.h for reporting information about hybrid CPUs.
+    - Use Linux cpufreq frequencies to rank cores by efficiency.
+    - Use x86 CPUID hybrid leaf and future Linux kernels sysfs CPU type
+      files to identify Intel Atom and Core cores.
+    - Use the Windows native EfficiencyClass to separate kinds.
+* Backends
+  + Properly handle Linux kernel 5.10+ exposing ACPI HMAT information
+    with knowledge of Generic Initiators.
+* Tools
+  + lstopo has new --cpukinds and --no-cpukinds options for showing
+    CPU kinds or not in textual and graphical modes respectively.
+  + hwloc-calc has a new --cpukind option for filtering PUs by kind.
+  + hwloc-annotate has a new cpukind command for modifying CPU kinds.
+* Misc
+  + Fix hwloc_bitmap_nr_ulongs(), thanks to Norbert Eicker.
+  + Add a documentation section about
+    "Topology Attributes: Distances, Memory Attributes and CPU Kinds".
+  + Silence some spurious warnings in the OpenCL backend and when showing
+    process binding with lstopo --ps.
+
+
+Version 2.3.0
+-------------
+* API
+  + Add hwloc/memattrs.h for exposing latency/bandwidth information
+    between initiators (CPU sets for now) and target NUMA nodes,
+    typically on heterogeneous platforms.
+    - When available, bandwidths and latencies are read from the ACPI HMAT
+      table exposed by Linux kernel 5.2+.
+    - Attributes may also be customized to expose user-defined performance
+      information.
+  + Add hwloc_get_local_numanode_objs() for listing NUMA nodes that are
+    local to some locality.
+  + The new topology flag HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT causes
+    support arrays to be loaded from XML exported with hwloc 2.3+.
+    - hwloc_topology_get_support() now returns an additional "misc"
+      array with feature "imported_support" set when support was imported.
+  + Add hwloc_topology_refresh() to refresh internal caches after modifying
+    the topology and before consulting the topology in a multithread context.
+* Backends
+  + Add a ROCm SMI backend and a hwloc/rsmi.h helper file for getting
+    the locality of AMD GPUs, now exposed as "rsmi" OS devices.
+    Thanks to Mike Li.
+  + Remove POWER device-tree-based topology on Linux,
+    (it was disabled by default since 2.1).
+* Tools
+  + Command-line options for specifying flags now understand comma-separated
+    lists of flag names (substrings).
+  + hwloc-info and hwloc-calc have new --local-memory --local-memory-flags
+    and --best-memattr options for reporting local memory nodes and filtering
+    by memory attributes.
+  + hwloc-bind has a new --best-memattr option for filtering by memory attributes
+    among the memory binding set.
+  + Tools that have a --restrict option may now receive a nodeset or
+    some custom flags for restricting the topology.
+  + lstopo now has a --thickness option for changing line thickness in the
+    graphical output.
+  + Fix lstopo drawing when autoresizing on Windows 10.
+  + Pressing the F5 key in lstopo X11 and Windows graphical/interactive outputs
+    now refreshes the display according to the current topology and binding.
+  + Add a tikz lstopo graphical backend to generate picture easily included into
+    LaTeX documents. Thanks to Clement Foyer.
+* Misc
+  + The default installation path of the Bash completion file has changed to
+    ${datadir}/bash-completion/completions/hwloc. Thanks to Tomasz Kłoczko.
+
+
 Version 2.2.0
 -------------
 * API

src/3rdparty/hwloc/README

@@ -23,9 +23,9 @@ APIs are documented after these sections.
 
 Installation
 
-hwloc (http://www.open-mpi.org/projects/hwloc/) is available under the BSD
-license. It is hosted as a sub-project of the overall Open MPI project (http://
-www.open-mpi.org/). Note that hwloc does not require any functionality from
+hwloc (https://www.open-mpi.org/projects/hwloc/) is available under the BSD
+license. It is hosted as a sub-project of the overall Open MPI project (https:/
+/www.open-mpi.org/). Note that hwloc does not require any functionality from
 Open MPI -- it is a wholly separate (and much smaller!) project and code base.
 It just happens to be hosted as part of the overall Open MPI project.
 
@@ -75,7 +75,7 @@ Bugs should be reported in the tracker (https://github.com/open-mpi/hwloc/
 issues). Opening a new issue automatically displays lots of hints about how to
 debug and report issues.
 
-Questions may be sent to the users or developers mailing lists (http://
+Questions may be sent to the users or developers mailing lists (https://
 www.open-mpi.org/community/lists/hwloc.php).
 
 There is also a #hwloc IRC channel on Freenode (irc.freenode.net).

src/3rdparty/hwloc/VERSION

@@ -8,8 +8,8 @@
 # Please update HWLOC_VERSION* in contrib/windows/hwloc_config.h too.
 
 major=2
-minor=2
-release=0
+minor=7
+release=1
 
 # greek is used for alpha or beta release tags.  If it is non-empty,
 # it will be appended to the version number.  It does not have to be
@@ -22,7 +22,7 @@ greek=
 
 # The date when this release was created
 
-date="Mar 30, 2020"
+date="Mar 20, 2022"
 
 # If snapshot=1, then use the value from snapshot_version as the
 # entire hwloc version (i.e., ignore major, minor, release, and
@@ -41,7 +41,7 @@ snapshot_version=${major}.${minor}.${release}${greek}-git
 # 2. Version numbers are described in the Libtool current:revision:age
 # format.
 
-libhwloc_so_version=17:0:2
+libhwloc_so_version=20:3:5
 libnetloc_so_version=0:0:0
 
 # Please also update the <TargetName> lines in contrib/windows/libhwloc.vcxproj

src/3rdparty/hwloc/include/hwloc.h

@@ -1,8 +1,8 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2020 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
- * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
+ * Copyright © 2009-2020 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -11,7 +11,7 @@
  *         ------------------------------------------------
  *               $tarball_directory/doc/doxygen-doc/
  *                                or
- *           http://www.open-mpi.org/projects/hwloc/doc/
+ *           https://www.open-mpi.org/projects/hwloc/doc/
  *=====================================================================
  *
  * FAIR WARNING: Do NOT expect to be able to figure out all the
@@ -29,7 +29,7 @@
  * THAT IS IN THE PDF/HTML THAT IS ***NOT*** IN hwloc.h!
  *
  * There are entire paragraph-length descriptions, discussions, and
- * pretty prictures to explain subtle corner cases, provide concrete
+ * pretty pictures to explain subtle corner cases, provide concrete
  * examples, etc.
  *
  * Please, go read the documentation.  :-)
@@ -93,7 +93,7 @@ extern "C" {
  * Two stable releases of the same series usually have the same ::HWLOC_API_VERSION
  * even if their HWLOC_VERSION are different.
  */
-#define HWLOC_API_VERSION 0x00020100
+#define HWLOC_API_VERSION 0x00020500
 
 /** \brief Indicate at runtime which hwloc API version was used at build time.
  *
@@ -102,7 +102,7 @@ extern "C" {
 HWLOC_DECLSPEC unsigned hwloc_get_api_version(void);
 
 /** \brief Current component and plugin ABI version (see hwloc/plugins.h) */
-#define HWLOC_COMPONENT_ABI 6
+#define HWLOC_COMPONENT_ABI 7
 
 /** @} */
 
@@ -196,7 +196,7 @@ typedef enum {
 			  */
   HWLOC_OBJ_CORE,	/**< \brief Core.
 			  * A computation unit (may be shared by several
-			  * logical processors).
+			  * PUs, aka logical processors).
 			  */
   HWLOC_OBJ_PU,		/**< \brief Processing Unit, or (Logical) Processor.
 			  * An execution unit (may share a core with some
@@ -257,22 +257,31 @@ typedef enum {
   HWLOC_OBJ_BRIDGE,	/**< \brief Bridge (filtered out by default).
 			  * Any bridge (or PCI switch) that connects the host or an I/O bus,
 			  * to another I/O bus.
-			  * They are not added to the topology unless I/O discovery
-			  * is enabled with hwloc_topology_set_flags().
+			  *
+			  * Bridges are not added to the topology unless their
+			  * filtering is changed (see hwloc_topology_set_type_filter()
+			  * and hwloc_topology_set_io_types_filter()).
+			  *
 			  * I/O objects are not listed in the main children list,
 			  * but rather in the dedicated io children list.
 			  * I/O objects have NULL CPU and node sets.
 			  */
   HWLOC_OBJ_PCI_DEVICE,	/**< \brief PCI device (filtered out by default).
-			  * They are not added to the topology unless I/O discovery
-			  * is enabled with hwloc_topology_set_flags().
+			  *
+			  * PCI devices are not added to the topology unless their
+			  * filtering is changed (see hwloc_topology_set_type_filter()
+			  * and hwloc_topology_set_io_types_filter()).
+			  *
 			  * I/O objects are not listed in the main children list,
 			  * but rather in the dedicated io children list.
 			  * I/O objects have NULL CPU and node sets.
 			  */
   HWLOC_OBJ_OS_DEVICE,	/**< \brief Operating system device (filtered out by default).
-			  * They are not added to the topology unless I/O discovery
-			  * is enabled with hwloc_topology_set_flags().
+			  *
+			  * OS devices are not added to the topology unless their
+			  * filtering is changed (see hwloc_topology_set_type_filter()
+			  * and hwloc_topology_set_io_types_filter()).
+			  *
 			  * I/O objects are not listed in the main children list,
 			  * but rather in the dedicated io children list.
 			  * I/O objects have NULL CPU and node sets.
@@ -282,6 +291,10 @@ typedef enum {
 			  * Objects without particular meaning, that can e.g. be
 			  * added by the application for its own use, or by hwloc
 			  * for miscellaneous objects such as MemoryModule (DIMMs).
+			  *
+			  * They are not added to the topology unless their filtering
+			  * is changed (see hwloc_topology_set_type_filter()).
+			  *
 			  * These objects are not listed in the main children list,
 			  * but rather in the dedicated misc children list.
 			  * Misc objects may only have Misc objects as children,
@@ -304,7 +317,6 @@ typedef enum {
 
   HWLOC_OBJ_DIE,	/**< \brief Die within a physical package.
 			 * A subpart of the physical package, that contains multiple cores.
-			 * \hideinitializer
 			 */
 
   HWLOC_OBJ_TYPE_MAX    /**< \private Sentinel value */
@@ -334,12 +346,12 @@ typedef enum hwloc_obj_osdev_type_e {
 				  * For instance the "eth0" interface on Linux. */
   HWLOC_OBJ_OSDEV_OPENFABRICS,	/**< \brief Operating system openfabrics device.
 				  * For instance the "mlx4_0" InfiniBand HCA,
-				  * or "hfi1_0" Omni-Path interface on Linux. */
+				  * "hfi1_0" Omni-Path interface,
+				  * or "bxi0" Atos/Bull BXI HCA on Linux. */
   HWLOC_OBJ_OSDEV_DMA,		/**< \brief Operating system dma engine device.
 				  * For instance the "dma0chan0" DMA channel on Linux. */
   HWLOC_OBJ_OSDEV_COPROC	/**< \brief Operating system co-processor device.
-				  * For instance "mic0" for a Xeon Phi (MIC) on Linux,
-				  * "opencl0d0" for a OpenCL device,
+				  * For instance "opencl0d0" for a OpenCL device,
 				  * "cuda0" for a CUDA device. */
 } hwloc_obj_osdev_type_t;
 
@@ -505,14 +517,14 @@ struct hwloc_obj {
                                           * objects).
                                           *
                                           * If the ::HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED configuration flag is set,
-                                          * some of these CPUs may not be allowed for binding,
+                                          * some of these CPUs may be online but not allowed for binding,
                                           * see hwloc_topology_get_allowed_cpuset().
                                           *
 					  * \note All objects have non-NULL CPU and node sets except Misc and I/O objects.
 					  *
                                           * \note Its value must not be changed, hwloc_bitmap_dup() must be used instead.
                                           */
-  hwloc_cpuset_t complete_cpuset;       /**< \brief The complete CPU set of logical processors of this object,
+  hwloc_cpuset_t complete_cpuset;       /**< \brief The complete CPU set of processors of this object,
                                           *
                                           * This may include not only the same as the cpuset field, but also some CPUs for
                                           * which topology information is unknown or incomplete, some offlines CPUs, and
@@ -533,9 +545,11 @@ struct hwloc_obj {
                                           * between this object and the NUMA node objects).
                                           *
                                           * In the end, these nodes are those that are close to the current object.
+                                          * Function hwloc_get_local_numanode_objs() may be used to list those NUMA
+                                          * nodes more precisely.
                                           *
                                           * If the ::HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED configuration flag is set,
-                                          * some of these nodes may not be allowed for allocation,
+                                          * some of these nodes may be online but not allowed for allocation,
                                           * see hwloc_topology_get_allowed_nodeset().
                                           *
                                           * If there are no NUMA nodes in the machine, all the memory is close to this
@@ -628,7 +642,7 @@ union hwloc_obj_attr_u {
     unsigned char revision;
     float linkspeed; /* in GB/s */
   } pcidev;
-  /** \brief Bridge specific Object Attribues */
+  /** \brief Bridge specific Object Attributes */
   struct hwloc_bridge_attr_s {
     union {
       struct hwloc_pcidev_attr_s pci;
@@ -1075,7 +1089,7 @@ HWLOC_DECLSPEC int hwloc_obj_add_info(hwloc_obj_t obj, const char *name, const c
  *
  * Some operating systems only support binding threads or processes to a single PU.
  * Others allow binding to larger sets such as entire Cores or Packages or
- * even random sets of invididual PUs. In such operating system, the scheduler
+ * even random sets of individual PUs. In such operating system, the scheduler
  * is free to run the task on one of these PU, then migrate it to another PU, etc.
  * It is often useful to call hwloc_bitmap_singlify() on the target CPU set before
  * passing it to the binding function to avoid these expensive migrations.
@@ -1153,7 +1167,7 @@ typedef enum {
    * CPUs are idle, operating systems may execute the thread/process
    * on those other CPUs instead of the designated CPUs, to let them
    * progress anyway.  Strict binding means that the thread/process
-   * will _never_ execute on other cpus than the designated CPUs, even
+   * will _never_ execute on other CPUs than the designated CPUs, even
    * when those are busy with other tasks and other CPUs are idle.
    *
    * \note Depending on the operating system, strict binding may not
@@ -1190,7 +1204,7 @@ typedef enum {
   HWLOC_CPUBIND_NOMEMBIND = (1<<3)
 } hwloc_cpubind_flags_t;
 
-/** \brief Bind current process or thread on cpus given in physical bitmap \p set.
+/** \brief Bind current process or thread on CPUs given in physical bitmap \p set.
  *
  * \return -1 with errno set to ENOSYS if the action is not supported
  * \return -1 with errno set to EXDEV if the binding cannot be enforced
@@ -1199,12 +1213,13 @@ HWLOC_DECLSPEC int hwloc_set_cpubind(hwloc_topology_t topology, hwloc_const_cpus
 
 /** \brief Get current process or thread binding.
  *
- * Writes into \p set the physical cpuset which the process or thread (according to \e
- * flags) was last bound to.
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the list of PUs which the process or
+ * thread (according to \e flags) was last bound to.
  */
 HWLOC_DECLSPEC int hwloc_get_cpubind(hwloc_topology_t topology, hwloc_cpuset_t set, int flags);
 
-/** \brief Bind a process \p pid on cpus given in physical bitmap \p set.
+/** \brief Bind a process \p pid on CPUs given in physical bitmap \p set.
  *
  * \note \p hwloc_pid_t is \p pid_t on Unix platforms,
  * and \p HANDLE on native Windows platforms.
@@ -1218,6 +1233,10 @@ HWLOC_DECLSPEC int hwloc_get_cpubind(hwloc_topology_t topology, hwloc_cpuset_t s
 HWLOC_DECLSPEC int hwloc_set_proc_cpubind(hwloc_topology_t topology, hwloc_pid_t pid, hwloc_const_cpuset_t set, int flags);
 
 /** \brief Get the current physical binding of process \p pid.
+ *
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the list of PUs which the process
+ * was last bound to.
  *
  * \note \p hwloc_pid_t is \p pid_t on Unix platforms,
  * and \p HANDLE on native Windows platforms.
@@ -1231,7 +1250,7 @@ HWLOC_DECLSPEC int hwloc_set_proc_cpubind(hwloc_topology_t topology, hwloc_pid_t
 HWLOC_DECLSPEC int hwloc_get_proc_cpubind(hwloc_topology_t topology, hwloc_pid_t pid, hwloc_cpuset_t set, int flags);
 
 #ifdef hwloc_thread_t
-/** \brief Bind a thread \p thread on cpus given in physical bitmap \p set.
+/** \brief Bind a thread \p thread on CPUs given in physical bitmap \p set.
  *
  * \note \p hwloc_thread_t is \p pthread_t on Unix platforms,
  * and \p HANDLE on native Windows platforms.
@@ -1243,6 +1262,10 @@ HWLOC_DECLSPEC int hwloc_set_thread_cpubind(hwloc_topology_t topology, hwloc_thr
 
 #ifdef hwloc_thread_t
 /** \brief Get the current physical binding of thread \p tid.
+ *
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the list of PUs which the thread
+ * was last bound to.
  *
  * \note \p hwloc_thread_t is \p pthread_t on Unix platforms,
  * and \p HANDLE on native Windows platforms.
@@ -1253,6 +1276,10 @@ HWLOC_DECLSPEC int hwloc_get_thread_cpubind(hwloc_topology_t topology, hwloc_thr
 #endif
 
 /** \brief Get the last physical CPU where the current process or thread ran.
+ *
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the list of PUs which the process or
+ * thread (according to \e flags) last ran on.
  *
  * The operating system may move some tasks from one processor
  * to another at any time according to their binding,
@@ -1268,6 +1295,10 @@ HWLOC_DECLSPEC int hwloc_get_thread_cpubind(hwloc_topology_t topology, hwloc_thr
 HWLOC_DECLSPEC int hwloc_get_last_cpu_location(hwloc_topology_t topology, hwloc_cpuset_t set, int flags);
 
 /** \brief Get the last physical CPU where a process ran.
+ *
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the list of PUs which the process
+ * last ran on.
  *
  * The operating system may move some tasks from one processor
  * to another at any time according to their binding,
@@ -1498,6 +1529,9 @@ HWLOC_DECLSPEC int hwloc_set_membind(hwloc_topology_t topology, hwloc_const_bitm
 /** \brief Query the default memory binding policy and physical locality of the
  * current process or thread.
  *
+ * The bitmap \p set (previously allocated by the caller)
+ * is filled with the process or thread memory binding.
+ *
  * This function has two output parameters: \p set and \p policy.
  * The values returned in these parameters depend on both the \p flags
  * passed in and the current memory binding policies and nodesets in
@@ -1558,6 +1592,9 @@ HWLOC_DECLSPEC int hwloc_set_proc_membind(hwloc_topology_t topology, hwloc_pid_t
 /** \brief Query the default memory binding policy and physical locality of the
  * specified process.
  *
+ * The bitmap \p set (previously allocated by the caller)
+ * is filled with the process memory binding.
+ *
  * This function has two output parameters: \p set and \p policy.
  * The values returned in these parameters depend on both the \p flags
  * passed in and the current memory binding policies and nodesets in
@@ -1611,6 +1648,9 @@ HWLOC_DECLSPEC int hwloc_set_area_membind(hwloc_topology_t topology, const void
 /** \brief Query the CPUs near the physical NUMA node(s) and binding policy of
  * the memory identified by (\p addr, \p len ).
  *
+ * The bitmap \p set (previously allocated by the caller)
+ * is filled with the memory area binding.
+ *
  * This function has two output parameters: \p set and \p policy.
  * The values returned in these parameters depend on both the \p flags
  * passed in and the memory binding policies and nodesets of the pages
@@ -1639,7 +1679,8 @@ HWLOC_DECLSPEC int hwloc_get_area_membind(hwloc_topology_t topology, const void
 
 /** \brief Get the NUMA nodes where memory identified by (\p addr, \p len ) is physically allocated.
  *
- * Fills \p set according to the NUMA nodes where the memory area pages
+ * The bitmap \p set (previously allocated by the caller)
+ * is filled according to the NUMA nodes where the memory area pages
  * are physically allocated. If no page is actually allocated yet,
  * \p set may be empty.
  *
@@ -1685,9 +1726,12 @@ HWLOC_DECLSPEC void *hwloc_alloc_membind(hwloc_topology_t topology, size_t len,
 
 /** \brief Allocate some memory on NUMA memory nodes specified by \p set
  *
- * This is similar to hwloc_alloc_membind_nodeset() except that it is allowed to change
- * the current memory binding policy, thus providing more binding support, at
- * the expense of changing the current state.
+ * First, try to allocate properly with hwloc_alloc_membind().
+ * On failure, the current process or thread memory binding policy
+ * is changed with hwloc_set_membind() before allocating memory.
+ * Thus this function works in more cases, at the expense of changing
+ * the current state (possibly affecting future allocations that
+ * would not specify any policy).
  *
  * If ::HWLOC_MEMBIND_BYNODESET is specified, set is considered a nodeset.
  * Otherwise it's a cpuset.
@@ -1870,8 +1914,9 @@ HWLOC_DECLSPEC int hwloc_topology_set_components(hwloc_topology_t __hwloc_restri
 enum hwloc_topology_flags_e {
  /** \brief Detect the whole system, ignore reservations, include disallowed objects.
    *
-   * Gather all resources, even if some were disabled by the administrator.
+   * Gather all online resources, even if some were disabled by the administrator.
    * For instance, ignore Linux Cgroup/Cpusets and gather all processors and memory nodes.
+   * However offline PUs and NUMA nodes are still ignored.
    *
    * When this flag is not set, PUs and NUMA nodes that are disallowed are not added to the topology.
    * Parent objects (package, core, cache, etc.) are added only if some of their children are allowed.
@@ -1929,17 +1974,105 @@ enum hwloc_topology_flags_e {
    * would result in the same behavior.
    * \hideinitializer
    */
-  HWLOC_TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES = (1UL<<2)
+  HWLOC_TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES = (1UL<<2),
+
+  /** \brief Import support from the imported topology.
+   *
+   * When importing a XML topology from a remote machine, binding is
+   * disabled by default (see ::HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM).
+   * This disabling is also marked by putting zeroes in the corresponding
+   * supported feature bits reported by hwloc_topology_get_support().
+   *
+   * The flag ::HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT actually imports
+   * support bits from the remote machine. It also sets the flag
+   * \p imported_support in the struct hwloc_topology_misc_support array.
+   * If the imported XML did not contain any support information
+   * (exporter hwloc is too old), this flag is not set.
+   *
+   * Note that these supported features are only relevant for the hwloc
+   * installation that actually exported the XML topology
+   * (it may vary with the operating system, or with how hwloc was compiled).
+   *
+   * Note that setting this flag however does not enable binding for the
+   * locally imported hwloc topology, it only reports what the remote
+   * hwloc and machine support.
+   *
+   */
+  HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT = (1UL<<3),
+
+  /** \brief Do not consider resources outside of the process CPU binding.
+   *
+   * If the binding of the process is limited to a subset of cores,
+   * ignore the other cores during discovery.
+   *
+   * The resulting topology is identical to what a call to hwloc_topology_restrict()
+   * would generate, but this flag also prevents hwloc from ever touching other
+   * resources during the discovery.
+   *
+   * This flag especially tells the x86 backend to never temporarily
+   * rebind a thread on any excluded core. This is useful on Windows
+   * because such temporary rebinding can change the process binding.
+   * Another use-case is to avoid cores that would not be able to
+   * perform the hwloc discovery anytime soon because they are busy
+   * executing some high-priority real-time tasks.
+   *
+   * If process CPU binding is not supported,
+   * the thread CPU binding is considered instead if supported,
+   * or the flag is ignored.
+   *
+   * This flag requires ::HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM as well
+   * since binding support is required.
+   */
+  HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING = (1UL<<4),
+
+  /** \brief Do not consider resources outside of the process memory binding.
+   *
+   * If the binding of the process is limited to a subset of NUMA nodes,
+   * ignore the other NUMA nodes during discovery.
+   *
+   * The resulting topology is identical to what a call to hwloc_topology_restrict()
+   * would generate, but this flag also prevents hwloc from ever touching other
+   * resources during the discovery.
+   *
+   * This flag is meant to be used together with
+   * ::HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING when both cores
+   * and NUMA nodes should be ignored outside of the process binding.
+   *
+   * If process memory binding is not supported,
+   * the thread memory binding is considered instead if supported,
+   * or the flag is ignored.
+   *
+   * This flag requires ::HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM as well
+   * since binding support is required.
+   */
+  HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING = (1UL<<5),
+
+  /** \brief Do not ever modify the process or thread binding during discovery.
+   *
+   * This flag disables all hwloc discovery steps that require a change of
+   * the process or thread binding. This currently only affects the x86
+   * backend which gets entirely disabled.
+   *
+   * This is useful when hwloc_topology_load() is called while the
+   * application also creates additional threads or modifies the binding.
+   *
+   * This flag is also a strict way to make sure the process binding will
+   * not change to due thread binding changes on Windows
+   * (see ::HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING).
+   */
+  HWLOC_TOPOLOGY_FLAG_DONT_CHANGE_BINDING = (1UL<<6)
 };
 
 /** \brief Set OR'ed flags to non-yet-loaded topology.
  *
  * Set a OR'ed set of ::hwloc_topology_flags_e onto a topology that was not yet loaded.
  *
- * If this function is called multiple times, the last invokation will erase
+ * If this function is called multiple times, the last invocation will erase
  * and replace the set of flags that was previously set.
  *
- * The flags set in a topology may be retrieved with hwloc_topology_get_flags()
+ * By default, no flags are set (\c 0).
+ *
+ * The flags set in a topology may be retrieved with hwloc_topology_get_flags().
  */
 HWLOC_DECLSPEC int hwloc_topology_set_flags (hwloc_topology_t topology, unsigned long flags);
 
@@ -1947,6 +2080,9 @@ HWLOC_DECLSPEC int hwloc_topology_set_flags (hwloc_topology_t topology, unsigned
  *
  * Get the OR'ed set of ::hwloc_topology_flags_e of a topology.
  *
+ * If hwloc_topology_set_flags() was not called earlier,
+ * no flags are set (\c 0 is returned).
+ *
  * \return the flags previously set with hwloc_topology_set_flags().
  */
 HWLOC_DECLSPEC unsigned long hwloc_topology_get_flags (hwloc_topology_t topology);
@@ -1972,6 +2108,8 @@ struct hwloc_topology_discovery_support {
   unsigned char disallowed_pu;
   /** \brief Detecting and identifying NUMA nodes that are not available to the current process is supported. */
   unsigned char disallowed_numa;
+  /** \brief Detecting the efficiency of CPU kinds is supported, see \ref hwlocality_cpukinds. */
+  unsigned char cpukind_efficiency;
 };
 
 /** \brief Flags describing actual PU binding support for this topology.
@@ -2042,6 +2180,13 @@ struct hwloc_topology_membind_support {
   unsigned char get_area_memlocation;
 };
 
+/** \brief Flags describing miscellaneous features.
+ */
+struct hwloc_topology_misc_support {
+  /** Support was imported when importing another topology, see ::HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT. */
+  unsigned char imported_support;
+};
+
 /** \brief Set of flags describing actual support for this topology.
  *
  * This is retrieved with hwloc_topology_get_support() and will be valid until
@@ -2052,6 +2197,7 @@ struct hwloc_topology_support {
   struct hwloc_topology_discovery_support *discovery;
   struct hwloc_topology_cpubind_support *cpubind;
   struct hwloc_topology_membind_support *membind;
+  struct hwloc_topology_misc_support *misc;
 };
 
 /** \brief Retrieve the topology support.
@@ -2062,6 +2208,18 @@ struct hwloc_topology_support {
  * call may still fail in some corner cases.
  *
  * These features are also listed by hwloc-info \--support
+ *
+ * The reported features are what the current topology supports
+ * on the current machine. If the topology was exported to XML
+ * from another machine and later imported here, support still
+ * describes what is supported for this imported topology after
+ * import. By default, binding will be reported as unsupported
+ * in this case (see ::HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM).
+ *
+ * Topology flag ::HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT may be used
+ * to report the supported features of the original remote machine
+ * instead. If it was successfully imported, \p imported_support
+ * will be set in the struct hwloc_topology_misc_support array.
  */
 HWLOC_DECLSPEC const struct hwloc_topology_support *hwloc_topology_get_support(hwloc_topology_t __hwloc_restrict topology);
 
@@ -2108,8 +2266,8 @@ enum hwloc_type_filter_e {
    *
    * It is only useful for I/O object types.
    * For ::HWLOC_OBJ_PCI_DEVICE and ::HWLOC_OBJ_OS_DEVICE, it means that only objects
-   * of major/common kinds are kept (storage, network, OpenFabrics, Intel MICs, CUDA,
-   * OpenCL, NVML, and displays).
+   * of major/common kinds are kept (storage, network, OpenFabrics, CUDA,
+   * OpenCL, RSMI, NVML, and displays).
    * Also, only OS devices directly attached on PCI (e.g. no USB) are reported.
    * For ::HWLOC_OBJ_BRIDGE, it means that bridges are kept only if they have children.
    *
@@ -2303,22 +2461,9 @@ HWLOC_DECLSPEC hwloc_obj_t hwloc_topology_insert_misc_object(hwloc_topology_t to
 /** \brief Allocate a Group object to insert later with hwloc_topology_insert_group_object().
  *
  * This function returns a new Group object.
- * The caller should (at least) initialize its sets before inserting the object.
- * See hwloc_topology_insert_group_object().
  *
- * The \p subtype object attribute may be set to display something else
- * than "Group" as the type name for this object in lstopo.
- * Custom name/value info pairs may be added with hwloc_obj_add_info() after
- * insertion.
- *
- * The \p kind group attribute should be 0. The \p subkind group attribute may
- * be set to identify multiple Groups of the same level.
- *
- * It is recommended not to set any other object attribute before insertion,
- * since the Group may get discarded during insertion.
- *
- * The object will be destroyed if passed to hwloc_topology_insert_group_object()
- * without any set defined.
+ * The caller should (at least) initialize its sets before inserting
+ * the object in the topology. See hwloc_topology_insert_group_object().
  */
 HWLOC_DECLSPEC hwloc_obj_t hwloc_topology_alloc_group_object(hwloc_topology_t topology);
 
@@ -2329,34 +2474,44 @@ HWLOC_DECLSPEC hwloc_obj_t hwloc_topology_alloc_group_object(hwloc_topology_t to
  * the final location of the Group in the topology.
  * Then the object can be passed to this function for actual insertion in the topology.
  *
- * The group \p dont_merge attribute may be set to prevent the core from
- * ever merging this object with another object hierarchically-identical.
- *
  * Either the cpuset or nodeset field (or both, if compatible) must be set
  * to a non-empty bitmap. The complete_cpuset or complete_nodeset may be set
  * instead if inserting with respect to the complete topology
  * (including disallowed, offline or unknown objects).
- *
- * It grouping several objects, hwloc_obj_add_other_obj_sets() is an easy way
+ * If grouping several objects, hwloc_obj_add_other_obj_sets() is an easy way
  * to build the Group sets iteratively.
- *
  * These sets cannot be larger than the current topology, or they would get
  * restricted silently.
- *
  * The core will setup the other sets after actual insertion.
  *
+ * The \p subtype object attribute may be defined (to a dynamically
+ * allocated string) to display something else than "Group" as the
+ * type name for this object in lstopo.
+ * Custom name/value info pairs may be added with hwloc_obj_add_info() after
+ * insertion.
+ *
+ * The group \p dont_merge attribute may be set to \c 1 to prevent
+ * the hwloc core from ever merging this object with another
+ * hierarchically-identical object.
+ * This is useful when the Group itself describes an important feature
+ * that cannot be exposed anywhere else in the hierarchy.
+ *
+ * The group \p kind attribute may be set to a high value such
+ * as \c 0xffffffff to tell hwloc that this new Group should always
+ * be discarded in favor of any existing Group with the same locality.
+ *
  * \return The inserted object if it was properly inserted.
  *
- * \return An existing object if the Group was discarded because the topology already
- * contained an object at the same location (the Group did not add any locality information).
- * Any name/info key pair set before inserting is appended to the existing object.
+ * \return An existing object if the Group was merged or discarded
+ * because the topology already contained an object at the same
+ * location (the Group did not add any hierarchy information).
  *
  * \return \c NULL if the insertion failed because of conflicting sets in topology tree.
  *
  * \return \c NULL if Group objects are filtered-out of the topology (::HWLOC_TYPE_FILTER_KEEP_NONE).
  *
- * \return \c NULL if the object was discarded because no set was initialized in the Group
- * before insert, or all of them were empty.
+ * \return \c NULL if the object was discarded because no set was
+ * initialized in the Group before insert, or all of them were empty.
  */
 HWLOC_DECLSPEC hwloc_obj_t hwloc_topology_insert_group_object(hwloc_topology_t topology, hwloc_obj_t group);
 
@@ -2371,6 +2526,22 @@ HWLOC_DECLSPEC hwloc_obj_t hwloc_topology_insert_group_object(hwloc_topology_t t
  */
 HWLOC_DECLSPEC int hwloc_obj_add_other_obj_sets(hwloc_obj_t dst, hwloc_obj_t src);
 
+/** \brief Refresh internal structures after topology modification.
+ *
+ * Modifying the topology (by restricting, adding objects, modifying structures
+ * such as distances or memory attributes, etc.) may cause some internal caches
+ * to become invalid. These caches are automatically refreshed when accessed
+ * but this refreshing is not thread-safe.
+ *
+ * This function is not thread-safe either, but it is a good way to end a
+ * non-thread-safe phase of topology modification. Once this refresh is done,
+ * multiple threads may concurrently consult the topology, objects, distances,
+ * attributes, etc.
+ *
+ * See also \ref threadsafety
+ */
+HWLOC_DECLSPEC int hwloc_topology_refresh(hwloc_topology_t topology);
+
 /** @} */
 
 
@@ -2386,6 +2557,12 @@ HWLOC_DECLSPEC int hwloc_obj_add_other_obj_sets(hwloc_obj_t dst, hwloc_obj_t src
 /* inline code of some functions above */
 #include "hwloc/inlines.h"
 
+/* memory attributes */
+#include "hwloc/memattrs.h"
+
+/* kinds of CPU cores */
+#include "hwloc/cpukinds.h"
+
 /* exporting to XML or synthetic */
 #include "hwloc/export.h"
 

src/3rdparty/hwloc/include/hwloc/autogen/config.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2019 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -11,10 +11,10 @@
 #ifndef HWLOC_CONFIG_H
 #define HWLOC_CONFIG_H
 
-#define HWLOC_VERSION "2.2.0"
+#define HWLOC_VERSION "2.7.1"
 #define HWLOC_VERSION_MAJOR 2
-#define HWLOC_VERSION_MINOR 2
-#define HWLOC_VERSION_RELEASE 0
+#define HWLOC_VERSION_MINOR 7
+#define HWLOC_VERSION_RELEASE 1
 #define HWLOC_VERSION_GREEK ""
 
 #define __hwloc_restrict

src/3rdparty/hwloc/include/hwloc/bitmap.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2018 Inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -231,7 +231,7 @@ HWLOC_DECLSPEC int hwloc_bitmap_clr_range(hwloc_bitmap_t bitmap, unsigned begin,
 /** \brief Keep a single index among those set in bitmap \p bitmap
  *
  * May be useful before binding so that the process does not
- * have a chance of migrating between multiple logical CPUs
+ * have a chance of migrating between multiple processors
  * in the original mask.
  * Instead of running the task on any PU inside the given CPU set,
  * the operating system scheduler will be forced to run it on a single

src/3rdparty/hwloc/include/hwloc/cpukinds.h

@@ -0,0 +1,193 @@
+/*
+ * Copyright © 2020-2021 Inria.  All rights reserved.
+ * See COPYING in top-level directory.
+ */
+
+/** \file
+ * \brief Kinds of CPU cores.
+ */
+
+#ifndef HWLOC_CPUKINDS_H
+#define HWLOC_CPUKINDS_H
+
+#include "hwloc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#elif 0
+}
+#endif
+
+/** \defgroup hwlocality_cpukinds Kinds of CPU cores
+ *
+ * Platforms with heterogeneous CPUs may have some cores with
+ * different features or frequencies.
+ * This API exposes identical PUs in sets called CPU kinds.
+ * Each PU of the topology may only be in a single kind.
+ *
+ * The number of kinds may be obtained with hwloc_cpukinds_get_nr().
+ * If the platform is homogeneous, there may be a single kind
+ * with all PUs.
+ * If the platform or operating system does not expose any
+ * information about CPU cores, there may be no kind at all.
+ *
+ * The index of the kind that describes a given CPU set
+ * (if any, and not partially)
+ * may be obtained with hwloc_cpukinds_get_by_cpuset().
+ *
+ * From the index of a kind, it is possible to retrieve information
+ * with hwloc_cpukinds_get_info():
+ * an abstracted efficiency value,
+ * and an array of info attributes
+ * (for instance the "CoreType" and "FrequencyMaxMHz",
+ *  see \ref topoattrs_cpukinds).
+ *
+ * A higher efficiency value means greater intrinsic performance
+ * (and possibly less performance/power efficiency).
+ * Kinds with lower efficiency values are ranked first:
+ * Passing 0 as \p kind_index to hwloc_cpukinds_get_info() will
+ * return information about the CPU kind with lower performance
+ * but higher energy-efficiency.
+ * Higher \p kind_index values would rather return information
+ * about power-hungry high-performance cores.
+ *
+ * When available, efficiency values are gathered from the operating system.
+ * If so, \p cpukind_efficiency is set in the struct hwloc_topology_discovery_support array.
+ * This is currently available on Windows 10, Mac OS X (Darwin),
+ * and on some Linux platforms where core "capacity" is exposed in sysfs.
+ *
+ * If the operating system does not expose core efficiencies natively,
+ * hwloc tries to compute efficiencies by comparing CPU kinds using
+ * frequencies (on ARM), or core types and frequencies (on other architectures).
+ * The environment variable HWLOC_CPUKINDS_RANKING may be used
+ * to change this heuristics, see \ref envvar.
+ *
+ * If hwloc fails to rank any kind, for instance because the operating
+ * system does not expose efficiencies and core frequencies,
+ * all kinds will have an unknown efficiency (\c -1),
+ * and they are not indexed/ordered in any specific way.
+ *
+ * @{
+ */
+
+/** \brief Get the number of different kinds of CPU cores in the topology.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return The number of CPU kinds (positive integer) on success.
+ * \return \c 0 if no information about kinds was found.
+ * \return \c -1 with \p errno set to \c EINVAL if \p flags is invalid.
+ */
+HWLOC_DECLSPEC int
+hwloc_cpukinds_get_nr(hwloc_topology_t topology,
+                      unsigned long flags);
+
+/** \brief Get the index of the CPU kind that contains CPUs listed in \p cpuset.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return The index of the CPU kind (positive integer or 0) on success.
+ * \return \c -1 with \p errno set to \c EXDEV if \p cpuset is
+ * only partially included in the some kind.
+ * \return \c -1 with \p errno set to \c ENOENT if \p cpuset is
+ * not included in any kind, even partially.
+ * \return \c -1 with \p errno set to \c EINVAL if parameters are invalid.
+ */
+HWLOC_DECLSPEC int
+hwloc_cpukinds_get_by_cpuset(hwloc_topology_t topology,
+                             hwloc_const_bitmap_t cpuset,
+                             unsigned long flags);
+
+/** \brief Get the CPU set and infos about a CPU kind in the topology.
+ *
+ * \p kind_index identifies one kind of CPU between 0 and the number
+ * of kinds returned by hwloc_cpukinds_get_nr() minus 1.
+ *
+ * If not \c NULL, the bitmap \p cpuset will be filled with
+ * the set of PUs of this kind.
+ *
+ * The integer pointed by \p efficiency, if not \c NULL will, be filled
+ * with the ranking of this kind of CPU in term of efficiency (see above).
+ * It ranges from \c 0 to the number of kinds
+ * (as reported by hwloc_cpukinds_get_nr()) minus 1.
+ *
+ * Kinds with lower efficiency are reported first.
+ *
+ * If there is a single kind in the topology, its efficiency \c 0.
+ * If the efficiency of some kinds of cores is unknown,
+ * the efficiency of all kinds is set to \c -1,
+ * and kinds are reported in no specific order.
+ *
+ * The array of info attributes (for instance the "CoreType",
+ * "FrequencyMaxMHz" or "FrequencyBaseMHz", see \ref topoattrs_cpukinds)
+ * and its length are returned in \p infos or \p nr_infos.
+ * The array belongs to the topology, it should not be freed or modified.
+ *
+ * If \p nr_infos or \p infos is \c NULL, no info is returned.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return \c 0 on success.
+ * \return \c -1 with \p errno set to \c ENOENT if \p kind_index does not match any CPU kind.
+ * \return \c -1 with \p errno set to \c EINVAL if parameters are invalid.
+ */
+HWLOC_DECLSPEC int
+hwloc_cpukinds_get_info(hwloc_topology_t topology,
+                        unsigned kind_index,
+                        hwloc_bitmap_t cpuset,
+                        int *efficiency,
+                        unsigned *nr_infos, struct hwloc_info_s **infos,
+                        unsigned long flags);
+
+/** \brief Register a kind of CPU in the topology.
+ *
+ * Mark the PUs listed in \p cpuset as being of the same kind
+ * with respect to the given attributes.
+ *
+ * \p forced_efficiency should be \c -1 if unknown.
+ * Otherwise it is an abstracted efficiency value to enforce
+ * the ranking of all kinds if all of them have valid (and
+ * different) efficiencies.
+ *
+ * The array \p infos of size \p nr_infos may be used to provide
+ * info names and values describing this kind of PUs.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * Parameters \p cpuset and \p infos will be duplicated internally,
+ * the caller is responsible for freeing them.
+ *
+ * If \p cpuset overlaps with some existing kinds, those might get
+ * modified or split. For instance if existing kind A contains
+ * PUs 0 and 1, and one registers another kind for PU 1 and 2,
+ * there will be 3 resulting kinds:
+ * existing kind A is restricted to only PU 0;
+ * new kind B contains only PU 1 and combines information from A
+ * and from the newly-registered kind;
+ * new kind C contains only PU 2 and only gets information from
+ * the newly-registered kind.
+ *
+ * \note The efficiency \p forced_efficiency provided to this function
+ * may be different from the one reported later by hwloc_cpukinds_get_info()
+ * because hwloc will scale efficiency values down to
+ * between 0 and the number of kinds minus 1.
+ *
+ * \return \c 0 on success.
+ * \return \c -1 with \p errno set to \c EINVAL if some parameters are invalid,
+ * for instance if \p cpuset is \c NULL or empty.
+ */
+HWLOC_DECLSPEC int
+hwloc_cpukinds_register(hwloc_topology_t topology,
+                        hwloc_bitmap_t cpuset,
+                        int forced_efficiency,
+                        unsigned nr_infos, struct hwloc_info_s *infos,
+                        unsigned long flags);
+
+/** @} */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* HWLOC_CPUKINDS_H */

src/3rdparty/hwloc/include/hwloc/cuda.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2017 Inria.  All rights reserved.
+ * Copyright © 2010-2021 Inria.  All rights reserved.
  * Copyright © 2010-2011 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -72,10 +72,10 @@ hwloc_cuda_get_device_pci_ids(hwloc_topology_t topology __hwloc_attribute_unused
   return 0;
 }
 
-/** \brief Get the CPU set of logical processors that are physically
+/** \brief Get the CPU set of processors that are physically
  * close to device \p cudevice.
  *
- * Return the CPU set describing the locality of the CUDA device \p cudevice.
+ * Store in \p set the CPU-set describing the locality of the CUDA device \p cudevice.
  *
  * Topology \p topology and device \p cudevice must match the local machine.
  * I/O devices detection and the CUDA component are not needed in the topology.
@@ -120,8 +120,8 @@ hwloc_cuda_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
 /** \brief Get the hwloc PCI device object corresponding to the
  * CUDA device \p cudevice.
  *
- * Return the PCI device object describing the CUDA device \p cudevice.
- * Return NULL if there is none.
+ * \return The hwloc PCI device object describing the CUDA device \p cudevice.
+ * \return \c NULL if none could be found.
  *
  * Topology \p topology and device \p cudevice must match the local machine.
  * I/O devices detection must be enabled in topology \p topology.
@@ -140,8 +140,8 @@ hwloc_cuda_get_device_pcidev(hwloc_topology_t topology, CUdevice cudevice)
 
 /** \brief Get the hwloc OS device object corresponding to CUDA device \p cudevice.
  *
- * Return the hwloc OS device object that describes the given
- * CUDA device \p cudevice. Return NULL if there is none.
+ * \return The hwloc OS device object that describes the given CUDA device \p cudevice.
+ * \return \c NULL if none could be found.
  *
  * Topology \p topology and device \p cudevice must match the local machine.
  * I/O devices detection and the CUDA component must be enabled in the topology.
@@ -183,8 +183,8 @@ hwloc_cuda_get_device_osdev(hwloc_topology_t topology, CUdevice cudevice)
 /** \brief Get the hwloc OS device object corresponding to the
  * CUDA device whose index is \p idx.
  *
- * Return the OS device object describing the CUDA device whose
- * index is \p idx. Return NULL if there is none.
+ * \return The hwloc OS device object describing the CUDA device whose index is \p idx.
+ * \return \c NULL if none could be found.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.

src/3rdparty/hwloc/include/hwloc/cudart.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2017 Inria.  All rights reserved.
+ * Copyright © 2010-2021 Inria.  All rights reserved.
  * Copyright © 2010-2011 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -69,10 +69,10 @@ hwloc_cudart_get_device_pci_ids(hwloc_topology_t topology __hwloc_attribute_unus
   return 0;
 }
 
-/** \brief Get the CPU set of logical processors that are physically
+/** \brief Get the CPU set of processors that are physically
  * close to device \p idx.
  *
- * Return the CPU set describing the locality of the CUDA device
+ * Store in \p set the CPU-set describing the locality of the CUDA device
  * whose index is \p idx.
  *
  * Topology \p topology and device \p idx must match the local machine.
@@ -117,8 +117,8 @@ hwloc_cudart_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unuse
 /** \brief Get the hwloc PCI device object corresponding to the
  * CUDA device whose index is \p idx.
  *
- * Return the PCI device object describing the CUDA device whose
- * index is \p idx. Return NULL if there is none.
+ * \return The hwloc PCI device object describing the CUDA device whose index is \p idx.
+ * \return \c NULL if none could be found.
  *
  * Topology \p topology and device \p idx must match the local machine.
  * I/O devices detection must be enabled in topology \p topology.
@@ -138,8 +138,8 @@ hwloc_cudart_get_device_pcidev(hwloc_topology_t topology, int idx)
 /** \brief Get the hwloc OS device object corresponding to the
  * CUDA device whose index is \p idx.
  *
- * Return the OS device object describing the CUDA device whose
- * index is \p idx. Return NULL if there is none.
+ * \return The hwloc OS device object describing the CUDA device whose index is \p idx.
+ * \return \c NULL if none could be found.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.

src/3rdparty/hwloc/include/hwloc/deprecated.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2018 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2010 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -30,6 +30,15 @@ extern "C" {
 /* backward compat with v1.10 before Node->NUMANode clarification */
 #define HWLOC_OBJ_NODE HWLOC_OBJ_NUMANODE
 
+/** \brief Add a distances structure.
+ *
+ * Superseded by hwloc_distances_add_create()+hwloc_distances_add_values()+hwloc_distances_add_commit()
+ * in v2.5.
+ */
+HWLOC_DECLSPEC int hwloc_distances_add(hwloc_topology_t topology,
+				       unsigned nbobjs, hwloc_obj_t *objs, hwloc_uint64_t *values,
+				       unsigned long kind, unsigned long flags) __hwloc_attribute_deprecated;
+
 /** \brief Insert a misc object by parent.
  *
  * Identical to hwloc_topology_insert_misc_object().

src/3rdparty/hwloc/include/hwloc/diff.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013-2018 Inria.  All rights reserved.
+ * Copyright © 2013-2020 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -110,7 +110,7 @@ union hwloc_topology_diff_obj_attr_u {
  */
 typedef enum hwloc_topology_diff_type_e {
   /** \brief An object attribute was changed.
-   * The union is a hwloc_topology_diff_obj_attr_u::hwloc_topology_diff_obj_attr_s.
+   * The union is a hwloc_topology_diff_u::hwloc_topology_diff_obj_attr_s.
    */
   HWLOC_TOPOLOGY_DIFF_OBJ_ATTR,
 
@@ -119,7 +119,7 @@ typedef enum hwloc_topology_diff_type_e {
    * this object has not been checked.
    * hwloc_topology_diff_build() will return 1.
    *
-   * The union is a hwloc_topology_diff_obj_attr_u::hwloc_topology_diff_too_complex_s.
+   * The union is a hwloc_topology_diff_u::hwloc_topology_diff_too_complex_s.
    */
   HWLOC_TOPOLOGY_DIFF_TOO_COMPLEX
 } hwloc_topology_diff_type_t;

src/3rdparty/hwloc/include/hwloc/distances.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2019 Inria.  All rights reserved.
+ * Copyright © 2010-2021 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -34,9 +34,21 @@ extern "C" {
  * It corresponds to the latency for accessing the memory of one node
  * from a core in another node.
  * The corresponding kind is ::HWLOC_DISTANCES_KIND_FROM_OS | ::HWLOC_DISTANCES_KIND_FROM_USER.
+ * The name of this distances structure is "NUMALatency".
+ * Others distance structures include and "XGMIBandwidth", "XGMIHops"
+ * and "NVLinkBandwidth".
  *
  * The matrix may also contain bandwidths between random sets of objects,
  * possibly provided by the user, as specified in the \p kind attribute.
+ *
+ * Pointers \p objs and \p values should not be replaced, reallocated, freed, etc.
+ * However callers are allowed to modify \p kind as well as the contents
+ * of \p objs and \p values arrays.
+ * For instance, if there is a single NUMA node per Package,
+ * hwloc_get_obj_with_same_locality() may be used to convert between them
+ * and replace NUMA nodes in the \p objs array with the corresponding Packages.
+ * See also hwloc_distances_transform() for applying some transformations
+ * to the structure.
  */
 struct hwloc_distances_s {
   unsigned nbobjs;		/**< \brief Number of objects described by the distance matrix. */
@@ -90,6 +102,8 @@ enum hwloc_distances_kind_e {
   HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH = (1UL<<3),
 
   /** \brief This distances structure covers objects of different types.
+   * This may apply to the "NVLinkBandwidth" structure in presence
+   * of a NVSwitch or POWER processor NVLink port.
    * \hideinitializer
    */
   HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES = (1UL<<4)
@@ -144,6 +158,9 @@ hwloc_distances_get_by_type(hwloc_topology_t topology, hwloc_obj_type_t type,
 /** \brief Retrieve a distance matrix with the given name.
  *
  * Usually only one distances structure may match a given name.
+ *
+ * The name of the most common structure is "NUMALatency".
+ * Others include "XGMIBandwidth", "XGMIHops" and "NVLinkBandwidth".
  */
 HWLOC_DECLSPEC int
 hwloc_distances_get_by_name(hwloc_topology_t topology, const char *name,
@@ -165,6 +182,85 @@ hwloc_distances_get_name(hwloc_topology_t topology, struct hwloc_distances_s *di
 HWLOC_DECLSPEC void
 hwloc_distances_release(hwloc_topology_t topology, struct hwloc_distances_s *distances);
 
+/** \brief Transformations of distances structures. */
+enum hwloc_distances_transform_e {
+  /** \brief Remove \c NULL objects from the distances structure.
+   *
+   * Every object that was replaced with \c NULL in the \p objs array
+   * is removed and the \p values array is updated accordingly.
+   *
+   * At least \c 2 objects must remain, otherwise hwloc_distances_transform()
+   * will return \c -1 with \p errno set to \c EINVAL.
+   *
+   * \p kind will be updated with or without ::HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES
+   * according to the remaining objects.
+   *
+   * \hideinitializer
+   */
+  HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL = 0,
+
+  /** \brief Replace bandwidth values with a number of links.
+   *
+   * Usually all values will be either \c 0 (no link) or \c 1 (one link).
+   * However some matrices could get larger values if some pairs of
+   * peers are connected by different numbers of links.
+   *
+   * Values on the diagonal are set to \c 0.
+   *
+   * This transformation only applies to bandwidth matrices.
+   *
+   * \hideinitializer
+   */
+  HWLOC_DISTANCES_TRANSFORM_LINKS = 1,
+
+  /** \brief Merge switches with multiple ports into a single object.
+   * This currently only applies to NVSwitches where GPUs seem connected to different
+   * separate switch ports in the NVLinkBandwidth matrix. This transformation will
+   * replace all of them with the same port connected to all GPUs.
+   * Other ports are removed by applying ::HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL internally.
+   * \hideinitializer
+   */
+  HWLOC_DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS = 2,
+
+  /** \brief Apply a transitive closure to the matrix to connect objects across switches.
+   * This currently only applies to GPUs and NVSwitches in the NVLinkBandwidth matrix.
+   * All pairs of GPUs will be reported as directly connected.
+   * \hideinitializer
+   */
+  HWLOC_DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE = 3
+};
+
+/** \brief Apply a transformation to a distances structure.
+ *
+ * Modify a distances structure that was previously obtained with
+ * hwloc_distances_get() or one of its variants.
+ *
+ * This modifies the local copy of the distances structures but does
+ * not modify the distances information stored inside the topology
+ * (retrieved by another call to hwloc_distances_get() or exported to XML).
+ * To do so, one should add a new distances structure with same
+ * name, kind, objects and values (see \ref hwlocality_distances_add)
+ * and then remove this old one with hwloc_distances_release_remove().
+ *
+ * \p transform must be one of the transformations listed
+ * in ::hwloc_distances_transform_e.
+ *
+ * These transformations may modify the contents of the \p objs or \p values arrays.
+ *
+ * \p transform_attr must be \c NULL for now.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \note Objects in distances array \p objs may be directly modified
+ * in place without using hwloc_distances_transform().
+ * One may use hwloc_get_obj_with_same_locality() to easily convert
+ * between similar objects of different types.
+ */
+HWLOC_DECLSPEC int hwloc_distances_transform(hwloc_topology_t topology, struct hwloc_distances_s *distances,
+                                             enum hwloc_distances_transform_e transform,
+                                             void *transform_attr,
+                                             unsigned long flags);
+
 /** @} */
 
 
@@ -212,13 +308,84 @@ hwloc_distances_obj_pair_values(struct hwloc_distances_s *distances,
 
 
 
-/** \defgroup hwlocality_distances_add Add or remove distances between objects
+/** \defgroup hwlocality_distances_add Add distances between objects
+ *
+ * The usual way to add distances is:
+ * \code
+ * hwloc_distances_add_handle_t handle;
+ * int err = -1;
+ * handle = hwloc_distances_add_create(topology, "name", kind, 0);
+ * if (handle) {
+ *   err = hwloc_distances_add_values(topology, handle, nbobjs, objs, values, 0);
+ *   if (!err)
+ *     err = hwloc_distances_add_commit(topology, handle, flags);
+ * }
+ * \endcode
+ * If \p err is \c 0 at the end, then addition was successful.
+ *
  * @{
  */
 
+/** \brief Handle to a new distances structure during its addition to the topology. */
+typedef void * hwloc_distances_add_handle_t;
+
+/** \brief Create a new empty distances structure.
+ *
+ * Create an empty distances structure
+ * to be filled with hwloc_distances_add_values()
+ * and then committed with hwloc_distances_add_commit().
+ *
+ * Parameter \p name is optional, it may be \c NULL.
+ * Otherwise, it will be copied internally and may later be freed by the caller.
+ *
+ * \p kind specifies the kind of distance as a OR'ed set of ::hwloc_distances_kind_e.
+ * Kind ::HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES will be automatically set
+ * according to objects having different types in hwloc_distances_add_values().
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return A hwloc_distances_add_handle_t that should then be passed
+ * to hwloc_distances_add_values() and hwloc_distances_add_commit().
+ *
+ * \return \c NULL on error.
+ */
+HWLOC_DECLSPEC hwloc_distances_add_handle_t
+hwloc_distances_add_create(hwloc_topology_t topology,
+                           const char *name, unsigned long kind,
+                           unsigned long flags);
+
+/** \brief Specify the objects and values in a new empty distances structure.
+ *
+ * Specify the objects and values for a new distances structure
+ * that was returned as a handle by hwloc_distances_add_create().
+ * The structure must then be committed with hwloc_distances_add_commit().
+ *
+ * The number of objects is \p nbobjs and the array of objects is \p objs.
+ * Distance values are stored as a one-dimension array in \p values.
+ * The distance from object i to object j is in slot i*nbobjs+j.
+ *
+ * \p nbobjs must be at least 2.
+ *
+ * Arrays \p objs and \p values will be copied internally,
+ * they may later be freed by the caller.
+ *
+ * On error, the temporary distances structure and its content are destroyed.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return \c 0 on success.
+ * \return \c -1 on error.
+ */
+HWLOC_DECLSPEC int hwloc_distances_add_values(hwloc_topology_t topology,
+                                              hwloc_distances_add_handle_t handle,
+                                              unsigned nbobjs, hwloc_obj_t *objs,
+                                              hwloc_uint64_t *values,
+                                              unsigned long flags);
+
 /** \brief Flags for adding a new distances to a topology. */
 enum hwloc_distances_add_flag_e {
   /** \brief Try to group objects based on the newly provided distance information.
+   * This is ignored for distances between objects of different types.
    * \hideinitializer
    */
   HWLOC_DISTANCES_ADD_FLAG_GROUP = (1UL<<0),
@@ -230,23 +397,33 @@ enum hwloc_distances_add_flag_e {
   HWLOC_DISTANCES_ADD_FLAG_GROUP_INACCURATE = (1UL<<1)
 };
 
-/** \brief Provide a new distance matrix.
+/** \brief Commit a new distances structure.
  *
- * Provide the matrix of distances between a set of objects given by \p nbobjs
- * and the \p objs array. \p nbobjs must be at least 2.
- * The distances are stored as a one-dimension array in \p values.
- * The distance from object i to object j is in slot i*nbobjs+j.
+ * This function finalizes the distances structure and inserts in it the topology.
  *
- * \p kind specifies the kind of distance as a OR'ed set of ::hwloc_distances_kind_e.
- * Kind ::HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES will be automatically added
- * if objects of different types are given.
+ * Parameter \p handle was previously returned by hwloc_distances_add_create().
+ * Then objects and values were specified with hwloc_distances_add_values().
  *
  * \p flags configures the behavior of the function using an optional OR'ed set of
  * ::hwloc_distances_add_flag_e.
+ * It may be used to request the grouping of existing objects based on distances.
+ *
+ * On error, the temporary distances structure and its content are destroyed.
+ *
+ * \return \c 0 on success.
+ * \return \c -1 on error.
+ */
+HWLOC_DECLSPEC int hwloc_distances_add_commit(hwloc_topology_t topology,
+                                              hwloc_distances_add_handle_t handle,
+                                              unsigned long flags);
+
+/** @} */
+
+
+
+/** \defgroup hwlocality_distances_remove Remove distances between objects
+ * @{
  */
-HWLOC_DECLSPEC int hwloc_distances_add(hwloc_topology_t topology,
-				       unsigned nbobjs, hwloc_obj_t *objs, hwloc_uint64_t *values,
-				       unsigned long kind, unsigned long flags);
 
 /** \brief Remove all distance matrices from a topology.
  *

src/3rdparty/hwloc/include/hwloc/gl.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2012 Blue Brain Project, EPFL. All rights reserved.
- * Copyright © 2012-2013 Inria.  All rights reserved.
+ * Copyright © 2012-2021 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -39,9 +39,9 @@ extern "C" {
 /** \brief Get the hwloc OS device object corresponding to the
  * OpenGL display given by port and device index.
  *
- * Return the OS device object describing the OpenGL display
+ * \return The hwloc OS device object describing the OpenGL display
  * whose port (server) is \p port and device (screen) is \p device.
- * Return NULL if there is none.
+ * \return \c NULL if none could be found.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.
@@ -70,9 +70,9 @@ hwloc_gl_get_display_osdev_by_port_device(hwloc_topology_t topology,
 /** \brief Get the hwloc OS device object corresponding to the
  * OpenGL display given by name.
  *
- * Return the OS device object describing the OpenGL display
+ * \return The hwloc OS device object describing the OpenGL display
  * whose name is \p name, built as ":port.device" such as ":0.0" .
- * Return NULL if there is none.
+ * \return \c NULL if none could be found.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.
@@ -99,9 +99,10 @@ hwloc_gl_get_display_osdev_by_name(hwloc_topology_t topology,
 /** \brief Get the OpenGL display port and device corresponding
  * to the given hwloc OS object.
  *
- * Return the OpenGL display port (server) in \p port and device (screen)
+ * Retrieves the OpenGL display port (server) in \p port and device (screen)
  * in \p screen that correspond to the given hwloc OS device object.
- * Return \c -1 if there is none.
+ *
+ * \return \c -1 if none could be found.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.

src/3rdparty/hwloc/include/hwloc/glibc-sched.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2013 inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009-2011 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -22,7 +22,7 @@
 
 #include <assert.h>
 
-#if !defined _GNU_SOURCE || !defined _SCHED_H || (!defined CPU_SETSIZE && !defined sched_priority)
+#if !defined _GNU_SOURCE || (!defined _SCHED_H && !defined _SCHED_H_) || (!defined CPU_SETSIZE && !defined sched_priority)
 #error Please make sure to include sched.h before including glibc-sched.h, and define _GNU_SOURCE before any inclusion of sched.h
 #endif
 

src/3rdparty/hwloc/include/hwloc/helper.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2020 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012 Université Bordeaux
  * Copyright © 2009-2010 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -807,6 +807,49 @@ hwloc_get_obj_below_array_by_type (hwloc_topology_t topology, int nr, hwloc_obj_
   return obj;
 }
 
+/** \brief Return an object of a different type with same locality.
+ *
+ * If the source object \p src is a normal or memory type,
+ * this function returns an object of type \p type with same
+ * CPU and node sets, either below or above in the hierarchy.
+ *
+ * If the source object \p src is a PCI or an OS device within a PCI
+ * device, the function may either return that PCI device, or another
+ * OS device in the same PCI parent.
+ * This may for instance be useful for converting between OS devices
+ * such as "nvml0" or "rsmi1" used in distance structures into the
+ * the PCI device, or the CUDA or OpenCL OS device that correspond
+ * to the same physical card.
+ *
+ * If not \c NULL, parameter \p subtype only select objects whose
+ * subtype attribute exists and is \p subtype (case-insensitively),
+ * for instance "OpenCL" or "CUDA".
+ *
+ * If not \c NULL, parameter \p nameprefix only selects objects whose
+ * name attribute exists and starts with \p nameprefix (case-insensitively),
+ * for instance "rsmi" for matching "rsmi0".
+ *
+ * If multiple objects match, the first one is returned.
+ *
+ * This function will not walk the hierarchy across bridges since
+ * the PCI locality may become different.
+ * This function cannot also convert between normal/memory objects
+ * and I/O or Misc objects.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \return An object with identical locality,
+ * matching \p subtype and \p nameprefix if any.
+ *
+ * \return \c NULL if no matching object could be found,
+ * or if the source object and target type are incompatible,
+ * for instance if converting between CPU and I/O objects.
+ */
+HWLOC_DECLSPEC hwloc_obj_t
+hwloc_get_obj_with_same_locality(hwloc_topology_t topology, hwloc_obj_t src,
+                                 hwloc_obj_type_t type, const char *subtype, const char *nameprefix,
+                                 unsigned long flags);
+
 /** @} */
 
 
@@ -872,8 +915,8 @@ hwloc_distrib(hwloc_topology_t topology,
     unsigned chunk, weight;
     hwloc_obj_t root = roots[flags & HWLOC_DISTRIB_FLAG_REVERSE ? n_roots-1-i : i];
     hwloc_cpuset_t cpuset = root->cpuset;
-    if (root->type == HWLOC_OBJ_NUMANODE)
-      /* NUMANodes have same cpuset as their parent, but we need normal objects below */
+    while (!hwloc_obj_type_is_normal(root->type))
+      /* If memory/io/misc, walk up to normal parent */
       root = root->parent;
     weight = (unsigned) hwloc_bitmap_weight(cpuset);
     if (!weight)
@@ -919,7 +962,7 @@ hwloc_distrib(hwloc_topology_t topology,
 
 /** \brief Get complete CPU set
  *
- * \return the complete CPU set of logical processors of the system.
+ * \return the complete CPU set of processors of the system.
  *
  * \note The returned cpuset is not newly allocated and should thus not be
  * changed or freed; hwloc_bitmap_dup() must be used to obtain a local copy.
@@ -931,7 +974,7 @@ hwloc_topology_get_complete_cpuset(hwloc_topology_t topology) __hwloc_attribute_
 
 /** \brief Get topology CPU set
  *
- * \return the CPU set of logical processors of the system for which hwloc
+ * \return the CPU set of processors of the system for which hwloc
  * provides topology information. This is equivalent to the cpuset of the
  * system object.
  *
@@ -945,7 +988,7 @@ hwloc_topology_get_topology_cpuset(hwloc_topology_t topology) __hwloc_attribute_
 
 /** \brief Get allowed CPU set
  *
- * \return the CPU set of allowed logical processors of the system.
+ * \return the CPU set of allowed processors of the system.
  *
  * \note If the topology flag ::HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED was not set,
  * this is identical to hwloc_topology_get_topology_cpuset(), which means

src/3rdparty/hwloc/include/hwloc/levelzero.h

@@ -0,0 +1,157 @@
+/*
+ * Copyright © 2021 Inria.  All rights reserved.
+ * See COPYING in top-level directory.
+ */
+
+/** \file
+ * \brief Macros to help interaction between hwloc and the oneAPI Level Zero interface.
+ *
+ * Applications that use both hwloc and Level Zero may want to
+ * include this file so as to get topology information for L0 devices.
+ */
+
+#ifndef HWLOC_LEVELZERO_H
+#define HWLOC_LEVELZERO_H
+
+#include "hwloc.h"
+#include "hwloc/autogen/config.h"
+#include "hwloc/helper.h"
+#ifdef HWLOC_LINUX_SYS
+#include "hwloc/linux.h"
+#endif
+
+#include <level_zero/ze_api.h>
+#include <level_zero/zes_api.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** \defgroup hwlocality_levelzero Interoperability with the oneAPI Level Zero interface.
+ *
+ * This interface offers ways to retrieve topology information about
+ * devices managed by the Level Zero API.
+ *
+ * @{
+ */
+
+/** \brief Get the CPU set of logical processors that are physically
+ * close to the Level Zero device \p device
+ *
+ * Store in \p set the CPU-set describing the locality of
+ * the Level Zero device \p device.
+ *
+ * Topology \p topology and device \p device must match the local machine.
+ * The Level Zero must have been initialized with Sysman enabled
+ * (ZES_ENABLE_SYSMAN=1 in the environment).
+ * I/O devices detection and the Level Zero component are not needed in the
+ * topology.
+ *
+ * The function only returns the locality of the device.
+ * If more information about the device is needed, OS objects should
+ * be used instead, see hwloc_levelzero_get_device_osdev().
+ *
+ * This function is currently only implemented in a meaningful way for
+ * Linux; other systems will simply get a full cpuset.
+ */
+static __hwloc_inline int
+hwloc_levelzero_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
+                                  ze_device_handle_t device, hwloc_cpuset_t set)
+{
+#ifdef HWLOC_LINUX_SYS
+  /* If we're on Linux, use the sysfs mechanism to get the local cpus */
+#define HWLOC_LEVELZERO_DEVICE_SYSFS_PATH_MAX 128
+  char path[HWLOC_LEVELZERO_DEVICE_SYSFS_PATH_MAX];
+  zes_pci_properties_t pci;
+  zes_device_handle_t sdevice = device;
+  ze_result_t res;
+
+  if (!hwloc_topology_is_thissystem(topology)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  res = zesDevicePciGetProperties(sdevice, &pci);
+  if (res != ZE_RESULT_SUCCESS) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  sprintf(path, "/sys/bus/pci/devices/%04x:%02x:%02x.%01x/local_cpus",
+          pci.address.domain, pci.address.bus, pci.address.device, pci.address.function);
+  if (hwloc_linux_read_path_as_cpumask(path, set) < 0
+      || hwloc_bitmap_iszero(set))
+    hwloc_bitmap_copy(set, hwloc_topology_get_complete_cpuset(topology));
+#else
+  /* Non-Linux systems simply get a full cpuset */
+  hwloc_bitmap_copy(set, hwloc_topology_get_complete_cpuset(topology));
+#endif
+  return 0;
+}
+
+/** \brief Get the hwloc OS device object corresponding to Level Zero device
+ * \p device.
+ *
+ * \return The hwloc OS device object that describes the given Level Zero device \p device.
+ * \return \c NULL if none could be found.
+ *
+ * Topology \p topology and device \p dv_ind must match the local machine.
+ * I/O devices detection and the Level Zero component must be enabled in the
+ * topology. If not, the locality of the object may still be found using
+ * hwloc_levelzero_get_device_cpuset().
+ *
+ * \note The corresponding hwloc PCI device may be found by looking
+ * at the result parent pointer (unless PCI devices are filtered out).
+ */
+static __hwloc_inline hwloc_obj_t
+hwloc_levelzero_get_device_osdev(hwloc_topology_t topology, ze_device_handle_t device)
+{
+  zes_device_handle_t sdevice = device;
+  zes_pci_properties_t pci;
+  ze_result_t res;
+  hwloc_obj_t osdev;
+
+  if (!hwloc_topology_is_thissystem(topology)) {
+    errno = EINVAL;
+    return NULL;
+  }
+
+  res = zesDevicePciGetProperties(sdevice, &pci);
+  if (res != ZE_RESULT_SUCCESS) {
+    /* L0 was likely initialized without sysman, don't bother */
+    errno = EINVAL;
+    return NULL;
+  }
+
+  osdev = NULL;
+  while ((osdev = hwloc_get_next_osdev(topology, osdev)) != NULL) {
+    hwloc_obj_t pcidev = osdev->parent;
+
+    if (strncmp(osdev->name, "ze", 2))
+      continue;
+
+    if (pcidev
+      && pcidev->type == HWLOC_OBJ_PCI_DEVICE
+      && pcidev->attr->pcidev.domain == pci.address.domain
+      && pcidev->attr->pcidev.bus == pci.address.bus
+      && pcidev->attr->pcidev.dev == pci.address.device
+      && pcidev->attr->pcidev.func == pci.address.function)
+      return osdev;
+
+    /* FIXME: when we'll have serialnumber, try it in case PCI is filtered-out */
+  }
+
+  return NULL;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* HWLOC_LEVELZERO_H */

src/3rdparty/hwloc/include/hwloc/linux.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2016 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2011 Université Bordeaux
  * See COPYING in top-level directory.
  */
@@ -44,6 +44,10 @@ extern "C" {
 HWLOC_DECLSPEC int hwloc_linux_set_tid_cpubind(hwloc_topology_t topology, pid_t tid, hwloc_const_cpuset_t set);
 
 /** \brief Get the current binding of thread \p tid
+ *
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the list of PUs which the thread
+ * was last bound to.
  *
  * The behavior is exactly the same as the Linux sched_getaffinity system call,
  * but uses a hwloc cpuset.
@@ -54,6 +58,9 @@ HWLOC_DECLSPEC int hwloc_linux_set_tid_cpubind(hwloc_topology_t topology, pid_t
 HWLOC_DECLSPEC int hwloc_linux_get_tid_cpubind(hwloc_topology_t topology, pid_t tid, hwloc_cpuset_t set);
 
 /** \brief Get the last physical CPU where thread \p tid ran.
+ *
+ * The CPU-set \p set (previously allocated by the caller)
+ * is filled with the PU which the thread last ran on.
  *
  * \note This is equivalent to calling hwloc_get_proc_last_cpu_location() with
  * ::HWLOC_CPUBIND_THREAD as flags.

src/3rdparty/hwloc/include/hwloc/memattrs.h

@@ -0,0 +1,455 @@
+/*
+ * Copyright © 2019-2022 Inria.  All rights reserved.
+ * See COPYING in top-level directory.
+ */
+
+/** \file
+ * \brief Memory node attributes.
+ */
+
+#ifndef HWLOC_MEMATTR_H
+#define HWLOC_MEMATTR_H
+
+#include "hwloc.h"
+
+#ifdef __cplusplus
+extern "C" {
+#elif 0
+}
+#endif
+
+/** \defgroup hwlocality_memattrs Comparing memory node attributes for finding where to allocate on
+ *
+ * Platforms with heterogeneous memory require ways to decide whether
+ * a buffer should be allocated on "fast" memory (such as HBM),
+ * "normal" memory (DDR) or even "slow" but large-capacity memory
+ * (non-volatile memory).
+ * These memory nodes are called "Targets" while the CPU accessing them
+ * is called the "Initiator". Access performance depends on their
+ * locality (NUMA platforms) as well as the intrinsic performance
+ * of the targets (heterogeneous platforms).
+ *
+ * The following attributes describe the performance of memory accesses
+ * from an Initiator to a memory Target, for instance their latency
+ * or bandwidth.
+ * Initiators performing these memory accesses are usually some PUs or Cores
+ * (described as a CPU set).
+ * Hence a Core may choose where to allocate a memory buffer by comparing
+ * the attributes of different target memory nodes nearby.
+ *
+ * There are also some attributes that are system-wide.
+ * Their value does not depend on a specific initiator performing
+ * an access.
+ * The memory node Capacity is an example of such attribute without
+ * initiator.
+ *
+ * One way to use this API is to start with a cpuset describing the Cores where
+ * a program is bound. The best target NUMA node for allocating memory in this
+ * program on these Cores may be obtained by passing this cpuset as an initiator
+ * to hwloc_memattr_get_best_target() with the relevant memory attribute.
+ * For instance, if the code is latency limited, use the Latency attribute.
+ *
+ * A more flexible approach consists in getting the list of local NUMA nodes
+ * by passing this cpuset to hwloc_get_local_numanode_objs().
+ * Attribute values for these nodes, if any, may then be obtained with
+ * hwloc_memattr_get_value() and manually compared with the desired criteria.
+ *
+ * \note The API also supports specific objects as initiator,
+ * but it is currently not used internally by hwloc.
+ * Users may for instance use it to provide custom performance
+ * values for host memory accesses performed by GPUs.
+ *
+ * \note The interface actually also accepts targets that are not NUMA nodes.
+ * @{
+ */
+
+/** \brief Memory node attributes. */
+enum hwloc_memattr_id_e {
+  /** \brief "Capacity".
+   * The capacity is returned in bytes
+   * (local_memory attribute in objects).
+   *
+   * Best capacity nodes are nodes with <b>higher capacity</b>.
+   *
+   * No initiator is involved when looking at this attribute.
+   * The corresponding attribute flags are ::HWLOC_MEMATTR_FLAG_HIGHER_FIRST.
+   */
+  HWLOC_MEMATTR_ID_CAPACITY = 0,
+
+  /** \brief "Locality".
+   * The locality is returned as the number of PUs in that locality
+   * (e.g. the weight of its cpuset).
+   *
+   * Best locality nodes are nodes with <b>smaller locality</b>
+   * (nodes that are local to very few PUs).
+   * Poor locality nodes are nodes with larger locality
+   * (nodes that are local to the entire machine).
+   *
+   * No initiator is involved when looking at this attribute.
+   * The corresponding attribute flags are ::HWLOC_MEMATTR_FLAG_HIGHER_FIRST.
+   */
+  HWLOC_MEMATTR_ID_LOCALITY = 1,
+
+  /** \brief "Bandwidth".
+   * The bandwidth is returned in MiB/s, as seen from the given initiator location.
+   * Best bandwidth nodes are nodes with <b>higher bandwidth</b>.
+   * The corresponding attribute flags are ::HWLOC_MEMATTR_FLAG_HIGHER_FIRST
+   * and ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR.
+   */
+  HWLOC_MEMATTR_ID_BANDWIDTH = 2,
+
+  /** \brief "Latency".
+   * The latency is returned as nanoseconds, as seen from the given initiator location.
+   * Best latency nodes are nodes with <b>smaller latency</b>.
+   * The corresponding attribute flags are ::HWLOC_MEMATTR_FLAG_LOWER_FIRST
+   * and ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR.
+   */
+  HWLOC_MEMATTR_ID_LATENCY = 3
+
+  /* TODO read vs write, persistence? */
+};
+
+/** \brief A memory attribute identifier.
+ * May be either one of ::hwloc_memattr_id_e or a new id returned by hwloc_memattr_register().
+ */
+typedef unsigned hwloc_memattr_id_t;
+
+/** \brief Return the identifier of the memory attribute with the given name.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_by_name(hwloc_topology_t topology,
+                          const char *name,
+                          hwloc_memattr_id_t *id);
+
+
+/** \brief Type of location. */
+enum hwloc_location_type_e {
+  /** \brief Location is given as a cpuset, in the location cpuset union field. \hideinitializer */
+  HWLOC_LOCATION_TYPE_CPUSET = 1,
+  /** \brief Location is given as an object, in the location object union field. \hideinitializer */
+  HWLOC_LOCATION_TYPE_OBJECT = 0
+};
+
+/** \brief Where to measure attributes from. */
+struct hwloc_location {
+  /** \brief Type of location. */
+  enum hwloc_location_type_e type;
+  /** \brief Actual location. */
+  union hwloc_location_u {
+    /** \brief Location as a cpuset, when the location type is ::HWLOC_LOCATION_TYPE_CPUSET. */
+    hwloc_cpuset_t cpuset;
+    /** \brief Location as an object, when the location type is ::HWLOC_LOCATION_TYPE_OBJECT. */
+    hwloc_obj_t object;
+  } location;
+};
+
+
+/** \brief Flags for selecting target NUMA nodes. */
+enum hwloc_local_numanode_flag_e {
+  /** \brief Select NUMA nodes whose locality is larger than the given cpuset.
+   * For instance, if a single PU (or its cpuset) is given in \p initiator,
+   * select all nodes close to the package that contains this PU.
+   * \hideinitializer
+   */
+  HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY = (1UL<<0),
+
+  /** \brief Select NUMA nodes whose locality is smaller than the given cpuset.
+   * For instance, if a package (or its cpuset) is given in \p initiator,
+   * also select nodes that are attached to only a half of that package.
+   * \hideinitializer
+   */
+  HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY = (1UL<<1),
+
+  /** \brief Select all NUMA nodes in the topology.
+   * The initiator \p initiator is ignored.
+   * \hideinitializer
+   */
+  HWLOC_LOCAL_NUMANODE_FLAG_ALL = (1UL<<2)
+};
+
+/** \brief Return an array of local NUMA nodes.
+ *
+ * By default only select the NUMA nodes whose locality is exactly
+ * the given \p location. More nodes may be selected if additional flags
+ * are given as a OR'ed set of ::hwloc_local_numanode_flag_e.
+ *
+ * If \p location is given as an explicit object, its CPU set is used
+ * to find NUMA nodes with the corresponding locality.
+ * If the object does not have a CPU set (e.g. I/O object), the CPU
+ * parent (where the I/O object is attached) is used.
+ *
+ * On input, \p nr points to the number of nodes that may be stored
+ * in the \p nodes array.
+ * On output, \p nr will be changed to the number of stored nodes,
+ * or the number of nodes that would have been stored if there were
+ * enough room.
+ *
+ * \note Some of these NUMA nodes may not have any memory attribute
+ * values and hence not be reported as actual targets in other functions.
+ *
+ * \note The number of NUMA nodes in the topology (obtained by
+ * hwloc_bitmap_weight() on the root object nodeset) may be used
+ * to allocate the \p nodes array.
+ *
+ * \note When an object CPU set is given as locality, for instance a Package,
+ * and when flags contain both ::HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY
+ * and ::HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY,
+ * the returned array corresponds to the nodeset of that object.
+ */
+HWLOC_DECLSPEC int
+hwloc_get_local_numanode_objs(hwloc_topology_t topology,
+                              struct hwloc_location *location,
+                              unsigned *nr,
+                              hwloc_obj_t *nodes,
+                              unsigned long flags);
+
+
+
+/** \brief Return an attribute value for a specific target NUMA node.
+ *
+ * If the attribute does not relate to a specific initiator
+ * (it does not have the flag ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR),
+ * location \p initiator is ignored and may be \c NULL.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \note The initiator \p initiator should be of type ::HWLOC_LOCATION_TYPE_CPUSET
+ * when refering to accesses performed by CPU cores.
+ * ::HWLOC_LOCATION_TYPE_OBJECT is currently unused internally by hwloc,
+ * but users may for instance use it to provide custom information about
+ * host memory accesses performed by GPUs.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_value(hwloc_topology_t topology,
+                        hwloc_memattr_id_t attribute,
+                        hwloc_obj_t target_node,
+                        struct hwloc_location *initiator,
+                        unsigned long flags,
+                        hwloc_uint64_t *value);
+
+/** \brief Return the best target NUMA node for the given attribute and initiator.
+ *
+ * If the attribute does not relate to a specific initiator
+ * (it does not have the flag ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR),
+ * location \p initiator is ignored and may be \c NULL.
+ *
+ * If \p value is non \c NULL, the corresponding value is returned there.
+ *
+ * If multiple targets have the same attribute values, only one is
+ * returned (and there is no way to clarify how that one is chosen).
+ * Applications that want to detect targets with identical/similar
+ * values, or that want to look at values for multiple attributes,
+ * should rather get all values using hwloc_memattr_get_value()
+ * and manually select the target they consider the best.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * If there are no matching targets, \c -1 is returned with \p errno set to \c ENOENT;
+ *
+ * \note The initiator \p initiator should be of type ::HWLOC_LOCATION_TYPE_CPUSET
+ * when refering to accesses performed by CPU cores.
+ * ::HWLOC_LOCATION_TYPE_OBJECT is currently unused internally by hwloc,
+ * but users may for instance use it to provide custom information about
+ * host memory accesses performed by GPUs.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_best_target(hwloc_topology_t topology,
+                              hwloc_memattr_id_t attribute,
+                              struct hwloc_location *initiator,
+                              unsigned long flags,
+                              hwloc_obj_t *best_target, hwloc_uint64_t *value);
+
+/** \brief Return the best initiator for the given attribute and target NUMA node.
+ *
+ * If the attribute does not relate to a specific initiator
+ * (it does not have the flag ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR),
+ * \c -1 is returned and \p errno is set to \c EINVAL.
+ *
+ * If \p value is non \c NULL, the corresponding value is returned there.
+ *
+ * If multiple initiators have the same attribute values, only one is
+ * returned (and there is no way to clarify how that one is chosen).
+ * Applications that want to detect initiators with identical/similar
+ * values, or that want to look at values for multiple attributes,
+ * should rather get all values using hwloc_memattr_get_value()
+ * and manually select the initiator they consider the best.
+ *
+ * The returned initiator should not be modified or freed,
+ * it belongs to the topology.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * If there are no matching initiators, \c -1 is returned with \p errno set to \c ENOENT;
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_best_initiator(hwloc_topology_t topology,
+                                 hwloc_memattr_id_t attribute,
+                                 hwloc_obj_t target,
+                                 unsigned long flags,
+                                 struct hwloc_location *best_initiator, hwloc_uint64_t *value);
+
+/** @} */
+
+
+/** \defgroup hwlocality_memattrs_manage Managing memory attributes
+ * @{
+ */
+
+/** \brief Return the name of a memory attribute.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_name(hwloc_topology_t topology,
+                       hwloc_memattr_id_t attribute,
+                       const char **name);
+
+/** \brief Return the flags of the given attribute.
+ *
+ * Flags are a OR'ed set of ::hwloc_memattr_flag_e.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_flags(hwloc_topology_t topology,
+                        hwloc_memattr_id_t attribute,
+                        unsigned long *flags);
+
+/** \brief Memory attribute flags.
+ * Given to hwloc_memattr_register() and returned by hwloc_memattr_get_flags().
+ */
+enum hwloc_memattr_flag_e {
+  /** \brief The best nodes for this memory attribute are those with the higher values.
+   * For instance Bandwidth.
+   */
+  HWLOC_MEMATTR_FLAG_HIGHER_FIRST = (1UL<<0),
+  /** \brief The best nodes for this memory attribute are those with the lower values.
+   * For instance Latency.
+   */
+  HWLOC_MEMATTR_FLAG_LOWER_FIRST = (1UL<<1),
+  /** \brief The value returned for this memory attribute depends on the given initiator.
+   * For instance Bandwidth and Latency, but not Capacity.
+   */
+  HWLOC_MEMATTR_FLAG_NEED_INITIATOR = (1UL<<2)
+};
+
+/** \brief Register a new memory attribute.
+ *
+ * Add a specific memory attribute that is not defined in ::hwloc_memattr_id_e.
+ * Flags are a OR'ed set of ::hwloc_memattr_flag_e. It must contain at least
+ * one of ::HWLOC_MEMATTR_FLAG_HIGHER_FIRST or ::HWLOC_MEMATTR_FLAG_LOWER_FIRST.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_register(hwloc_topology_t topology,
+                       const char *name,
+                       unsigned long flags,
+                       hwloc_memattr_id_t *id);
+
+/** \brief Set an attribute value for a specific target NUMA node.
+ *
+ * If the attribute does not relate to a specific initiator
+ * (it does not have the flag ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR),
+ * location \p initiator is ignored and may be \c NULL.
+ *
+ * The initiator will be copied into the topology,
+ * the caller should free anything allocated to store the initiator,
+ * for instance the cpuset.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \note The initiator \p initiator should be of type ::HWLOC_LOCATION_TYPE_CPUSET
+ * when referring to accesses performed by CPU cores.
+ * ::HWLOC_LOCATION_TYPE_OBJECT is currently unused internally by hwloc,
+ * but users may for instance use it to provide custom information about
+ * host memory accesses performed by GPUs.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_set_value(hwloc_topology_t topology,
+                        hwloc_memattr_id_t attribute,
+                        hwloc_obj_t target_node,
+                        struct hwloc_location *initiator,
+                        unsigned long flags,
+                        hwloc_uint64_t value);
+
+/** \brief Return the target NUMA nodes that have some values for a given attribute.
+ *
+ * Return targets for the given attribute in the \p targets array
+ * (for the given initiator if any).
+ * If \p values is not \c NULL, the corresponding attribute values
+ * are stored in the array it points to.
+ *
+ * On input, \p nr points to the number of targets that may be stored
+ * in the array \p targets (and \p values).
+ * On output, \p nr points to the number of targets (and values) that
+ * were actually found, even if some of them couldn't be stored in the array.
+ * Targets that couldn't be stored are ignored, but the function still
+ * returns success (\c 0). The caller may find out by comparing the value pointed
+ * by \p nr before and after the function call.
+ *
+ * The returned targets should not be modified or freed,
+ * they belong to the topology.
+ *
+ * Argument \p initiator is ignored if the attribute does not relate to a specific
+ * initiator (it does not have the flag ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR).
+ * Otherwise \p initiator may be non \c NULL to report only targets
+ * that have a value for that initiator.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * \note This function is meant for tools and debugging (listing internal information)
+ * rather than for application queries. Applications should rather select useful
+ * NUMA nodes with hwloc_get_local_numanode_objs() and then look at their attribute
+ * values.
+ *
+ * \note The initiator \p initiator should be of type ::HWLOC_LOCATION_TYPE_CPUSET
+ * when referring to accesses performed by CPU cores.
+ * ::HWLOC_LOCATION_TYPE_OBJECT is currently unused internally by hwloc,
+ * but users may for instance use it to provide custom information about
+ * host memory accesses performed by GPUs.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_targets(hwloc_topology_t topology,
+                          hwloc_memattr_id_t attribute,
+                          struct hwloc_location *initiator,
+                          unsigned long flags,
+                          unsigned *nr, hwloc_obj_t *targets, hwloc_uint64_t *values);
+
+/** \brief Return the initiators that have values for a given attribute for a specific target NUMA node.
+ *
+ * Return initiators for the given attribute and target node in the
+ * \p initiators array.
+ * If \p values is not \c NULL, the corresponding attribute values
+ * are stored in the array it points to.
+ *
+ * On input, \p nr points to the number of initiators that may be stored
+ * in the array \p initiators (and \p values).
+ * On output, \p nr points to the number of initiators (and values) that
+ * were actually found, even if some of them couldn't be stored in the array.
+ * Initiators that couldn't be stored are ignored, but the function still
+ * returns success (\c 0). The caller may find out by comparing the value pointed
+ * by \p nr before and after the function call.
+ *
+ * The returned initiators should not be modified or freed,
+ * they belong to the topology.
+ *
+ * \p flags must be \c 0 for now.
+ *
+ * If the attribute does not relate to a specific initiator
+ * (it does not have the flag ::HWLOC_MEMATTR_FLAG_NEED_INITIATOR),
+ * no initiator is returned.
+ *
+ * \note This function is meant for tools and debugging (listing internal information)
+ * rather than for application queries. Applications should rather select useful
+ * NUMA nodes with hwloc_get_local_numanode_objs() and then look at their attribute
+ * values for some relevant initiators.
+ */
+HWLOC_DECLSPEC int
+hwloc_memattr_get_initiators(hwloc_topology_t topology,
+                             hwloc_memattr_id_t attribute,
+                             hwloc_obj_t target_node,
+                             unsigned long flags,
+                             unsigned *nr, struct hwloc_location *initiators, hwloc_uint64_t *values);
+/** @} */
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* HWLOC_MEMATTR_H */

src/3rdparty/hwloc/include/hwloc/nvml.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012-2016 Inria.  All rights reserved.
+ * Copyright © 2012-2021 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -36,10 +36,10 @@ extern "C" {
  * @{
  */
 
-/** \brief Get the CPU set of logical processors that are physically
+/** \brief Get the CPU set of processors that are physically
  * close to NVML device \p device.
  *
- * Return the CPU set describing the locality of the NVML device \p device.
+ * Store in \p set the CPU-set describing the locality of the NVML device \p device.
  *
  * Topology \p topology and device \p device must match the local machine.
  * I/O devices detection and the NVML component are not needed in the topology.
@@ -88,8 +88,8 @@ hwloc_nvml_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
 /** \brief Get the hwloc OS device object corresponding to the
  * NVML device whose index is \p idx.
  *
- * Return the OS device object describing the NVML device whose
- * index is \p idx. Returns NULL if there is none.
+ * \return The hwloc OS device object describing the NVML device whose index is \p idx.
+ * \return \c NULL if none could be found.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.
@@ -114,8 +114,8 @@ hwloc_nvml_get_device_osdev_by_index(hwloc_topology_t topology, unsigned idx)
 
 /** \brief Get the hwloc OS device object corresponding to NVML device \p device.
  *
- * Return the hwloc OS device object that describes the given
- * NVML device \p device. Return NULL if there is none.
+ * \return The hwloc OS device object that describes the given NVML device \p device.
+ * \return \c NULL if none could be found.
  *
  * Topology \p topology and device \p device must match the local machine.
  * I/O devices detection and the NVML component must be enabled in the topology.

src/3rdparty/hwloc/include/hwloc/opencl.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012-2019 Inria.  All rights reserved.
+ * Copyright © 2012-2021 Inria.  All rights reserved.
  * Copyright © 2013, 2018 Université Bordeaux.  All right reserved.
  * See COPYING in top-level directory.
  */
@@ -82,9 +82,10 @@ hwloc_opencl_get_device_pci_busid(cl_device_id device,
 	if (CL_SUCCESS == clret
 	    && HWLOC_CL_DEVICE_TOPOLOGY_TYPE_PCIE_AMD == amdtopo.raw.type) {
 		*domain = 0; /* can't do anything better */
-		*bus = (unsigned) amdtopo.pcie.bus;
-		*dev = (unsigned) amdtopo.pcie.device;
-		*func = (unsigned) amdtopo.pcie.function;
+		/* cl_device_topology_amd stores bus ID in cl_char, dont convert those signed char directly to unsigned int */
+		*bus = (unsigned) (unsigned char) amdtopo.pcie.bus;
+		*dev = (unsigned) (unsigned char) amdtopo.pcie.device;
+		*func = (unsigned) (unsigned char) amdtopo.pcie.function;
 		return 0;
 	}
 
@@ -109,10 +110,10 @@ hwloc_opencl_get_device_pci_busid(cl_device_id device,
 	return -1;
 }
 
-/** \brief Get the CPU set of logical processors that are physically
+/** \brief Get the CPU set of processors that are physically
  * close to OpenCL device \p device.
  *
- * Return the CPU set describing the locality of the OpenCL device \p device.
+ * Store in \p set the CPU-set describing the locality of the OpenCL device \p device.
  *
  * Topology \p topology and device \p device must match the local machine.
  * I/O devices detection and the OpenCL component are not needed in the topology.
@@ -161,10 +162,10 @@ hwloc_opencl_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unuse
 /** \brief Get the hwloc OS device object corresponding to the
  * OpenCL device for the given indexes.
  *
- * Return the OS device object describing the OpenCL device
+ * \return The hwloc OS device object describing the OpenCL device
  * whose platform index is \p platform_index,
  * and whose device index within this platform if \p device_index.
- * Return NULL if there is none.
+ * \return \c NULL if there is none.
  *
  * The topology \p topology does not necessarily have to match the current
  * machine. For instance the topology may be an XML import of a remote host.
@@ -191,8 +192,9 @@ hwloc_opencl_get_device_osdev_by_index(hwloc_topology_t topology,
 
 /** \brief Get the hwloc OS device object corresponding to OpenCL device \p deviceX.
  *
- * Use OpenCL device attributes to find the corresponding hwloc OS device object.
- * Return NULL if there is none or if useful attributes are not available.
+ * \return The hwloc OS device object corresponding to the given OpenCL device \p device.
+ * \return \c NULL if none could be found, for instance
+ * if required OpenCL attributes are not available.
  *
  * This function currently only works on AMD and NVIDIA OpenCL devices that support
  * relevant OpenCL extensions. hwloc_opencl_get_device_osdev_by_index()

src/3rdparty/hwloc/include/hwloc/openfabrics-verbs.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2016 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2010 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -41,10 +41,10 @@ extern "C" {
  * @{
  */
 
-/** \brief Get the CPU set of logical processors that are physically
+/** \brief Get the CPU set of processors that are physically
  * close to device \p ibdev.
  *
- * Return the CPU set describing the locality of the OpenFabrics
+ * Store in \p set the CPU-set describing the locality of the OpenFabrics
  * device \p ibdev (InfiniBand, etc).
  *
  * Topology \p topology and device \p ibdev must match the local machine.
@@ -88,10 +88,11 @@ hwloc_ibv_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
 /** \brief Get the hwloc OS device object corresponding to the OpenFabrics
  * device named \p ibname.
  *
- * Return the OS device object describing the OpenFabrics device
+ * \return The hwloc OS device object describing the OpenFabrics device
  * (InfiniBand, Omni-Path, usNIC, etc) whose name is \p ibname
  * (mlx5_0, hfi1_0, usnic_0, qib0, etc).
- * Returns NULL if there is none.
+ * \return \c NULL if none could be found.
+ *
  * The name \p ibname is usually obtained from ibv_get_device_name().
  *
  * The topology \p topology does not necessarily have to match the current
@@ -117,8 +118,9 @@ hwloc_ibv_get_device_osdev_by_name(hwloc_topology_t topology,
 /** \brief Get the hwloc OS device object corresponding to the OpenFabrics
  * device \p ibdev.
  *
- * Return the OS device object describing the OpenFabrics device \p ibdev
- * (InfiniBand, etc). Returns NULL if there is none.
+ * \return The hwloc OS device object describing the OpenFabrics
+ * device \p ibdev (InfiniBand, etc).
+ * \return \c NULL if none could be found.
  *
  * Topology \p topology and device \p ibdev must match the local machine.
  * I/O devices detection must be enabled in the topology.

src/3rdparty/hwloc/include/hwloc/plugins.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013-2020 Inria.  All rights reserved.
+ * Copyright © 2013-2021 Inria.  All rights reserved.
  * Copyright © 2016 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
  */
@@ -27,6 +27,9 @@ struct hwloc_backend;
 
 
 /** \defgroup hwlocality_disc_components Components and Plugins: Discovery components
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
@@ -93,6 +96,9 @@ struct hwloc_disc_component {
 
 
 /** \defgroup hwlocality_disc_backends Components and Plugins: Discovery backends
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
@@ -241,6 +247,9 @@ HWLOC_DECLSPEC int hwloc_backend_enable(struct hwloc_backend *backend);
 
 
 /** \defgroup hwlocality_generic_components Components and Plugins: Generic components
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
@@ -310,10 +319,32 @@ struct hwloc_component {
 
 
 /** \defgroup hwlocality_components_core_funcs Components and Plugins: Core functions to be used by components
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
+/** \brief Check whether error messages are hidden.
+ *
+ * Callers should print critical error messages
+ * (e.g. invalid hw topo info, invalid config)
+ * only if this function returns strictly less than 2.
+ *
+ * Callers should print non-critical error messages
+ * (e.g. failure to initialize CUDA)
+ * if this function returns 0.
+ *
+ * This function return 1 by default (show critical only),
+ * 0 in lstopo (show all),
+ * or anything set in HWLOC_HIDE_ERRORS in the environment.
+ */
+HWLOC_DECLSPEC int hwloc_hide_errors(void);
+
 /** \brief Add an object to the topology.
+ *
+ * Insert new object \p obj in the topology starting under existing object \p root
+ * (if \c NULL, the topology root object is used).
  *
  * It is sorted along the tree of other objects according to the inclusion of
  * cpusets, to eventually be added as a child of the smallest object including
@@ -327,32 +358,20 @@ struct hwloc_component {
  *
  * This shall only be called before levels are built.
  *
- * In case of error, hwloc_report_os_error() is called.
- *
  * The caller should check whether the object type is filtered-out before calling this function.
  *
  * The topology cpuset/nodesets will be enlarged to include the object sets.
  *
+ * \p reason is a unique string identifying where and why this insertion call was performed
+ * (it will be displayed in case of internal insertion error).
+ *
  * Returns the object on success.
  * Returns NULL and frees obj on error.
  * Returns another object and frees obj if it was merged with an identical pre-existing object.
  */
-HWLOC_DECLSPEC struct hwloc_obj *hwloc_insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t obj);
-
-/** \brief Type of error callbacks during object insertion */
-typedef void (*hwloc_report_error_t)(const char * msg, int line);
-/** \brief Report an insertion error from a backend */
-HWLOC_DECLSPEC void hwloc_report_os_error(const char * msg, int line);
-/** \brief Check whether insertion errors are hidden */
-HWLOC_DECLSPEC int hwloc_hide_errors(void);
-
-/** \brief Add an object to the topology and specify which error callback to use.
- *
- * This function is similar to hwloc_insert_object_by_cpuset() but it allows specifying
- * where to start insertion from (if \p root is NULL, the topology root object is used),
- * and specifying the error callback.
- */
-HWLOC_DECLSPEC struct hwloc_obj *hwloc__insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t root, hwloc_obj_t obj, hwloc_report_error_t report_error);
+HWLOC_DECLSPEC hwloc_obj_t
+hwloc__insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t root,
+                               hwloc_obj_t obj, const char *reason);
 
 /** \brief Insert an object somewhere in the topology.
  *
@@ -461,6 +480,9 @@ hwloc_plugin_check_namespace(const char *pluginname __hwloc_attribute_unused, co
 
 
 /** \defgroup hwlocality_components_filtering Components and Plugins: Filtering objects
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
@@ -475,9 +497,11 @@ hwloc_filter_check_pcidev_subtype_important(unsigned classid)
   return (baseclass == 0x03 /* PCI_BASE_CLASS_DISPLAY */
 	  || baseclass == 0x02 /* PCI_BASE_CLASS_NETWORK */
 	  || baseclass == 0x01 /* PCI_BASE_CLASS_STORAGE */
+	  || baseclass == 0x00 /* Unclassified, for Atos/Bull BXI */
 	  || baseclass == 0x0b /* PCI_BASE_CLASS_PROCESSOR */
 	  || classid == 0x0c04 /* PCI_CLASS_SERIAL_FIBER */
 	  || classid == 0x0c06 /* PCI_CLASS_SERIAL_INFINIBAND */
+          || baseclass == 0x06 /* PCI_BASE_CLASS_BRIDGE with non-PCI downstream. the core will drop the useless ones later */
 	  || baseclass == 0x12 /* Processing Accelerators */);
 }
 
@@ -533,6 +557,9 @@ hwloc_filter_check_keep_object(hwloc_topology_t topology, hwloc_obj_t obj)
 
 
 /** \defgroup hwlocality_components_pcidisc Components and Plugins: helpers for PCI discovery
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
@@ -584,18 +611,76 @@ HWLOC_DECLSPEC int hwloc_pcidisc_tree_attach(struct hwloc_topology *topology, st
 
 
 /** \defgroup hwlocality_components_pcifind Components and Plugins: finding PCI objects during other discoveries
+ *
+ * \note These structures and functions may change when ::HWLOC_COMPONENT_ABI is modified.
+ *
  * @{
  */
 
-/** \brief Find the normal parent of a PCI bus ID.
+/** \brief Find the object or a parent of a PCI bus ID.
  *
- * Look at PCI affinity to find out where the given PCI bus ID should be attached.
+ * When attaching a new object (typically an OS device) whose locality
+ * is specified by PCI bus ID, this function returns the PCI object
+ * to use as a parent for attaching.
  *
- * This function should be used to attach an I/O device under the corresponding
- * PCI object (if any), or under a normal (non-I/O) object with same locality.
+ * If the exact PCI device with this bus ID exists, it is returned.
+ * Otherwise (for instance if it was filtered out), the function returns
+ * another object with similar locality (for instance a parent bridge,
+ * or the local CPU Package).
  */
 HWLOC_DECLSPEC struct hwloc_obj * hwloc_pci_find_parent_by_busid(struct hwloc_topology *topology, unsigned domain, unsigned bus, unsigned dev, unsigned func);
 
+/** \brief Find the PCI device or bridge matching a PCI bus ID exactly.
+ *
+ * This is useful for adding specific information about some objects
+ * based on their PCI id. When it comes to attaching objects based on
+ * PCI locality, hwloc_pci_find_parent_by_busid() should be preferred.
+ */
+HWLOC_DECLSPEC struct hwloc_obj * hwloc_pci_find_by_busid(struct hwloc_topology *topology, unsigned domain, unsigned bus, unsigned dev, unsigned func);
+
+/** \brief Handle to a new distances structure during its addition to the topology. */
+typedef void * hwloc_backend_distances_add_handle_t;
+
+/** \brief Create a new empty distances structure.
+ *
+ * This is identical to hwloc_distances_add_create()
+ * but this variant is designed for backend inserting
+ * distances during topology discovery.
+ */
+HWLOC_DECLSPEC hwloc_backend_distances_add_handle_t
+hwloc_backend_distances_add_create(hwloc_topology_t topology,
+                                   const char *name, unsigned long kind,
+                                   unsigned long flags);
+
+/** \brief Specify the objects and values in a new empty distances structure.
+ *
+ * This is similar to hwloc_distances_add_values()
+ * but this variant is designed for backend inserting
+ * distances during topology discovery.
+ *
+ * The only semantical difference is that \p objs and \p values
+ * are not duplicated, but directly attached to the topology.
+ * On success, these arrays are given to the core and should not
+ * ever be freed by the caller anymore.
+ */
+HWLOC_DECLSPEC int
+hwloc_backend_distances_add_values(hwloc_topology_t topology,
+                                   hwloc_backend_distances_add_handle_t handle,
+                                   unsigned nbobjs, hwloc_obj_t *objs,
+                                   hwloc_uint64_t *values,
+                                   unsigned long flags);
+
+/** \brief Commit a new distances structure.
+ *
+ * This is similar to hwloc_distances_add_commit()
+ * but this variant is designed for backend inserting
+ * distances during topology discovery.
+ */
+HWLOC_DECLSPEC int
+hwloc_backend_distances_add_commit(hwloc_topology_t topology,
+                                   hwloc_backend_distances_add_handle_t handle,
+                                   unsigned long flags);
+
 /** @} */
 
 

src/3rdparty/hwloc/include/hwloc/rename.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
- * Copyright © 2010-2019 Inria.  All rights reserved.
+ * Copyright © 2010-2021 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -119,6 +119,10 @@ extern "C" {
 #define HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED HWLOC_NAME_CAPS(TOPOLOGY_FLAG_WITH_DISALLOWED)
 #define HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM HWLOC_NAME_CAPS(TOPOLOGY_FLAG_IS_THISSYSTEM)
 #define HWLOC_TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES HWLOC_NAME_CAPS(TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES)
+#define HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT HWLOC_NAME_CAPS(TOPOLOGY_FLAG_IMPORT_SUPPORT)
+#define HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING HWLOC_NAME_CAPS(TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING)
+#define HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING HWLOC_NAME_CAPS(TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING)
+#define HWLOC_TOPOLOGY_FLAG_DONT_CHANGE_BINDING HWLOC_NAME_CAPS(TOPOLOGY_FLAG_DONT_CHANGE_BINDING)
 
 #define hwloc_topology_set_pid HWLOC_NAME(topology_set_pid)
 #define hwloc_topology_set_synthetic HWLOC_NAME(topology_set_synthetic)
@@ -134,6 +138,7 @@ extern "C" {
 #define hwloc_topology_discovery_support HWLOC_NAME(topology_discovery_support)
 #define hwloc_topology_cpubind_support HWLOC_NAME(topology_cpubind_support)
 #define hwloc_topology_membind_support HWLOC_NAME(topology_membind_support)
+#define hwloc_topology_misc_support HWLOC_NAME(topology_misc_support)
 #define hwloc_topology_support HWLOC_NAME(topology_support)
 #define hwloc_topology_get_support HWLOC_NAME(topology_get_support)
 
@@ -170,6 +175,7 @@ extern "C" {
 #define hwloc_topology_alloc_group_object HWLOC_NAME(topology_alloc_group_object)
 #define hwloc_topology_insert_group_object HWLOC_NAME(topology_insert_group_object)
 #define hwloc_obj_add_other_obj_sets HWLOC_NAME(obj_add_other_obj_sets)
+#define hwloc_topology_refresh HWLOC_NAME(topology_refresh)
 
 #define hwloc_topology_get_depth HWLOC_NAME(topology_get_depth)
 #define hwloc_get_type_depth HWLOC_NAME(get_type_depth)
@@ -353,6 +359,7 @@ extern "C" {
 #define hwloc_get_closest_objs HWLOC_NAME(get_closest_objs)
 #define hwloc_get_obj_below_by_type HWLOC_NAME(get_obj_below_by_type)
 #define hwloc_get_obj_below_array_by_type HWLOC_NAME(get_obj_below_array_by_type)
+#define hwloc_get_obj_with_same_locality HWLOC_NAME(get_obj_with_same_locality)
 #define hwloc_distrib_flags_e HWLOC_NAME(distrib_flags_e)
 #define HWLOC_DISTRIB_FLAG_REVERSE HWLOC_NAME_CAPS(DISTRIB_FLAG_REVERSE)
 #define hwloc_distrib HWLOC_NAME(distrib)
@@ -367,6 +374,51 @@ extern "C" {
 #define hwloc_cpuset_to_nodeset HWLOC_NAME(cpuset_to_nodeset)
 #define hwloc_cpuset_from_nodeset HWLOC_NAME(cpuset_from_nodeset)
 
+/* memattrs.h */
+
+#define hwloc_memattr_id_e HWLOC_NAME(memattr_id_e)
+#define HWLOC_MEMATTR_ID_CAPACITY HWLOC_NAME_CAPS(MEMATTR_ID_CAPACITY)
+#define HWLOC_MEMATTR_ID_LOCALITY HWLOC_NAME_CAPS(MEMATTR_ID_LOCALITY)
+#define HWLOC_MEMATTR_ID_BANDWIDTH HWLOC_NAME_CAPS(MEMATTR_ID_BANDWIDTH)
+#define HWLOC_MEMATTR_ID_LATENCY HWLOC_NAME_CAPS(MEMATTR_ID_LATENCY)
+
+#define hwloc_memattr_id_t HWLOC_NAME(memattr_id_t)
+#define hwloc_memattr_get_by_name HWLOC_NAME(memattr_get_by_name)
+
+#define hwloc_location HWLOC_NAME(location)
+#define hwloc_location_type_e HWLOC_NAME(location_type_e)
+#define HWLOC_LOCATION_TYPE_OBJECT HWLOC_NAME_CAPS(LOCATION_TYPE_OBJECT)
+#define HWLOC_LOCATION_TYPE_CPUSET HWLOC_NAME_CAPS(LOCATION_TYPE_CPUSET)
+#define hwloc_location_u HWLOC_NAME(location_u)
+
+#define hwloc_memattr_get_value HWLOC_NAME(memattr_get_value)
+#define hwloc_memattr_get_best_target HWLOC_NAME(memattr_get_best_target)
+#define hwloc_memattr_get_best_initiator HWLOC_NAME(memattr_get_best_initiator)
+
+#define hwloc_local_numanode_flag_e HWLOC_NAME(local_numanode_flag_e)
+#define HWLOC_LOCAL_NUMANODE_FLAG_LARGER_LOCALITY HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_LARGER_LOCALITY)
+#define HWLOC_LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_SMALLER_LOCALITY)
+#define HWLOC_LOCAL_NUMANODE_FLAG_ALL HWLOC_NAME_CAPS(LOCAL_NUMANODE_FLAG_ALL)
+#define hwloc_get_local_numanode_objs HWLOC_NAME(get_local_numanode_objs)
+
+#define hwloc_memattr_get_name HWLOC_NAME(memattr_get_name)
+#define hwloc_memattr_get_flags HWLOC_NAME(memattr_get_flags)
+#define hwloc_memattr_flag_e HWLOC_NAME(memattr_flag_e)
+#define HWLOC_MEMATTR_FLAG_HIGHER_FIRST HWLOC_NAME_CAPS(MEMATTR_FLAG_HIGHER_FIRST)
+#define HWLOC_MEMATTR_FLAG_LOWER_FIRST HWLOC_NAME_CAPS(MEMATTR_FLAG_LOWER_FIRST)
+#define HWLOC_MEMATTR_FLAG_NEED_INITIATOR HWLOC_NAME_CAPS(MEMATTR_FLAG_NEED_INITIATOR)
+#define hwloc_memattr_register HWLOC_NAME(memattr_register)
+#define hwloc_memattr_set_value HWLOC_NAME(memattr_set_value)
+#define hwloc_memattr_get_targets HWLOC_NAME(memattr_get_targets)
+#define hwloc_memattr_get_initiators HWLOC_NAME(memattr_get_initiators)
+
+/* cpukinds.h */
+
+#define hwloc_cpukinds_get_nr HWLOC_NAME(cpukinds_get_nr)
+#define hwloc_cpukinds_get_by_cpuset HWLOC_NAME(cpukinds_get_by_cpuset)
+#define hwloc_cpukinds_get_info HWLOC_NAME(cpukinds_get_info)
+#define hwloc_cpukinds_register HWLOC_NAME(cpukinds_register)
+
 /* export.h */
 
 #define hwloc_topology_export_xml_flags_e HWLOC_NAME(topology_export_xml_flags_e)
@@ -406,11 +458,22 @@ extern "C" {
 #define hwloc_distances_obj_index HWLOC_NAME(distances_obj_index)
 #define hwloc_distances_obj_pair_values HWLOC_NAME(distances_pair_values)
 
+#define hwloc_distances_transform_e HWLOC_NAME(distances_transform_e)
+#define HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL HWLOC_NAME_CAPS(DISTANCES_TRANSFORM_REMOVE_NULL)
+#define HWLOC_DISTANCES_TRANSFORM_LINKS HWLOC_NAME_CAPS(DISTANCES_TRANSFORM_LINKS)
+#define HWLOC_DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS HWLOC_NAME_CAPS(DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS)
+#define HWLOC_DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE HWLOC_NAME_CAPS(DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE)
+#define hwloc_distances_transform HWLOC_NAME(distances_transform)
+
 #define hwloc_distances_add_flag_e HWLOC_NAME(distances_add_flag_e)
 #define HWLOC_DISTANCES_ADD_FLAG_GROUP HWLOC_NAME_CAPS(DISTANCES_ADD_FLAG_GROUP)
 #define HWLOC_DISTANCES_ADD_FLAG_GROUP_INACCURATE HWLOC_NAME_CAPS(DISTANCES_ADD_FLAG_GROUP_INACCURATE)
 
-#define hwloc_distances_add HWLOC_NAME(distances_add)
+#define hwloc_distances_add_handle_t HWLOC_NAME(distances_add_handle_t)
+#define hwloc_distances_add_create HWLOC_NAME(distances_add_create)
+#define hwloc_distances_add_values HWLOC_NAME(distances_add_values)
+#define hwloc_distances_add_commit HWLOC_NAME(distances_add_commit)
+
 #define hwloc_distances_remove HWLOC_NAME(distances_remove)
 #define hwloc_distances_remove_by_depth HWLOC_NAME(distances_remove_by_depth)
 #define hwloc_distances_remove_by_type HWLOC_NAME(distances_remove_by_type)
@@ -475,6 +538,11 @@ extern "C" {
 #define hwloc_linux_get_tid_last_cpu_location HWLOC_NAME(linux_get_tid_last_cpu_location)
 #define hwloc_linux_read_path_as_cpumask HWLOC_NAME(linux_read_file_cpumask)
 
+/* windows.h */
+
+#define hwloc_windows_get_nr_processor_groups HWLOC_NAME(windows_get_nr_processor_groups)
+#define hwloc_windows_get_processor_group_cpuset HWLOC_NAME(windows_get_processor_group_cpuset)
+
 /* openfabrics-verbs.h */
 
 #define hwloc_ibv_get_device_cpuset HWLOC_NAME(ibv_get_device_cpuset)
@@ -510,6 +578,17 @@ extern "C" {
 #define hwloc_nvml_get_device_osdev HWLOC_NAME(nvml_get_device_osdev)
 #define hwloc_nvml_get_device_osdev_by_index HWLOC_NAME(nvml_get_device_osdev_by_index)
 
+/* rsmi.h */
+
+#define hwloc_rsmi_get_device_cpuset HWLOC_NAME(rsmi_get_device_cpuset)
+#define hwloc_rsmi_get_device_osdev HWLOC_NAME(rsmi_get_device_osdev)
+#define hwloc_rsmi_get_device_osdev_by_index HWLOC_NAME(rsmi_get_device_osdev_by_index)
+
+/* levelzero.h */
+
+#define hwloc_levelzero_get_device_cpuset HWLOC_NAME(levelzero_get_device_cpuset)
+#define hwloc_levelzero_get_device_osdev HWLOC_NAME(levelzero_get_device_osdev)
+
 /* gl.h */
 
 #define hwloc_gl_get_display_osdev_by_port_device HWLOC_NAME(gl_get_display_osdev_by_port_device)
@@ -547,9 +626,6 @@ extern "C" {
 
 #define hwloc_plugin_check_namespace HWLOC_NAME(plugin_check_namespace)
 
-#define hwloc_insert_object_by_cpuset HWLOC_NAME(insert_object_by_cpuset)
-#define hwloc_report_error_t HWLOC_NAME(report_error_t)
-#define hwloc_report_os_error HWLOC_NAME(report_os_error)
 #define hwloc_hide_errors HWLOC_NAME(hide_errors)
 #define hwloc__insert_object_by_cpuset HWLOC_NAME(_insert_object_by_cpuset)
 #define hwloc_insert_object_by_parent HWLOC_NAME(insert_object_by_parent)
@@ -569,10 +645,18 @@ extern "C" {
 #define hwloc_pcidisc_tree_insert_by_busid HWLOC_NAME(pcidisc_tree_insert_by_busid)
 #define hwloc_pcidisc_tree_attach HWLOC_NAME(pcidisc_tree_attach)
 
+#define hwloc_pci_find_by_busid HWLOC_NAME(pcidisc_find_by_busid)
 #define hwloc_pci_find_parent_by_busid HWLOC_NAME(pcidisc_find_busid_parent)
 
+#define hwloc_backend_distances_add_handle_t HWLOC_NAME(backend_distances_add_handle_t)
+#define hwloc_backend_distances_add_create HWLOC_NAME(backend_distances_add_create)
+#define hwloc_backend_distances_add_values HWLOC_NAME(backend_distances_add_values)
+#define hwloc_backend_distances_add_commit HWLOC_NAME(backend_distances_add_commit)
+
 /* hwloc/deprecated.h */
 
+#define hwloc_distances_add HWLOC_NAME(distances_add)
+
 #define hwloc_topology_insert_misc_object_by_parent HWLOC_NAME(topology_insert_misc_object_by_parent)
 #define hwloc_obj_cpuset_snprintf HWLOC_NAME(obj_cpuset_snprintf)
 #define hwloc_obj_type_sscanf HWLOC_NAME(obj_type_sscanf)
@@ -682,7 +766,9 @@ extern "C" {
 
 #define hwloc_cuda_component HWLOC_NAME(cuda_component)
 #define hwloc_gl_component HWLOC_NAME(gl_component)
+#define hwloc_levelzero_component HWLOC_NAME(levelzero_component)
 #define hwloc_nvml_component HWLOC_NAME(nvml_component)
+#define hwloc_rsmi_component HWLOC_NAME(rsmi_component)
 #define hwloc_opencl_component HWLOC_NAME(opencl_component)
 #define hwloc_pci_component HWLOC_NAME(pci_component)
 
@@ -691,6 +777,8 @@ extern "C" {
 
 /* private/private.h */
 
+#define hwloc_internal_location_s HWLOC_NAME(internal_location_s)
+
 #define hwloc_special_level_s HWLOC_NAME(special_level_s)
 
 #define hwloc_pci_forced_locality_s HWLOC_NAME(pci_forced_locality_s)
@@ -713,16 +801,18 @@ extern "C" {
 
 #define hwloc__attach_memory_object HWLOC_NAME(insert_memory_object)
 
+#define hwloc_get_obj_by_type_and_gp_index HWLOC_NAME(get_obj_by_type_and_gp_index)
+
 #define hwloc_pci_discovery_init HWLOC_NAME(pci_discovery_init)
 #define hwloc_pci_discovery_prepare HWLOC_NAME(pci_discovery_prepare)
 #define hwloc_pci_discovery_exit HWLOC_NAME(pci_discovery_exit)
-#define hwloc_pci_find_by_busid HWLOC_NAME(pcidisc_find_by_busid)
 #define hwloc_find_insert_io_parent_by_complete_cpuset HWLOC_NAME(hwloc_find_insert_io_parent_by_complete_cpuset)
 
 #define hwloc__add_info HWLOC_NAME(_add_info)
 #define hwloc__add_info_nodup HWLOC_NAME(_add_info_nodup)
 #define hwloc__move_infos HWLOC_NAME(_move_infos)
 #define hwloc__free_infos HWLOC_NAME(_free_infos)
+#define hwloc__tma_dup_infos HWLOC_NAME(_tma_dup_infos)
 
 #define hwloc_binding_hooks HWLOC_NAME(binding_hooks)
 #define hwloc_set_native_binding_hooks HWLOC_NAME(set_native_binding_hooks)
@@ -759,11 +849,28 @@ extern "C" {
 #define hwloc_internal_distances_dup HWLOC_NAME(internal_distances_dup)
 #define hwloc_internal_distances_refresh HWLOC_NAME(internal_distances_refresh)
 #define hwloc_internal_distances_destroy HWLOC_NAME(internal_distances_destroy)
-
 #define hwloc_internal_distances_add HWLOC_NAME(internal_distances_add)
 #define hwloc_internal_distances_add_by_index HWLOC_NAME(internal_distances_add_by_index)
 #define hwloc_internal_distances_invalidate_cached_objs HWLOC_NAME(hwloc_internal_distances_invalidate_cached_objs)
 
+#define hwloc_internal_memattr_s HWLOC_NAME(internal_memattr_s)
+#define hwloc_internal_memattr_target_s HWLOC_NAME(internal_memattr_target_s)
+#define hwloc_internal_memattr_initiator_s HWLOC_NAME(internal_memattr_initiator_s)
+#define hwloc_internal_memattrs_init HWLOC_NAME(internal_memattrs_init)
+#define hwloc_internal_memattrs_prepare HWLOC_NAME(internal_memattrs_prepare)
+#define hwloc_internal_memattrs_dup HWLOC_NAME(internal_memattrs_dup)
+#define hwloc_internal_memattrs_destroy HWLOC_NAME(internal_memattrs_destroy)
+#define hwloc_internal_memattrs_need_refresh HWLOC_NAME(internal_memattrs_need_refresh)
+#define hwloc_internal_memattrs_refresh HWLOC_NAME(internal_memattrs_refresh)
+
+#define hwloc_internal_cpukind_s HWLOC_NAME(internal_cpukind_s)
+#define hwloc_internal_cpukinds_init HWLOC_NAME(internal_cpukinds_init)
+#define hwloc_internal_cpukinds_destroy HWLOC_NAME(internal_cpukinds_destroy)
+#define hwloc_internal_cpukinds_dup HWLOC_NAME(internal_cpukinds_dup)
+#define hwloc_internal_cpukinds_register HWLOC_NAME(internal_cpukinds_register)
+#define hwloc_internal_cpukinds_rank HWLOC_NAME(internal_cpukinds_rank)
+#define hwloc_internal_cpukinds_restrict HWLOC_NAME(internal_cpukinds_restrict)
+
 #define hwloc_encode_to_base64 HWLOC_NAME(encode_to_base64)
 #define hwloc_decode_from_base64 HWLOC_NAME(decode_from_base64)
 

src/3rdparty/hwloc/include/hwloc/rsmi.h

@@ -0,0 +1,203 @@
+/*
+ * Copyright © 2012-2021 Inria.  All rights reserved.
+ * Copyright (c) 2020, Advanced Micro Devices, Inc. All rights reserved.
+ * Written by Advanced Micro Devices,
+ * See COPYING in top-level directory.
+ */
+
+/** \file
+ * \brief Macros to help interaction between hwloc and the ROCm SMI Management Library.
+ *
+ * Applications that use both hwloc and the ROCm SMI Management Library may want to
+ * include this file so as to get topology information for AMD GPU devices.
+ */
+
+#ifndef HWLOC_RSMI_H
+#define HWLOC_RSMI_H
+
+#include "hwloc.h"
+#include "hwloc/autogen/config.h"
+#include "hwloc/helper.h"
+#ifdef HWLOC_LINUX_SYS
+#include "hwloc/linux.h"
+#endif
+
+#include <rocm_smi/rocm_smi.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** \defgroup hwlocality_rsmi Interoperability with the ROCm SMI Management Library
+ *
+ * This interface offers ways to retrieve topology information about
+ * devices managed by the ROCm SMI Management Library.
+ *
+ * @{
+ */
+
+/** \brief Get the CPU set of logical processors that are physically
+ * close to AMD GPU device whose index is \p dv_ind.
+ *
+ * Store in \p set the CPU-set describing the locality of the AMD GPU device
+ * whose index is \p dv_ind.
+ *
+ * Topology \p topology and device \p dv_ind must match the local machine.
+ * I/O devices detection and the ROCm SMI component are not needed in the
+ * topology.
+ *
+ * The function only returns the locality of the device.
+ * If more information about the device is needed, OS objects should
+ * be used instead, see hwloc_rsmi_get_device_osdev()
+ * and hwloc_rsmi_get_device_osdev_by_index().
+ *
+ * This function is currently only implemented in a meaningful way for
+ * Linux; other systems will simply get a full cpuset.
+ */
+static __hwloc_inline int
+hwloc_rsmi_get_device_cpuset(hwloc_topology_t topology __hwloc_attribute_unused,
+                             uint32_t dv_ind, hwloc_cpuset_t set)
+{
+#ifdef HWLOC_LINUX_SYS
+  /* If we're on Linux, use the sysfs mechanism to get the local cpus */
+#define HWLOC_RSMI_DEVICE_SYSFS_PATH_MAX 128
+  char path[HWLOC_RSMI_DEVICE_SYSFS_PATH_MAX];
+  rsmi_status_t ret;
+  uint64_t bdfid = 0;
+  unsigned domain, device, bus;
+
+  if (!hwloc_topology_is_thissystem(topology)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  ret = rsmi_dev_pci_id_get(dv_ind, &bdfid);
+  if (RSMI_STATUS_SUCCESS != ret) {
+    errno = EINVAL;
+    return -1;
+  }
+  domain = (bdfid>>32) & 0xffffffff;
+  bus = ((bdfid & 0xffff)>>8) & 0xff;
+  device = ((bdfid & 0xff)>>3) & 0x1f;
+
+  sprintf(path, "/sys/bus/pci/devices/%04x:%02x:%02x.0/local_cpus", domain, bus, device);
+  if (hwloc_linux_read_path_as_cpumask(path, set) < 0
+      || hwloc_bitmap_iszero(set))
+    hwloc_bitmap_copy(set, hwloc_topology_get_complete_cpuset(topology));
+#else
+  /* Non-Linux systems simply get a full cpuset */
+  hwloc_bitmap_copy(set, hwloc_topology_get_complete_cpuset(topology));
+#endif
+  return 0;
+}
+
+/** \brief Get the hwloc OS device object corresponding to the
+ * AMD GPU device whose index is \p dv_ind.
+ *
+ * \return The hwloc OS device object describing the AMD GPU device whose
+ * index is \p dv_ind.
+ * \return \c NULL if none could be found.
+ *
+ * The topology \p topology does not necessarily have to match the current
+ * machine. For instance the topology may be an XML import of a remote host.
+ * I/O devices detection and the ROCm SMI component must be enabled in the
+ * topology.
+ *
+ * \note The corresponding PCI device object can be obtained by looking
+ * at the OS device parent object (unless PCI devices are filtered out).
+ */
+static __hwloc_inline hwloc_obj_t
+hwloc_rsmi_get_device_osdev_by_index(hwloc_topology_t topology, uint32_t dv_ind)
+{
+  hwloc_obj_t osdev = NULL;
+  while ((osdev = hwloc_get_next_osdev(topology, osdev)) != NULL) {
+    if (HWLOC_OBJ_OSDEV_GPU == osdev->attr->osdev.type
+      && osdev->name
+      && !strncmp("rsmi", osdev->name, 4)
+      && atoi(osdev->name + 4) == (int) dv_ind)
+      return osdev;
+  }
+  return NULL;
+}
+
+/** \brief Get the hwloc OS device object corresponding to AMD GPU device,
+ * whose index is \p dv_ind.
+ *
+ * \return The hwloc OS device object that describes the given
+ * AMD GPU, whose index is \p dv_ind.
+ * \return \c NULL if none could be found.
+ *
+ * Topology \p topology and device \p dv_ind must match the local machine.
+ * I/O devices detection and the ROCm SMI component must be enabled in the
+ * topology. If not, the locality of the object may still be found using
+ * hwloc_rsmi_get_device_cpuset().
+ *
+ * \note The corresponding hwloc PCI device may be found by looking
+ * at the result parent pointer (unless PCI devices are filtered out).
+ */
+static __hwloc_inline hwloc_obj_t
+hwloc_rsmi_get_device_osdev(hwloc_topology_t topology, uint32_t dv_ind)
+{
+  hwloc_obj_t osdev;
+  rsmi_status_t ret;
+  uint64_t bdfid = 0;
+  unsigned domain, device, bus, func;
+  uint64_t id;
+  char uuid[64];
+
+  if (!hwloc_topology_is_thissystem(topology)) {
+    errno = EINVAL;
+    return NULL;
+  }
+
+  ret = rsmi_dev_pci_id_get(dv_ind, &bdfid);
+  if (RSMI_STATUS_SUCCESS != ret) {
+    errno = EINVAL;
+    return NULL;
+  }
+  domain = (bdfid>>32) & 0xffffffff;
+  bus = ((bdfid & 0xffff)>>8) & 0xff;
+  device = ((bdfid & 0xff)>>3) & 0x1f;
+  func = bdfid & 0x7;
+
+  ret = rsmi_dev_unique_id_get(dv_ind, &id);
+  if (RSMI_STATUS_SUCCESS != ret)
+    uuid[0] = '\0';
+  else
+    sprintf(uuid, "%lx", id);
+
+  osdev = NULL;
+  while ((osdev = hwloc_get_next_osdev(topology, osdev)) != NULL) {
+    hwloc_obj_t pcidev = osdev->parent;
+    const char *info;
+
+    if (strncmp(osdev->name, "rsmi", 4))
+      continue;
+
+    if (pcidev
+      && pcidev->type == HWLOC_OBJ_PCI_DEVICE
+      && pcidev->attr->pcidev.domain == domain
+      && pcidev->attr->pcidev.bus == bus
+      && pcidev->attr->pcidev.dev == device
+      && pcidev->attr->pcidev.func == func)
+      return osdev;
+
+    info = hwloc_obj_get_info_by_name(osdev, "AMDUUID");
+    if (info && !strcmp(info, uuid))
+      return osdev;
+  }
+
+  return NULL;
+}
+
+/** @} */
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* HWLOC_RSMI_H */

src/3rdparty/hwloc/include/hwloc/windows.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright © 2021 Inria.  All rights reserved.
+ * See COPYING in top-level directory.
+ */
+
+/** \file
+ * \brief Macros to help interaction between hwloc and Windows.
+ *
+ * Applications that use hwloc on Windows may want to include this file
+ * for Windows specific hwloc features.
+ */
+
+#ifndef HWLOC_WINDOWS_H
+#define HWLOC_WINDOWS_H
+
+#include "hwloc.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** \defgroup hwlocality_windows Windows-specific helpers
+ *
+ * These functions query Windows processor groups.
+ * These groups partition the operating system into virtual sets
+ * of up to 64 neighbor PUs.
+ * Threads and processes may only be bound inside a single group.
+ * Although Windows processor groups may be exposed in the hwloc
+ * hierarchy as hwloc Groups, they are also often merged into
+ * existing hwloc objects such as NUMA nodes or Packages.
+ * This API provides explicit information about Windows processor
+ * groups so that applications know whether binding to a large
+ * set of PUs may fail because it spans over multiple Windows
+ * processor groups.
+ *
+ * @{
+ */
+
+
+/** \brief Get the number of Windows processor groups
+ *
+ * \p flags must be 0 for now.
+ *
+ * \return at least \c 1 on success.
+ * \return -1 on error, for instance if the topology does not match
+ * the current system (e.g. loaded from another machine through XML).
+ */
+HWLOC_DECLSPEC int hwloc_windows_get_nr_processor_groups(hwloc_topology_t topology, unsigned long flags);
+
+/** \brief Get the CPU-set of a Windows processor group.
+ *
+ * Get the set of PU included in the processor group specified
+ * by \p pg_index.
+ * \p pg_index must be between \c 0 and the value returned
+ * by hwloc_windows_get_nr_processor_groups() minus 1.
+ *
+ * \p flags must be 0 for now.
+ *
+ * \return \c 0 on success.
+ * \return \c -1 on error, for instance if \p pg_index is invalid,
+ * or if the topology does not match the current system (e.g. loaded
+ * from another machine through XML).
+ */
+HWLOC_DECLSPEC int hwloc_windows_get_processor_group_cpuset(hwloc_topology_t topology, unsigned pg_index, hwloc_cpuset_t cpuset, unsigned long flags);
+
+/** @} */
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif
+
+
+#endif /* HWLOC_WINDOWS_H */

src/3rdparty/hwloc/include/private/autogen/config.h

@@ -1,8 +1,8 @@
 /*
  * Copyright © 2009, 2011, 2012 CNRS.  All rights reserved.
- * Copyright © 2009-2018 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009, 2011, 2012, 2015 Université Bordeaux.  All rights reserved.
- * Copyright © 2009 Cisco Systems, Inc.  All rights reserved.
+ * Copyright © 2009-2020 Cisco Systems, Inc.  All rights reserved.
  * $COPYRIGHT$
  *
  * Additional copyrights may follow
@@ -290,10 +290,6 @@
 /* Define to '1' if sysctlbyname is present and usable */
 /* #undef HAVE_SYSCTLBYNAME */
 
-/* Define to 1 if the system has the type
-   `SYSTEM_LOGICAL_PROCESSOR_INFORMATION'. */
-#define HAVE_SYSTEM_LOGICAL_PROCESSOR_INFORMATION 1
-
 /* Define to 1 if the system has the type
    `SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX'. */
 #define HAVE_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX 1
@@ -575,7 +571,7 @@
 #define PACKAGE "hwloc"
 
 /* Define to the address where bug reports for this package should be sent. */
-#define PACKAGE_BUGREPORT "http://www.open-mpi.org/projects/hwloc/"
+#define PACKAGE_BUGREPORT "https://www.open-mpi.org/projects/hwloc/"
 
 /* Define to the full name of this package. */
 #define PACKAGE_NAME "hwloc"
@@ -668,5 +664,9 @@
 /* Define this to the thread ID type */
 #define hwloc_thread_t HANDLE
 
+/* Define to 1 if you have the declaration of `GetModuleFileName', and to 0 if
+   you don't. */
+#define HAVE_DECL_GETMODULEFILENAME 1
+
 
 #endif /* HWLOC_CONFIGURE_H */

src/3rdparty/hwloc/include/private/debug.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2017 Inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009, 2011 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -19,6 +19,10 @@
 #include <stdio.h>
 #endif
 
+#ifdef ANDROID
+extern void JNIDebug(char *text);
+#endif
+
 /* Compile-time assertion */
 #define HWLOC_BUILD_ASSERT(condition) ((void)sizeof(char[1 - 2*!(condition)]))
 
@@ -44,9 +48,17 @@ static __hwloc_inline void hwloc_debug(const char *s __hwloc_attribute_unused, .
 {
 #ifdef HWLOC_DEBUG
   if (hwloc_debug_enabled()) {
+#ifdef ANDROID
+    char buffer[256];
+#endif
     va_list ap;
     va_start(ap, s);
+#ifdef ANDROID
+    vsprintf(buffer, s, ap);
+    JNIDebug(buffer);
+#else
     vfprintf(stderr, s, ap);
+#endif
     va_end(ap);
   }
 #endif
@@ -57,21 +69,21 @@ static __hwloc_inline void hwloc_debug(const char *s __hwloc_attribute_unused, .
 if (hwloc_debug_enabled()) { \
   char *s; \
   hwloc_bitmap_asprintf(&s, bitmap); \
-  fprintf(stderr, fmt, s); \
+  hwloc_debug(fmt, s); \
   free(s); \
 } } while (0)
 #define hwloc_debug_1arg_bitmap(fmt, arg1, bitmap) do { \
 if (hwloc_debug_enabled()) { \
   char *s; \
   hwloc_bitmap_asprintf(&s, bitmap); \
-  fprintf(stderr, fmt, arg1, s); \
+  hwloc_debug(fmt, arg1, s); \
   free(s); \
 } } while (0)
 #define hwloc_debug_2args_bitmap(fmt, arg1, arg2, bitmap) do { \
 if (hwloc_debug_enabled()) { \
   char *s; \
   hwloc_bitmap_asprintf(&s, bitmap); \
-  fprintf(stderr, fmt, arg1, arg2, s); \
+  hwloc_debug(fmt, arg1, arg2, s); \
   free(s); \
 } } while (0)
 #else

src/3rdparty/hwloc/include/private/internal-components.h

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2018-2019 Inria.  All rights reserved.
+ * Copyright © 2018-2020 Inria.  All rights reserved.
  *
  * See COPYING in top-level directory.
  */
@@ -30,6 +30,8 @@ HWLOC_DECLSPEC extern const struct hwloc_component hwloc_x86_component;
 HWLOC_DECLSPEC extern const struct hwloc_component hwloc_cuda_component;
 HWLOC_DECLSPEC extern const struct hwloc_component hwloc_gl_component;
 HWLOC_DECLSPEC extern const struct hwloc_component hwloc_nvml_component;
+HWLOC_DECLSPEC extern const struct hwloc_component hwloc_rsmi_component;
+HWLOC_DECLSPEC extern const struct hwloc_component hwloc_levelzero_component;
 HWLOC_DECLSPEC extern const struct hwloc_component hwloc_opencl_component;
 HWLOC_DECLSPEC extern const struct hwloc_component hwloc_pci_component;
 

src/3rdparty/hwloc/include/private/misc.h

@@ -504,7 +504,7 @@ hwloc__obj_type_is_icache(hwloc_obj_type_t type)
   }                                    \
 } while(0)
 #else /* HAVE_USELOCALE */
-#if __HWLOC_HAVE_ATTRIBUTE_UNUSED
+#if HWLOC_HAVE_ATTRIBUTE_UNUSED
 #define hwloc_localeswitch_declare int __dummy_nolocale __hwloc_attribute_unused
 #define hwloc_localeswitch_init()
 #else

src/3rdparty/hwloc/include/private/private.h

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009      CNRS
- * Copyright © 2009-2019 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012, 2020 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  *
@@ -40,7 +40,19 @@
 #endif
 #include <string.h>
 
-#define HWLOC_TOPOLOGY_ABI 0x20100 /* version of the layout of struct topology */
+#define HWLOC_TOPOLOGY_ABI 0x20400 /* version of the layout of struct topology */
+
+struct hwloc_internal_location_s {
+  enum hwloc_location_type_e type;
+  union {
+    struct {
+      hwloc_obj_t obj; /* cached between refreshes */
+      uint64_t gp_index;
+      hwloc_obj_type_t type;
+    } object; /* if type == HWLOC_LOCATION_TYPE_OBJECT */
+    hwloc_cpuset_t cpuset; /* if type == HWLOC_LOCATION_TYPE_CPUSET */
+  } location;
+};
 
 /*****************************************************
  * WARNING:
@@ -154,6 +166,7 @@ struct hwloc_topology {
     unsigned long kind;
 
 #define HWLOC_INTERNAL_DIST_FLAG_OBJS_VALID (1U<<0) /* if the objs array is valid below */
+#define HWLOC_INTERNAL_DIST_FLAG_NOT_COMMITTED (1U<<1) /* if the distances isn't in the list yet */
     unsigned iflags;
 
     /* objects are currently stored in physical_index order */
@@ -163,6 +176,50 @@ struct hwloc_topology {
   } *first_dist, *last_dist;
   unsigned next_dist_id;
 
+  /* memory attributes */
+  unsigned nr_memattrs;
+  struct hwloc_internal_memattr_s {
+    /* memattr info */
+    char *name; /* TODO unit is implicit, in the documentation of standard attributes, or in the name? */
+    unsigned long flags;
+#define HWLOC_IMATTR_FLAG_STATIC_NAME (1U<<0) /* no need to free name */
+#define HWLOC_IMATTR_FLAG_CACHE_VALID (1U<<1) /* target and initiator are valid */
+#define HWLOC_IMATTR_FLAG_CONVENIENCE (1U<<2) /* convenience attribute reporting values from non-memattr attributes (R/O and no actual targets stored) */
+    unsigned iflags;
+
+    /* array of values */
+    unsigned nr_targets;
+    struct hwloc_internal_memattr_target_s {
+      /* target object */
+      hwloc_obj_t obj; /* cached between refreshes */
+      hwloc_obj_type_t type;
+      unsigned os_index; /* only used temporarily during discovery when there's no obj/gp_index yet */
+      hwloc_uint64_t gp_index;
+
+      /* value if there are no initiator for this attr */
+      hwloc_uint64_t noinitiator_value;
+      /* initiators otherwise */
+      unsigned nr_initiators;
+      struct hwloc_internal_memattr_initiator_s {
+        struct hwloc_internal_location_s initiator;
+        hwloc_uint64_t value;
+      } *initiators;
+    } *targets;
+  } *memattrs;
+
+  /* hybridcpus */
+  unsigned nr_cpukinds;
+  unsigned nr_cpukinds_allocated;
+  struct hwloc_internal_cpukind_s {
+    hwloc_cpuset_t cpuset;
+#define HWLOC_CPUKIND_EFFICIENCY_UNKNOWN -1
+    int efficiency;
+    int forced_efficiency; /* returned by the hardware or OS if any */
+    hwloc_uint64_t ranking_value; /* internal value for ranking */
+    unsigned nr_infos;
+    struct hwloc_info_s *infos;
+  } *cpukinds;
+
   int grouping;
   int grouping_verbose;
   unsigned grouping_nbaccuracies;
@@ -240,18 +297,14 @@ extern void hwloc_topology_clear(struct hwloc_topology *topology);
 
 /* insert memory object as memory child of normal parent */
 extern struct hwloc_obj * hwloc__attach_memory_object(struct hwloc_topology *topology, hwloc_obj_t parent,
-						      hwloc_obj_t obj,
-						      hwloc_report_error_t report_error);
+                                                      hwloc_obj_t obj, const char *reason);
+
+extern hwloc_obj_t hwloc_get_obj_by_type_and_gp_index(hwloc_topology_t topology, hwloc_obj_type_t type, uint64_t gp_index);
 
 extern void hwloc_pci_discovery_init(struct hwloc_topology *topology);
 extern void hwloc_pci_discovery_prepare(struct hwloc_topology *topology);
 extern void hwloc_pci_discovery_exit(struct hwloc_topology *topology);
 
-/* Look for an object matching the given domain/bus/func,
- * either exactly or return the smallest container bridge
- */
-extern struct hwloc_obj * hwloc_pci_find_by_busid(struct hwloc_topology *topology, unsigned domain, unsigned bus, unsigned dev, unsigned func);
-
 /* Look for an object matching complete cpuset exactly, or insert one.
  * Return NULL on failure.
  * Return a good fallback (object above) on failure to insert.
@@ -261,6 +314,7 @@ extern hwloc_obj_t hwloc_find_insert_io_parent_by_complete_cpuset(struct hwloc_t
 extern int hwloc__add_info(struct hwloc_info_s **infosp, unsigned *countp, const char *name, const char *value);
 extern int hwloc__add_info_nodup(struct hwloc_info_s **infosp, unsigned *countp, const char *name, const char *value, int replace);
 extern int hwloc__move_infos(struct hwloc_info_s **dst_infosp, unsigned *dst_countp, struct hwloc_info_s **src_infosp, unsigned *src_countp);
+extern int hwloc__tma_dup_infos(struct hwloc_tma *tma, struct hwloc_info_s **dst_infosp, unsigned *dst_countp, struct hwloc_info_s *src_infos, unsigned src_count);
 extern void hwloc__free_infos(struct hwloc_info_s *infos, unsigned count);
 
 /* set native OS binding hooks */
@@ -350,10 +404,30 @@ extern void hwloc_internal_distances_prepare(hwloc_topology_t topology);
 extern void hwloc_internal_distances_destroy(hwloc_topology_t topology);
 extern int hwloc_internal_distances_dup(hwloc_topology_t new, hwloc_topology_t old);
 extern void hwloc_internal_distances_refresh(hwloc_topology_t topology);
-extern int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name, unsigned nbobjs, hwloc_obj_t *objs, uint64_t *values, unsigned long kind, unsigned long flags);
-extern int hwloc_internal_distances_add_by_index(hwloc_topology_t topology, const char *name, hwloc_obj_type_t unique_type, hwloc_obj_type_t *different_types, unsigned nbobjs, uint64_t *indexes, uint64_t *values, unsigned long kind, unsigned long flags);
 extern void hwloc_internal_distances_invalidate_cached_objs(hwloc_topology_t topology);
 
+/* these distances_add() functions are higher-level than those in hwloc/plugins.h
+ * but they may change in the future, hence they are not exported to plugins.
+ */
+extern int hwloc_internal_distances_add_by_index(hwloc_topology_t topology, const char *name, hwloc_obj_type_t unique_type, hwloc_obj_type_t *different_types, unsigned nbobjs, uint64_t *indexes, uint64_t *values, unsigned long kind, unsigned long flags);
+extern int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name, unsigned nbobjs, hwloc_obj_t *objs, uint64_t *values, unsigned long kind, unsigned long flags);
+
+extern void hwloc_internal_memattrs_init(hwloc_topology_t topology);
+extern void hwloc_internal_memattrs_prepare(hwloc_topology_t topology);
+extern void hwloc_internal_memattrs_destroy(hwloc_topology_t topology);
+extern void hwloc_internal_memattrs_need_refresh(hwloc_topology_t topology);
+extern void hwloc_internal_memattrs_refresh(hwloc_topology_t topology);
+extern int hwloc_internal_memattrs_dup(hwloc_topology_t new, hwloc_topology_t old);
+extern int hwloc_internal_memattr_set_value(hwloc_topology_t topology, hwloc_memattr_id_t id, hwloc_obj_type_t target_type, hwloc_uint64_t target_gp_index, unsigned target_os_index, struct hwloc_internal_location_s *initiator, hwloc_uint64_t value);
+
+extern void hwloc_internal_cpukinds_init(hwloc_topology_t topology);
+extern int hwloc_internal_cpukinds_rank(hwloc_topology_t topology);
+extern void hwloc_internal_cpukinds_destroy(hwloc_topology_t topology);
+extern int hwloc_internal_cpukinds_dup(hwloc_topology_t new, hwloc_topology_t old);
+#define HWLOC_CPUKINDS_REGISTER_FLAG_OVERWRITE_FORCED_EFFICIENCY (1<<0)
+extern int hwloc_internal_cpukinds_register(hwloc_topology_t topology, hwloc_cpuset_t cpuset, int forced_efficiency, const struct hwloc_info_s *infos, unsigned nr_infos, unsigned long flags);
+extern void hwloc_internal_cpukinds_restrict(hwloc_topology_t topology);
+
 /* encode src buffer into target buffer.
  * targsize must be at least 4*((srclength+2)/3)+1.
  * target will be 0-terminated.
@@ -406,6 +480,7 @@ extern char * hwloc_progname(struct hwloc_topology *topology);
 #define HWLOC_GROUP_KIND_AIX_SDL_UNKNOWN		210	/* subkind is SDL level */
 #define HWLOC_GROUP_KIND_WINDOWS_PROCESSOR_GROUP	220	/* no subkind */
 #define HWLOC_GROUP_KIND_WINDOWS_RELATIONSHIP_UNKNOWN	221	/* no subkind */
+#define HWLOC_GROUP_KIND_LINUX_CLUSTER                  222     /* no subkind */
 /* distance groups */
 #define HWLOC_GROUP_KIND_DISTANCE			900	/* subkind is round of adding these groups during distance based grouping */
 /* finally, hwloc-specific groups required to insert something else, should disappear as soon as possible */

src/3rdparty/hwloc/include/private/windows.h

@@ -0,0 +1,21 @@
+/*
+ * Copyright © 2009 Université Bordeaux
+ * Copyright © 2020 Inria.  All rights reserved.
+ *
+ * See COPYING in top-level directory.
+ */
+
+#ifndef HWLOC_PRIVATE_WINDOWS_H
+#define HWLOC_PRIVATE_WINDOWS_H
+
+#ifdef __GNUC__
+#define _ANONYMOUS_UNION __extension__
+#define _ANONYMOUS_STRUCT __extension__
+#else
+#define _ANONYMOUS_UNION
+#define _ANONYMOUS_STRUCT
+#endif /* __GNUC__ */
+#define DUMMYUNIONNAME
+#define DUMMYSTRUCTNAME
+
+#endif /* HWLOC_PRIVATE_WINDOWS_H */

src/3rdparty/hwloc/include/private/xml.h

@@ -46,7 +46,7 @@ struct hwloc_xml_backend_data_s {
   int (*find_child)(struct hwloc__xml_import_state_s * state, struct hwloc__xml_import_state_s * childstate, char **tagp);
   int (*close_tag)(struct hwloc__xml_import_state_s * state); /* look for an explicit closing tag </name> */
   void (*close_child)(struct hwloc__xml_import_state_s * state);
-  int (*get_content)(struct hwloc__xml_import_state_s * state, char **beginp, size_t expected_length); /* return 0 on empty content (and sets beginp to empty string), 1 on actual content, -1 on error or unexpected content length */
+  int (*get_content)(struct hwloc__xml_import_state_s * state, const char **beginp, size_t expected_length); /* return 0 on empty content (and sets beginp to empty string), 1 on actual content, -1 on error or unexpected content length */
   void (*close_content)(struct hwloc__xml_import_state_s * state);
   char * msgprefix;
   void *data; /* libxml2 doc, or nolibxml buffer */

src/3rdparty/hwloc/src/bind.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2019 Inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009-2010, 2012 Université Bordeaux
  * Copyright © 2011-2015 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -921,5 +921,6 @@ hwloc_set_binding_hooks(struct hwloc_topology *topology)
     DO(mem,get_area_membind);
     DO(mem,get_area_memlocation);
     DO(mem,alloc_membind);
+#undef DO
   }
 }

src/3rdparty/hwloc/src/bitmap.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2018 Inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009-2011 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -818,7 +818,7 @@ int hwloc_bitmap_nr_ulongs(const struct hwloc_bitmap_s *set)
 		return -1;
 
 	last = hwloc_bitmap_last(set);
-	return (last + HWLOC_BITS_PER_LONG-1)/HWLOC_BITS_PER_LONG;
+	return (last + HWLOC_BITS_PER_LONG)/HWLOC_BITS_PER_LONG;
 }
 
 int hwloc_bitmap_only(struct hwloc_bitmap_s * set, unsigned cpu)

src/3rdparty/hwloc/src/components.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2009-2020 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2012 Université Bordeaux
  * See COPYING in top-level directory.
  */
@@ -124,7 +124,7 @@ hwloc_dlforeachfile(const char *_paths,
       *colon = '\0';
 
     if (hwloc_plugins_verbose)
-      fprintf(stderr, " Looking under %s\n", path);
+      fprintf(stderr, "hwloc:  Looking under %s\n", path);
 
     dir = opendir(path);
     if (!dir)
@@ -198,7 +198,7 @@ hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
   char *componentsymbolname;
 
   if (hwloc_plugins_verbose)
-    fprintf(stderr, "Plugin dlforeach found `%s'\n", filename);
+    fprintf(stderr, "hwloc: Plugin dlforeach found `%s'\n", filename);
 
   basename = strrchr(filename, '/');
   if (!basename)
@@ -208,7 +208,7 @@ hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
 
   if (hwloc_plugins_blacklist && strstr(hwloc_plugins_blacklist, basename)) {
     if (hwloc_plugins_verbose)
-      fprintf(stderr, "Plugin `%s' is blacklisted in the environment\n", basename);
+      fprintf(stderr, "hwloc: Plugin `%s' is blacklisted in the environment\n", basename);
     goto out;
   }
 
@@ -216,14 +216,14 @@ hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
   handle = hwloc_dlopenext(filename);
   if (!handle) {
     if (hwloc_plugins_verbose)
-      fprintf(stderr, "Failed to load plugin: %s\n", hwloc_dlerror());
+      fprintf(stderr, "hwloc: Failed to load plugin: %s\n", hwloc_dlerror());
     goto out;
   }
 
   componentsymbolname = malloc(strlen(basename)+10+1);
   if (!componentsymbolname) {
     if (hwloc_plugins_verbose)
-      fprintf(stderr, "Failed to allocation component `%s' symbol\n",
+      fprintf(stderr, "hwloc: Failed to allocation component `%s' symbol\n",
 	      basename);
     goto out_with_handle;
   }
@@ -231,38 +231,38 @@ hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
   component = hwloc_dlsym(handle, componentsymbolname);
   if (!component) {
     if (hwloc_plugins_verbose)
-      fprintf(stderr, "Failed to find component symbol `%s'\n",
+      fprintf(stderr, "hwloc: Failed to find component symbol `%s'\n",
 	      componentsymbolname);
     free(componentsymbolname);
     goto out_with_handle;
   }
   if (component->abi != HWLOC_COMPONENT_ABI) {
     if (hwloc_plugins_verbose)
-      fprintf(stderr, "Plugin symbol ABI %u instead of %d\n",
+      fprintf(stderr, "hwloc: Plugin symbol ABI %u instead of %d\n",
 	      component->abi, HWLOC_COMPONENT_ABI);
     free(componentsymbolname);
     goto out_with_handle;
   }
   if (hwloc_plugins_verbose)
-    fprintf(stderr, "Plugin contains expected symbol `%s'\n",
+    fprintf(stderr, "hwloc: Plugin contains expected symbol `%s'\n",
 	    componentsymbolname);
   free(componentsymbolname);
 
   if (HWLOC_COMPONENT_TYPE_DISC == component->type) {
     if (strncmp(basename, "hwloc_", 6)) {
       if (hwloc_plugins_verbose)
-	fprintf(stderr, "Plugin name `%s' doesn't match its type DISCOVERY\n", basename);
+	fprintf(stderr, "hwloc: Plugin name `%s' doesn't match its type DISCOVERY\n", basename);
       goto out_with_handle;
     }
   } else if (HWLOC_COMPONENT_TYPE_XML == component->type) {
     if (strncmp(basename, "hwloc_xml_", 10)) {
       if (hwloc_plugins_verbose)
-	fprintf(stderr, "Plugin name `%s' doesn't match its type XML\n", basename);
+	fprintf(stderr, "hwloc: Plugin name `%s' doesn't match its type XML\n", basename);
       goto out_with_handle;
     }
   } else {
     if (hwloc_plugins_verbose)
-      fprintf(stderr, "Plugin name `%s' has invalid type %u\n",
+      fprintf(stderr, "hwloc: Plugin name `%s' has invalid type %u\n",
 	      basename, (unsigned) component->type);
     goto out_with_handle;
   }
@@ -277,7 +277,7 @@ hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
   desc->handle = handle;
   desc->next = NULL;
   if (hwloc_plugins_verbose)
-    fprintf(stderr, "Plugin descriptor `%s' ready\n", basename);
+    fprintf(stderr, "hwloc: Plugin descriptor `%s' ready\n", basename);
 
   /* append to the list */
   prevdesc = &hwloc_plugins;
@@ -285,7 +285,7 @@ hwloc__dlforeach_cb(const char *filename, void *_data __hwloc_attribute_unused)
     prevdesc = &((*prevdesc)->next);
   *prevdesc = desc;
   if (hwloc_plugins_verbose)
-    fprintf(stderr, "Plugin descriptor `%s' queued\n", basename);
+    fprintf(stderr, "hwloc: Plugin descriptor `%s' queued\n", basename);
   return 0;
 
  out_with_handle:
@@ -300,7 +300,7 @@ hwloc_plugins_exit(void)
   struct hwloc__plugin_desc *desc, *next;
 
   if (hwloc_plugins_verbose)
-    fprintf(stderr, "Closing all plugins\n");
+    fprintf(stderr, "hwloc: Closing all plugins\n");
 
   desc = hwloc_plugins;
   while (desc) {
@@ -340,7 +340,7 @@ hwloc_plugins_init(void)
   hwloc_plugins = NULL;
 
   if (hwloc_plugins_verbose)
-    fprintf(stderr, "Starting plugin dlforeach in %s\n", path);
+    fprintf(stderr, "hwloc: Starting plugin dlforeach in %s\n", path);
   err = hwloc_dlforeachfile(path, hwloc__dlforeach_cb, NULL);
   if (err)
     goto out_with_init;
@@ -364,14 +364,14 @@ hwloc_disc_component_register(struct hwloc_disc_component *component,
   /* check that the component name is valid */
   if (!strcmp(component->name, HWLOC_COMPONENT_STOP_NAME)) {
     if (hwloc_components_verbose)
-      fprintf(stderr, "Cannot register discovery component with reserved name `" HWLOC_COMPONENT_STOP_NAME "'\n");
+      fprintf(stderr, "hwloc: Cannot register discovery component with reserved name `" HWLOC_COMPONENT_STOP_NAME "'\n");
     return -1;
   }
   if (strchr(component->name, HWLOC_COMPONENT_EXCLUDE_CHAR)
       || strchr(component->name, HWLOC_COMPONENT_PHASESEP_CHAR)
       || strcspn(component->name, HWLOC_COMPONENT_SEPS) != strlen(component->name)) {
     if (hwloc_components_verbose)
-      fprintf(stderr, "Cannot register discovery component with name `%s' containing reserved characters `%c" HWLOC_COMPONENT_SEPS "'\n",
+      fprintf(stderr, "hwloc: Cannot register discovery component with name `%s' containing reserved characters `%c" HWLOC_COMPONENT_SEPS "'\n",
 	      component->name, HWLOC_COMPONENT_EXCLUDE_CHAR);
     return -1;
   }
@@ -386,7 +386,8 @@ hwloc_disc_component_register(struct hwloc_disc_component *component,
 				   |HWLOC_DISC_PHASE_MISC
 				   |HWLOC_DISC_PHASE_ANNOTATE
 				   |HWLOC_DISC_PHASE_TWEAK))) {
-    fprintf(stderr, "Cannot register discovery component `%s' with invalid phases 0x%x\n",
+    if (hwloc_hide_errors() < 2)
+      fprintf(stderr, "hwloc: Cannot register discovery component `%s' with invalid phases 0x%x\n",
               component->name, component->phases);
     return -1;
   }
@@ -398,13 +399,13 @@ hwloc_disc_component_register(struct hwloc_disc_component *component,
       if ((*prev)->priority < component->priority) {
 	/* drop the existing component */
 	if (hwloc_components_verbose)
-	  fprintf(stderr, "Dropping previously registered discovery component `%s', priority %u lower than new one %u\n",
+	  fprintf(stderr, "hwloc: Dropping previously registered discovery component `%s', priority %u lower than new one %u\n",
 		  (*prev)->name, (*prev)->priority, component->priority);
 	*prev = (*prev)->next;
       } else {
 	/* drop the new one */
 	if (hwloc_components_verbose)
-	  fprintf(stderr, "Ignoring new discovery component `%s', priority %u lower than previously registered one %u\n",
+	  fprintf(stderr, "hwloc: Ignoring new discovery component `%s', priority %u lower than previously registered one %u\n",
 		  component->name, component->priority, (*prev)->priority);
 	return -1;
       }
@@ -412,7 +413,7 @@ hwloc_disc_component_register(struct hwloc_disc_component *component,
     prev = &((*prev)->next);
   }
   if (hwloc_components_verbose)
-    fprintf(stderr, "Registered discovery component `%s' phases 0x%x with priority %u (%s%s)\n",
+    fprintf(stderr, "hwloc: Registered discovery component `%s' phases 0x%x with priority %u (%s%s)\n",
 	    component->name, component->phases, component->priority,
 	    filename ? "from plugin " : "statically build", filename ? filename : "");
 
@@ -475,7 +476,8 @@ hwloc_components_init(void)
   /* hwloc_static_components is created by configure in static-components.h */
   for(i=0; NULL != hwloc_static_components[i]; i++) {
     if (hwloc_static_components[i]->flags) {
-      fprintf(stderr, "Ignoring static component with invalid flags %lx\n",
+      if (hwloc_hide_errors() < 2)
+        fprintf(stderr, "hwloc: Ignoring static component with invalid flags %lx\n",
                 hwloc_static_components[i]->flags);
       continue;
     }
@@ -483,7 +485,7 @@ hwloc_components_init(void)
     /* initialize the component */
     if (hwloc_static_components[i]->init && hwloc_static_components[i]->init(0) < 0) {
       if (hwloc_components_verbose)
-	fprintf(stderr, "Ignoring static component, failed to initialize\n");
+	fprintf(stderr, "hwloc: Ignoring static component, failed to initialize\n");
       continue;
     }
     /* queue ->finalize() callback if any */
@@ -503,7 +505,8 @@ hwloc_components_init(void)
 #ifdef HWLOC_HAVE_PLUGINS
   for(desc = hwloc_plugins; NULL != desc; desc = desc->next) {
     if (desc->component->flags) {
-      fprintf(stderr, "Ignoring plugin `%s' component with invalid flags %lx\n",
+      if (hwloc_hide_errors() < 2)
+        fprintf(stderr, "hwloc: Ignoring plugin `%s' component with invalid flags %lx\n",
                 desc->name, desc->component->flags);
       continue;
     }
@@ -511,7 +514,7 @@ hwloc_components_init(void)
     /* initialize the component */
     if (desc->component->init && desc->component->init(0) < 0) {
       if (hwloc_components_verbose)
-	fprintf(stderr, "Ignoring plugin `%s', failed to initialize\n", desc->name);
+	fprintf(stderr, "hwloc: Ignoring plugin `%s', failed to initialize\n", desc->name);
       continue;
     }
     /* queue ->finalize() callback if any */
@@ -608,7 +611,7 @@ hwloc_disc_component_blacklist_one(struct hwloc_topology *topology,
     /* replace linuxpci and linuxio with linux (with IO phases)
      * for backward compatibility with pre-v2.0 and v2.0 respectively */
     if (hwloc_components_verbose)
-      fprintf(stderr, "Replacing deprecated component `%s' with `linux' IO phases in blacklisting\n", name);
+      fprintf(stderr, "hwloc: Replacing deprecated component `%s' with `linux' IO phases in blacklisting\n", name);
     comp = hwloc_disc_component_find("linux", NULL);
     phases = HWLOC_DISC_PHASE_PCI | HWLOC_DISC_PHASE_IO | HWLOC_DISC_PHASE_MISC | HWLOC_DISC_PHASE_ANNOTATE;
 
@@ -624,7 +627,7 @@ hwloc_disc_component_blacklist_one(struct hwloc_topology *topology,
   }
 
   if (hwloc_components_verbose)
-    fprintf(stderr, "Blacklisting component `%s` phases 0x%x\n", comp->name, phases);
+    fprintf(stderr, "hwloc: Blacklisting component `%s` phases 0x%x\n", comp->name, phases);
 
   for(i=0; i<topology->nr_blacklisted_components; i++) {
     if (topology->blacklisted_components[i].component == comp) {
@@ -727,7 +730,7 @@ hwloc_disc_component_try_enable(struct hwloc_topology *topology,
     if (hwloc_components_verbose)
       /* do not warn if envvar_forced since system-wide HWLOC_COMPONENTS must be silently ignored after set_xml() etc.
        */
-      fprintf(stderr, "Excluding discovery component `%s' phases 0x%x, conflicts with excludes 0x%x\n",
+      fprintf(stderr, "hwloc: Excluding discovery component `%s' phases 0x%x, conflicts with excludes 0x%x\n",
 	      comp->name, comp->phases, topology->backend_excluded_phases);
     return -1;
   }
@@ -735,8 +738,8 @@ hwloc_disc_component_try_enable(struct hwloc_topology *topology,
   backend = comp->instantiate(topology, comp, topology->backend_excluded_phases | blacklisted_phases,
 			      NULL, NULL, NULL);
   if (!backend) {
-    if (hwloc_components_verbose || envvar_forced)
-      fprintf(stderr, "Failed to instantiate discovery component `%s'\n", comp->name);
+    if (hwloc_components_verbose || (envvar_forced && hwloc_hide_errors() < 2))
+      fprintf(stderr, "hwloc: Failed to instantiate discovery component `%s'\n", comp->name);
     return -1;
   }
 
@@ -817,7 +820,7 @@ hwloc_disc_components_enable_others(struct hwloc_topology *topology)
 	name = curenv;
 	if (!strcmp(name, "linuxpci") || !strcmp(name, "linuxio")) {
 	  if (hwloc_components_verbose)
-	    fprintf(stderr, "Replacing deprecated component `%s' with `linux' in envvar forcing\n", name);
+	    fprintf(stderr, "hwloc: Replacing deprecated component `%s' with `linux' in envvar forcing\n", name);
 	  name = "linux";
 	}
 
@@ -832,7 +835,8 @@ hwloc_disc_components_enable_others(struct hwloc_topology *topology)
 	  if (comp->phases & ~blacklisted_phases)
 	    hwloc_disc_component_try_enable(topology, comp, 1 /* envvar forced */, blacklisted_phases);
 	} else {
-	  fprintf(stderr, "Cannot find discovery component `%s'\n", name);
+          if (hwloc_hide_errors() < 2)
+            fprintf(stderr, "hwloc: Cannot find discovery component `%s'\n", name);
 	}
 
 	/* restore chars (the second loop below needs env to be unmodified) */
@@ -864,7 +868,7 @@ hwloc_disc_components_enable_others(struct hwloc_topology *topology)
 
       if (!(comp->phases & ~blacklisted_phases)) {
 	if (hwloc_components_verbose)
-	  fprintf(stderr, "Excluding blacklisted discovery component `%s' phases 0x%x\n",
+	  fprintf(stderr, "hwloc: Excluding blacklisted discovery component `%s' phases 0x%x\n",
 		  comp->name, comp->phases);
 	goto nextcomp;
       }
@@ -879,7 +883,7 @@ nextcomp:
     /* print a summary */
     int first = 1;
     backend = topology->backends;
-    fprintf(stderr, "Final list of enabled discovery components: ");
+    fprintf(stderr, "hwloc: Final list of enabled discovery components: ");
     while (backend != NULL) {
       fprintf(stderr, "%s%s(0x%x)", first ? "" : ",", backend->component->name, backend->phases);
       backend = backend->next;
@@ -935,7 +939,7 @@ hwloc_backend_alloc(struct hwloc_topology *topology,
   /* filter-out component phases that are excluded */
   backend->phases = component->phases & ~topology->backend_excluded_phases;
   if (backend->phases != component->phases && hwloc_components_verbose)
-    fprintf(stderr, "Trying discovery component `%s' with phases 0x%x instead of 0x%x\n",
+    fprintf(stderr, "hwloc: Trying discovery component `%s' with phases 0x%x instead of 0x%x\n",
 	    component->name, backend->phases, component->phases);
   backend->flags = 0;
   backend->discover = NULL;
@@ -963,7 +967,8 @@ hwloc_backend_enable(struct hwloc_backend *backend)
 
   /* check backend flags */
   if (backend->flags) {
-    fprintf(stderr, "Cannot enable discovery component `%s' phases 0x%x with unknown flags %lx\n",
+    if (hwloc_hide_errors() < 2)
+      fprintf(stderr, "hwloc: Cannot enable discovery component `%s' phases 0x%x with unknown flags %lx\n",
               backend->component->name, backend->component->phases, backend->flags);
     return -1;
   }
@@ -973,7 +978,7 @@ hwloc_backend_enable(struct hwloc_backend *backend)
   while (NULL != *pprev) {
     if ((*pprev)->component == backend->component) {
       if (hwloc_components_verbose)
-	fprintf(stderr, "Cannot enable  discovery component `%s' phases 0x%x twice\n",
+	fprintf(stderr, "hwloc: Cannot enable  discovery component `%s' phases 0x%x twice\n",
 		backend->component->name, backend->component->phases);
       hwloc_backend_disable(backend);
       errno = EBUSY;
@@ -983,7 +988,7 @@ hwloc_backend_enable(struct hwloc_backend *backend)
   }
 
   if (hwloc_components_verbose)
-    fprintf(stderr, "Enabling discovery component `%s' with phases 0x%x (among 0x%x)\n",
+    fprintf(stderr, "hwloc: Enabling discovery component `%s' with phases 0x%x (among 0x%x)\n",
 	    backend->component->name, backend->phases, backend->component->phases);
 
   /* enqueue at the end */
@@ -1067,7 +1072,7 @@ hwloc_backends_disable_all(struct hwloc_topology *topology)
   while (NULL != (backend = topology->backends)) {
     struct hwloc_backend *next = backend->next;
     if (hwloc_components_verbose)
-      fprintf(stderr, "Disabling discovery component `%s'\n",
+      fprintf(stderr, "hwloc: Disabling discovery component `%s'\n",
 	      backend->component->name);
     hwloc_backend_disable(backend);
     topology->backends = next;

src/3rdparty/hwloc/src/cpukinds.c

@@ -0,0 +1,661 @@
+/*
+ * Copyright © 2020-2021 Inria.  All rights reserved.
+ * See COPYING in top-level directory.
+ */
+
+#include "private/autogen/config.h"
+#include "hwloc.h"
+#include "private/private.h"
+#include "private/debug.h"
+
+
+/*****************
+ * Basics
+ */
+
+void
+hwloc_internal_cpukinds_init(struct hwloc_topology *topology)
+{
+  topology->cpukinds = NULL;
+  topology->nr_cpukinds = 0;
+  topology->nr_cpukinds_allocated = 0;
+}
+
+void
+hwloc_internal_cpukinds_destroy(struct hwloc_topology *topology)
+{
+  unsigned i;
+  for(i=0; i<topology->nr_cpukinds; i++) {
+    struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+    hwloc_bitmap_free(kind->cpuset);
+    hwloc__free_infos(kind->infos, kind->nr_infos);
+  }
+  free(topology->cpukinds);
+  topology->cpukinds = NULL;
+  topology->nr_cpukinds = 0;
+}
+
+int
+hwloc_internal_cpukinds_dup(hwloc_topology_t new, hwloc_topology_t old)
+{
+  struct hwloc_tma *tma = new->tma;
+  struct hwloc_internal_cpukind_s *kinds;
+  unsigned i;
+
+  if (!old->nr_cpukinds)
+    return 0;
+
+  kinds = hwloc_tma_malloc(tma, old->nr_cpukinds * sizeof(*kinds));
+  if (!kinds)
+    return -1;
+  new->cpukinds = kinds;
+  new->nr_cpukinds = old->nr_cpukinds;
+  memcpy(kinds, old->cpukinds, old->nr_cpukinds * sizeof(*kinds));
+
+  for(i=0;i<old->nr_cpukinds; i++) {
+    kinds[i].cpuset = hwloc_bitmap_tma_dup(tma, old->cpukinds[i].cpuset);
+    if (!kinds[i].cpuset) {
+      new->nr_cpukinds = i;
+      goto failed;
+    }
+    if (hwloc__tma_dup_infos(tma,
+                             &kinds[i].infos, &kinds[i].nr_infos,
+                             old->cpukinds[i].infos, old->cpukinds[i].nr_infos) < 0) {
+      assert(!tma || !tma->dontfree); /* this tma cannot fail to allocate */
+      hwloc_bitmap_free(kinds[i].cpuset);
+      new->nr_cpukinds = i;
+      goto failed;
+    }
+  }
+
+  return 0;
+
+ failed:
+  hwloc_internal_cpukinds_destroy(new);
+  return -1;
+}
+
+void
+hwloc_internal_cpukinds_restrict(hwloc_topology_t topology)
+{
+  unsigned i;
+  int removed = 0;
+  for(i=0; i<topology->nr_cpukinds; i++) {
+    struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+    hwloc_bitmap_and(kind->cpuset, kind->cpuset, hwloc_get_root_obj(topology)->cpuset);
+    if (hwloc_bitmap_iszero(kind->cpuset)) {
+      hwloc_bitmap_free(kind->cpuset);
+      hwloc__free_infos(kind->infos, kind->nr_infos);
+      memmove(kind, kind+1, (topology->nr_cpukinds - i - 1)*sizeof(*kind));
+      i--;
+      topology->nr_cpukinds--;
+      removed = 1;
+    }
+  }
+  if (removed)
+    hwloc_internal_cpukinds_rank(topology);
+}
+
+
+/********************
+ * Registering
+ */
+
+static __hwloc_inline int
+hwloc__cpukind_check_duplicate_info(struct hwloc_internal_cpukind_s *kind,
+                                    const char *name, const char *value)
+{
+  unsigned i;
+  for(i=0; i<kind->nr_infos; i++)
+    if (!strcmp(kind->infos[i].name, name)
+        && !strcmp(kind->infos[i].value, value))
+      return 1;
+  return 0;
+}
+
+static __hwloc_inline void
+hwloc__cpukind_add_infos(struct hwloc_internal_cpukind_s *kind,
+                         const struct hwloc_info_s *infos, unsigned nr_infos)
+{
+  unsigned i;
+  for(i=0; i<nr_infos; i++) {
+    if (hwloc__cpukind_check_duplicate_info(kind, infos[i].name, infos[i].value))
+      continue;
+    hwloc__add_info(&kind->infos, &kind->nr_infos, infos[i].name, infos[i].value);
+  }
+}
+
+int
+hwloc_internal_cpukinds_register(hwloc_topology_t topology, hwloc_cpuset_t cpuset,
+                                 int forced_efficiency,
+                                 const struct hwloc_info_s *infos, unsigned nr_infos,
+                                 unsigned long flags)
+{
+  struct hwloc_internal_cpukind_s *kinds;
+  unsigned i, max, bits, oldnr, newnr;
+
+  if (hwloc_bitmap_iszero(cpuset)) {
+    hwloc_bitmap_free(cpuset);
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (flags & ~HWLOC_CPUKINDS_REGISTER_FLAG_OVERWRITE_FORCED_EFFICIENCY) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  /* TODO: for now, only windows provides a forced efficiency.
+   * if another backend ever provides a conflicting value, the first backend value will be kept.
+   * (user-provided values are not an issue, they are meant to overwrite)
+   */
+
+  /* If we have N kinds currently, we may need 2N+1 kinds after inserting the new one:
+   * - each existing kind may get split into which PUs are in the new kind and which aren't.
+   * - some PUs might not have been in any kind yet.
+   */
+  max = 2 * topology->nr_cpukinds + 1;
+  /* Allocate the power-of-two above 2N+1. */
+  bits = hwloc_flsl(max-1) + 1;
+  max = 1U<<bits;
+  /* Allocate 8 minimum to avoid multiple reallocs */
+  if (max < 8)
+    max = 8;
+
+  /* Create or enlarge the array of kinds if needed */
+  kinds = topology->cpukinds;
+  if (max > topology->nr_cpukinds_allocated) {
+    kinds = realloc(kinds, max * sizeof(*kinds));
+    if (!kinds) {
+      hwloc_bitmap_free(cpuset);
+      return -1;
+    }
+    memset(&kinds[topology->nr_cpukinds_allocated], 0, (max - topology->nr_cpukinds_allocated) * sizeof(*kinds));
+    topology->nr_cpukinds_allocated = max;
+    topology->cpukinds = kinds;
+  }
+
+  newnr = oldnr = topology->nr_cpukinds;
+  for(i=0; i<oldnr; i++) {
+    int res = hwloc_bitmap_compare_inclusion(cpuset, kinds[i].cpuset);
+    if (res == HWLOC_BITMAP_INTERSECTS || res == HWLOC_BITMAP_INCLUDED) {
+      /* new kind with intersection of cpusets and union of infos */
+      kinds[newnr].cpuset = hwloc_bitmap_alloc();
+      kinds[newnr].efficiency = HWLOC_CPUKIND_EFFICIENCY_UNKNOWN;
+      kinds[newnr].forced_efficiency = forced_efficiency;
+      hwloc_bitmap_and(kinds[newnr].cpuset, cpuset, kinds[i].cpuset);
+      hwloc__cpukind_add_infos(&kinds[newnr], kinds[i].infos, kinds[i].nr_infos);
+      hwloc__cpukind_add_infos(&kinds[newnr], infos, nr_infos);
+      /* remove cpuset PUs from the existing kind that we just split */
+      hwloc_bitmap_andnot(kinds[i].cpuset, kinds[i].cpuset, kinds[newnr].cpuset);
+      /* clear cpuset PUs that were taken care of */
+      hwloc_bitmap_andnot(cpuset, cpuset, kinds[newnr].cpuset);
+
+      newnr++;
+
+    } else if (res == HWLOC_BITMAP_CONTAINS
+               || res == HWLOC_BITMAP_EQUAL) {
+      /* append new info to existing smaller (or equal) kind */
+      hwloc__cpukind_add_infos(&kinds[i], infos, nr_infos);
+      if ((flags & HWLOC_CPUKINDS_REGISTER_FLAG_OVERWRITE_FORCED_EFFICIENCY)
+          || kinds[i].forced_efficiency == HWLOC_CPUKIND_EFFICIENCY_UNKNOWN)
+        kinds[i].forced_efficiency = forced_efficiency;
+      /* clear cpuset PUs that were taken care of */
+      hwloc_bitmap_andnot(cpuset, cpuset, kinds[i].cpuset);
+
+    } else {
+      assert(res == HWLOC_BITMAP_DIFFERENT);
+      /* nothing to do */
+    }
+
+    /* don't compare with anything else if already empty */
+    if (hwloc_bitmap_iszero(cpuset))
+      break;
+  }
+
+  /* add a final kind with remaining PUs if any */
+  if (!hwloc_bitmap_iszero(cpuset)) {
+    kinds[newnr].cpuset = cpuset;
+    kinds[newnr].efficiency = HWLOC_CPUKIND_EFFICIENCY_UNKNOWN;
+    kinds[newnr].forced_efficiency = forced_efficiency;
+    hwloc__cpukind_add_infos(&kinds[newnr], infos, nr_infos);
+    newnr++;
+  } else {
+    hwloc_bitmap_free(cpuset);
+  }
+
+  topology->nr_cpukinds = newnr;
+  return 0;
+}
+
+int
+hwloc_cpukinds_register(hwloc_topology_t topology, hwloc_cpuset_t _cpuset,
+                        int forced_efficiency,
+                        unsigned nr_infos, struct hwloc_info_s *infos,
+                        unsigned long flags)
+{
+  hwloc_bitmap_t cpuset;
+  int err;
+
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (!_cpuset || hwloc_bitmap_iszero(_cpuset)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  cpuset = hwloc_bitmap_dup(_cpuset);
+  if (!cpuset)
+    return -1;
+
+  if (forced_efficiency < 0)
+    forced_efficiency = HWLOC_CPUKIND_EFFICIENCY_UNKNOWN;
+
+  err = hwloc_internal_cpukinds_register(topology, cpuset, forced_efficiency, infos, nr_infos, HWLOC_CPUKINDS_REGISTER_FLAG_OVERWRITE_FORCED_EFFICIENCY);
+  if (err < 0)
+    return err;
+
+  hwloc_internal_cpukinds_rank(topology);
+  return 0;
+}
+
+
+/*********************
+ * Ranking
+ */
+
+static int
+hwloc__cpukinds_check_duplicate_rankings(struct hwloc_topology *topology)
+{
+  unsigned i,j;
+  for(i=0; i<topology->nr_cpukinds; i++)
+    for(j=i+1; j<topology->nr_cpukinds; j++)
+      if (topology->cpukinds[i].ranking_value == topology->cpukinds[j].ranking_value)
+        /* if any duplicate, fail */
+        return -1;
+  return 0;
+}
+
+static int
+hwloc__cpukinds_try_rank_by_forced_efficiency(struct hwloc_topology *topology)
+{
+  unsigned i;
+
+  hwloc_debug("Trying to rank cpukinds by forced efficiency...\n");
+  for(i=0; i<topology->nr_cpukinds; i++) {
+    if (topology->cpukinds[i].forced_efficiency == HWLOC_CPUKIND_EFFICIENCY_UNKNOWN)
+      /* if any unknown, fail */
+      return -1;
+    topology->cpukinds[i].ranking_value = topology->cpukinds[i].forced_efficiency;
+  }
+
+  return hwloc__cpukinds_check_duplicate_rankings(topology);
+}
+
+struct hwloc_cpukinds_info_summary {
+  int have_max_freq;
+  int have_base_freq;
+  int have_intel_core_type;
+  struct hwloc_cpukind_info_summary {
+    unsigned intel_core_type; /* 1 for atom, 2 for core */
+    unsigned max_freq, base_freq; /* MHz, hence < 100000 */
+  } * summaries;
+};
+
+static void
+hwloc__cpukinds_summarize_info(struct hwloc_topology *topology,
+                               struct hwloc_cpukinds_info_summary *summary)
+{
+  unsigned i, j;
+
+  summary->have_max_freq = 1;
+  summary->have_base_freq = 1;
+  summary->have_intel_core_type = 1;
+
+  for(i=0; i<topology->nr_cpukinds; i++) {
+    struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+    for(j=0; j<kind->nr_infos; j++) {
+      struct hwloc_info_s *info = &kind->infos[j];
+      if (!strcmp(info->name, "FrequencyMaxMHz")) {
+        summary->summaries[i].max_freq = atoi(info->value);
+      } else if (!strcmp(info->name, "FrequencyBaseMHz")) {
+        summary->summaries[i].base_freq = atoi(info->value);
+      } else if (!strcmp(info->name, "CoreType")) {
+        if (!strcmp(info->value, "IntelAtom"))
+          summary->summaries[i].intel_core_type = 1;
+        else if (!strcmp(info->value, "IntelCore"))
+          summary->summaries[i].intel_core_type = 2;
+      }
+    }
+    hwloc_debug("cpukind #%u has intel_core_type %u max_freq %u base_freq %u\n",
+                i, summary->summaries[i].intel_core_type,
+                summary->summaries[i].max_freq, summary->summaries[i].base_freq);
+    if (!summary->summaries[i].base_freq)
+      summary->have_base_freq = 0;
+    if (!summary->summaries[i].max_freq)
+      summary->have_max_freq = 0;
+    if (!summary->summaries[i].intel_core_type)
+      summary->have_intel_core_type = 0;
+  }
+}
+
+enum hwloc_cpukinds_ranking {
+  HWLOC_CPUKINDS_RANKING_DEFAULT, /* forced + frequency on ARM, forced + coretype_frequency otherwise */
+  HWLOC_CPUKINDS_RANKING_NO_FORCED_EFFICIENCY, /* default without forced */
+  HWLOC_CPUKINDS_RANKING_FORCED_EFFICIENCY,
+  HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY, /* either coretype or frequency or both */
+  HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY_STRICT, /* both coretype and frequency are required */
+  HWLOC_CPUKINDS_RANKING_CORETYPE,
+  HWLOC_CPUKINDS_RANKING_FREQUENCY,
+  HWLOC_CPUKINDS_RANKING_FREQUENCY_MAX,
+  HWLOC_CPUKINDS_RANKING_FREQUENCY_BASE,
+  HWLOC_CPUKINDS_RANKING_NONE
+};
+
+static int
+hwloc__cpukinds_try_rank_by_info(struct hwloc_topology *topology,
+                                 enum hwloc_cpukinds_ranking heuristics,
+                                 struct hwloc_cpukinds_info_summary *summary)
+{
+  unsigned i;
+
+  if (HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY_STRICT == heuristics) {
+    hwloc_debug("Trying to rank cpukinds by coretype+frequency_strict...\n");
+    /* we need intel_core_type AND (base or max freq) for all kinds */
+    if (!summary->have_intel_core_type
+        || (!summary->have_max_freq && !summary->have_base_freq))
+      return -1;
+    /* rank first by coretype (Core>>Atom) then by frequency, base if available, max otherwise */
+    for(i=0; i<topology->nr_cpukinds; i++) {
+      struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+      if (summary->have_base_freq)
+        kind->ranking_value = (summary->summaries[i].intel_core_type << 20) + summary->summaries[i].base_freq;
+      else
+        kind->ranking_value = (summary->summaries[i].intel_core_type << 20) + summary->summaries[i].max_freq;
+    }
+
+  } else if (HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY == heuristics) {
+    hwloc_debug("Trying to rank cpukinds by coretype+frequency...\n");
+    /* we need intel_core_type OR (base or max freq) for all kinds */
+    if (!summary->have_intel_core_type
+        && (!summary->have_max_freq && !summary->have_base_freq))
+      return -1;
+    /* rank first by coretype (Core>>Atom) then by frequency, base if available, max otherwise */
+    for(i=0; i<topology->nr_cpukinds; i++) {
+      struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+      if (summary->have_base_freq)
+        kind->ranking_value = (summary->summaries[i].intel_core_type << 20) + summary->summaries[i].base_freq;
+      else
+        kind->ranking_value = (summary->summaries[i].intel_core_type << 20) + summary->summaries[i].max_freq;
+    }
+
+  } else if (HWLOC_CPUKINDS_RANKING_CORETYPE == heuristics) {
+    hwloc_debug("Trying to rank cpukinds by coretype...\n");
+    /* we need intel_core_type */
+    if (!summary->have_intel_core_type)
+      return -1;
+    /* rank by coretype (Core>>Atom) */
+    for(i=0; i<topology->nr_cpukinds; i++) {
+      struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+      kind->ranking_value = (summary->summaries[i].intel_core_type << 20);
+    }
+
+  } else if (HWLOC_CPUKINDS_RANKING_FREQUENCY == heuristics) {
+    hwloc_debug("Trying to rank cpukinds by frequency...\n");
+    /* we need base or max freq for all kinds */
+    if (!summary->have_max_freq && !summary->have_base_freq)
+      return -1;
+    /* rank first by frequency, base if available, max otherwise */
+    for(i=0; i<topology->nr_cpukinds; i++) {
+      struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+      if (summary->have_base_freq)
+        kind->ranking_value = summary->summaries[i].base_freq;
+      else
+        kind->ranking_value = summary->summaries[i].max_freq;
+    }
+
+  } else if (HWLOC_CPUKINDS_RANKING_FREQUENCY_MAX == heuristics) {
+    hwloc_debug("Trying to rank cpukinds by frequency max...\n");
+    /* we need max freq for all kinds */
+    if (!summary->have_max_freq)
+      return -1;
+    /* rank first by frequency, base if available, max otherwise */
+    for(i=0; i<topology->nr_cpukinds; i++) {
+      struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+      kind->ranking_value = summary->summaries[i].max_freq;
+    }
+
+  } else if (HWLOC_CPUKINDS_RANKING_FREQUENCY_BASE == heuristics) {
+    hwloc_debug("Trying to rank cpukinds by frequency base...\n");
+    /* we need max freq for all kinds */
+    if (!summary->have_base_freq)
+      return -1;
+    /* rank first by frequency, base if available, max otherwise */
+    for(i=0; i<topology->nr_cpukinds; i++) {
+      struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+      kind->ranking_value = summary->summaries[i].base_freq;
+    }
+
+  } else assert(0);
+
+  return hwloc__cpukinds_check_duplicate_rankings(topology);
+}
+
+static int hwloc__cpukinds_compare_ranking_values(const void *_a, const void *_b)
+{
+  const struct hwloc_internal_cpukind_s *a = _a;
+  const struct hwloc_internal_cpukind_s *b = _b;
+  uint64_t arv = a->ranking_value;
+  uint64_t brv = b->ranking_value;
+  return arv < brv ? -1 : arv > brv ? 1 : 0;
+}
+
+/* this function requires ranking values to be unique */
+static void
+hwloc__cpukinds_finalize_ranking(struct hwloc_topology *topology)
+{
+  unsigned i;
+  /* sort */
+  qsort(topology->cpukinds, topology->nr_cpukinds, sizeof(*topology->cpukinds), hwloc__cpukinds_compare_ranking_values);
+  /* define our own efficiency between 0 and N-1 */
+  for(i=0; i<topology->nr_cpukinds; i++)
+    topology->cpukinds[i].efficiency = i;
+}
+
+int
+hwloc_internal_cpukinds_rank(struct hwloc_topology *topology)
+{
+  enum hwloc_cpukinds_ranking heuristics;
+  char *env;
+  unsigned i;
+  int err;
+
+  if (!topology->nr_cpukinds)
+    return 0;
+
+  if (topology->nr_cpukinds == 1) {
+    topology->cpukinds[0].efficiency = 0;
+    return 0;
+  }
+
+  heuristics = HWLOC_CPUKINDS_RANKING_DEFAULT;
+  env = getenv("HWLOC_CPUKINDS_RANKING");
+  if (env) {
+    if (!strcmp(env, "default"))
+      heuristics = HWLOC_CPUKINDS_RANKING_DEFAULT;
+    else if (!strcmp(env, "none"))
+      heuristics = HWLOC_CPUKINDS_RANKING_NONE;
+    else if (!strcmp(env, "coretype+frequency"))
+      heuristics = HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY;
+    else if (!strcmp(env, "coretype+frequency_strict"))
+      heuristics = HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY_STRICT;
+    else if (!strcmp(env, "coretype"))
+      heuristics = HWLOC_CPUKINDS_RANKING_CORETYPE;
+    else if (!strcmp(env, "frequency"))
+      heuristics = HWLOC_CPUKINDS_RANKING_FREQUENCY;
+    else if (!strcmp(env, "frequency_max"))
+      heuristics = HWLOC_CPUKINDS_RANKING_FREQUENCY_MAX;
+    else if (!strcmp(env, "frequency_base"))
+      heuristics = HWLOC_CPUKINDS_RANKING_FREQUENCY_BASE;
+    else if (!strcmp(env, "forced_efficiency"))
+      heuristics = HWLOC_CPUKINDS_RANKING_FORCED_EFFICIENCY;
+    else if (!strcmp(env, "no_forced_efficiency"))
+      heuristics = HWLOC_CPUKINDS_RANKING_NO_FORCED_EFFICIENCY;
+    else if (hwloc_hide_errors() < 2)
+      fprintf(stderr, "hwloc: Failed to recognize HWLOC_CPUKINDS_RANKING value %s\n", env);
+  }
+
+  if (heuristics == HWLOC_CPUKINDS_RANKING_DEFAULT
+      || heuristics == HWLOC_CPUKINDS_RANKING_NO_FORCED_EFFICIENCY) {
+    /* default is forced_efficiency first */
+    struct hwloc_cpukinds_info_summary summary;
+
+    if (heuristics == HWLOC_CPUKINDS_RANKING_DEFAULT)
+      hwloc_debug("Using default ranking strategy...\n");
+    else
+      hwloc_debug("Using custom ranking strategy from HWLOC_CPUKINDS_RANKING=%s\n", env);
+
+    if (heuristics != HWLOC_CPUKINDS_RANKING_NO_FORCED_EFFICIENCY) {
+      err = hwloc__cpukinds_try_rank_by_forced_efficiency(topology);
+      if (!err)
+        goto ready;
+    }
+
+    summary.summaries = calloc(topology->nr_cpukinds, sizeof(*summary.summaries));
+    if (!summary.summaries)
+      goto failed;
+    hwloc__cpukinds_summarize_info(topology, &summary);
+
+    err = hwloc__cpukinds_try_rank_by_info(topology, HWLOC_CPUKINDS_RANKING_CORETYPE_FREQUENCY, &summary);
+    free(summary.summaries);
+    if (!err)
+      goto ready;
+
+  } else if (heuristics == HWLOC_CPUKINDS_RANKING_FORCED_EFFICIENCY) {
+    hwloc_debug("Using custom ranking strategy from HWLOC_CPUKINDS_RANKING=%s\n", env);
+
+    err = hwloc__cpukinds_try_rank_by_forced_efficiency(topology);
+    if (!err)
+      goto ready;
+
+  } else if (heuristics != HWLOC_CPUKINDS_RANKING_NONE) {
+    /* custom heuristics */
+    struct hwloc_cpukinds_info_summary summary;
+
+    hwloc_debug("Using custom ranking strategy from HWLOC_CPUKINDS_RANKING=%s\n", env);
+
+    summary.summaries = calloc(topology->nr_cpukinds, sizeof(*summary.summaries));
+    if (!summary.summaries)
+      goto failed;
+    hwloc__cpukinds_summarize_info(topology, &summary);
+
+    err = hwloc__cpukinds_try_rank_by_info(topology, heuristics, &summary);
+    free(summary.summaries);
+    if (!err)
+      goto ready;
+  }
+
+ failed:
+  /* failed to rank, clear efficiencies */
+  for(i=0; i<topology->nr_cpukinds; i++)
+    topology->cpukinds[i].efficiency = HWLOC_CPUKIND_EFFICIENCY_UNKNOWN;
+  hwloc_debug("Failed to rank cpukinds.\n\n");
+  return 0;
+
+ ready:
+  for(i=0; i<topology->nr_cpukinds; i++)
+    hwloc_debug("cpukind #%u got ranking value %llu\n", i, (unsigned long long) topology->cpukinds[i].ranking_value);
+  hwloc__cpukinds_finalize_ranking(topology);
+#ifdef HWLOC_DEBUG
+  for(i=0; i<topology->nr_cpukinds; i++)
+    assert(topology->cpukinds[i].efficiency == (int) i);
+#endif
+  hwloc_debug("\n");
+  return 0;
+}
+
+
+/*****************
+ * Consulting
+ */
+
+int
+hwloc_cpukinds_get_nr(hwloc_topology_t topology, unsigned long flags)
+{
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  return topology->nr_cpukinds;
+}
+
+int
+hwloc_cpukinds_get_info(hwloc_topology_t topology,
+                        unsigned id,
+                        hwloc_bitmap_t cpuset,
+                        int *efficiencyp,
+                        unsigned *nr_infosp, struct hwloc_info_s **infosp,
+                        unsigned long flags)
+{
+  struct hwloc_internal_cpukind_s *kind;
+
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (id >= topology->nr_cpukinds) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  kind = &topology->cpukinds[id];
+
+  if (cpuset)
+    hwloc_bitmap_copy(cpuset, kind->cpuset);
+
+  if (efficiencyp)
+    *efficiencyp = kind->efficiency;
+
+  if (nr_infosp && infosp) {
+    *nr_infosp = kind->nr_infos;
+    *infosp = kind->infos;
+  }
+  return 0;
+}
+
+int
+hwloc_cpukinds_get_by_cpuset(hwloc_topology_t topology,
+                             hwloc_const_bitmap_t cpuset,
+                             unsigned long flags)
+{
+  unsigned id;
+
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (!cpuset || hwloc_bitmap_iszero(cpuset)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  for(id=0; id<topology->nr_cpukinds; id++) {
+    struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[id];
+    int res = hwloc_bitmap_compare_inclusion(cpuset, kind->cpuset);
+    if (res == HWLOC_BITMAP_EQUAL || res == HWLOC_BITMAP_INCLUDED) {
+      return (int) id;
+    } else if (res == HWLOC_BITMAP_INTERSECTS || res == HWLOC_BITMAP_CONTAINS) {
+      errno = EXDEV;
+      return -1;
+    }
+  }
+
+  errno = ENOENT;
+  return -1;
+}

src/3rdparty/hwloc/src/diff.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013-2019 Inria.  All rights reserved.
+ * Copyright © 2013-2020 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -333,10 +333,8 @@ int hwloc_topology_diff_build(hwloc_topology_t topo1,
 
 	if (!err) {
 		if (SETS_DIFFERENT(allowed_cpuset, topo1, topo2)
-		    || SETS_DIFFERENT(allowed_nodeset, topo1, topo2)) {
-			hwloc_append_diff_too_complex(hwloc_get_root_obj(topo1), diffp, &lastdiff);
-			err = 1;
-		}
+		    || SETS_DIFFERENT(allowed_nodeset, topo1, topo2))
+                  goto roottoocomplex;
 	}
 
 	if (!err) {
@@ -346,33 +344,78 @@ int hwloc_topology_diff_build(hwloc_topology_t topo1,
 		dist1 = topo1->first_dist;
 		dist2 = topo2->first_dist;
 		while (dist1 || dist2) {
-			if (!!dist1 != !!dist2) {
-				hwloc_append_diff_too_complex(hwloc_get_root_obj(topo1), diffp, &lastdiff);
-				err = 1;
-				break;
-			}
+			if (!!dist1 != !!dist2)
+                          goto roottoocomplex;
 			if (dist1->unique_type != dist2->unique_type
 			    || dist1->different_types || dist2->different_types /* too lazy to support this case */
 			    || dist1->nbobjs != dist2->nbobjs
 			    || dist1->kind != dist2->kind
-			    || memcmp(dist1->values, dist2->values, dist1->nbobjs * dist1->nbobjs * sizeof(*dist1->values))) {
-				hwloc_append_diff_too_complex(hwloc_get_root_obj(topo1), diffp, &lastdiff);
-				err = 1;
-				break;
-			}
+			    || memcmp(dist1->values, dist2->values, dist1->nbobjs * dist1->nbobjs * sizeof(*dist1->values)))
+                          goto roottoocomplex;
 			for(i=0; i<dist1->nbobjs; i++)
 				/* gp_index isn't enforced above. so compare logical_index instead, which is enforced. requires distances refresh() above */
-				if (dist1->objs[i]->logical_index != dist2->objs[i]->logical_index) {
-					hwloc_append_diff_too_complex(hwloc_get_root_obj(topo1), diffp, &lastdiff);
-					err = 1;
-					break;
-				}
+				if (dist1->objs[i]->logical_index != dist2->objs[i]->logical_index)
+                                  goto roottoocomplex;
 			dist1 = dist1->next;
 			dist2 = dist2->next;
 		}
 	}
 
+        if (!err) {
+          /* memattrs */
+          hwloc_internal_memattrs_refresh(topo1);
+          hwloc_internal_memattrs_refresh(topo2);
+          if (topo1->nr_memattrs != topo2->nr_memattrs)
+            goto roottoocomplex;
+          for(i=0; i<topo1->nr_memattrs; i++) {
+            struct hwloc_internal_memattr_s *imattr1 = &topo1->memattrs[i], *imattr2 = &topo2->memattrs[i];
+            unsigned j;
+           if (strcmp(imattr1->name, imattr2->name)
+                || imattr1->flags != imattr2->flags
+                || imattr1->nr_targets != imattr2->nr_targets)
+              goto roottoocomplex;
+            if (i == HWLOC_MEMATTR_ID_CAPACITY
+                || i == HWLOC_MEMATTR_ID_LOCALITY)
+              /* no need to check virtual attributes, there were refreshed from other topology attributes, checked above */
+              continue;
+            for(j=0; j<imattr1->nr_targets; j++) {
+              struct hwloc_internal_memattr_target_s *imtg1 = &imattr1->targets[j], *imtg2 = &imattr2->targets[j];
+              if (imtg1->type != imtg2->type)
+                goto roottoocomplex;
+              if (imtg1->obj->logical_index != imtg2->obj->logical_index)
+                goto roottoocomplex;
+              if (imattr1->flags & HWLOC_MEMATTR_FLAG_NEED_INITIATOR) {
+                unsigned k;
+                for(k=0; k<imtg1->nr_initiators; k++) {
+                  struct hwloc_internal_memattr_initiator_s *imi1 = &imtg1->initiators[k], *imi2 = &imtg2->initiators[k];
+                  if (imi1->value != imi2->value
+                      || imi1->initiator.type != imi2->initiator.type)
+                    goto roottoocomplex;
+                  if (imi1->initiator.type == HWLOC_LOCATION_TYPE_CPUSET) {
+                    if (!hwloc_bitmap_isequal(imi1->initiator.location.cpuset, imi2->initiator.location.cpuset))
+                      goto roottoocomplex;
+                  } else if (imi1->initiator.type == HWLOC_LOCATION_TYPE_OBJECT) {
+                    if (imi1->initiator.location.object.type != imi2->initiator.location.object.type)
+                      goto roottoocomplex;
+                    if (imi1->initiator.location.object.obj->logical_index != imi2->initiator.location.object.obj->logical_index)
+                      goto roottoocomplex;
+                  } else {
+                    assert(0);
+                  }
+                }
+              } else {
+                if (imtg1->noinitiator_value != imtg2->noinitiator_value)
+                  goto roottoocomplex;
+              }
+            }
+          }
+        }
+
 	return err;
+
+ roottoocomplex:
+  hwloc_append_diff_too_complex(hwloc_get_root_obj(topo1), diffp, &lastdiff);
+  return 1;
 }
 
 /********************

src/3rdparty/hwloc/src/distances.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2019 Inria.  All rights reserved.
+ * Copyright © 2010-2021 Inria.  All rights reserved.
  * Copyright © 2011-2012 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -17,6 +17,37 @@
 static struct hwloc_internal_distances_s *
 hwloc__internal_distances_from_public(hwloc_topology_t topology, struct hwloc_distances_s *distances);
 
+static void
+hwloc__groups_by_distances(struct hwloc_topology *topology, unsigned nbobjs, struct hwloc_obj **objs, uint64_t *values, unsigned long kind, unsigned nbaccuracies, float *accuracies, int needcheck);
+
+static void
+hwloc_internal_distances_restrict(hwloc_obj_t *objs,
+				  uint64_t *indexes,
+				  hwloc_obj_type_t *different_types,
+				  uint64_t *values,
+				  unsigned nbobjs, unsigned disappeared);
+
+static void
+hwloc_internal_distances_print_matrix(struct hwloc_internal_distances_s *dist)
+{
+  unsigned nbobjs = dist->nbobjs;
+  hwloc_obj_t *objs = dist->objs;
+  hwloc_uint64_t *values = dist->values;
+  int gp = !HWLOC_DIST_TYPE_USE_OS_INDEX(dist->unique_type);
+  unsigned i, j;
+
+  fprintf(stderr, "%s", gp ? "gp_index" : "os_index");
+  for(j=0; j<nbobjs; j++)
+    fprintf(stderr, " % 5d", (int)(gp ? objs[j]->gp_index : objs[j]->os_index));
+  fprintf(stderr, "\n");
+  for(i=0; i<nbobjs; i++) {
+    fprintf(stderr, "  % 5d", (int)(gp ? objs[i]->gp_index : objs[i]->os_index));
+    for(j=0; j<nbobjs; j++)
+      fprintf(stderr, " % 5lld", (long long) values[i*nbobjs + j]);
+    fprintf(stderr, "\n");
+  }
+}
+
 /******************************************************
  * Global init, prepare, destroy, dup
  */
@@ -244,27 +275,33 @@ int hwloc_distances_release_remove(hwloc_topology_t topology,
   return 0;
 }
 
-/******************************************************
- * Add distances to the topology
+/*********************************************************
+ * Backend functions for adding distances to the topology
  */
 
+/* cancel a distances handle. only needed internally for now */
 static void
-hwloc__groups_by_distances(struct hwloc_topology *topology, unsigned nbobjs, struct hwloc_obj **objs, uint64_t *values, unsigned long kind, unsigned nbaccuracies, float *accuracies, int needcheck);
+hwloc_backend_distances_add__cancel(struct hwloc_internal_distances_s *dist)
+{
+  /* everything is set to NULL in hwloc_backend_distances_add_create() */
+  free(dist->name);
+  free(dist->indexes);
+  free(dist->objs);
+  free(dist->different_types);
+  free(dist->values);
+  free(dist);
+}
 
-/* insert a distance matrix in the topology.
- * the caller gives us the distances and objs pointers, we'll free them later.
+/* prepare a distances handle for later commit in the topology.
+ * we duplicate the caller's name.
  */
-static int
-hwloc_internal_distances__add(hwloc_topology_t topology, const char *name,
-			      hwloc_obj_type_t unique_type, hwloc_obj_type_t *different_types,
-			      unsigned nbobjs, hwloc_obj_t *objs, uint64_t *indexes, uint64_t *values,
-			      unsigned long kind, unsigned iflags)
+hwloc_backend_distances_add_handle_t
+hwloc_backend_distances_add_create(hwloc_topology_t topology,
+                                   const char *name, unsigned long kind, unsigned long flags)
 {
   struct hwloc_internal_distances_s *dist;
 
-  if (different_types) {
-    kind |= HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES; /* the user isn't forced to give it */
-  } else if (kind & HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES) {
+  if (flags) {
     errno = EINVAL;
     goto err;
   }
@@ -273,110 +310,54 @@ hwloc_internal_distances__add(hwloc_topology_t topology, const char *name,
   if (!dist)
     goto err;
 
-  if (name)
+  if (name) {
     dist->name = strdup(name); /* ignore failure */
+    if (!dist->name)
+      goto err_with_dist;
+  }
 
-  dist->unique_type = unique_type;
-  dist->different_types = different_types;
-  dist->nbobjs = nbobjs;
   dist->kind = kind;
-  dist->iflags = iflags;
+  dist->iflags = HWLOC_INTERNAL_DIST_FLAG_NOT_COMMITTED;
 
-  assert(!!(iflags & HWLOC_INTERNAL_DIST_FLAG_OBJS_VALID) == !!objs);
-
-  if (!objs) {
-    assert(indexes);
-    /* we only have indexes, we'll refresh objs from there */
-    dist->indexes = indexes;
-    dist->objs = calloc(nbobjs, sizeof(hwloc_obj_t));
-    if (!dist->objs)
-      goto err_with_dist;
-
-  } else {
-    unsigned i;
-    assert(!indexes);
-    /* we only have objs, generate the indexes arrays so that we can refresh objs later */
-    dist->objs = objs;
-    dist->indexes = malloc(nbobjs * sizeof(*dist->indexes));
-    if (!dist->indexes)
-      goto err_with_dist;
-    if (HWLOC_DIST_TYPE_USE_OS_INDEX(dist->unique_type)) {
-      for(i=0; i<nbobjs; i++)
-	dist->indexes[i] = objs[i]->os_index;
-    } else {
-      for(i=0; i<nbobjs; i++)
-	dist->indexes[i] = objs[i]->gp_index;
-    }
-  }
-
-  dist->values = values;
+  dist->unique_type = HWLOC_OBJ_TYPE_NONE;
+  dist->different_types = NULL;
+  dist->nbobjs = 0;
+  dist->indexes = NULL;
+  dist->objs = NULL;
+  dist->values = NULL;
 
   dist->id = topology->next_dist_id++;
-
-  if (topology->last_dist)
-    topology->last_dist->next = dist;
-  else
-    topology->first_dist = dist;
-  dist->prev = topology->last_dist;
-  dist->next = NULL;
-  topology->last_dist = dist;
-  return 0;
+  return dist;
 
  err_with_dist:
-  if (name)
-    free(dist->name);
-  free(dist);
+  hwloc_backend_distances_add__cancel(dist);
  err:
-  free(different_types);
-  free(objs);
-  free(indexes);
-  free(values);
-  return -1;
+  return NULL;
 }
 
-int hwloc_internal_distances_add_by_index(hwloc_topology_t topology, const char *name,
-					  hwloc_obj_type_t unique_type, hwloc_obj_type_t *different_types, unsigned nbobjs, uint64_t *indexes, uint64_t *values,
-					  unsigned long kind, unsigned long flags)
-{
-  unsigned iflags = 0; /* objs not valid */
-
-  if (nbobjs < 2) {
-    errno = EINVAL;
-    goto err;
-  }
-
-  /* cannot group without objects,
-   * and we don't group from XML anyway since the hwloc that generated the XML should have grouped already.
+/* attach objects and values to a distances handle.
+ * on success, objs and values arrays are attached and will be freed with the distances.
+ * on failure, the handle is freed.
  */
-  if (flags & HWLOC_DISTANCES_ADD_FLAG_GROUP) {
+int
+hwloc_backend_distances_add_values(hwloc_topology_t topology __hwloc_attribute_unused,
+                                   hwloc_backend_distances_add_handle_t handle,
+                                   unsigned nbobjs, hwloc_obj_t *objs,
+                                   hwloc_uint64_t *values,
+                                   unsigned long flags)
+{
+  struct hwloc_internal_distances_s *dist = handle;
+  hwloc_obj_type_t unique_type, *different_types = NULL;
+  hwloc_uint64_t *indexes = NULL;
+  unsigned i, disappeared = 0;
+
+  if (dist->nbobjs || !(dist->iflags & HWLOC_INTERNAL_DIST_FLAG_NOT_COMMITTED)) {
+    /* target distances is already set */
     errno = EINVAL;
     goto err;
   }
 
-  return hwloc_internal_distances__add(topology, name, unique_type, different_types, nbobjs, NULL, indexes, values, kind, iflags);
-
- err:
-  free(indexes);
-  free(values);
-  free(different_types);
-  return -1;
-}
-
-static void
-hwloc_internal_distances_restrict(hwloc_obj_t *objs,
-				  uint64_t *indexes,
-				  uint64_t *values,
-				  unsigned nbobjs, unsigned disappeared);
-
-int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name,
-				 unsigned nbobjs, hwloc_obj_t *objs, uint64_t *values,
-				 unsigned long kind, unsigned long flags)
-{
-  hwloc_obj_type_t unique_type, *different_types;
-  unsigned i, disappeared = 0;
-  unsigned iflags = HWLOC_INTERNAL_DIST_FLAG_OBJS_VALID;
-
-  if (nbobjs < 2) {
+  if (flags || nbobjs < 2 || !objs || !values) {
     errno = EINVAL;
     goto err;
   }
@@ -389,15 +370,18 @@ int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name,
     /* some objects are NULL */
     if (disappeared == nbobjs) {
       /* nothing left, drop the matrix */
-      free(objs);
-      free(values);
-      return 0;
+      errno = ENOENT;
+      goto err;
     }
     /* restrict the matrix */
-    hwloc_internal_distances_restrict(objs, NULL, values, nbobjs, disappeared);
+    hwloc_internal_distances_restrict(objs, NULL, NULL, values, nbobjs, disappeared);
     nbobjs -= disappeared;
   }
 
+  indexes = malloc(nbobjs * sizeof(*indexes));
+  if (!indexes)
+    goto err;
+
   unique_type = objs[0]->type;
   for(i=1; i<nbobjs; i++)
     if (objs[i]->type != unique_type) {
@@ -408,16 +392,108 @@ int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name,
     /* heterogeneous types */
     different_types = malloc(nbobjs * sizeof(*different_types));
     if (!different_types)
-      goto err;
+      goto err_with_indexes;
     for(i=0; i<nbobjs; i++)
       different_types[i] = objs[i]->type;
-
-  } else {
-    /* homogeneous types */
-    different_types = NULL;
   }
 
-  if (topology->grouping && (flags & HWLOC_DISTANCES_ADD_FLAG_GROUP) && !different_types) {
+  dist->nbobjs = nbobjs;
+  dist->objs = objs;
+  dist->iflags |= HWLOC_INTERNAL_DIST_FLAG_OBJS_VALID;
+  dist->indexes = indexes;
+  dist->unique_type = unique_type;
+  dist->different_types = different_types;
+  dist->values = values;
+
+  if (different_types)
+    dist->kind |= HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES;
+
+  if (HWLOC_DIST_TYPE_USE_OS_INDEX(dist->unique_type)) {
+      for(i=0; i<nbobjs; i++)
+	dist->indexes[i] = objs[i]->os_index;
+    } else {
+      for(i=0; i<nbobjs; i++)
+	dist->indexes[i] = objs[i]->gp_index;
+    }
+
+  return 0;
+
+ err_with_indexes:
+  free(indexes);
+ err:
+  hwloc_backend_distances_add__cancel(dist);
+  return -1;
+}
+
+/* attach objects and values to a distance handle.
+ * on success, objs and values arrays are attached and will be freed with the distances.
+ * on failure, the handle is freed.
+ */
+static int
+hwloc_backend_distances_add_values_by_index(hwloc_topology_t topology __hwloc_attribute_unused,
+                                            hwloc_backend_distances_add_handle_t handle,
+                                            unsigned nbobjs, hwloc_obj_type_t unique_type, hwloc_obj_type_t *different_types, hwloc_uint64_t *indexes,
+                                            hwloc_uint64_t *values)
+{
+  struct hwloc_internal_distances_s *dist = handle;
+  hwloc_obj_t *objs;
+
+  if (dist->nbobjs || !(dist->iflags & HWLOC_INTERNAL_DIST_FLAG_NOT_COMMITTED)) {
+    /* target distances is already set */
+    errno = EINVAL;
+    goto err;
+  }
+  if (nbobjs < 2 || !indexes || !values || (unique_type == HWLOC_OBJ_TYPE_NONE && !different_types)) {
+    errno = EINVAL;
+    goto err;
+  }
+
+  objs = malloc(nbobjs * sizeof(*objs));
+  if (!objs)
+    goto err;
+
+  dist->nbobjs = nbobjs;
+  dist->objs = objs;
+  dist->indexes = indexes;
+  dist->unique_type = unique_type;
+  dist->different_types = different_types;
+  dist->values = values;
+
+  if (different_types)
+    dist->kind |= HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES;
+
+  return 0;
+
+ err:
+  hwloc_backend_distances_add__cancel(dist);
+  return -1;
+}
+
+/* commit a distances handle.
+ * on failure, the handle is freed with its objects and values arrays.
+ */
+int
+hwloc_backend_distances_add_commit(hwloc_topology_t topology,
+                                   hwloc_backend_distances_add_handle_t handle,
+                                   unsigned long flags)
+{
+  struct hwloc_internal_distances_s *dist = handle;
+
+  if (!dist->nbobjs || !(dist->iflags & HWLOC_INTERNAL_DIST_FLAG_NOT_COMMITTED)) {
+    /* target distances not ready for commit */
+    errno = EINVAL;
+    goto err;
+  }
+
+  if ((flags & HWLOC_DISTANCES_ADD_FLAG_GROUP) && !dist->objs) {
+    /* cannot group without objects,
+     * and we don't group from XML anyway since the hwloc that generated the XML should have grouped already.
+     */
+    errno = EINVAL;
+    goto err;
+  }
+
+  if (topology->grouping && (flags & HWLOC_DISTANCES_ADD_FLAG_GROUP) && !dist->different_types) {
     float full_accuracy = 0.f;
     float *accuracies;
     unsigned nbaccuracies;
@@ -431,26 +507,94 @@ int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name,
     }
 
     if (topology->grouping_verbose) {
-      unsigned j;
-      int gp = !HWLOC_DIST_TYPE_USE_OS_INDEX(unique_type);
       fprintf(stderr, "Trying to group objects using distance matrix:\n");
-      fprintf(stderr, "%s", gp ? "gp_index" : "os_index");
-      for(j=0; j<nbobjs; j++)
-	fprintf(stderr, " % 5d", (int)(gp ? objs[j]->gp_index : objs[j]->os_index));
-      fprintf(stderr, "\n");
-      for(i=0; i<nbobjs; i++) {
-	fprintf(stderr, "  % 5d", (int)(gp ? objs[i]->gp_index : objs[i]->os_index));
-	for(j=0; j<nbobjs; j++)
-	  fprintf(stderr, " % 5lld", (long long) values[i*nbobjs + j]);
-	fprintf(stderr, "\n");
-      }
+      hwloc_internal_distances_print_matrix(dist);
     }
 
-    hwloc__groups_by_distances(topology, nbobjs, objs, values,
-			       kind, nbaccuracies, accuracies, 1 /* check the first matrice */);
+    hwloc__groups_by_distances(topology, dist->nbobjs, dist->objs, dist->values,
+			       dist->kind, nbaccuracies, accuracies, 1 /* check the first matrix */);
   }
 
-  return hwloc_internal_distances__add(topology, name, unique_type, different_types, nbobjs, objs, NULL, values, kind, iflags);
+  if (topology->last_dist)
+    topology->last_dist->next = dist;
+  else
+    topology->first_dist = dist;
+  dist->prev = topology->last_dist;
+  dist->next = NULL;
+  topology->last_dist = dist;
+
+  dist->iflags &= ~HWLOC_INTERNAL_DIST_FLAG_NOT_COMMITTED;
+  return 0;
+
+ err:
+  hwloc_backend_distances_add__cancel(dist);
+  return -1;
+}
+
+/* all-in-one backend function not exported to plugins, only used by XML for now */
+int hwloc_internal_distances_add_by_index(hwloc_topology_t topology, const char *name,
+                                          hwloc_obj_type_t unique_type, hwloc_obj_type_t *different_types, unsigned nbobjs, uint64_t *indexes, uint64_t *values,
+                                          unsigned long kind, unsigned long flags)
+{
+  hwloc_backend_distances_add_handle_t handle;
+  int err;
+
+  handle = hwloc_backend_distances_add_create(topology, name, kind, 0);
+  if (!handle)
+    goto err;
+
+  err = hwloc_backend_distances_add_values_by_index(topology, handle,
+                                                    nbobjs, unique_type, different_types, indexes,
+                                                    values);
+  if (err < 0)
+    goto err;
+
+  /* arrays are now attached to the handle */
+  indexes = NULL;
+  different_types = NULL;
+  values = NULL;
+
+  err = hwloc_backend_distances_add_commit(topology, handle, flags);
+  if (err < 0)
+    goto err;
+
+  return 0;
+
+ err:
+  free(indexes);
+  free(different_types);
+  free(values);
+  return -1;
+}
+
+/* all-in-one backend function not exported to plugins, used by OS backends */
+int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name,
+                                 unsigned nbobjs, hwloc_obj_t *objs, uint64_t *values,
+                                 unsigned long kind, unsigned long flags)
+{
+  hwloc_backend_distances_add_handle_t handle;
+  int err;
+
+  handle = hwloc_backend_distances_add_create(topology, name, kind, 0);
+  if (!handle)
+    goto err;
+
+  err = hwloc_backend_distances_add_values(topology, handle,
+                                           nbobjs, objs,
+                                           values,
+                                           0);
+  if (err < 0)
+    goto err;
+
+  /* arrays are now attached to the handle */
+  objs = NULL;
+  values = NULL;
+
+  err = hwloc_backend_distances_add_commit(topology, handle, flags);
+  if (err < 0)
+    goto err;
+
+  return 0;
 
  err:
   free(objs);
@@ -458,44 +602,54 @@ int hwloc_internal_distances_add(hwloc_topology_t topology, const char *name,
   return -1;
 }
 
+/********************************
+ * User API for adding distances
+ */
+
 #define HWLOC_DISTANCES_KIND_FROM_ALL (HWLOC_DISTANCES_KIND_FROM_OS|HWLOC_DISTANCES_KIND_FROM_USER)
 #define HWLOC_DISTANCES_KIND_MEANS_ALL (HWLOC_DISTANCES_KIND_MEANS_LATENCY|HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH)
-#define HWLOC_DISTANCES_KIND_ALL (HWLOC_DISTANCES_KIND_FROM_ALL|HWLOC_DISTANCES_KIND_MEANS_ALL)
+#define HWLOC_DISTANCES_KIND_ALL (HWLOC_DISTANCES_KIND_FROM_ALL|HWLOC_DISTANCES_KIND_MEANS_ALL|HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES)
 #define HWLOC_DISTANCES_ADD_FLAG_ALL (HWLOC_DISTANCES_ADD_FLAG_GROUP|HWLOC_DISTANCES_ADD_FLAG_GROUP_INACCURATE)
 
-/* The actual function exported to the user
- */
-int hwloc_distances_add(hwloc_topology_t topology,
-			unsigned nbobjs, hwloc_obj_t *objs, hwloc_uint64_t *values,
-			unsigned long kind, unsigned long flags)
+void * hwloc_distances_add_create(hwloc_topology_t topology,
+                                  const char *name, unsigned long kind,
+                                  unsigned long flags)
+{
+  if (!topology->is_loaded) {
+    errno = EINVAL;
+    return NULL;
+  }
+  if (topology->adopted_shmem_addr) {
+    errno = EPERM;
+    return NULL;
+  }
+  if ((kind & ~HWLOC_DISTANCES_KIND_ALL)
+      || hwloc_weight_long(kind & HWLOC_DISTANCES_KIND_FROM_ALL) != 1
+      || hwloc_weight_long(kind & HWLOC_DISTANCES_KIND_MEANS_ALL) != 1) {
+    errno = EINVAL;
+    return NULL;
+  }
+
+  return hwloc_backend_distances_add_create(topology, name, kind, flags);
+}
+
+int hwloc_distances_add_values(hwloc_topology_t topology,
+                               void *handle,
+                               unsigned nbobjs, hwloc_obj_t *objs,
+                               hwloc_uint64_t *values,
+                               unsigned long flags)
 {
   unsigned i;
   uint64_t *_values;
   hwloc_obj_t *_objs;
   int err;
 
-  if (nbobjs < 2 || !objs || !values || !topology->is_loaded) {
-    errno = EINVAL;
-    return -1;
-  }
-  if (topology->adopted_shmem_addr) {
-    errno = EPERM;
-    return -1;
-  }
-  if ((kind & ~HWLOC_DISTANCES_KIND_ALL)
-      || hwloc_weight_long(kind & HWLOC_DISTANCES_KIND_FROM_ALL) != 1
-      || hwloc_weight_long(kind & HWLOC_DISTANCES_KIND_MEANS_ALL) != 1
-      || (flags & ~HWLOC_DISTANCES_ADD_FLAG_ALL)) {
-    errno = EINVAL;
-    return -1;
-  }
-
   /* no strict need to check for duplicates, things shouldn't break */
 
   for(i=1; i<nbobjs; i++)
     if (!objs[i]) {
       errno = EINVAL;
-      return -1;
+      goto out;
     }
 
   /* copy the input arrays and give them to the topology */
@@ -506,59 +660,86 @@ int hwloc_distances_add(hwloc_topology_t topology,
 
   memcpy(_objs, objs, nbobjs*sizeof(hwloc_obj_t));
   memcpy(_values, values, nbobjs*nbobjs*sizeof(*_values));
-  err = hwloc_internal_distances_add(topology, NULL, nbobjs, _objs, _values, kind, flags);
-  if (err < 0)
-    goto out; /* _objs and _values freed in hwloc_internal_distances_add() */
+
+  err = hwloc_backend_distances_add_values(topology, handle, nbobjs, _objs, _values, flags);
+  if (err < 0) {
+    /* handle was canceled inside hwloc_backend_distances_add_values */
+    handle = NULL;
+    goto out_with_arrays;
+  }
+
+  return 0;
+
+ out_with_arrays:
+  free(_objs);
+  free(_values);
+ out:
+  if (handle)
+    hwloc_backend_distances_add__cancel(handle);
+  return -1;
+}
+
+int
+hwloc_distances_add_commit(hwloc_topology_t topology,
+                           void *handle,
+                           unsigned long flags)
+{
+  int err;
+
+  if (flags & ~HWLOC_DISTANCES_ADD_FLAG_ALL) {
+    errno = EINVAL;
+    goto out;
+  }
+
+  err = hwloc_backend_distances_add_commit(topology, handle, flags);
+  if (err < 0) {
+    /* handle was canceled inside hwloc_backend_distances_add_commit */
+    handle = NULL;
+    goto out;
+  }
 
   /* in case we added some groups, see if we need to reconnect */
   hwloc_topology_reconnect(topology, 0);
 
   return 0;
 
- out_with_arrays:
-  free(_values);
-  free(_objs);
  out:
+  if (handle)
+    hwloc_backend_distances_add__cancel(handle);
   return -1;
 }
 
+/* deprecated all-in-one user function */
+int hwloc_distances_add(hwloc_topology_t topology,
+			unsigned nbobjs, hwloc_obj_t *objs, hwloc_uint64_t *values,
+			unsigned long kind, unsigned long flags)
+{
+  void *handle;
+  int err;
+
+  handle = hwloc_distances_add_create(topology, NULL, kind, 0);
+  if (!handle)
+    return -1;
+
+  err = hwloc_distances_add_values(topology, handle, nbobjs, objs, values, 0);
+  if (err < 0)
+    return -1;
+
+  err = hwloc_distances_add_commit(topology, handle, flags);
+  if (err < 0)
+    return -1;
+
+  return 0;
+}
+
 /******************************************************
  * Refresh objects in distances
  */
 
-static hwloc_obj_t hwloc_find_obj_by_depth_and_gp_index(hwloc_topology_t topology, unsigned depth, uint64_t gp_index)
-{
-  hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, depth, 0);
-  while (obj) {
-    if (obj->gp_index == gp_index)
-      return obj;
-    obj = obj->next_cousin;
-  }
-  return NULL;
-}
-
-static hwloc_obj_t hwloc_find_obj_by_type_and_gp_index(hwloc_topology_t topology, hwloc_obj_type_t type, uint64_t gp_index)
-{
-  int depth = hwloc_get_type_depth(topology, type);
-  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
-    return NULL;
-  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE) {
-    int topodepth = hwloc_topology_get_depth(topology);
-    for(depth=0; depth<topodepth; depth++) {
-      if (hwloc_get_depth_type(topology, depth) == type) {
-	hwloc_obj_t obj = hwloc_find_obj_by_depth_and_gp_index(topology, depth, gp_index);
-	if (obj)
-	  return obj;
-      }
-    }
-    return NULL;
-  }
-  return hwloc_find_obj_by_depth_and_gp_index(topology, depth, gp_index);
-}
-
 static void
 hwloc_internal_distances_restrict(hwloc_obj_t *objs,
 				  uint64_t *indexes,
+                                  hwloc_obj_type_t *different_types,
 				  uint64_t *values,
 				  unsigned nbobjs, unsigned disappeared)
 {
@@ -580,6 +761,8 @@ hwloc_internal_distances_restrict(hwloc_obj_t *objs,
       objs[newi] = objs[i];
       if (indexes)
 	indexes[newi] = indexes[i];
+      if (different_types)
+        different_types[newi] = different_types[i];
       newi++;
     }
 }
@@ -612,7 +795,7 @@ hwloc_internal_distances_refresh_one(hwloc_topology_t topology,
       else
 	abort();
     } else {
-      obj = hwloc_find_obj_by_type_and_gp_index(topology, different_types ? different_types[i] : unique_type, indexes[i]);
+      obj = hwloc_get_obj_by_type_and_gp_index(topology, different_types ? different_types[i] : unique_type, indexes[i]);
     }
     objs[i] = obj;
     if (!obj)
@@ -624,7 +807,7 @@ hwloc_internal_distances_refresh_one(hwloc_topology_t topology,
     return -1;
 
   if (disappeared) {
-    hwloc_internal_distances_restrict(objs, dist->indexes, dist->values, nbobjs, disappeared);
+    hwloc_internal_distances_restrict(objs, dist->indexes, dist->different_types, dist->values, nbobjs, disappeared);
     dist->nbobjs -= disappeared;
   }
 
@@ -874,26 +1057,6 @@ hwloc_distances_get_by_type(hwloc_topology_t topology, hwloc_obj_type_t type,
  * Grouping objects according to distances
  */
 
-static void hwloc_report_user_distance_error(const char *msg, int line)
-{
-  static int reported = 0;
-
-  if (!reported && !hwloc_hide_errors()) {
-    fprintf(stderr, "****************************************************************************\n");
-    fprintf(stderr, "* hwloc %s was given invalid distances by the user.\n", HWLOC_VERSION);
-    fprintf(stderr, "*\n");
-    fprintf(stderr, "* %s\n", msg);
-    fprintf(stderr, "* Error occurred in topology.c line %d\n", line);
-    fprintf(stderr, "*\n");
-    fprintf(stderr, "* Please make sure that distances given through the programming API\n");
-    fprintf(stderr, "* do not contradict any other topology information.\n");
-    fprintf(stderr, "* \n");
-    fprintf(stderr, "* hwloc will now ignore this invalid topology information and continue.\n");
-    fprintf(stderr, "****************************************************************************\n");
-    reported = 1;
-  }
-}
-
 static int hwloc_compare_values(uint64_t a, uint64_t b, float accuracy)
 {
   if (accuracy != 0.0f && fabsf((float)a-(float)b) < (float)a * accuracy)
@@ -1086,7 +1249,7 @@ hwloc__groups_by_distances(struct hwloc_topology *topology,
           hwloc_debug_1arg_bitmap("adding Group object with %u objects and cpuset %s\n",
                                   groupsizes[i], group_obj->cpuset);
           res_obj = hwloc__insert_object_by_cpuset(topology, NULL, group_obj,
-						   (kind & HWLOC_DISTANCES_KIND_FROM_USER) ? hwloc_report_user_distance_error : hwloc_report_os_error);
+                                                   (kind & HWLOC_DISTANCES_KIND_FROM_USER) ? "distances:fromuser:group" : "distances:group");
 	  /* res_obj may be NULL on failure to insert. */
 	  if (!res_obj)
 	    failed++;
@@ -1137,3 +1300,210 @@ hwloc__groups_by_distances(struct hwloc_topology *topology,
  out_with_groupids:
   free(groupids);
 }
+
+static int
+hwloc__distances_transform_remove_null(struct hwloc_distances_s *distances)
+{
+  hwloc_uint64_t *values = distances->values;
+  hwloc_obj_t *objs = distances->objs;
+  unsigned i, nb, nbobjs = distances->nbobjs;
+  hwloc_obj_type_t unique_type;
+
+  for(i=0, nb=0; i<nbobjs; i++)
+    if (objs[i])
+      nb++;
+
+  if (nb < 2) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (nb == nbobjs)
+    return 0;
+
+  hwloc_internal_distances_restrict(objs, NULL, NULL, values, nbobjs, nbobjs-nb);
+  distances->nbobjs = nb;
+
+  /* update HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES for convenience */
+  unique_type = objs[0]->type;
+  for(i=1; i<nb; i++)
+    if (objs[i]->type != unique_type) {
+      unique_type = HWLOC_OBJ_TYPE_NONE;
+      break;
+    }
+  if (unique_type == HWLOC_OBJ_TYPE_NONE)
+    distances->kind |= HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES;
+  else
+    distances->kind &= ~HWLOC_DISTANCES_KIND_HETEROGENEOUS_TYPES;
+
+  return 0;
+}
+
+static int
+hwloc__distances_transform_links(struct hwloc_distances_s *distances)
+{
+  /* FIXME: we should look for the greatest common denominator
+   * but we just use the smallest positive value, that's enough for current use-cases.
+   * We'll return -1 in other cases.
+   */
+  hwloc_uint64_t divider, *values = distances->values;
+  unsigned i, nbobjs = distances->nbobjs;
+
+  if (!(distances->kind & HWLOC_DISTANCES_KIND_MEANS_BANDWIDTH)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  for(i=0; i<nbobjs; i++)
+    values[i*nbobjs+i] = 0;
+
+  /* find the smallest positive value */
+  divider = 0;
+  for(i=0; i<nbobjs*nbobjs; i++)
+    if (values[i] && (!divider || values[i] < divider))
+      divider = values[i];
+
+  if (!divider)
+    /* only zeroes? do nothing */
+    return 0;
+
+  /* check it divides all values */
+  for(i=0; i<nbobjs*nbobjs; i++)
+    if (values[i]%divider) {
+      errno = ENOENT;
+      return -1;
+    }
+
+  /* ok, now divide for real */
+  for(i=0; i<nbobjs*nbobjs; i++)
+    values[i] /= divider;
+
+  return 0;
+}
+
+static __hwloc_inline int is_nvswitch(hwloc_obj_t obj)
+{
+  return obj && obj->subtype && !strcmp(obj->subtype, "NVSwitch");
+}
+
+static int
+hwloc__distances_transform_merge_switch_ports(hwloc_topology_t topology,
+                                              struct hwloc_distances_s *distances)
+{
+  struct hwloc_internal_distances_s *dist = hwloc__internal_distances_from_public(topology, distances);
+  hwloc_obj_t *objs = distances->objs;
+  hwloc_uint64_t *values = distances->values;
+  unsigned first, i, j, nbobjs = distances->nbobjs;
+
+  if (strcmp(dist->name, "NVLinkBandwidth")) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  /* find the first port */
+  first = (unsigned) -1;
+  for(i=0; i<nbobjs; i++)
+    if (is_nvswitch(objs[i])) {
+      first = i;
+      break;
+    }
+  if (first == (unsigned)-1) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  for(j=i+1; j<nbobjs; j++) {
+    if (is_nvswitch(objs[j])) {
+      /* another port, merge it */
+      unsigned k;
+      for(k=0; k<nbobjs; k++) {
+        if (k==i || k==j)
+          continue;
+        values[k*nbobjs+i] += values[k*nbobjs+j];
+        values[k*nbobjs+j] = 0;
+        values[i*nbobjs+k] += values[j*nbobjs+k];
+        values[j*nbobjs+k] = 0;
+      }
+      values[i*nbobjs+i] += values[j*nbobjs+j];
+      values[j*nbobjs+j] = 0;
+    }
+    /* the caller will also call REMOVE_NULL to remove other ports */
+    objs[j] = NULL;
+  }
+
+  return 0;
+}
+
+static int
+hwloc__distances_transform_transitive_closure(hwloc_topology_t topology,
+                                              struct hwloc_distances_s *distances)
+{
+  struct hwloc_internal_distances_s *dist = hwloc__internal_distances_from_public(topology, distances);
+  hwloc_obj_t *objs = distances->objs;
+  hwloc_uint64_t *values = distances->values;
+  unsigned nbobjs = distances->nbobjs;
+  unsigned i, j, k;
+
+  if (strcmp(dist->name, "NVLinkBandwidth")) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  for(i=0; i<nbobjs; i++) {
+    hwloc_uint64_t bw_i2sw = 0;
+    if (is_nvswitch(objs[i]))
+      continue;
+    /* count our BW to the switch */
+    for(k=0; k<nbobjs; k++)
+      if (is_nvswitch(objs[k]))
+        bw_i2sw += values[i*nbobjs+k];
+
+    for(j=0; j<nbobjs; j++) {
+      hwloc_uint64_t bw_sw2j = 0;
+      if (i == j || is_nvswitch(objs[j]))
+        continue;
+      /* count our BW from the switch */
+      for(k=0; k<nbobjs; k++)
+        if (is_nvswitch(objs[k]))
+          bw_sw2j += values[k*nbobjs+j];
+
+      /* bandwidth from i to j is now min(i2sw,sw2j) */
+      values[i*nbobjs+j] = bw_i2sw > bw_sw2j ? bw_sw2j : bw_i2sw;
+    }
+  }
+
+  return 0;
+}
+
+int
+hwloc_distances_transform(hwloc_topology_t topology,
+                          struct hwloc_distances_s *distances,
+                          enum hwloc_distances_transform_e transform,
+                          void *transform_attr,
+                          unsigned long flags)
+{
+  if (flags || transform_attr) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  switch (transform) {
+  case HWLOC_DISTANCES_TRANSFORM_REMOVE_NULL:
+    return hwloc__distances_transform_remove_null(distances);
+  case HWLOC_DISTANCES_TRANSFORM_LINKS:
+    return hwloc__distances_transform_links(distances);
+  case HWLOC_DISTANCES_TRANSFORM_MERGE_SWITCH_PORTS:
+  {
+    int err;
+    err = hwloc__distances_transform_merge_switch_ports(topology, distances);
+    if (!err)
+      err = hwloc__distances_transform_remove_null(distances);
+    return err;
+  }
+  case HWLOC_DISTANCES_TRANSFORM_TRANSITIVE_CLOSURE:
+    return hwloc__distances_transform_transitive_closure(topology, distances);
+  default:
+    errno = EINVAL;
+    return -1;
+  }
+}

src/3rdparty/hwloc/src/misc.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2018 Inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009-2010 Université Bordeaux
  * Copyright © 2009-2018 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -114,7 +114,7 @@ void hwloc_add_uname_info(struct hwloc_topology *topology __hwloc_attribute_unus
 char *
 hwloc_progname(struct hwloc_topology *topology __hwloc_attribute_unused)
 {
-#if HAVE_DECL_GETMODULEFILENAME
+#if (defined HAVE_DECL_GETMODULEFILENAME) && HAVE_DECL_GETMODULEFILENAME
   char name[256], *local_basename;
   unsigned res = GetModuleFileName(NULL, name, sizeof(name));
   if (res == sizeof(name) || !res)

src/3rdparty/hwloc/src/pci-common.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2009-2020 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -146,7 +146,8 @@ hwloc_pci_discovery_prepare(struct hwloc_topology *topology)
 	  }
 	  free(buffer);
 	} else {
-	  fprintf(stderr, "Ignoring HWLOC_PCI_LOCALITY file `%s' too large (%lu bytes)\n",
+          if (hwloc_hide_errors() < 2)
+            fprintf(stderr, "hwloc/pci: Ignoring HWLOC_PCI_LOCALITY file `%s' too large (%lu bytes)\n",
                     env, (unsigned long) st.st_size);
 	}
       }
@@ -206,8 +207,11 @@ hwloc_pci_traverse_print_cb(void * cbdata __hwloc_attribute_unused,
     else
       hwloc_debug("%s Bridge [%04x:%04x]", busid,
 		  pcidev->attr->pcidev.vendor_id, pcidev->attr->pcidev.device_id);
+    if (pcidev->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI)
       hwloc_debug(" to %04x:[%02x:%02x]\n",
                   pcidev->attr->bridge.downstream.pci.domain, pcidev->attr->bridge.downstream.pci.secondary_bus, pcidev->attr->bridge.downstream.pci.subordinate_bus);
+    else
+      assert(0);
   } else
     hwloc_debug("%s Device [%04x:%04x (%04x:%04x) rev=%02x class=%04x]\n", busid,
 		pcidev->attr->pcidev.vendor_id, pcidev->attr->pcidev.device_id,
@@ -232,7 +236,8 @@ enum hwloc_pci_busid_comparison_e {
   HWLOC_PCI_BUSID_LOWER,
   HWLOC_PCI_BUSID_HIGHER,
   HWLOC_PCI_BUSID_INCLUDED,
-  HWLOC_PCI_BUSID_SUPERSET
+  HWLOC_PCI_BUSID_SUPERSET,
+  HWLOC_PCI_BUSID_EQUAL
 };
 
 static enum hwloc_pci_busid_comparison_e
@@ -250,11 +255,11 @@ hwloc_pci_compare_busids(struct hwloc_obj *a, struct hwloc_obj *b)
   if (a->attr->pcidev.domain > b->attr->pcidev.domain)
     return HWLOC_PCI_BUSID_HIGHER;
 
-  if (a->type == HWLOC_OBJ_BRIDGE
+  if (a->type == HWLOC_OBJ_BRIDGE && a->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI
       && b->attr->pcidev.bus >= a->attr->bridge.downstream.pci.secondary_bus
       && b->attr->pcidev.bus <= a->attr->bridge.downstream.pci.subordinate_bus)
     return HWLOC_PCI_BUSID_SUPERSET;
-  if (b->type == HWLOC_OBJ_BRIDGE
+  if (b->type == HWLOC_OBJ_BRIDGE && b->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI
       && a->attr->pcidev.bus >= b->attr->bridge.downstream.pci.secondary_bus
       && a->attr->pcidev.bus <= b->attr->bridge.downstream.pci.subordinate_bus)
     return HWLOC_PCI_BUSID_INCLUDED;
@@ -274,11 +279,8 @@ hwloc_pci_compare_busids(struct hwloc_obj *a, struct hwloc_obj *b)
   if (a->attr->pcidev.func > b->attr->pcidev.func)
     return HWLOC_PCI_BUSID_HIGHER;
 
-  /* Should never reach here.  Abort on both debug builds and
-     non-debug builds */
-  assert(0);
-  fprintf(stderr, "Bad assertion in hwloc %s:%d (aborting)\n", __FILE__, __LINE__);
-  exit(1);
+  /* Should never reach here. */
+  return HWLOC_PCI_BUSID_EQUAL;
 }
 
 static void
@@ -304,7 +306,7 @@ hwloc_pci_add_object(struct hwloc_obj *parent, struct hwloc_obj **parent_io_firs
       new->next_sibling = *curp;
       *curp = new;
       new->parent = parent;
-      if (new->type == HWLOC_OBJ_BRIDGE) {
+      if (new->type == HWLOC_OBJ_BRIDGE && new->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI) {
 	/* look at remaining siblings and move some below new */
 	childp = &new->io_first_child;
 	curp = &new->next_sibling;
@@ -329,6 +331,23 @@ hwloc_pci_add_object(struct hwloc_obj *parent, struct hwloc_obj **parent_io_firs
       }
       return;
     }
+    case HWLOC_PCI_BUSID_EQUAL: {
+      static int reported = 0;
+      if (!reported && hwloc_hide_errors() < 2) {
+        fprintf(stderr, "*********************************************************\n");
+        fprintf(stderr, "* hwloc %s received invalid PCI information.\n", HWLOC_VERSION);
+        fprintf(stderr, "*\n");
+        fprintf(stderr, "* Trying to insert PCI object %04x:%02x:%02x.%01x at %04x:%02x:%02x.%01x\n",
+                new->attr->pcidev.domain, new->attr->pcidev.bus, new->attr->pcidev.dev, new->attr->pcidev.func,
+                (*curp)->attr->pcidev.domain, (*curp)->attr->pcidev.bus, (*curp)->attr->pcidev.dev, (*curp)->attr->pcidev.func);
+        fprintf(stderr, "*\n");
+        fprintf(stderr, "* hwloc will now ignore this object and continue.\n");
+        fprintf(stderr, "*********************************************************\n");
+        reported = 1;
+      }
+      hwloc_free_unlinked_object(new);
+      return;
+    }
     }
   }
   /* add to the end of the list if higher than everybody */
@@ -396,7 +415,7 @@ hwloc_pcidisc_add_hostbridges(struct hwloc_topology *topology,
     dstnextp = &child->next_sibling;
 
     /* compute hostbridge secondary/subordinate buses */
-    if (child->type == HWLOC_OBJ_BRIDGE
+    if (child->type == HWLOC_OBJ_BRIDGE && child->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI
 	&& child->attr->bridge.downstream.pci.subordinate_bus > current_subordinate)
       current_subordinate = child->attr->bridge.downstream.pci.subordinate_bus;
 
@@ -425,39 +444,10 @@ hwloc_pcidisc_add_hostbridges(struct hwloc_topology *topology,
 
 static struct hwloc_obj *
 hwloc_pci_fixup_busid_parent(struct hwloc_topology *topology __hwloc_attribute_unused,
-			     struct hwloc_pcidev_attr_s *busid,
-			     struct hwloc_obj *parent)
+			     struct hwloc_pcidev_attr_s *busid __hwloc_attribute_unused,
+			     struct hwloc_obj *parent __hwloc_attribute_unused)
 {
-  /* Xeon E5v3 in cluster-on-die mode only have PCI on the first NUMA node of each package.
-   * but many dual-processor host report the second PCI hierarchy on 2nd NUMA of first package.
-   */
-  if (parent->depth >= 2
-      && parent->type == HWLOC_OBJ_NUMANODE
-      && parent->sibling_rank == 1 && parent->parent->arity == 2
-      && parent->parent->type == HWLOC_OBJ_PACKAGE
-      && parent->parent->sibling_rank == 0 && parent->parent->parent->arity == 2) {
-    const char *cpumodel = hwloc_obj_get_info_by_name(parent->parent, "CPUModel");
-    if (cpumodel && strstr(cpumodel, "Xeon")) {
-      if (!hwloc_hide_errors()) {
-	fprintf(stderr, "****************************************************************************\n");
-	fprintf(stderr, "* hwloc %s has encountered an incorrect PCI locality information.\n", HWLOC_VERSION);
-	fprintf(stderr, "* PCI bus %04x:%02x is supposedly close to 2nd NUMA node of 1st package,\n",
-		busid->domain, busid->bus);
-	fprintf(stderr, "* however hwloc believes this is impossible on this architecture.\n");
-	fprintf(stderr, "* Therefore the PCI bus will be moved to 1st NUMA node of 2nd package.\n");
-	fprintf(stderr, "*\n");
-	fprintf(stderr, "* If you feel this fixup is wrong, disable it by setting in your environment\n");
-	fprintf(stderr, "* HWLOC_PCI_%04x_%02x_LOCALCPUS= (empty value), and report the problem\n",
-		busid->domain, busid->bus);
-	fprintf(stderr, "* to the hwloc's user mailing list together with the XML output of lstopo.\n");
-	fprintf(stderr, "*\n");
-	fprintf(stderr, "* You may silence this message by setting HWLOC_HIDE_ERRORS=1 in your environment.\n");
-	fprintf(stderr, "****************************************************************************\n");
-      }
-      return parent->parent->next_sibling->first_child;
-    }
-  }
-
+  /* no quirk for now */
   return parent;
 }
 
@@ -500,7 +490,8 @@ hwloc__pci_find_busid_parent(struct hwloc_topology *topology, struct hwloc_pcide
     if (env) {
       static int reported = 0;
       if (!topology->pci_has_forced_locality && !reported) {
-	fprintf(stderr, "Environment variable %s is deprecated, please use HWLOC_PCI_LOCALITY instead.\n", env);
+        if (!hwloc_hide_errors())
+          fprintf(stderr, "hwloc/pci: Environment variable %s is deprecated, please use HWLOC_PCI_LOCALITY instead.\n", env);
 	reported = 1;
       }
       if (*env) {
@@ -579,7 +570,7 @@ hwloc_pcidisc_tree_attach(struct hwloc_topology *topology, struct hwloc_obj *tre
     assert(pciobj->type == HWLOC_OBJ_PCI_DEVICE
 	   || (pciobj->type == HWLOC_OBJ_BRIDGE && pciobj->attr->bridge.upstream_type == HWLOC_OBJ_BRIDGE_PCI));
 
-    if (obj->type == HWLOC_OBJ_BRIDGE) {
+    if (obj->type == HWLOC_OBJ_BRIDGE && obj->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI) {
       domain = obj->attr->bridge.downstream.pci.domain;
       bus_min = obj->attr->bridge.downstream.pci.secondary_bus;
       bus_max = obj->attr->bridge.downstream.pci.subordinate_bus;
@@ -819,13 +810,14 @@ hwloc_pcidisc_find_linkspeed(const unsigned char *config,
    * PCIe Gen3 = 8  GT/s signal-rate per lane with 128/130 encoding = 1   GB/s data-rate per lane
    * PCIe Gen4 = 16 GT/s signal-rate per lane with 128/130 encoding = 2   GB/s data-rate per lane
    * PCIe Gen5 = 32 GT/s signal-rate per lane with 128/130 encoding = 4   GB/s data-rate per lane
+   * PCIe Gen6 = 64 GT/s signal-rate per lane with 128/130 encoding = 8   GB/s data-rate per lane
    */
 
   /* lanespeed in Gbit/s */
   if (speed <= 2)
     lanespeed = 2.5f * speed * 0.8f;
   else
-    lanespeed = 8.0f * (1<<(speed-3)) * 128/130; /* assume Gen6 will be 64 GT/s and so on */
+    lanespeed = 8.0f * (1<<(speed-3)) * 128/130; /* assume Gen7 will be 128 GT/s and so on */
 
   /* linkspeed in GB/s */
   *linkspeed = lanespeed * width / 8;

src/3rdparty/hwloc/src/shmem.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2017-2019 Inria.  All rights reserved.
+ * Copyright © 2017-2020 Inria.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -97,6 +97,7 @@ hwloc_shmem_topology_write(hwloc_topology_t topology,
    * without being able to free() them.
    */
   hwloc_internal_distances_refresh(topology);
+  hwloc_internal_memattrs_refresh(topology);
 
   header.header_version = HWLOC_SHMEM_HEADER_VERSION;
   header.header_length = sizeof(header);
@@ -134,8 +135,9 @@ hwloc_shmem_topology_write(hwloc_topology_t topology,
 
   assert((char *)mmap_res <= (char *)mmap_address + length);
 
-  /* now refresh the new distances so that adopters can use them without refreshing the R/O shmem mapping */
+  /* now refresh the new distances/memattrs so that adopters can use them without refreshing the R/O shmem mapping */
   hwloc_internal_distances_refresh(new);
+  hwloc_internal_memattrs_refresh(topology);
 
   /* topology is saved, release resources now */
   munmap(mmap_address, length);
@@ -214,11 +216,13 @@ hwloc_shmem_topology_adopt(hwloc_topology_t *topologyp,
   new->support.discovery = malloc(sizeof(*new->support.discovery));
   new->support.cpubind = malloc(sizeof(*new->support.cpubind));
   new->support.membind = malloc(sizeof(*new->support.membind));
-  if (!new->support.discovery || !new->support.cpubind || !new->support.membind)
+  new->support.misc = malloc(sizeof(*new->support.misc));
+  if (!new->support.discovery || !new->support.cpubind || !new->support.membind || !new->support.misc)
     goto out_with_support;
   memcpy(new->support.discovery, old->support.discovery, sizeof(*new->support.discovery));
   memcpy(new->support.cpubind, old->support.cpubind, sizeof(*new->support.cpubind));
   memcpy(new->support.membind, old->support.membind, sizeof(*new->support.membind));
+  memcpy(new->support.misc, old->support.misc, sizeof(*new->support.misc));
   hwloc_set_binding_hooks(new);
   /* clear userdata callbacks pointing to the writer process' functions */
   new->userdata_export_cb = NULL;
@@ -236,6 +240,7 @@ hwloc_shmem_topology_adopt(hwloc_topology_t *topologyp,
   free(new->support.discovery);
   free(new->support.cpubind);
   free(new->support.membind);
+  free(new->support.misc);
   free(new);
  out_with_components:
   hwloc_components_fini();
@@ -252,6 +257,7 @@ hwloc__topology_disadopt(hwloc_topology_t topology)
   free(topology->support.discovery);
   free(topology->support.cpubind);
   free(topology->support.membind);
+  free(topology->support.misc);
   free(topology);
 }
 

src/3rdparty/hwloc/src/topology-synthetic.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2019 Inria.  All rights reserved.
+ * Copyright © 2009-2020 Inria.  All rights reserved.
  * Copyright © 2009-2010 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -471,7 +471,7 @@ hwloc_backend_synthetic_init(struct hwloc_synthetic_backend_data_s *data,
     /* initialize parent arity to 0 so that the levels are not infinite */
     data->level[count-1].arity = 0;
 
-    while (*pos == ' ')
+    while (*pos == ' ' || *pos == '\n')
       pos++;
 
     if (!*pos)
@@ -912,7 +912,7 @@ hwloc_synthetic_insert_attached(struct hwloc_topology *topology,
 
   hwloc_synthetic_set_attr(&attached->attr, child);
 
-  hwloc_insert_object_by_cpuset(topology, child);
+  hwloc__insert_object_by_cpuset(topology, NULL, child, "synthetic:attached");
 
   hwloc_synthetic_insert_attached(topology, data, attached->next, set);
 }
@@ -964,7 +964,7 @@ hwloc__look_synthetic(struct hwloc_topology *topology,
 
     hwloc_synthetic_set_attr(&curlevel->attr, obj);
 
-    hwloc_insert_object_by_cpuset(topology, obj);
+    hwloc__insert_object_by_cpuset(topology, NULL, obj, "synthetic");
   }
 
   hwloc_synthetic_insert_attached(topology, data, curlevel->attached, set);

src/3rdparty/hwloc/src/topology-windows.c

@@ -1,6 +1,6 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2020 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012, 2020 Université Bordeaux
  * Copyright © 2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -11,7 +11,9 @@
 
 #include "private/autogen/config.h"
 #include "hwloc.h"
+#include "hwloc/windows.h"
 #include "private/private.h"
+#include "private/windows.h" /* must be before windows.h */
 #include "private/debug.h"
 
 #include <windows.h>
@@ -64,26 +66,6 @@ typedef enum _LOGICAL_PROCESSOR_RELATIONSHIP {
 #  endif /* HAVE_RELATIONPROCESSORPACKAGE */
 #endif /* HAVE_LOGICAL_PROCESSOR_RELATIONSHIP */
 
-#ifndef HAVE_SYSTEM_LOGICAL_PROCESSOR_INFORMATION
-typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION {
-  ULONG_PTR ProcessorMask;
-  LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
-  _ANONYMOUS_UNION
-  union {
-    struct {
-      BYTE flags;
-    } ProcessorCore;
-    struct {
-      DWORD NodeNumber;
-    } NumaNode;
-    CACHE_DESCRIPTOR Cache;
-    ULONGLONG Reserved[2];
-  } DUMMYUNIONNAME;
-} SYSTEM_LOGICAL_PROCESSOR_INFORMATION, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION;
-#endif
-
-/* Extended interface, for group support */
-
 #ifndef HAVE_GROUP_AFFINITY
 typedef struct _GROUP_AFFINITY {
   KAFFINITY Mask;
@@ -92,34 +74,40 @@ typedef struct _GROUP_AFFINITY {
 } GROUP_AFFINITY, *PGROUP_AFFINITY;
 #endif
 
-#ifndef HAVE_PROCESSOR_RELATIONSHIP
-typedef struct _PROCESSOR_RELATIONSHIP {
+/* always use our own structure because the EfficiencyClass field didn't exist before Win10 */
+typedef struct HWLOC_PROCESSOR_RELATIONSHIP {
   BYTE Flags;
-  BYTE Reserved[21];
+  BYTE EfficiencyClass; /* for RelationProcessorCore, higher means greater performance but less efficiency */
+  BYTE Reserved[20];
   WORD GroupCount;
   GROUP_AFFINITY GroupMask[ANYSIZE_ARRAY];
-} PROCESSOR_RELATIONSHIP, *PPROCESSOR_RELATIONSHIP;
-#endif
+} HWLOC_PROCESSOR_RELATIONSHIP;
 
-#ifndef HAVE_NUMA_NODE_RELATIONSHIP
-typedef struct _NUMA_NODE_RELATIONSHIP {
+/* always use our own structure because the GroupCount and GroupMasks fields didn't exist in some Win10 */
+typedef struct HWLOC_NUMA_NODE_RELATIONSHIP {
   DWORD NodeNumber;
-  BYTE Reserved[20];
+  BYTE Reserved[18];
+  WORD GroupCount;
+  _ANONYMOUS_UNION
+  union {
     GROUP_AFFINITY GroupMask;
-} NUMA_NODE_RELATIONSHIP, *PNUMA_NODE_RELATIONSHIP;
-#endif
+    GROUP_AFFINITY GroupMasks[ANYSIZE_ARRAY];
+  } DUMMYUNIONNAME;
+} HWLOC_NUMA_NODE_RELATIONSHIP;
 
-#ifndef HAVE_CACHE_RELATIONSHIP
-typedef struct _CACHE_RELATIONSHIP {
+typedef struct HWLOC_CACHE_RELATIONSHIP {
   BYTE Level;
   BYTE Associativity;
   WORD LineSize;
   DWORD CacheSize;
   PROCESSOR_CACHE_TYPE Type;
-  BYTE Reserved[20];
+  BYTE Reserved[18];
+  WORD GroupCount;
+  union {
     GROUP_AFFINITY GroupMask;
-} CACHE_RELATIONSHIP, *PCACHE_RELATIONSHIP;
-#endif
+    GROUP_AFFINITY GroupMasks[ANYSIZE_ARRAY];
+  } DUMMYUNIONNAME;
+} HWLOC_CACHE_RELATIONSHIP;
 
 #ifndef HAVE_PROCESSOR_GROUP_INFO
 typedef struct _PROCESSOR_GROUP_INFO {
@@ -139,20 +127,19 @@ typedef struct _GROUP_RELATIONSHIP {
 } GROUP_RELATIONSHIP, *PGROUP_RELATIONSHIP;
 #endif
 
-#ifndef HAVE_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX
-typedef struct _SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX {
+/* always use our own structure because we need our own HWLOC_PROCESSOR/CACHE/NUMA_NODE_RELATIONSHIP */
+typedef struct HWLOC_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX {
   LOGICAL_PROCESSOR_RELATIONSHIP Relationship;
   DWORD Size;
   _ANONYMOUS_UNION
   union {
-    PROCESSOR_RELATIONSHIP Processor;
-    NUMA_NODE_RELATIONSHIP NumaNode;
-    CACHE_RELATIONSHIP Cache;
+    HWLOC_PROCESSOR_RELATIONSHIP Processor;
+    HWLOC_NUMA_NODE_RELATIONSHIP NumaNode;
+    HWLOC_CACHE_RELATIONSHIP Cache;
     GROUP_RELATIONSHIP Group;
     /* Odd: no member to tell the cpu mask of the package... */
   } DUMMYUNIONNAME;
-} SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, *PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;
-#endif
+} HWLOC_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX;
 
 #ifndef HAVE_PSAPI_WORKING_SET_EX_BLOCK
 typedef union _PSAPI_WORKING_SET_EX_BLOCK {
@@ -189,9 +176,6 @@ typedef struct _PROCESSOR_NUMBER {
 typedef WORD (WINAPI *PFN_GETACTIVEPROCESSORGROUPCOUNT)(void);
 static PFN_GETACTIVEPROCESSORGROUPCOUNT GetActiveProcessorGroupCountProc;
 
-static unsigned long nr_processor_groups = 1;
-static unsigned long max_numanode_index = 0;
-
 typedef WORD (WINAPI *PFN_GETACTIVEPROCESSORCOUNT)(WORD);
 static PFN_GETACTIVEPROCESSORCOUNT GetActiveProcessorCountProc;
 
@@ -201,10 +185,7 @@ static PFN_GETCURRENTPROCESSORNUMBER GetCurrentProcessorNumberProc;
 typedef VOID (WINAPI *PFN_GETCURRENTPROCESSORNUMBEREX)(PPROCESSOR_NUMBER);
 static PFN_GETCURRENTPROCESSORNUMBEREX GetCurrentProcessorNumberExProc;
 
-typedef BOOL (WINAPI *PFN_GETLOGICALPROCESSORINFORMATION)(PSYSTEM_LOGICAL_PROCESSOR_INFORMATION Buffer, PDWORD ReturnLength);
-static PFN_GETLOGICALPROCESSORINFORMATION GetLogicalProcessorInformationProc;
-
-typedef BOOL (WINAPI *PFN_GETLOGICALPROCESSORINFORMATIONEX)(LOGICAL_PROCESSOR_RELATIONSHIP relationship, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX Buffer, PDWORD ReturnLength);
+typedef BOOL (WINAPI *PFN_GETLOGICALPROCESSORINFORMATIONEX)(LOGICAL_PROCESSOR_RELATIONSHIP relationship, HWLOC_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *Buffer, PDWORD ReturnLength);
 static PFN_GETLOGICALPROCESSORINFORMATIONEX GetLogicalProcessorInformationExProc;
 
 typedef BOOL (WINAPI *PFN_SETTHREADGROUPAFFINITY)(HANDLE hThread, const GROUP_AFFINITY *GroupAffinity, PGROUP_AFFINITY PreviousGroupAffinity);
@@ -228,9 +209,12 @@ static PFN_VIRTUALFREEEX VirtualFreeExProc;
 typedef BOOL (WINAPI *PFN_QUERYWORKINGSETEX)(HANDLE hProcess, PVOID pv, DWORD cb);
 static PFN_QUERYWORKINGSETEX QueryWorkingSetExProc;
 
+typedef NTSTATUS (WINAPI *PFN_RTLGETVERSION)(OSVERSIONINFOEX*);
+PFN_RTLGETVERSION RtlGetVersionProc;
+
 static void hwloc_win_get_function_ptrs(void)
 {
-    HMODULE kernel32;
+  HMODULE kernel32, ntdll;
 
 #if HWLOC_HAVE_GCC_W_CAST_FUNCTION_TYPE
 #pragma GCC diagnostic ignored "-Wcast-function-type"
@@ -242,8 +226,6 @@ static void hwloc_win_get_function_ptrs(void)
 	(PFN_GETACTIVEPROCESSORGROUPCOUNT) GetProcAddress(kernel32, "GetActiveProcessorGroupCount");
       GetActiveProcessorCountProc =
 	(PFN_GETACTIVEPROCESSORCOUNT) GetProcAddress(kernel32, "GetActiveProcessorCount");
-      GetLogicalProcessorInformationProc =
-	(PFN_GETLOGICALPROCESSORINFORMATION) GetProcAddress(kernel32, "GetLogicalProcessorInformation");
       GetCurrentProcessorNumberProc =
 	(PFN_GETCURRENTPROCESSORNUMBER) GetProcAddress(kernel32, "GetCurrentProcessorNumber");
       GetCurrentProcessorNumberExProc =
@@ -266,15 +248,15 @@ static void hwloc_win_get_function_ptrs(void)
 	(PFN_VIRTUALFREEEX) GetProcAddress(kernel32, "VirtualFreeEx");
     }
 
-    if (GetActiveProcessorGroupCountProc)
-      nr_processor_groups = GetActiveProcessorGroupCountProc();
-
     if (!QueryWorkingSetExProc) {
       HMODULE psapi = LoadLibrary("psapi.dll");
       if (psapi)
         QueryWorkingSetExProc = (PFN_QUERYWORKINGSETEX) GetProcAddress(psapi, "QueryWorkingSetEx");
     }
 
+    ntdll = GetModuleHandle("ntdll");
+    RtlGetVersionProc = (PFN_RTLGETVERSION) GetProcAddress(ntdll, "RtlGetVersion");
+
 #if HWLOC_HAVE_GCC_W_CAST_FUNCTION_TYPE
 #pragma GCC diagnostic warning "-Wcast-function-type"
 #endif
@@ -356,6 +338,173 @@ static int hwloc_bitmap_to_single_ULONG_PTR(hwloc_const_bitmap_t set, unsigned *
   return 0;
 }
 
+/**********************
+ * Processor Groups
+ */
+
+static unsigned long max_numanode_index = 0;
+
+static unsigned long nr_processor_groups = 1;
+static hwloc_cpuset_t * processor_group_cpusets = NULL;
+
+static void
+hwloc_win_get_processor_groups(void)
+{
+  HWLOC_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *procInfoTotal, *tmpprocInfoTotal, *procInfo;
+  DWORD length;
+  unsigned i;
+
+  hwloc_debug("querying windows processor groups\n");
+
+  if (!GetLogicalProcessorInformationExProc)
+    goto error;
+
+  nr_processor_groups = GetActiveProcessorGroupCountProc();
+  if (!nr_processor_groups)
+    goto error;
+
+  hwloc_debug("found %lu windows processor groups\n", nr_processor_groups);
+
+  if (nr_processor_groups > 1 && SIZEOF_VOID_P == 4) {
+    if (!hwloc_hide_errors())
+      fprintf(stderr, "hwloc: multiple processor groups found on 32bits Windows, topology may be invalid/incomplete.\n");
+  }
+
+  length = 0;
+  procInfoTotal = NULL;
+
+  while (1) {
+    if (GetLogicalProcessorInformationExProc(RelationGroup, procInfoTotal, &length))
+      break;
+    if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
+      goto error;
+    tmpprocInfoTotal = realloc(procInfoTotal, length);
+    if (!tmpprocInfoTotal)
+      goto error_with_procinfo;
+    procInfoTotal = tmpprocInfoTotal;
+  }
+
+  processor_group_cpusets = calloc(nr_processor_groups, sizeof(*processor_group_cpusets));
+  if (!processor_group_cpusets)
+    goto error_with_procinfo;
+
+  for (procInfo = procInfoTotal;
+       (void*) procInfo < (void*) ((uintptr_t) procInfoTotal + length);
+       procInfo = (void*) ((uintptr_t) procInfo + procInfo->Size)) {
+    unsigned id;
+
+    assert(procInfo->Relationship == RelationGroup);
+
+    hwloc_debug("Found %u active windows processor groups\n",
+                (unsigned) procInfo->Group.ActiveGroupCount);
+    for (id = 0; id < procInfo->Group.ActiveGroupCount; id++) {
+      KAFFINITY mask;
+      hwloc_bitmap_t set;
+
+      set = hwloc_bitmap_alloc();
+      if (!set)
+        goto error_with_cpusets;
+
+      mask = procInfo->Group.GroupInfo[id].ActiveProcessorMask;
+      hwloc_debug("group %u with %u cpus mask 0x%llx\n", id,
+                  (unsigned) procInfo->Group.GroupInfo[id].ActiveProcessorCount, (unsigned long long) mask);
+      /* KAFFINITY is ULONG_PTR */
+      hwloc_bitmap_set_ith_ULONG_PTR(set, id, mask);
+      /* FIXME: what if running 32bits on a 64bits windows with 64-processor groups?
+       * ULONG_PTR is 32bits, so half the group is invisible?
+       * maybe scale id to id*8/sizeof(ULONG_PTR) so that groups are 64-PU aligned?
+       */
+      hwloc_debug_2args_bitmap("group %u %d bitmap %s\n", id, procInfo->Group.GroupInfo[id].ActiveProcessorCount, set);
+      processor_group_cpusets[id] = set;
+    }
+  }
+
+  free(procInfoTotal);
+  return;
+
+ error_with_cpusets:
+  for(i=0; i<nr_processor_groups; i++) {
+    if (processor_group_cpusets[i])
+      hwloc_bitmap_free(processor_group_cpusets[i]);
+  }
+  free(processor_group_cpusets);
+  processor_group_cpusets = NULL;
+ error_with_procinfo:
+  free(procInfoTotal);
+ error:
+  /* on error set nr to 1 and keep cpusets NULL. We'll use the topology cpuset whenever needed */
+  nr_processor_groups = 1;
+}
+
+static void
+hwloc_win_free_processor_groups(void)
+{
+  unsigned i;
+  for(i=0; i<nr_processor_groups; i++) {
+    if (processor_group_cpusets[i])
+      hwloc_bitmap_free(processor_group_cpusets[i]);
+  }
+  free(processor_group_cpusets);
+  processor_group_cpusets = NULL;
+  nr_processor_groups = 1;
+}
+
+
+int
+hwloc_windows_get_nr_processor_groups(hwloc_topology_t topology, unsigned long flags)
+{
+  if (!topology->is_loaded || !topology->is_thissystem) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  return nr_processor_groups;
+}
+
+int
+hwloc_windows_get_processor_group_cpuset(hwloc_topology_t topology, unsigned pg_index, hwloc_cpuset_t cpuset, unsigned long flags)
+{
+  if (!topology->is_loaded || !topology->is_thissystem) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (!cpuset) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (flags) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if (pg_index >= nr_processor_groups) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  if (!processor_group_cpusets) {
+    assert(nr_processor_groups == 1);
+    /* we found no processor groups, return the entire topology as a single one */
+    hwloc_bitmap_copy(cpuset, topology->levels[0][0]->cpuset);
+    return 0;
+  }
+
+  if (!processor_group_cpusets[pg_index]) {
+    errno = ENOENT;
+    return -1;
+  }
+
+  hwloc_bitmap_copy(cpuset, processor_group_cpusets[pg_index]);
+  return 0;
+}
+
 /**************************************************************
  * hwloc PU numbering with respect to Windows processor groups
  *
@@ -734,6 +883,88 @@ hwloc_win_get_area_memlocation(hwloc_topology_t topology __hwloc_attribute_unuse
 }
 
 
+
+/*************************
+ * Efficiency classes
+ */
+
+struct hwloc_win_efficiency_classes {
+  unsigned nr_classes;
+  unsigned nr_classes_allocated;
+  struct hwloc_win_efficiency_class {
+    unsigned value;
+    hwloc_bitmap_t cpuset;
+  } *classes;
+};
+
+static void
+hwloc_win_efficiency_classes_init(struct hwloc_win_efficiency_classes *classes)
+{
+  classes->classes = NULL;
+  classes->nr_classes_allocated = 0;
+  classes->nr_classes = 0;
+}
+
+static int
+hwloc_win_efficiency_classes_add(struct hwloc_win_efficiency_classes *classes,
+                                 hwloc_const_bitmap_t cpuset,
+                                 unsigned value)
+{
+  unsigned i;
+
+  /* look for existing class with that efficiency value */
+  for(i=0; i<classes->nr_classes; i++) {
+    if (classes->classes[i].value == value) {
+      hwloc_bitmap_or(classes->classes[i].cpuset, classes->classes[i].cpuset, cpuset);
+      return 0;
+    }
+  }
+
+  /* extend the array if needed */
+  if (classes->nr_classes == classes->nr_classes_allocated) {
+    struct hwloc_win_efficiency_class *tmp;
+    unsigned new_nr_allocated = 2*classes->nr_classes_allocated;
+    if (!new_nr_allocated) {
+#define HWLOC_WIN_EFFICIENCY_CLASSES_DEFAULT_MAX 4 /* 2 should be enough is most cases */
+      new_nr_allocated = HWLOC_WIN_EFFICIENCY_CLASSES_DEFAULT_MAX;
+    }
+    tmp = realloc(classes->classes, new_nr_allocated * sizeof(*classes->classes));
+    if (!tmp)
+      return -1;
+    classes->classes = tmp;
+    classes->nr_classes_allocated = new_nr_allocated;
+  }
+
+  /* add new class */
+  classes->classes[classes->nr_classes].cpuset = hwloc_bitmap_alloc();
+  if (!classes->classes[classes->nr_classes].cpuset)
+    return -1;
+  classes->classes[classes->nr_classes].value = value;
+  hwloc_bitmap_copy(classes->classes[classes->nr_classes].cpuset, cpuset);
+  classes->nr_classes++;
+  return 0;
+}
+
+static void
+hwloc_win_efficiency_classes_register(hwloc_topology_t topology,
+                                      struct hwloc_win_efficiency_classes *classes)
+{
+  unsigned i;
+  for(i=0; i<classes->nr_classes; i++) {
+    hwloc_internal_cpukinds_register(topology, classes->classes[i].cpuset, classes->classes[i].value, NULL, 0, 0);
+    classes->classes[i].cpuset = NULL; /* given to cpukinds */
+  }
+}
+
+static void
+hwloc_win_efficiency_classes_destroy(struct hwloc_win_efficiency_classes *classes)
+{
+  unsigned i;
+  for(i=0; i<classes->nr_classes; i++)
+    hwloc_bitmap_free(classes->classes[i].cpuset);
+  free(classes->classes);
+}
+
 /*************************
  * discovery
  */
@@ -753,6 +984,14 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
   DWORD length;
   int gotnuma = 0;
   int gotnumamemory = 0;
+  OSVERSIONINFOEX osvi;
+  char versionstr[20];
+  char hostname[122] = "";
+  unsigned hostname_size = sizeof(hostname);
+  int has_efficiencyclass = 0;
+  struct hwloc_win_efficiency_classes eclasses;
+  char *env = getenv("HWLOC_WINDOWS_PROCESSOR_GROUP_OBJS");
+  int keep_pgroup_objs = (env && atoi(env));
 
   assert(dstatus->phase == HWLOC_DISC_PHASE_CPU);
 
@@ -760,141 +999,31 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
     /* somebody discovered things */
     return -1;
 
+  ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
+  osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+
+  if (RtlGetVersionProc) {
+    /* RtlGetVersion() returns the currently-running Windows version */
+    RtlGetVersionProc(&osvi);
+  } else {
+    /* GetVersionEx() and isWindows10OrGreater() depend on what the manifest says
+     * (manifest of the program, not of libhwloc.dll), they may return old versions
+     * if the currently-running Windows is not listed in the manifest.
+     */
+    GetVersionEx((LPOSVERSIONINFO)&osvi);
+  }
+
+  if (osvi.dwMajorVersion >= 10) {
+    has_efficiencyclass = 1;
+    hwloc_win_efficiency_classes_init(&eclasses);
+  }
+
   hwloc_alloc_root_sets(topology->levels[0][0]);
 
   GetSystemInfo(&SystemInfo);
 
-  if (!GetLogicalProcessorInformationExProc && GetLogicalProcessorInformationProc) {
-      PSYSTEM_LOGICAL_PROCESSOR_INFORMATION procInfo, tmpprocInfo;
-      unsigned id;
-      unsigned i;
-      struct hwloc_obj *obj;
-      hwloc_obj_type_t type;
-
-      length = 0;
-      procInfo = NULL;
-
-      while (1) {
-	if (GetLogicalProcessorInformationProc(procInfo, &length))
-	  break;
-	if (GetLastError() != ERROR_INSUFFICIENT_BUFFER)
-	  return -1;
-	tmpprocInfo = realloc(procInfo, length);
-	if (!tmpprocInfo) {
-	  free(procInfo);
-	  goto out;
-	}
-	procInfo = tmpprocInfo;
-      }
-
-      assert(!length || procInfo);
-
-      for (i = 0; i < length / sizeof(*procInfo); i++) {
-
-        /* Ignore unknown caches */
-	if (procInfo->Relationship == RelationCache
-		&& procInfo->Cache.Type != CacheUnified
-		&& procInfo->Cache.Type != CacheData
-		&& procInfo->Cache.Type != CacheInstruction)
-	  continue;
-
-	id = HWLOC_UNKNOWN_INDEX;
-	switch (procInfo[i].Relationship) {
-	  case RelationNumaNode:
-	    type = HWLOC_OBJ_NUMANODE;
-	    id = procInfo[i].NumaNode.NodeNumber;
-	    gotnuma++;
-	    if (id > max_numanode_index)
-	      max_numanode_index = id;
-	    break;
-	  case RelationProcessorPackage:
-	    type = HWLOC_OBJ_PACKAGE;
-	    break;
-	  case RelationCache:
-	    type = (procInfo[i].Cache.Type == CacheInstruction ? HWLOC_OBJ_L1ICACHE : HWLOC_OBJ_L1CACHE) + procInfo[i].Cache.Level - 1;
-	    break;
-	  case RelationProcessorCore:
-	    type = HWLOC_OBJ_CORE;
-	    break;
-	  case RelationGroup:
-	  default:
-	    type = HWLOC_OBJ_GROUP;
-	    break;
-	}
-
-	if (!hwloc_filter_check_keep_object_type(topology, type))
-	  continue;
-
-	obj = hwloc_alloc_setup_object(topology, type, id);
-        obj->cpuset = hwloc_bitmap_alloc();
-	hwloc_debug("%s#%u mask %llx\n", hwloc_obj_type_string(type), id, (unsigned long long) procInfo[i].ProcessorMask);
-	/* ProcessorMask is a ULONG_PTR */
-	hwloc_bitmap_set_ith_ULONG_PTR(obj->cpuset, 0, procInfo[i].ProcessorMask);
-	hwloc_debug_2args_bitmap("%s#%u bitmap %s\n", hwloc_obj_type_string(type), id, obj->cpuset);
-
-	switch (type) {
-	  case HWLOC_OBJ_NUMANODE:
-	    {
-	      ULONGLONG avail;
-	      obj->nodeset = hwloc_bitmap_alloc();
-	      hwloc_bitmap_set(obj->nodeset, id);
-	      if ((GetNumaAvailableMemoryNodeExProc && GetNumaAvailableMemoryNodeExProc(id, &avail))
-		  || (GetNumaAvailableMemoryNodeProc && GetNumaAvailableMemoryNodeProc(id, &avail))) {
-		obj->attr->numanode.local_memory = avail;
-		gotnumamemory++;
-	      }
-	      obj->attr->numanode.page_types_len = 2;
-	      obj->attr->numanode.page_types = malloc(2 * sizeof(*obj->attr->numanode.page_types));
-	      memset(obj->attr->numanode.page_types, 0, 2 * sizeof(*obj->attr->numanode.page_types));
-	      obj->attr->numanode.page_types_len = 1;
-	      obj->attr->numanode.page_types[0].size = SystemInfo.dwPageSize;
-#if HAVE_DECL__SC_LARGE_PAGESIZE
-	      obj->attr->numanode.page_types_len++;
-	      obj->attr->numanode.page_types[1].size = sysconf(_SC_LARGE_PAGESIZE);
-#endif
-	      break;
-	    }
-	  case HWLOC_OBJ_L1CACHE:
-	  case HWLOC_OBJ_L2CACHE:
-	  case HWLOC_OBJ_L3CACHE:
-	  case HWLOC_OBJ_L4CACHE:
-	  case HWLOC_OBJ_L5CACHE:
-	  case HWLOC_OBJ_L1ICACHE:
-	  case HWLOC_OBJ_L2ICACHE:
-	  case HWLOC_OBJ_L3ICACHE:
-	    obj->attr->cache.size = procInfo[i].Cache.Size;
-	    obj->attr->cache.associativity = procInfo[i].Cache.Associativity == CACHE_FULLY_ASSOCIATIVE ? -1 : procInfo[i].Cache.Associativity ;
-	    obj->attr->cache.linesize = procInfo[i].Cache.LineSize;
-	    obj->attr->cache.depth = procInfo[i].Cache.Level;
-	    switch (procInfo->Cache.Type) {
-	      case CacheUnified:
-		obj->attr->cache.type = HWLOC_OBJ_CACHE_UNIFIED;
-		break;
-	      case CacheData:
-		obj->attr->cache.type = HWLOC_OBJ_CACHE_DATA;
-		break;
-	      case CacheInstruction:
-		obj->attr->cache.type = HWLOC_OBJ_CACHE_INSTRUCTION;
-		break;
-	      default:
-		hwloc_free_unlinked_object(obj);
-		continue;
-	    }
-	    break;
-	  case HWLOC_OBJ_GROUP:
-	    obj->attr->group.kind = procInfo[i].Relationship == RelationGroup ? HWLOC_GROUP_KIND_WINDOWS_PROCESSOR_GROUP : HWLOC_GROUP_KIND_WINDOWS_RELATIONSHIP_UNKNOWN;
-	    break;
-	  default:
-	    break;
-	}
-	hwloc_insert_object_by_cpuset(topology, obj);
-      }
-
-      free(procInfo);
-  }
-
   if (GetLogicalProcessorInformationExProc) {
-      PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX procInfoTotal, tmpprocInfoTotal, procInfo;
+      HWLOC_SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *procInfoTotal, *tmpprocInfoTotal, *procInfo;
       unsigned id;
       struct hwloc_obj *obj;
       hwloc_obj_type_t type;
@@ -919,6 +1048,7 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 	   (void*) procInfo < (void*) ((uintptr_t) procInfoTotal + length);
 	   procInfo = (void*) ((uintptr_t) procInfo + procInfo->Size)) {
         unsigned num, i;
+        unsigned efficiency_class = 0;
         GROUP_AFFINITY *GroupMask;
 
         /* Ignore unknown caches */
@@ -932,8 +1062,16 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 	switch (procInfo->Relationship) {
 	  case RelationNumaNode:
 	    type = HWLOC_OBJ_NUMANODE;
+            /* Starting with Windows 11 and Server 2022, the GroupCount field is valid and >=1
+             * and we may read GroupMasks[]. Older releases have GroupCount==0 and we must read GroupMask.
+             */
+            if (procInfo->NumaNode.GroupCount) {
+              num = procInfo->NumaNode.GroupCount;
+              GroupMask = procInfo->NumaNode.GroupMasks;
+            } else {
               num = 1;
               GroupMask = &procInfo->NumaNode.GroupMask;
+            }
 	    id = procInfo->NumaNode.NodeNumber;
 	    gotnuma++;
 	    if (id > max_numanode_index)
@@ -946,13 +1084,20 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 	    break;
 	  case RelationCache:
 	    type = (procInfo->Cache.Type == CacheInstruction ? HWLOC_OBJ_L1ICACHE : HWLOC_OBJ_L1CACHE) + procInfo->Cache.Level - 1;
+            /* GroupCount added approximately with NumaNode.GroupCount above */
+            if (procInfo->Cache.GroupCount) {
+              num = procInfo->Cache.GroupCount;
+              GroupMask = procInfo->Cache.GroupMasks;
+            } else {
               num = 1;
               GroupMask = &procInfo->Cache.GroupMask;
+            }
 	    break;
 	  case RelationProcessorCore:
 	    type = HWLOC_OBJ_CORE;
             num = procInfo->Processor.GroupCount;
             GroupMask = procInfo->Processor.GroupMask;
+            efficiency_class = procInfo->Processor.EfficiencyClass;
 	    break;
 	  case RelationGroup:
 	    /* So strange an interface... */
@@ -977,11 +1122,12 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 		groups_pu_set = hwloc_bitmap_alloc();
 	      hwloc_bitmap_or(groups_pu_set, groups_pu_set, set);
 
-	      if (hwloc_filter_check_keep_object_type(topology, HWLOC_OBJ_GROUP)) {
+              /* Ignore processor groups unless requested and filtered-in */
+              if (keep_pgroup_objs && hwloc_filter_check_keep_object_type(topology, HWLOC_OBJ_GROUP)) {
 		obj = hwloc_alloc_setup_object(topology, HWLOC_OBJ_GROUP, id);
 		obj->cpuset = set;
 		obj->attr->group.kind = HWLOC_GROUP_KIND_WINDOWS_PROCESSOR_GROUP;
-		hwloc_insert_object_by_cpuset(topology, obj);
+		hwloc__insert_object_by_cpuset(topology, NULL, obj, "windows:GetLogicalProcessorInformationEx:ProcessorGroup");
 	      } else
 		hwloc_bitmap_free(set);
 	    }
@@ -1005,6 +1151,11 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
         }
 	hwloc_debug_2args_bitmap("%s#%u bitmap %s\n", hwloc_obj_type_string(type), id, obj->cpuset);
 	switch (type) {
+        case HWLOC_OBJ_CORE: {
+          if (has_efficiencyclass)
+            hwloc_win_efficiency_classes_add(&eclasses, obj->cpuset, efficiency_class);
+          break;
+        }
 	  case HWLOC_OBJ_NUMANODE:
 	    {
 	      ULONGLONG avail;
@@ -1055,7 +1206,7 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 	  default:
 	    break;
 	}
-	hwloc_insert_object_by_cpuset(topology, obj);
+	hwloc__insert_object_by_cpuset(topology, NULL, obj, "windows:GetLogicalProcessorInformationEx");
       }
       free(procInfoTotal);
   }
@@ -1076,29 +1227,88 @@ hwloc_look_windows(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
       hwloc_bitmap_only(obj->cpuset, idx);
       hwloc_debug_1arg_bitmap("cpu %u has cpuset %s\n",
 			      idx, obj->cpuset);
-      hwloc_insert_object_by_cpuset(topology, obj);
+      hwloc__insert_object_by_cpuset(topology, NULL, obj, "windows:ProcessorGroup:pu");
     } hwloc_bitmap_foreach_end();
     hwloc_bitmap_free(groups_pu_set);
   } else {
     /* no processor groups */
-    SYSTEM_INFO sysinfo;
     hwloc_obj_t obj;
     unsigned idx;
-    GetSystemInfo(&sysinfo);
     for(idx=0; idx<32; idx++)
-      if (sysinfo.dwActiveProcessorMask & (((DWORD_PTR)1)<<idx)) {
+      if (SystemInfo.dwActiveProcessorMask & (((DWORD_PTR)1)<<idx)) {
 	obj = hwloc_alloc_setup_object(topology, HWLOC_OBJ_PU, idx);
 	obj->cpuset = hwloc_bitmap_alloc();
 	hwloc_bitmap_only(obj->cpuset, idx);
 	hwloc_debug_1arg_bitmap("cpu %u has cpuset %s\n",
 				idx, obj->cpuset);
-	hwloc_insert_object_by_cpuset(topology, obj);
+	hwloc__insert_object_by_cpuset(topology, NULL, obj, "windows:pu");
       }
   }
 
+  if (has_efficiencyclass) {
+    topology->support.discovery->cpukind_efficiency = 1;
+    hwloc_win_efficiency_classes_register(topology, &eclasses);
+  }
+
  out:
+  if (has_efficiencyclass)
+    hwloc_win_efficiency_classes_destroy(&eclasses);
+
+  /* emulate uname instead of calling hwloc_add_uname_info() */
   hwloc_obj_add_info(topology->levels[0][0], "Backend", "Windows");
-  hwloc_add_uname_info(topology, NULL);
+  hwloc_obj_add_info(topology->levels[0][0], "OSName", "Windows");
+
+#if defined(__CYGWIN__)
+  hwloc_obj_add_info(topology->levels[0][0], "WindowsBuildEnvironment", "Cygwin");
+#elif defined(__MINGW32__)
+  hwloc_obj_add_info(topology->levels[0][0], "WindowsBuildEnvironment", "MinGW");
+#endif
+
+  /* see https://docs.microsoft.com/en-us/windows/win32/api/winnt/ns-winnt-osversioninfoexa */
+  if (osvi.dwMajorVersion == 10) {
+    if (osvi.dwMinorVersion == 0)
+      hwloc_obj_add_info(topology->levels[0][0], "OSRelease", "10");
+  } else if (osvi.dwMajorVersion == 6) {
+    if (osvi.dwMinorVersion == 3)
+      hwloc_obj_add_info(topology->levels[0][0], "OSRelease", "8.1"); /* or "Server 2012 R2" */
+    else if (osvi.dwMinorVersion == 2)
+      hwloc_obj_add_info(topology->levels[0][0], "OSRelease", "8"); /* or "Server 2012" */
+    else if (osvi.dwMinorVersion == 1)
+      hwloc_obj_add_info(topology->levels[0][0], "OSRelease", "7"); /* or "Server 2008 R2" */
+    else if (osvi.dwMinorVersion == 0)
+      hwloc_obj_add_info(topology->levels[0][0], "OSRelease", "Vista"); /* or "Server 2008" */
+  } /* earlier versions are ignored */
+
+  snprintf(versionstr, sizeof(versionstr), "%u.%u.%u", osvi.dwMajorVersion, osvi.dwMinorVersion, osvi.dwBuildNumber);
+  hwloc_obj_add_info(topology->levels[0][0], "OSVersion", versionstr);
+
+#if !defined(__CYGWIN__)
+  GetComputerName(hostname, &hostname_size);
+#else
+  gethostname(hostname, hostname_size);
+#endif
+  if (*hostname)
+    hwloc_obj_add_info(topology->levels[0][0], "Hostname", hostname);
+
+  /* convert to unix-like architecture strings */
+  switch (SystemInfo.wProcessorArchitecture) {
+  case 0:
+    hwloc_obj_add_info(topology->levels[0][0], "Architecture", "i686");
+    break;
+  case 9:
+    hwloc_obj_add_info(topology->levels[0][0], "Architecture", "x86_64");
+    break;
+  case 5:
+    hwloc_obj_add_info(topology->levels[0][0], "Architecture", "arm");
+    break;
+  case 12:
+    hwloc_obj_add_info(topology->levels[0][0], "Architecture", "arm64");
+    break;
+  case 6:
+    hwloc_obj_add_info(topology->levels[0][0], "Architecture", "ia64");
+    break;
+  }
+
   return 0;
 }
 
@@ -1144,11 +1354,13 @@ hwloc_set_windows_hooks(struct hwloc_binding_hooks *hooks,
 static int hwloc_windows_component_init(unsigned long flags __hwloc_attribute_unused)
 {
   hwloc_win_get_function_ptrs();
+  hwloc_win_get_processor_groups();
   return 0;
 }
 
 static void hwloc_windows_component_finalize(unsigned long flags __hwloc_attribute_unused)
 {
+  hwloc_win_free_processor_groups();
 }
 
 static struct hwloc_backend *

src/3rdparty/hwloc/src/topology-x86.c

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2010-2019 Inria.  All rights reserved.
+ * Copyright © 2010-2021 Inria.  All rights reserved.
  * Copyright © 2010-2013 Université Bordeaux
  * Copyright © 2010-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
@@ -7,11 +7,14 @@
  *
  * This backend is only used when the operating system does not export
  * the necessary hardware topology information to user-space applications.
- * Currently, only the FreeBSD backend relies on this x86 backend.
+ * Currently, FreeBSD and NetBSD only add PUs and then fallback to this
+ * backend for CPU/Cache discovery.
  *
  * Other backends such as Linux have their own way to retrieve various
  * pieces of hardware topology information from the operating system
  * on various architectures, without having to use this x86-specific code.
+ * But this backend is still used after them to annotate some objects with
+ * additional details (CPU info in Package, Inclusiveness in Caches).
  */
 
 #include "private/autogen/config.h"
@@ -181,6 +184,7 @@ enum hwloc_x86_disc_flags {
 
 #define has_topoext(features) ((features)[6] & (1 << 22))
 #define has_x2apic(features) ((features)[4] & (1 << 21))
+#define has_hybrid(features) ((features)[18] & (1 << 15))
 
 struct cacheinfo {
   hwloc_obj_cache_type_t type;
@@ -217,6 +221,9 @@ struct procinfo {
   unsigned cpustepping;
   unsigned cpumodelnumber;
   unsigned cpufamilynumber;
+
+  unsigned hybridcoretype;
+  unsigned hybridnativemodel;
 };
 
 enum cpuid_type {
@@ -493,7 +500,8 @@ static void read_amd_cores_topoext(struct procinfo *infos, unsigned long flags,
       nodes_per_proc = ((ecx >> 8) & 7) + 1;
     }
     if ((infos->cpufamilynumber == 0x15 && nodes_per_proc > 2)
-	|| ((infos->cpufamilynumber == 0x17 || infos->cpufamilynumber == 0x18) && nodes_per_proc > 4)) {
+	|| ((infos->cpufamilynumber == 0x17 || infos->cpufamilynumber == 0x18) && nodes_per_proc > 4)
+        || (infos->cpufamilynumber == 0x19 && nodes_per_proc > 1)) {
       hwloc_debug("warning: undefined nodes_per_proc value %u, assuming it means %u\n", nodes_per_proc, nodes_per_proc);
     }
   }
@@ -606,10 +614,13 @@ static void look_proc(struct hwloc_backend *backend, struct procinfo *infos, uns
   eax = 0x01;
   cpuid_or_from_dump(&eax, &ebx, &ecx, &edx, src_cpuiddump);
   infos->apicid = ebx >> 24;
-  if (edx & (1 << 28))
+  if (edx & (1 << 28)) {
     legacy_max_log_proc = 1 << hwloc_flsl(((ebx >> 16) & 0xff) - 1);
-  else
+  } else {
+    hwloc_debug("HTT bit not set in CPUID 0x01.edx, assuming legacy_max_log_proc = 1\n");
     legacy_max_log_proc = 1;
+  }
+
   hwloc_debug("APIC ID 0x%02x legacy_max_log_proc %u\n", infos->apicid, legacy_max_log_proc);
   infos->ids[PKG] = infos->apicid / legacy_max_log_proc;
   legacy_log_proc_id = infos->apicid % legacy_max_log_proc;
@@ -672,14 +683,34 @@ static void look_proc(struct hwloc_backend *backend, struct procinfo *infos, uns
       unsigned max_nbcores;
       unsigned max_nbthreads;
       unsigned threadid __hwloc_attribute_unused;
+      hwloc_debug("Trying to get core/thread IDs from 0x04...\n");
       max_nbcores = ((eax >> 26) & 0x3f) + 1;
+      hwloc_debug("found %u cores max\n", max_nbcores);
+      /* some VMs (e.g. issue#525) don't report valid information, check things before dividing by 0. */
+      if (!max_nbcores) {
+        hwloc_debug("cannot detect core/thread IDs from 0x04 without a valid max of cores\n");
+      } else {
         max_nbthreads = legacy_max_log_proc / max_nbcores;
-      hwloc_debug("thus %u threads\n", max_nbthreads);
+        hwloc_debug("found %u threads max\n", max_nbthreads);
+        if (!max_nbthreads) {
+          hwloc_debug("cannot detect core/thread IDs from 0x04 without a valid max of threads\n");
+        } else {
           threadid = legacy_log_proc_id % max_nbthreads;
           infos->ids[CORE] = legacy_log_proc_id / max_nbthreads;
           hwloc_debug("this is thread %u of core %u\n", threadid, infos->ids[CORE]);
         }
       }
+    }
+  }
+
+  if (highest_cpuid >= 0x1a && has_hybrid(features)) {
+    /* Get hybrid cpu information from cpuid 0x1a */
+    eax = 0x1a;
+    ecx = 0;
+    cpuid_or_from_dump(&eax, &ebx, &ecx, &edx, src_cpuiddump);
+    infos->hybridcoretype = eax >> 24;
+    infos->hybridnativemodel = eax & 0xffffff;
+  }
 
   /*********************************************************************************
    * Get the hierarchy of thread, core, die, package, etc. from CPU-specific leaves
@@ -751,15 +782,27 @@ static void look_proc(struct hwloc_backend *backend, struct procinfo *infos, uns
     /* default cacheid value */
     cache->cacheid = infos->apicid / cache->nbthreads_sharing;
 
-    if (cpuid_type == amd) {
+    if (cpuid_type == intel) {
+      /* round nbthreads_sharing to nearest power of two to build a mask (for clearing lower bits) */
+      unsigned bits = hwloc_flsl(cache->nbthreads_sharing-1);
+      unsigned mask = ~((1U<<bits) - 1);
+      cache->cacheid = infos->apicid & mask;
+
+    } else if (cpuid_type == amd) {
       /* AMD quirks */
-      if (infos->cpufamilynumber == 0x17
-	  && cache->level == 3 && cache->nbthreads_sharing == 6) {
-	/* AMD family 0x17 always shares L3 between 8 APIC ids,
-	 * even when only 6 APIC ids are enabled and reported in nbthreads_sharing
-	 * (on 24-core CPUs).
+      if (infos->cpufamilynumber >= 0x17 && cache->level == 3) {
+	/* AMD family 0x19 always shares L3 between 16 APIC ids (8 HT cores).
+         * while Family 0x17 shares between 8 APIC ids (4 HT cores).
+         * But many models have less APIC ids enabled and reported in nbthreads_sharing.
+         * It means we must round-up nbthreads_sharing to the nearest power of 2
+         * before computing cacheid.
 	 */
-	cache->cacheid = infos->apicid / 8;
+        unsigned nbapics_sharing = cache->nbthreads_sharing;
+        if (nbapics_sharing & (nbapics_sharing-1))
+          /* not a power of two, round-up */
+          nbapics_sharing = 1U<<(1+hwloc_ffsl(nbapics_sharing));
+
+	cache->cacheid = infos->apicid / nbapics_sharing;
 
       } else if (infos->cpufamilynumber== 0x10 && infos->cpumodelnumber == 0x9
 	  && cache->level == 3
@@ -785,7 +828,7 @@ static void look_proc(struct hwloc_backend *backend, struct procinfo *infos, uns
       } else if (infos->cpufamilynumber == 0x15
 		 && (infos->cpumodelnumber == 0x1 /* Bulldozer */ || infos->cpumodelnumber == 0x2 /* Piledriver */)
 		 && cache->level == 3 && cache->nbthreads_sharing == 6) {
-	/* AMD Bulldozer and Piledriver 12-core processors have same APIC ids as Magny-Cours below,
+	/* AMD Bulldozer and Piledriver 12-core processors have same APIC ids as Magny-Cours above,
 	 * but we can't merge the checks because the original nbthreads_sharing must be exactly 6 here.
 	 */
 	cache->cacheid = (infos->apicid % legacy_max_log_proc) / cache->nbthreads_sharing /* cacheid within the package */
@@ -872,7 +915,7 @@ hwloc_x86_add_groups(hwloc_topology_t topology,
     obj->attr->group.dont_merge = dont_merge;
     hwloc_debug_2args_bitmap("os %s %u has cpuset %s\n",
 			     subtype, id, obj_cpuset);
-    hwloc_insert_object_by_cpuset(topology, obj);
+    hwloc__insert_object_by_cpuset(topology, NULL, obj, "x86:group");
   }
 }
 
@@ -889,6 +932,16 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
   int gotnuma = 0;
   int fulldiscovery = (flags & HWLOC_X86_DISC_FLAG_FULL);
 
+#ifdef HWLOC_DEBUG
+  hwloc_debug("\nSummary of x86 CPUID topology:\n");
+  for(i=0; i<nbprocs; i++) {
+    hwloc_debug("PU %u present=%u apicid=%u on PKG %d CORE %d DIE %d NODE %d\n",
+                i, infos[i].present, infos[i].apicid,
+                infos[i].ids[PKG], infos[i].ids[CORE], infos[i].ids[DIE], infos[i].ids[NODE]);
+  }
+  hwloc_debug("\n");
+#endif
+
   for (i = 0; i < nbprocs; i++)
     if (infos[i].present) {
       hwloc_bitmap_set(complete_cpuset, i);
@@ -930,7 +983,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
 
 	hwloc_debug_1arg_bitmap("os package %u has cpuset %s\n",
 				packageid, package_cpuset);
-	hwloc_insert_object_by_cpuset(topology, package);
+	hwloc__insert_object_by_cpuset(topology, NULL, package, "x86:package");
 
       } else {
 	/* Annotate packages previously-existing packages */
@@ -986,7 +1039,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
       hwloc_bitmap_set(node->nodeset, nodeid);
       hwloc_debug_1arg_bitmap("os node %u has cpuset %s\n",
           nodeid, node_cpuset);
-      hwloc_insert_object_by_cpuset(topology, node);
+      hwloc__insert_object_by_cpuset(topology, NULL, node, "x86:numa");
       gotnuma++;
     }
   }
@@ -1033,7 +1086,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
 	      unknown_obj->attr->group.subkind = level;
 	      hwloc_debug_2args_bitmap("os unknown%u %u has cpuset %s\n",
 				       level, unknownid, unknown_cpuset);
-	      hwloc_insert_object_by_cpuset(topology, unknown_obj);
+	      hwloc__insert_object_by_cpuset(topology, NULL, unknown_obj, "x86:group:unknown");
 	    }
 	  }
 	}
@@ -1073,7 +1126,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
 	die->cpuset = die_cpuset;
 	hwloc_debug_1arg_bitmap("os die %u has cpuset %s\n",
 				dieid, die_cpuset);
-	hwloc_insert_object_by_cpuset(topology, die);
+	hwloc__insert_object_by_cpuset(topology, NULL, die, "x86:die");
       }
     }
   }
@@ -1111,7 +1164,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
 	core->cpuset = core_cpuset;
 	hwloc_debug_1arg_bitmap("os core %u has cpuset %s\n",
 				coreid, core_cpuset);
-	hwloc_insert_object_by_cpuset(topology, core);
+	hwloc__insert_object_by_cpuset(topology, NULL, core, "x86:core");
       }
     }
   }
@@ -1125,7 +1178,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
        obj->cpuset = hwloc_bitmap_alloc();
        hwloc_bitmap_only(obj->cpuset, i);
        hwloc_debug_1arg_bitmap("PU %u has cpuset %s\n", i, obj->cpuset);
-       hwloc_insert_object_by_cpuset(topology, obj);
+       hwloc__insert_object_by_cpuset(topology, NULL, obj, "x86:pu");
      }
   }
 
@@ -1199,6 +1252,18 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
 	    }
 	  }
 	  cache = hwloc_alloc_setup_object(topology, otype, HWLOC_UNKNOWN_INDEX);
+          /* We don't specify the os_index of caches because we want to be
+           * 100% sure they are identical to what the Linux kernel reports
+           * (so that things like resctrl work).
+           * However, vendor/model-specific quirks in the x86 code above
+           * make this difficult.
+           *
+           * Caveat: if the x86 backend is used on Linux to avoid kernel bugs,
+           * IDs won't be available to resctrl users. But resctrl heavily
+           * relies on the kernel x86 discovery being non-buggy anyway.
+           *
+           * TODO: make this optional? or only disable it on Linux?
+           */
 	  cache->attr->cache.depth = level;
 	  cache->attr->cache.size = infos[i].cache[l].size;
 	  cache->attr->cache.linesize = infos[i].cache[l].linesize;
@@ -1208,7 +1273,7 @@ static void summarize(struct hwloc_backend *backend, struct procinfo *infos, uns
 	  hwloc_obj_add_info(cache, "Inclusive", infos[i].cache[l].inclusive ? "1" : "0");
 	  hwloc_debug_2args_bitmap("os L%u cache %u has cpuset %s\n",
 				   level, cacheid, cache_cpuset);
-	  hwloc_insert_object_by_cpuset(topology, cache);
+	  hwloc__insert_object_by_cpuset(topology, NULL, cache, "x86:cache");
 	}
       }
     }
@@ -1228,7 +1293,8 @@ static int
 look_procs(struct hwloc_backend *backend, struct procinfo *infos, unsigned long flags,
 	   unsigned highest_cpuid, unsigned highest_ext_cpuid, unsigned *features, enum cpuid_type cpuid_type,
 	   int (*get_cpubind)(hwloc_topology_t topology, hwloc_cpuset_t set, int flags),
-	   int (*set_cpubind)(hwloc_topology_t topology, hwloc_const_cpuset_t set, int flags))
+	   int (*set_cpubind)(hwloc_topology_t topology, hwloc_const_cpuset_t set, int flags),
+           hwloc_bitmap_t restrict_set)
 {
   struct hwloc_x86_backend_data_s *data = backend->private_data;
   struct hwloc_topology *topology = backend->topology;
@@ -1248,6 +1314,12 @@ look_procs(struct hwloc_backend *backend, struct procinfo *infos, unsigned long
 
   for (i = 0; i < nbprocs; i++) {
     struct cpuiddump *src_cpuiddump = NULL;
+
+    if (restrict_set && !hwloc_bitmap_isset(restrict_set, i)) {
+      /* skip this CPU outside of the binding mask */
+      continue;
+    }
+
     if (data->src_cpuiddump_path) {
       src_cpuiddump = cpuiddump_read(data->src_cpuiddump_path, i);
       if (!src_cpuiddump)
@@ -1274,8 +1346,41 @@ look_procs(struct hwloc_backend *backend, struct procinfo *infos, unsigned long
     hwloc_bitmap_free(orig_cpuset);
   }
 
-  if (data->apicid_unique)
+  if (data->apicid_unique) {
     summarize(backend, infos, flags);
+
+    if (has_hybrid(features)) {
+      /* use hybrid info for cpukinds */
+      hwloc_bitmap_t atomset = hwloc_bitmap_alloc();
+      hwloc_bitmap_t coreset = hwloc_bitmap_alloc();
+      for(i=0; i<nbprocs; i++) {
+        if (infos[i].hybridcoretype == 0x20)
+          hwloc_bitmap_set(atomset, i);
+        else if (infos[i].hybridcoretype == 0x40)
+          hwloc_bitmap_set(coreset, i);
+      }
+      /* register IntelAtom set if any */
+      if (!hwloc_bitmap_iszero(atomset)) {
+        struct hwloc_info_s infoattr;
+        infoattr.name = (char *) "CoreType";
+        infoattr.value = (char *) "IntelAtom";
+        hwloc_internal_cpukinds_register(topology, atomset, HWLOC_CPUKIND_EFFICIENCY_UNKNOWN, &infoattr, 1, 0);
+        /* the cpuset is given to the callee */
+      } else {
+        hwloc_bitmap_free(atomset);
+      }
+      /* register IntelCore set if any */
+      if (!hwloc_bitmap_iszero(coreset)) {
+        struct hwloc_info_s infoattr;
+        infoattr.name = (char *) "CoreType";
+        infoattr.value = (char *) "IntelCore";
+        hwloc_internal_cpukinds_register(topology, coreset, HWLOC_CPUKIND_EFFICIENCY_UNKNOWN, &infoattr, 1, 0);
+        /* the cpuset is given to the callee */
+      } else {
+        hwloc_bitmap_free(coreset);
+      }
+    }
+  }
   /* if !data->apicid_unique, do nothing and return success, so that the caller does nothing either */
 
   return 0;
@@ -1348,13 +1453,14 @@ static
 int hwloc_look_x86(struct hwloc_backend *backend, unsigned long flags)
 {
   struct hwloc_x86_backend_data_s *data = backend->private_data;
+  struct hwloc_topology *topology = backend->topology;
   unsigned nbprocs = data->nbprocs;
   unsigned eax, ebx, ecx = 0, edx;
   unsigned i;
   unsigned highest_cpuid;
   unsigned highest_ext_cpuid;
   /* This stores cpuid features with the same indexing as Linux */
-  unsigned features[10] = { 0 };
+  unsigned features[19] = { 0 };
   struct procinfo *infos = NULL;
   enum cpuid_type cpuid_type = unknown;
   hwloc_x86_os_state_t os_state;
@@ -1363,9 +1469,21 @@ int hwloc_look_x86(struct hwloc_backend *backend, unsigned long flags)
   struct hwloc_topology_membind_support memsupport __hwloc_attribute_unused;
   int (*get_cpubind)(hwloc_topology_t topology, hwloc_cpuset_t set, int flags) = NULL;
   int (*set_cpubind)(hwloc_topology_t topology, hwloc_const_cpuset_t set, int flags) = NULL;
+  hwloc_bitmap_t restrict_set = NULL;
   struct cpuiddump *src_cpuiddump = NULL;
   int ret = -1;
 
+  /* check if binding works */
+  memset(&hooks, 0, sizeof(hooks));
+  support.membind = &memsupport;
+  /* We could just copy the main hooks (except in some corner cases),
+   * but the current overhead is negligible, so just always reget them.
+   */
+  hwloc_set_native_binding_hooks(&hooks, &support);
+  /* in theory, those are only needed if !data->src_cpuiddump_path || HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_BINDING
+   * but that's the vast majority of cases anyway, and the overhead is very small.
+   */
+
   if (data->src_cpuiddump_path) {
     /* Just read cpuid from the dump (implies !topology->is_thissystem by default) */
     src_cpuiddump = cpuiddump_read(data->src_cpuiddump_path, 0);
@@ -1378,10 +1496,6 @@ int hwloc_look_x86(struct hwloc_backend *backend, unsigned long flags)
      * we may still force use this backend when debugging with !thissystem.
      */
 
-    /* check if binding works */
-    memset(&hooks, 0, sizeof(hooks));
-    support.membind = &memsupport;
-    hwloc_set_native_binding_hooks(&hooks, &support);
     if (hooks.get_thisthread_cpubind && hooks.set_thisthread_cpubind) {
       get_cpubind = hooks.get_thisthread_cpubind;
       set_cpubind = hooks.set_thisthread_cpubind;
@@ -1401,6 +1515,20 @@ int hwloc_look_x86(struct hwloc_backend *backend, unsigned long flags)
     }
   }
 
+  if (topology->flags & HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING) {
+    restrict_set = hwloc_bitmap_alloc();
+    if (!restrict_set)
+      goto out;
+    if (hooks.get_thisproc_cpubind)
+      hooks.get_thisproc_cpubind(topology, restrict_set, 0);
+    else if (hooks.get_thisthread_cpubind)
+      hooks.get_thisthread_cpubind(topology, restrict_set, 0);
+    if (hwloc_bitmap_iszero(restrict_set)) {
+      hwloc_bitmap_free(restrict_set);
+      restrict_set = NULL;
+    }
+  }
+
   if (!src_cpuiddump && !hwloc_have_x86_cpuid())
     goto out;
 
@@ -1451,6 +1579,7 @@ int hwloc_look_x86(struct hwloc_backend *backend, unsigned long flags)
     ecx = 0;
     cpuid_or_from_dump(&eax, &ebx, &ecx, &edx, src_cpuiddump);
     features[9] = ebx;
+    features[18] = edx;
   }
 
   if (cpuid_type != intel && highest_ext_cpuid >= 0x80000001) {
@@ -1464,7 +1593,7 @@ int hwloc_look_x86(struct hwloc_backend *backend, unsigned long flags)
 
   ret = look_procs(backend, infos, flags,
 		   highest_cpuid, highest_ext_cpuid, features, cpuid_type,
-		   get_cpubind, set_cpubind);
+		   get_cpubind, set_cpubind, restrict_set);
   if (!ret)
     /* success, we're done */
     goto out_with_os_state;
@@ -1489,6 +1618,7 @@ out_with_infos:
   }
 
 out:
+  hwloc_bitmap_free(restrict_set);
   if (src_cpuiddump)
     cpuiddump_free(src_cpuiddump);
   return ret;
@@ -1505,6 +1635,11 @@ hwloc_x86_discover(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
 
   assert(dstatus->phase == HWLOC_DISC_PHASE_CPU);
 
+  if (topology->flags & HWLOC_TOPOLOGY_FLAG_DONT_CHANGE_BINDING) {
+    /* TODO: Things would work if there's a single PU, no need to rebind */
+    return 0;
+  }
+
   if (getenv("HWLOC_X86_TOPOEXT_NUMANODES")) {
     flags |= HWLOC_X86_DISC_FLAG_TOPOEXT_NUMANODES;
   }
@@ -1531,7 +1666,8 @@ hwloc_x86_discover(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
   }
 
   if (topology->levels[0][0]->cpuset) {
-    /* somebody else discovered things */
+    /* somebody else discovered things, reconnect levels so that we can look at them */
+    hwloc_topology_reconnect(topology, 0);
     if (topology->nb_levels == 2 && topology->level_nbobjects[1] == data->nbprocs) {
       /* only PUs were discovered, as much as we would, complete the topology with everything else */
       alreadypus = 1;
@@ -1539,7 +1675,6 @@ hwloc_x86_discover(struct hwloc_backend *backend, struct hwloc_disc_status *dsta
     }
 
     /* several object types were added, we can't easily complete, just do partial discovery */
-    hwloc_topology_reconnect(topology, 0);
     ret = hwloc_look_x86(backend, flags);
     if (ret)
       hwloc_obj_add_info(topology->levels[0][0], "Backend", "x86");

src/3rdparty/hwloc/src/topology-xml-nolibxml.c

@@ -213,7 +213,7 @@ hwloc__nolibxml_import_close_child(hwloc__xml_import_state_t state)
 
 static int
 hwloc__nolibxml_import_get_content(hwloc__xml_import_state_t state,
-				   char **beginp, size_t expected_length)
+				   const char **beginp, size_t expected_length)
 {
   hwloc__nolibxml_import_state_data_t nstate = (void*) state->data;
   char *buffer = nstate->tagbuffer;
@@ -224,7 +224,7 @@ hwloc__nolibxml_import_get_content(hwloc__xml_import_state_t state,
   if (nstate->closed) {
     if (expected_length)
       return -1;
-    *beginp = (char *) "";
+    *beginp = "";
     return 0;
   }
 

src/3rdparty/hwloc/src/topology-xml.c

@@ -1,7 +1,7 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2020 Inria.  All rights reserved.
- * Copyright © 2009-2011 Université Bordeaux
+ * Copyright © 2009-2021 Inria.  All rights reserved.
+ * Copyright © 2009-2011, 2020 Université Bordeaux
  * Copyright © 2009-2018 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
  */
@@ -192,6 +192,7 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
 	  || lvalue == HWLOC_OBJ_CACHE_INSTRUCTION)
 	obj->attr->cache.type = (hwloc_obj_cache_type_t) lvalue;
       else
+        if (hwloc__xml_verbose())
           fprintf(stderr, "%s: ignoring invalid cache_type attribute %lu\n",
                   state->global->msgprefix, lvalue);
     } else if (hwloc__xml_verbose())
@@ -242,7 +243,7 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
   else if (!strcmp(name, "dont_merge")) {
     unsigned long lvalue = strtoul(value, NULL, 10);
     if (obj->type == HWLOC_OBJ_GROUP)
-      obj->attr->group.dont_merge = lvalue;
+      obj->attr->group.dont_merge = (unsigned char) lvalue;
     else if (hwloc__xml_verbose())
       fprintf(stderr, "%s: ignoring dont_merge attribute for non-group object type\n",
 	      state->global->msgprefix);
@@ -262,8 +263,8 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
 #ifndef HWLOC_HAVE_32BITS_PCI_DOMAIN
       } else if (domain > 0xffff) {
 	static int warned = 0;
-	if (!warned && !hwloc_hide_errors())
-	  fprintf(stderr, "Ignoring PCI device with non-16bit domain.\nPass --enable-32bits-pci-domain to configure to support such devices\n(warning: it would break the library ABI, don't enable unless really needed).\n");
+	if (!warned && hwloc_hide_errors() < 2)
+	  fprintf(stderr, "hwloc/xml: Ignoring PCI device with non-16bit domain.\nPass --enable-32bits-pci-domain to configure to support such devices\n(warning: it would break the library ABI, don't enable unless really needed).\n");
 	warned = 1;
 	*ignore = 1;
 #endif
@@ -337,6 +338,7 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
       } else {
 	obj->attr->bridge.upstream_type = (hwloc_obj_bridge_type_t) upstream_type;
 	obj->attr->bridge.downstream_type = (hwloc_obj_bridge_type_t) downstream_type;
+        /* FIXME verify that upstream/downstream type is valid */
       };
       break;
     }
@@ -361,12 +363,13 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
 #ifndef HWLOC_HAVE_32BITS_PCI_DOMAIN
       } else if (domain > 0xffff) {
 	static int warned = 0;
-	if (!warned && !hwloc_hide_errors())
-	  fprintf(stderr, "Ignoring bridge to PCI with non-16bit domain.\nPass --enable-32bits-pci-domain to configure to support such devices\n(warning: it would break the library ABI, don't enable unless really needed).\n");
+	if (!warned && hwloc_hide_errors() < 2)
+	  fprintf(stderr, "hwloc/xml: Ignoring bridge to PCI with non-16bit domain.\nPass --enable-32bits-pci-domain to configure to support such devices\n(warning: it would break the library ABI, don't enable unless really needed).\n");
 	warned = 1;
 	*ignore = 1;
 #endif
       } else {
+        /* FIXME verify that downstream type vs pci info are valid */
 	obj->attr->bridge.downstream.pci.domain = domain;
 	obj->attr->bridge.downstream.pci.secondary_bus = secbus;
 	obj->attr->bridge.downstream.pci.subordinate_bus = subbus;
@@ -481,10 +484,8 @@ hwloc__xml_import_object_attr(struct hwloc_topology *topology,
   }
 }
 
-
 static int
-hwloc__xml_import_info(struct hwloc_xml_backend_data_s *data,
-		       hwloc_obj_t obj,
+hwloc___xml_import_info(char **infonamep, char **infovaluep,
                         hwloc__xml_import_state_t state)
 {
   char *infoname = NULL;
@@ -502,6 +503,25 @@ hwloc__xml_import_info(struct hwloc_xml_backend_data_s *data,
       return -1;
   }
 
+  *infonamep = infoname;
+  *infovaluep = infovalue;
+
+  return state->global->close_tag(state);
+}
+
+static int
+hwloc__xml_import_obj_info(struct hwloc_xml_backend_data_s *data,
+                           hwloc_obj_t obj,
+                           hwloc__xml_import_state_t state)
+{
+  char *infoname = NULL;
+  char *infovalue = NULL;
+  int err;
+
+  err = hwloc___xml_import_info(&infoname, &infovalue, state);
+  if (err < 0)
+    return err;
+
   if (infoname) {
     /* empty strings are ignored by libxml */
     if (data->version_major < 2 &&
@@ -518,7 +538,7 @@ hwloc__xml_import_info(struct hwloc_xml_backend_data_s *data,
     }
   }
 
-  return state->global->close_tag(state);
+  return err;
 }
 
 static int
@@ -694,14 +714,15 @@ hwloc__xml_import_userdata(hwloc_topology_t topology __hwloc_attribute_unused, h
   }
 
   if (!topology->userdata_import_cb) {
-    char *buffer;
+    const char *buffer;
     size_t reallength = encoded ? BASE64_ENCODED_LENGTH(length) : length;
     ret = state->global->get_content(state, &buffer, reallength);
     if (ret < 0)
       return -1;
 
   } else if (topology->userdata_not_decoded) {
-      char *buffer, *fakename;
+      const char *buffer;
+      char *fakename;
       size_t reallength = encoded ? BASE64_ENCODED_LENGTH(length) : length;
       ret = state->global->get_content(state, &buffer, reallength);
       if (ret < 0)
@@ -714,7 +735,7 @@ hwloc__xml_import_userdata(hwloc_topology_t topology __hwloc_attribute_unused, h
       free(fakename);
 
   } else if (encoded && length) {
-      char *encoded_buffer;
+      const char *encoded_buffer;
       size_t encoded_length = BASE64_ENCODED_LENGTH(length);
       ret = state->global->get_content(state, &encoded_buffer, encoded_length);
       if (ret < 0)
@@ -734,7 +755,7 @@ hwloc__xml_import_userdata(hwloc_topology_t topology __hwloc_attribute_unused, h
       }
 
   } else { /* always handle length==0 in the non-encoded case */
-      char *buffer = (char *) "";
+      const char *buffer = "";
       if (length) {
 	ret = state->global->get_content(state, &buffer, length);
 	if (ret < 0)
@@ -888,7 +909,7 @@ hwloc__xml_import_object(hwloc_topology_t topology,
       }
 
     } else if (!strcmp(tag, "info")) {
-      ret = hwloc__xml_import_info(data, obj, &childstate);
+      ret = hwloc__xml_import_obj_info(data, obj, &childstate);
     } else if (data->version_major < 2 && !strcmp(tag, "distances")) {
       ret = hwloc__xml_v1import_distances(data, obj, &childstate);
     } else if (!strcmp(tag, "userdata")) {
@@ -1214,7 +1235,7 @@ hwloc__xml_import_object(hwloc_topology_t topology,
 	/* next should be before cur */
 	if (!childrengotignored) {
 	  static int reported = 0;
-	  if (!reported && !hwloc_hide_errors()) {
+	  if (!reported && hwloc_hide_errors() < 2) {
 	    hwloc__xml_import_report_outoforder(topology, next, cur);
 	    reported = 1;
 	  }
@@ -1238,6 +1259,80 @@ hwloc__xml_import_object(hwloc_topology_t topology,
   return -1;
 }
 
+static int
+hwloc__xml_v2import_support(hwloc_topology_t topology,
+                            hwloc__xml_import_state_t state)
+{
+  char *name = NULL;
+  int value = 1; /* value is optional */
+  while (1) {
+    char *attrname, *attrvalue;
+    if (state->global->next_attr(state, &attrname, &attrvalue) < 0)
+      break;
+    if (!strcmp(attrname, "name"))
+      name = attrvalue;
+    else if (!strcmp(attrname, "value"))
+      value = atoi(attrvalue);
+    else {
+      if (hwloc__xml_verbose())
+	fprintf(stderr, "%s: ignoring unknown support attribute %s\n",
+		state->global->msgprefix, attrname);
+    }
+  }
+
+  if (name && topology->flags & HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT) {
+#ifdef HWLOC_DEBUG
+    HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_support) == 4*sizeof(void*));
+    HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_discovery_support) == 6);
+    HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_cpubind_support) == 11);
+    HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_membind_support) == 15);
+    HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_misc_support) == 1);
+#endif
+
+#define DO(_cat,_name) if (!strcmp(#_cat "." #_name, name)) topology->support._cat->_name = value
+    DO(discovery,pu);
+    else DO(discovery,numa);
+    else DO(discovery,numa_memory);
+    else DO(discovery,disallowed_pu);
+    else DO(discovery,disallowed_numa);
+    else DO(discovery,cpukind_efficiency);
+    else DO(cpubind,set_thisproc_cpubind);
+    else DO(cpubind,get_thisproc_cpubind);
+    else DO(cpubind,set_proc_cpubind);
+    else DO(cpubind,get_proc_cpubind);
+    else DO(cpubind,set_thisthread_cpubind);
+    else DO(cpubind,get_thisthread_cpubind);
+    else DO(cpubind,set_thread_cpubind);
+    else DO(cpubind,get_thread_cpubind);
+    else DO(cpubind,get_thisproc_last_cpu_location);
+    else DO(cpubind,get_proc_last_cpu_location);
+    else DO(cpubind,get_thisthread_last_cpu_location);
+    else DO(membind,set_thisproc_membind);
+    else DO(membind,get_thisproc_membind);
+    else DO(membind,set_proc_membind);
+    else DO(membind,get_proc_membind);
+    else DO(membind,set_thisthread_membind);
+    else DO(membind,get_thisthread_membind);
+    else DO(membind,set_area_membind);
+    else DO(membind,get_area_membind);
+    else DO(membind,alloc_membind);
+    else DO(membind,firsttouch_membind);
+    else DO(membind,bind_membind);
+    else DO(membind,interleave_membind);
+    else DO(membind,nexttouch_membind);
+    else DO(membind,migrate_membind);
+    else DO(membind,get_area_memlocation);
+
+    else if (!strcmp("custom.exported_support", name))
+      /* support was exported in a custom/fake field, mark it as imported here */
+      topology->support.misc->imported_support = 1;
+
+#undef DO
+  }
+
+  return 0;
+}
+
 static int
 hwloc__xml_v2import_distances(hwloc_topology_t topology,
 			      hwloc__xml_import_state_t state,
@@ -1317,7 +1412,8 @@ hwloc__xml_v2import_distances(hwloc_topology_t topology,
   nr_u64values = 0;
   while (1) {
     struct hwloc__xml_import_state_s childstate;
-    char *attrname, *attrvalue, *tag, *buffer;
+    char *attrname, *attrvalue, *tag;
+    const char *buffer;
     int length;
     int is_index = 0;
     int is_u64values = 0;
@@ -1356,7 +1452,7 @@ hwloc__xml_v2import_distances(hwloc_topology_t topology,
 
     if (is_index) {
       /* get indexes */
-      char *tmp, *tmp2;
+      const char *tmp, *tmp2;
       if (nr_indexes >= nbobjs) {
 	if (hwloc__xml_verbose())
 	  fprintf(stderr, "%s: %s with more than %u indexes\n",
@@ -1369,6 +1465,9 @@ hwloc__xml_v2import_distances(hwloc_topology_t topology,
 	unsigned long long u;
 	if (heterotypes) {
 	  hwloc_obj_type_t t = HWLOC_OBJ_TYPE_NONE;
+          if (!*tmp)
+            /* reached the end of this indexes attribute */
+            break;
 	  if (hwloc_type_sscanf(tmp, &t, NULL, 0) < 0) {
 	    if (hwloc__xml_verbose())
 	      fprintf(stderr, "%s: %s with unrecognized heterogeneous type %s\n",
@@ -1398,7 +1497,7 @@ hwloc__xml_v2import_distances(hwloc_topology_t topology,
 
     } else if (is_u64values) {
       /* get uint64_t values */
-      char *tmp;
+      const char *tmp;
       if (nr_u64values >= nbobjs*nbobjs) {
 	if (hwloc__xml_verbose())
 	  fprintf(stderr, "%s: %s with more than %u u64values\n",
@@ -1469,7 +1568,7 @@ hwloc__xml_v2import_distances(hwloc_topology_t topology,
     }
   }
 
-  hwloc_internal_distances_add_by_index(topology, name, unique_type, different_types, nbobjs, indexes, u64values, kind, 0);
+  hwloc_internal_distances_add_by_index(topology, name, unique_type, different_types, nbobjs, indexes, u64values, kind, 0 /* assume grouping was applied when this matrix was discovered before exporting to XML */);
 
   /* prevent freeing below */
   indexes = NULL;
@@ -1491,6 +1590,259 @@ hwloc__xml_v2import_distances(hwloc_topology_t topology,
 #undef _TAG_NAME
 }
 
+static int
+hwloc__xml_import_memattr_value(hwloc_topology_t topology,
+                                hwloc_memattr_id_t id,
+                                unsigned long flags,
+                                hwloc__xml_import_state_t state)
+{
+  char *target_obj_gp_index_s = NULL;
+  char *target_obj_type_s = NULL;
+  hwloc_uint64_t target_obj_gp_index;
+  char *value_s = NULL;
+  hwloc_uint64_t value;
+  char *initiator_cpuset_s = NULL;
+  char *initiator_obj_gp_index_s = NULL;
+  char *initiator_obj_type_s = NULL;
+  hwloc_obj_type_t target_obj_type = HWLOC_OBJ_TYPE_NONE;
+
+  while (1) {
+    char *attrname, *attrvalue;
+    if (state->global->next_attr(state, &attrname, &attrvalue) < 0)
+      break;
+    if (!strcmp(attrname, "target_obj_gp_index"))
+      target_obj_gp_index_s = attrvalue;
+    else if (!strcmp(attrname, "target_obj_type"))
+      target_obj_type_s = attrvalue;
+    else if (!strcmp(attrname, "value"))
+      value_s = attrvalue;
+    else if (!strcmp(attrname, "initiator_cpuset"))
+      initiator_cpuset_s = attrvalue;
+    else if (!strcmp(attrname, "initiator_obj_gp_index"))
+      initiator_obj_gp_index_s = attrvalue;
+    else if (!strcmp(attrname, "initiator_obj_type"))
+      initiator_obj_type_s = attrvalue;
+    else {
+      if (hwloc__xml_verbose())
+        fprintf(stderr, "%s: ignoring unknown memattr_value attribute %s\n",
+                state->global->msgprefix, attrname);
+      return -1;
+    }
+  }
+
+  if (!target_obj_type_s) {
+    if (hwloc__xml_verbose())
+      fprintf(stderr, "%s: ignoring memattr_value without target_obj_type.\n",
+              state->global->msgprefix);
+    return -1;
+  }
+  if (hwloc_type_sscanf(target_obj_type_s, &target_obj_type, NULL, 0) < 0) {
+    if (hwloc__xml_verbose())
+      fprintf(stderr, "%s: failed to identify memattr_value target object type %s\n",
+              state->global->msgprefix, target_obj_type_s);
+    return -1;
+  }
+
+  if (!value_s || !target_obj_gp_index_s) {
+    if (hwloc__xml_verbose())
+      fprintf(stderr, "%s: ignoring memattr_value without value and target_obj_gp_index\n",
+              state->global->msgprefix);
+    return -1;
+  }
+  target_obj_gp_index = strtoull(target_obj_gp_index_s, NULL, 10);
+  value = strtoull(value_s, NULL, 10);
+
+  if (flags & HWLOC_MEMATTR_FLAG_NEED_INITIATOR) {
+    /* add a value with initiator */
+    struct hwloc_internal_location_s loc;
+    if (!initiator_cpuset_s && (!initiator_obj_gp_index_s || !initiator_obj_type_s)) {
+      if (hwloc__xml_verbose())
+        fprintf(stderr, "%s: ignoring memattr_value without initiator attributes\n",
+                state->global->msgprefix);
+      return -1;
+    }
+
+    /* setup the initiator */
+    if (initiator_cpuset_s) {
+      loc.type = HWLOC_LOCATION_TYPE_CPUSET;
+      loc.location.cpuset = hwloc_bitmap_alloc();
+      if (!loc.location.cpuset) {
+        if (hwloc__xml_verbose())
+          fprintf(stderr, "%s: failed to allocated memattr_value initiator cpuset\n",
+                  state->global->msgprefix);
+        return -1;
+      }
+      hwloc_bitmap_sscanf(loc.location.cpuset, initiator_cpuset_s);
+    } else {
+      loc.type = HWLOC_LOCATION_TYPE_OBJECT;
+      loc.location.object.gp_index = strtoull(initiator_obj_gp_index_s, NULL, 10);
+      if (hwloc_type_sscanf(initiator_obj_type_s, &loc.location.object.type, NULL, 0) < 0) {
+        if (hwloc__xml_verbose())
+          fprintf(stderr, "%s: failed to identify memattr_value initiator object type %s\n",
+                  state->global->msgprefix, initiator_obj_type_s);
+        return -1;
+      }
+    }
+
+    hwloc_internal_memattr_set_value(topology, id, target_obj_type, target_obj_gp_index, (unsigned)-1, &loc, value);
+
+    if (loc.type == HWLOC_LOCATION_TYPE_CPUSET)
+      hwloc_bitmap_free(loc.location.cpuset);
+
+  } else {
+    /* add a value without initiator */
+    hwloc_internal_memattr_set_value(topology, id, target_obj_type, target_obj_gp_index, (unsigned)-1, NULL, value);
+  }
+
+  return 0;
+}
+
+static int
+hwloc__xml_import_memattr(hwloc_topology_t topology,
+                          hwloc__xml_import_state_t state)
+{
+  char *name = NULL;
+  unsigned long flags = (unsigned long) -1;
+  hwloc_memattr_id_t id = (hwloc_memattr_id_t) -1;
+  int ret;
+
+  while (1) {
+    char *attrname, *attrvalue;
+    if (state->global->next_attr(state, &attrname, &attrvalue) < 0)
+      break;
+    if (!strcmp(attrname, "name"))
+      name = attrvalue;
+    else if (!strcmp(attrname, "flags"))
+      flags = strtoul(attrvalue, NULL, 10);
+    else {
+      if (hwloc__xml_verbose())
+        fprintf(stderr, "%s: ignoring unknown memattr attribute %s\n",
+                state->global->msgprefix, attrname);
+      return -1;
+    }
+  }
+
+  if (name && flags != (unsigned long) -1) {
+    hwloc_memattr_id_t _id;
+
+    ret = hwloc_memattr_get_by_name(topology, name, &_id);
+    if (ret < 0) {
+      /* register a new attribute */
+      ret = hwloc_memattr_register(topology, name, flags, &_id);
+      if (!ret)
+        id = _id;
+    } else {
+      /* check the flags of the existing attribute  */
+      unsigned long mflags;
+      ret = hwloc_memattr_get_flags(topology, _id, &mflags);
+      if (!ret && mflags == flags)
+        id = _id;
+    }
+    /* if there's no matching attribute, id is -1 and values will be ignored below */
+  }
+
+  while (1) {
+    struct hwloc__xml_import_state_s childstate;
+    char *tag;
+
+    ret = state->global->find_child(state, &childstate, &tag);
+    if (ret <= 0)
+      break;
+
+    if (!strcmp(tag, "memattr_value")) {
+      ret = hwloc__xml_import_memattr_value(topology, id, flags, &childstate);
+    } else {
+      if (hwloc__xml_verbose())
+        fprintf(stderr, "%s: memattr with unrecognized child %s\n",
+                state->global->msgprefix, tag);
+      ret = -1;
+    }
+
+    if (ret < 0)
+      goto error;
+
+    state->global->close_child(&childstate);
+  }
+
+  return state->global->close_tag(state);
+
+ error:
+  return -1;
+}
+
+static int
+hwloc__xml_import_cpukind(hwloc_topology_t topology,
+                          hwloc__xml_import_state_t state)
+{
+  hwloc_bitmap_t cpuset = NULL;
+  int forced_efficiency = HWLOC_CPUKIND_EFFICIENCY_UNKNOWN;
+  unsigned nr_infos = 0;
+  struct hwloc_info_s *infos = NULL;
+  int ret;
+
+  while (1) {
+    char *attrname, *attrvalue;
+    if (state->global->next_attr(state, &attrname, &attrvalue) < 0)
+      break;
+    if (!strcmp(attrname, "cpuset")) {
+      if (!cpuset)
+        cpuset = hwloc_bitmap_alloc();
+      hwloc_bitmap_sscanf(cpuset, attrvalue);
+    } else if (!strcmp(attrname, "forced_efficiency")) {
+      forced_efficiency = atoi(attrvalue);
+    } else {
+      if (hwloc__xml_verbose())
+        fprintf(stderr, "%s: ignoring unknown cpukind attribute %s\n",
+                state->global->msgprefix, attrname);
+      hwloc_bitmap_free(cpuset);
+      return -1;
+    }
+  }
+
+  while (1) {
+    struct hwloc__xml_import_state_s childstate;
+    char *tag;
+
+    ret = state->global->find_child(state, &childstate, &tag);
+    if (ret <= 0)
+      break;
+
+    if (!strcmp(tag, "info")) {
+      char *infoname = NULL;
+      char *infovalue = NULL;
+      ret = hwloc___xml_import_info(&infoname, &infovalue, &childstate);
+      if (!ret && infoname && infovalue)
+        hwloc__add_info(&infos, &nr_infos, infoname, infovalue);
+    } else {
+      if (hwloc__xml_verbose())
+        fprintf(stderr, "%s: cpukind with unrecognized child %s\n",
+                state->global->msgprefix, tag);
+      ret = -1;
+    }
+
+    if (ret < 0)
+      goto error;
+
+    state->global->close_child(&childstate);
+  }
+
+  if (!cpuset) {
+    if (hwloc__xml_verbose())
+      fprintf(stderr, "%s: ignoring cpukind without cpuset\n",
+              state->global->msgprefix);
+    goto error;
+  }
+
+  hwloc_internal_cpukinds_register(topology, cpuset, forced_efficiency, infos, nr_infos, HWLOC_CPUKINDS_REGISTER_FLAG_OVERWRITE_FORCED_EFFICIENCY);
+
+  return state->global->close_tag(state);
+
+ error:
+  hwloc__free_infos(infos, nr_infos);
+  hwloc_bitmap_free(cpuset);
+  return -1;
+}
+
 static int
 hwloc__xml_import_diff_one(hwloc__xml_import_state_t state,
 			   hwloc_topology_diff_t *firstdiffp,
@@ -1759,6 +2111,18 @@ hwloc_look_xml(struct hwloc_backend *backend, struct hwloc_disc_status *dstatus)
 	ret = hwloc__xml_v2import_distances(topology, &childstate, 1);
 	if (ret < 0)
 	  goto failed;
+      } else if (!strcmp(tag, "support")) {
+	ret = hwloc__xml_v2import_support(topology, &childstate);
+	if (ret < 0)
+	  goto failed;
+      } else if (!strcmp(tag, "memattr")) {
+        ret = hwloc__xml_import_memattr(topology, &childstate);
+        if (ret < 0)
+          goto failed;
+      } else if (!strcmp(tag, "cpukind")) {
+        ret = hwloc__xml_import_cpukind(topology, &childstate);
+        if (ret < 0)
+          goto failed;
       } else {
 	if (hwloc__xml_verbose())
 	  fprintf(stderr, "%s: ignoring unknown tag `%s' after root object.\n",
@@ -1864,6 +2228,7 @@ done:
   /* keep the "Backend" information intact */
   /* we could add "BackendSource=XML" to notify that XML was used between the actual backend and here */
 
+  if (!(topology->flags & HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT)) {
     topology->support.discovery->pu = 1;
     topology->support.discovery->disallowed_pu = 1;
     if (data->nbnumanodes) {
@@ -1871,6 +2236,7 @@ done:
       topology->support.discovery->numa_memory = 1; // FIXME
       topology->support.discovery->disallowed_numa = 1;
     }
+  }
 
   if (data->look_done)
     data->look_done(data, 0);
@@ -2284,7 +2650,8 @@ hwloc__xml_export_object_contents (hwloc__xml_export_state_t state, hwloc_topolo
 
       logical_to_v2array = malloc(nbobjs * sizeof(*logical_to_v2array));
       if (!logical_to_v2array) {
-	fprintf(stderr, "xml/export/v1: failed to allocated logical_to_v2array\n");
+        if (!hwloc_hide_errors())
+          fprintf(stderr, "hwloc/xml/export/v1: failed to allocated logical_to_v2array\n");
 	continue;
       }
 
@@ -2458,6 +2825,7 @@ hwloc__xml_v1export_object_with_memory(hwloc__xml_export_state_t parentstate, hw
     /* child has sibling, we must add a Group around those memory children */
     hwloc_obj_t group = parentstate->global->v1_memory_group;
     parentstate->new_child(parentstate, &gstate, "object");
+    group->parent = obj->parent;
     group->cpuset = obj->cpuset;
     group->complete_cpuset = obj->complete_cpuset;
     group->nodeset = obj->nodeset;
@@ -2620,9 +2988,199 @@ hwloc__xml_v2export_distances(hwloc__xml_export_state_t parentstate, hwloc_topol
       hwloc___xml_v2export_distances(parentstate, dist);
 }
 
+static void
+hwloc__xml_v2export_support(hwloc__xml_export_state_t parentstate, hwloc_topology_t topology)
+{
+  struct hwloc__xml_export_state_s state;
+  char tmp[11];
+
+#ifdef HWLOC_DEBUG
+  HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_support) == 4*sizeof(void*));
+  HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_discovery_support) == 6);
+  HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_cpubind_support) == 11);
+  HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_membind_support) == 15);
+  HWLOC_BUILD_ASSERT(sizeof(struct hwloc_topology_misc_support) == 1);
+#endif
+
+#define DO(_cat,_name) do {                                     \
+    if (topology->support._cat->_name) {                        \
+      parentstate->new_child(parentstate, &state, "support");   \
+      state.new_prop(&state, "name", #_cat "." #_name);         \
+      if (topology->support._cat->_name != 1) {                 \
+        sprintf(tmp, "%u", topology->support._cat->_name); \
+        state.new_prop(&state, "value", tmp);                   \
+      }                                                         \
+      state.end_object(&state, "support");                      \
+    }                                                           \
+  } while (0)
+
+  DO(discovery,pu);
+  DO(discovery,numa);
+  DO(discovery,numa_memory);
+  DO(discovery,disallowed_pu);
+  DO(discovery,disallowed_numa);
+  DO(discovery,cpukind_efficiency);
+  DO(cpubind,set_thisproc_cpubind);
+  DO(cpubind,get_thisproc_cpubind);
+  DO(cpubind,set_proc_cpubind);
+  DO(cpubind,get_proc_cpubind);
+  DO(cpubind,set_thisthread_cpubind);
+  DO(cpubind,get_thisthread_cpubind);
+  DO(cpubind,set_thread_cpubind);
+  DO(cpubind,get_thread_cpubind);
+  DO(cpubind,get_thisproc_last_cpu_location);
+  DO(cpubind,get_proc_last_cpu_location);
+  DO(cpubind,get_thisthread_last_cpu_location);
+  DO(membind,set_thisproc_membind);
+  DO(membind,get_thisproc_membind);
+  DO(membind,set_proc_membind);
+  DO(membind,get_proc_membind);
+  DO(membind,set_thisthread_membind);
+  DO(membind,get_thisthread_membind);
+  DO(membind,set_area_membind);
+  DO(membind,get_area_membind);
+  DO(membind,alloc_membind);
+  DO(membind,firsttouch_membind);
+  DO(membind,bind_membind);
+  DO(membind,interleave_membind);
+  DO(membind,nexttouch_membind);
+  DO(membind,migrate_membind);
+  DO(membind,get_area_memlocation);
+
+  /* misc.imported_support would be meaningless in the remote importer,
+   * but the importer needs to know whether we exported support or not
+   * (in case there are no support bit set at all),
+   * use a custom/fake field to do so.
+   */
+  parentstate->new_child(parentstate, &state, "support");
+  state.new_prop(&state, "name", "custom.exported_support");
+  state.end_object(&state, "support");
+
+#undef DO
+}
+
+static void
+hwloc__xml_export_memattr_target(hwloc__xml_export_state_t state,
+                                 struct hwloc_internal_memattr_s *imattr,
+                                 struct hwloc_internal_memattr_target_s *imtg)
+{
+  struct hwloc__xml_export_state_s vstate;
+  char tmp[255];
+
+  if (imattr->flags & HWLOC_MEMATTR_FLAG_NEED_INITIATOR) {
+    /* export all initiators */
+    unsigned k;
+    for(k=0; k<imtg->nr_initiators; k++) {
+      struct hwloc_internal_memattr_initiator_s *imi = &imtg->initiators[k];
+      state->new_child(state, &vstate, "memattr_value");
+      vstate.new_prop(&vstate, "target_obj_type", hwloc_obj_type_string(imtg->type));
+      snprintf(tmp, sizeof(tmp), "%llu", (unsigned long long) imtg->gp_index);
+      vstate.new_prop(&vstate, "target_obj_gp_index", tmp);
+      snprintf(tmp, sizeof(tmp), "%llu", (unsigned long long) imi->value);
+      vstate.new_prop(&vstate, "value", tmp);
+      switch (imi->initiator.type) {
+      case HWLOC_LOCATION_TYPE_OBJECT:
+        snprintf(tmp, sizeof(tmp), "%llu", (unsigned long long) imi->initiator.location.object.gp_index);
+        vstate.new_prop(&vstate, "initiator_obj_gp_index", tmp);
+        vstate.new_prop(&vstate, "initiator_obj_type", hwloc_obj_type_string(imi->initiator.location.object.type));
+        break;
+      case HWLOC_LOCATION_TYPE_CPUSET: {
+        char *setstring;
+        hwloc_bitmap_asprintf(&setstring, imi->initiator.location.cpuset);
+        if (setstring)
+          vstate.new_prop(&vstate, "initiator_cpuset", setstring);
+        free(setstring);
+        break;
+      }
+      default:
+        assert(0);
+      }
+      vstate.end_object(&vstate, "memattr_value");
+    }
+  } else {
+    /* just export the global value */
+    state->new_child(state, &vstate, "memattr_value");
+    vstate.new_prop(&vstate, "target_obj_type", hwloc_obj_type_string(imtg->type));
+    snprintf(tmp, sizeof(tmp), "%llu", (unsigned long long) imtg->gp_index);
+    vstate.new_prop(&vstate, "target_obj_gp_index", tmp);
+    snprintf(tmp, sizeof(tmp), "%llu", (unsigned long long) imtg->noinitiator_value);
+    vstate.new_prop(&vstate, "value", tmp);
+    vstate.end_object(&vstate, "memattr_value");
+  }
+}
+
+static void
+hwloc__xml_export_memattrs(hwloc__xml_export_state_t state, hwloc_topology_t topology)
+{
+  unsigned id;
+  for(id=0; id<topology->nr_memattrs; id++) {
+    struct hwloc_internal_memattr_s *imattr;
+    struct hwloc__xml_export_state_s mstate;
+    char tmp[255];
+    unsigned j;
+
+    if (id == HWLOC_MEMATTR_ID_CAPACITY || id == HWLOC_MEMATTR_ID_LOCALITY)
+      /* no need to export virtual memattrs */
+      continue;
+
+    imattr = &topology->memattrs[id];
+    if ((id == HWLOC_MEMATTR_ID_LATENCY || id == HWLOC_MEMATTR_ID_BANDWIDTH)
+        && !imattr->nr_targets)
+      /* no need to export target-less attributes for initial attributes, no release support attributes without those definitions */
+      continue;
+
+    state->new_child(state, &mstate, "memattr");
+    mstate.new_prop(&mstate, "name", imattr->name);
+    snprintf(tmp, sizeof(tmp), "%lu", imattr->flags);
+    mstate.new_prop(&mstate, "flags", tmp);
+
+    for(j=0; j<imattr->nr_targets; j++)
+      hwloc__xml_export_memattr_target(&mstate, imattr, &imattr->targets[j]);
+
+    mstate.end_object(&mstate, "memattr");
+  }
+}
+
+static void
+hwloc__xml_export_cpukinds(hwloc__xml_export_state_t state, hwloc_topology_t topology)
+{
+  unsigned i;
+  for(i=0; i<topology->nr_cpukinds; i++) {
+    struct hwloc_internal_cpukind_s *kind = &topology->cpukinds[i];
+    struct hwloc__xml_export_state_s cstate;
+    char *setstring;
+    unsigned j;
+
+    state->new_child(state, &cstate, "cpukind");
+    hwloc_bitmap_asprintf(&setstring, kind->cpuset);
+    cstate.new_prop(&cstate, "cpuset", setstring);
+    free(setstring);
+    if (kind->forced_efficiency != HWLOC_CPUKIND_EFFICIENCY_UNKNOWN) {
+      char tmp[11];
+      snprintf(tmp, sizeof(tmp), "%d", kind->forced_efficiency);
+      cstate.new_prop(&cstate, "forced_efficiency", tmp);
+    }
+
+    for(j=0; j<kind->nr_infos; j++) {
+      char *name = hwloc__xml_export_safestrdup(kind->infos[j].name);
+      char *value = hwloc__xml_export_safestrdup(kind->infos[j].value);
+      struct hwloc__xml_export_state_s istate;
+      cstate.new_child(&cstate, &istate, "info");
+      istate.new_prop(&istate, "name", name);
+      istate.new_prop(&istate, "value", value);
+      istate.end_object(&istate, "info");
+      free(name);
+      free(value);
+    }
+
+    cstate.end_object(&cstate, "cpukind");
+  }
+}
+
 void
 hwloc__xml_export_topology(hwloc__xml_export_state_t state, hwloc_topology_t topology, unsigned long flags)
 {
+  char *env;
   hwloc_obj_t root = hwloc_get_root_obj(topology);
 
   if (flags & HWLOC_TOPOLOGY_EXPORT_XML_FLAG_V1) {
@@ -2665,6 +3223,11 @@ hwloc__xml_export_topology(hwloc__xml_export_state_t state, hwloc_topology_t top
   } else {
     hwloc__xml_v2export_object (state, topology, root, flags);
     hwloc__xml_v2export_distances (state, topology);
+    env = getenv("HWLOC_XML_EXPORT_SUPPORT");
+    if (!env || atoi(env))
+      hwloc__xml_v2export_support(state, topology);
+    hwloc__xml_export_memattrs(state, topology);
+    hwloc__xml_export_cpukinds(state, topology);
   }
 }
 

src/3rdparty/hwloc/src/topology.c

@@ -1,8 +1,9 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2019 Inria.  All rights reserved.
+ * Copyright © 2009-2021 Inria.  All rights reserved.
  * Copyright © 2009-2012, 2020 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
+ * Copyright © 2022 IBM Corporation.  All rights reserved.
  * See COPYING in top-level directory.
  */
 
@@ -52,6 +53,57 @@
 #include <windows.h>
 #endif
 
+
+#ifdef HWLOC_HAVE_LEVELZERO
+/*
+ * Define ZES_ENABLE_SYSMAN=1 early so that the LevelZero backend gets Sysman enabled.
+ *
+ * Only if the levelzero was enabled in this build so that we don't enable sysman
+ * for external levelzero users when hwloc doesn't need it. If somebody ever loads
+ * an external levelzero plugin in a hwloc library built without levelzero (unlikely),
+ * he may have to manually set ZES_ENABLE_SYSMAN=1.
+ *
+ * Use the constructor if supported and/or the Windows DllMain callback.
+ * Do it in the main hwloc library instead of the levelzero component because
+ * the latter could be loaded later as a plugin.
+ *
+ * L0 seems to be using getenv() to check this variable on Windows
+ * (at least in the Intel Compute-Runtime of March 2021),
+ * but setenv() doesn't seem to exist on Windows, hence use putenv() to set the variable.
+ *
+ * For the record, Get/SetEnvironmentVariable() is not exactly the same as getenv/putenv():
+ * - getenv() doesn't see what was set with SetEnvironmentVariable()
+ * - GetEnvironmentVariable() doesn't see putenv() in cygwin (while it does in MSVC and MinGW).
+ * Hence, if L0 ever switches from getenv() to GetEnvironmentVariable(),
+ * it will break in cygwin, we'll have to use both putenv() and SetEnvironmentVariable().
+ * Hopefully L0 will provide a way to enable Sysman without env vars before it happens.
+ */
+#if HWLOC_HAVE_ATTRIBUTE_CONSTRUCTOR
+static void hwloc_constructor(void) __attribute__((constructor));
+static void hwloc_constructor(void)
+{
+  if (!getenv("ZES_ENABLE_SYSMAN"))
+#ifdef HWLOC_WIN_SYS
+    putenv("ZES_ENABLE_SYSMAN=1");
+#else
+    setenv("ZES_ENABLE_SYSMAN", "1", 1);
+#endif
+}
+#endif
+#ifdef HWLOC_WIN_SYS
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved)
+{
+  if (fdwReason == DLL_PROCESS_ATTACH) {
+    if (!getenv("ZES_ENABLE_SYSMAN"))
+      /* Windows does not have a setenv, so use putenv. */
+      putenv((char *) "ZES_ENABLE_SYSMAN=1");
+  }
+  return TRUE;
+}
+#endif
+#endif /* HWLOC_HAVE_LEVELZERO */
+
+
 unsigned hwloc_get_api_version(void)
 {
   return HWLOC_API_VERSION;
@@ -64,7 +116,7 @@ int hwloc_topology_abi_check(hwloc_topology_t topology)
 
 int hwloc_hide_errors(void)
 {
-  static int hide = 0;
+  static int hide = 1; /* only show critical errors by default. lstopo will show others */
   static int checked = 0;
   if (!checked) {
     const char *envvar = getenv("HWLOC_HIDE_ERRORS");
@@ -75,16 +127,49 @@ int hwloc_hide_errors(void)
   return hide;
 }
 
-void hwloc_report_os_error(const char *msg, int line)
+
+/* format the obj info to print in error messages */
+static void
+report_insert_error_format_obj(char *buf, size_t buflen, hwloc_obj_t obj)
+{
+  char typestr[64];
+  char *cpusetstr;
+  char *nodesetstr = NULL;
+
+  hwloc_obj_type_snprintf(typestr, sizeof(typestr), obj, 0);
+  hwloc_bitmap_asprintf(&cpusetstr, obj->cpuset);
+  if (obj->nodeset) /* may be missing during insert */
+    hwloc_bitmap_asprintf(&nodesetstr, obj->nodeset);
+  if (obj->os_index != HWLOC_UNKNOWN_INDEX)
+    snprintf(buf, buflen, "%s (P#%u cpuset %s%s%s)",
+             typestr, obj->os_index, cpusetstr,
+             nodesetstr ? " nodeset " : "",
+             nodesetstr ? nodesetstr : "");
+  else
+    snprintf(buf, buflen, "%s (cpuset %s%s%s)",
+             typestr, cpusetstr,
+             nodesetstr ? " nodeset " : "",
+             nodesetstr ? nodesetstr : "");
+  free(cpusetstr);
+  free(nodesetstr);
+}
+
+static void report_insert_error(hwloc_obj_t new, hwloc_obj_t old, const char *msg, const char *reason)
 {
   static int reported = 0;
 
-  if (!reported && !hwloc_hide_errors()) {
+  if (reason && !reported && hwloc_hide_errors() < 2) {
+    char newstr[512];
+    char oldstr[512];
+    report_insert_error_format_obj(newstr, sizeof(newstr), new);
+    report_insert_error_format_obj(oldstr, sizeof(oldstr), old);
+
     fprintf(stderr, "****************************************************************************\n");
     fprintf(stderr, "* hwloc %s received invalid information from the operating system.\n", HWLOC_VERSION);
     fprintf(stderr, "*\n");
-    fprintf(stderr, "* %s\n", msg);
-    fprintf(stderr, "* Error occurred in topology.c line %d\n", line);
+    fprintf(stderr, "* Failed with: %s\n", msg);
+    fprintf(stderr, "* while inserting %s at %s\n", newstr, oldstr);
+    fprintf(stderr, "* coming from: %s\n", reason);
     fprintf(stderr, "*\n");
     fprintf(stderr, "* The following FAQ entry in the hwloc documentation may help:\n");
     fprintf(stderr, "*   What should I do when hwloc reports \"operating system\" warnings?\n");
@@ -264,7 +349,7 @@ hwloc_setup_pu_level(struct hwloc_topology *topology,
 
       hwloc_debug_2args_bitmap("cpu %u (os %u) has cpuset %s\n",
 		 cpu, oscpu, obj->cpuset);
-      hwloc_insert_object_by_cpuset(topology, obj);
+      hwloc__insert_object_by_cpuset(topology, NULL, obj, "core:pulevel");
 
       cpu++;
     }
@@ -347,6 +432,7 @@ hwloc_debug_print_object(int indent __hwloc_attribute_unused, hwloc_obj_t obj)
 static void
 hwloc_debug_print_objects(int indent __hwloc_attribute_unused, hwloc_obj_t obj)
 {
+  if (hwloc_debug_enabled() >= 2) {
     hwloc_obj_t child;
     hwloc_debug_print_object(indent, obj);
     for_each_child (child, obj)
@@ -358,6 +444,7 @@ hwloc_debug_print_objects(int indent __hwloc_attribute_unused, hwloc_obj_t obj)
     for_each_misc_child (child, obj)
       hwloc_debug_print_objects(indent + 1, child);
   }
+}
 #else /* !HWLOC_DEBUG */
 #define hwloc_debug_print_object(indent, obj) do { /* nothing */ } while (0)
 #define hwloc_debug_print_objects(indent, obj) do { /* nothing */ } while (0)
@@ -472,29 +559,33 @@ int hwloc_obj_add_info(hwloc_obj_t obj, const char *name, const char *value)
 }
 
 /* This function may be called with topology->tma set, it cannot free() or realloc() */
-static int hwloc__tma_dup_infos(struct hwloc_tma *tma, hwloc_obj_t new, hwloc_obj_t src)
+int hwloc__tma_dup_infos(struct hwloc_tma *tma,
+                         struct hwloc_info_s **newip, unsigned *newcp,
+                         struct hwloc_info_s *oldi, unsigned oldc)
 {
+  struct hwloc_info_s *newi;
   unsigned i, j;
-  new->infos = hwloc_tma_calloc(tma, src->infos_count * sizeof(*src->infos));
-  if (!new->infos)
+  newi = hwloc_tma_calloc(tma, oldc * sizeof(*newi));
+  if (!newi)
     return -1;
-  for(i=0; i<src->infos_count; i++) {
-    new->infos[i].name = hwloc_tma_strdup(tma, src->infos[i].name);
-    new->infos[i].value = hwloc_tma_strdup(tma, src->infos[i].value);
-    if (!new->infos[i].name || !new->infos[i].value)
+  for(i=0; i<oldc; i++) {
+    newi[i].name = hwloc_tma_strdup(tma, oldi[i].name);
+    newi[i].value = hwloc_tma_strdup(tma, oldi[i].value);
+    if (!newi[i].name || !newi[i].value)
       goto failed;
   }
-  new->infos_count = src->infos_count;
+  *newip = newi;
+  *newcp = oldc;
   return 0;
 
  failed:
   assert(!tma || !tma->dontfree); /* this tma cannot fail to allocate */
   for(j=0; j<=i; j++) {
-    free(new->infos[i].name);
-    free(new->infos[i].value);
+    free(newi[i].name);
+    free(newi[i].value);
   }
-  free(new->infos);
-  new->infos = NULL;
+  free(newi);
+  *newip = NULL;
   return -1;
 }
 
@@ -528,8 +619,9 @@ hwloc_free_unlinked_object(hwloc_obj_t obj)
 }
 
 /* Replace old with contents of new object, and make new freeable by the caller.
- * Only updates next_sibling/first_child pointers,
- * so may only be used during early discovery.
+ * Requires reconnect (for siblings pointers and group depth),
+ * fixup of sets (only the main cpuset was likely compared before merging),
+ * and update of total_memory and group depth.
  */
 static void
 hwloc_replace_linked_object(hwloc_obj_t old, hwloc_obj_t new)
@@ -812,7 +904,7 @@ hwloc__duplicate_object(struct hwloc_topology *newtopology,
   newobj->nodeset = hwloc_bitmap_tma_dup(tma, src->nodeset);
   newobj->complete_nodeset = hwloc_bitmap_tma_dup(tma, src->complete_nodeset);
 
-  hwloc__tma_dup_infos(tma, newobj, src);
+  hwloc__tma_dup_infos(tma, &newobj->infos, &newobj->infos_count, src->infos, src->infos_count);
 
   /* find our level */
   if (src->depth < 0) {
@@ -970,6 +1062,7 @@ hwloc__topology_dup(hwloc_topology_t *newp,
   memcpy(new->support.discovery, old->support.discovery, sizeof(*old->support.discovery));
   memcpy(new->support.cpubind, old->support.cpubind, sizeof(*old->support.cpubind));
   memcpy(new->support.membind, old->support.membind, sizeof(*old->support.membind));
+  memcpy(new->support.misc, old->support.misc, sizeof(*old->support.misc));
 
   new->allowed_cpuset = hwloc_bitmap_tma_dup(tma, old->allowed_cpuset);
   new->allowed_nodeset = hwloc_bitmap_tma_dup(tma, old->allowed_nodeset);
@@ -1008,6 +1101,14 @@ hwloc__topology_dup(hwloc_topology_t *newp,
   if (err < 0)
     goto out_with_topology;
 
+  err = hwloc_internal_memattrs_dup(new, old);
+  if (err < 0)
+    goto out_with_topology;
+
+  err = hwloc_internal_cpukinds_dup(new, old);
+  if (err < 0)
+    goto out_with_topology;
+
   /* we connected everything during duplication */
   new->modified = 0;
 
@@ -1229,31 +1330,6 @@ hwloc__object_cpusets_compare_first(hwloc_obj_t obj1, hwloc_obj_t obj2)
   return 0;
 }
 
-/* format the obj info to print in error messages */
-static void
-hwloc__report_error_format_obj(char *buf, size_t buflen, hwloc_obj_t obj)
-{
-	char typestr[64];
-	char *cpusetstr;
-	char *nodesetstr = NULL;
-	hwloc_obj_type_snprintf(typestr, sizeof(typestr), obj, 0);
-	hwloc_bitmap_asprintf(&cpusetstr, obj->cpuset);
-	if (obj->nodeset) /* may be missing during insert */
-	  hwloc_bitmap_asprintf(&nodesetstr, obj->nodeset);
-	if (obj->os_index != HWLOC_UNKNOWN_INDEX)
-	  snprintf(buf, buflen, "%s (P#%u cpuset %s%s%s)",
-		   typestr, obj->os_index, cpusetstr,
-		   nodesetstr ? " nodeset " : "",
-		   nodesetstr ? nodesetstr : "");
-	else
-	  snprintf(buf, buflen, "%s (cpuset %s%s%s)",
-		   typestr, cpusetstr,
-		   nodesetstr ? " nodeset " : "",
-		   nodesetstr ? nodesetstr : "");
-	free(cpusetstr);
-	free(nodesetstr);
-}
-
 /*
  * How to insert objects into the topology.
  *
@@ -1325,7 +1401,7 @@ merge_insert_equal(hwloc_obj_t new, hwloc_obj_t old)
 
 /* returns the result of merge, or NULL if not merged */
 static __hwloc_inline hwloc_obj_t
-hwloc__insert_try_merge_group(hwloc_obj_t old, hwloc_obj_t new)
+hwloc__insert_try_merge_group(hwloc_topology_t topology, hwloc_obj_t old, hwloc_obj_t new)
 {
   if (new->type == HWLOC_OBJ_GROUP && old->type == HWLOC_OBJ_GROUP) {
     /* which group do we keep? */
@@ -1336,6 +1412,7 @@ hwloc__insert_try_merge_group(hwloc_obj_t old, hwloc_obj_t new)
 
       /* keep the new one, it doesn't want to be merged */
       hwloc_replace_linked_object(old, new);
+      topology->modified = 1;
       return new;
 
     } else {
@@ -1343,9 +1420,12 @@ hwloc__insert_try_merge_group(hwloc_obj_t old, hwloc_obj_t new)
 	/* keep the old one, it doesn't want to be merged */
 	return old;
 
-      /* compare subkinds to decice who to keep */
-      if (new->attr->group.kind < old->attr->group.kind)
+      /* compare subkinds to decide which group to keep */
+      if (new->attr->group.kind < old->attr->group.kind) {
+        /* keep smaller kind */
 	hwloc_replace_linked_object(old, new);
+        topology->modified = 1;
+      }
       return old;
     }
   }
@@ -1371,6 +1451,7 @@ hwloc__insert_try_merge_group(hwloc_obj_t old, hwloc_obj_t new)
      * and let the caller free the new object
      */
     hwloc_replace_linked_object(old, new);
+    topology->modified = 1;
     return old;
 
   } else {
@@ -1390,9 +1471,9 @@ hwloc__insert_try_merge_group(hwloc_obj_t old, hwloc_obj_t new)
  */
 static struct hwloc_obj *
 hwloc___insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t cur, hwloc_obj_t obj,
-			        hwloc_report_error_t report_error)
+			        const char *reason)
 {
-  hwloc_obj_t child, next_child = NULL;
+  hwloc_obj_t child, next_child = NULL, tmp;
   /* These will always point to the pointer to their next last child. */
   hwloc_obj_t *cur_children = &cur->first_child;
   hwloc_obj_t *obj_children = &obj->first_child;
@@ -1412,7 +1493,7 @@ hwloc___insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t cur
     int setres = res;
 
     if (res == HWLOC_OBJ_EQUAL) {
-      hwloc_obj_t merged = hwloc__insert_try_merge_group(child, obj);
+      hwloc_obj_t merged = hwloc__insert_try_merge_group(topology, child, obj);
       if (merged)
 	return merged;
       /* otherwise compare actual types to decide of the inclusion */
@@ -1430,18 +1511,10 @@ hwloc___insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t cur
 
       case HWLOC_OBJ_INCLUDED:
 	/* OBJ is strictly contained is some child of CUR, go deeper.  */
-	return hwloc___insert_object_by_cpuset(topology, child, obj, report_error);
+	return hwloc___insert_object_by_cpuset(topology, child, obj, reason);
 
       case HWLOC_OBJ_INTERSECTS:
-        if (report_error) {
-	  char childstr[512];
-	  char objstr[512];
-	  char msg[1100];
-	  hwloc__report_error_format_obj(objstr, sizeof(objstr), obj);
-	  hwloc__report_error_format_obj(childstr, sizeof(childstr), child);
-	  snprintf(msg, sizeof(msg), "%s intersects with %s without inclusion!", objstr, childstr);
-	  report_error(msg, __LINE__);
-	}
+        report_insert_error(obj, child, "intersection without inclusion", reason);
 	goto putback;
 
       case HWLOC_OBJ_DIFFERENT:
@@ -1464,6 +1537,8 @@ hwloc___insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t cur
 	if (setres == HWLOC_OBJ_EQUAL) {
 	  obj->memory_first_child = child->memory_first_child;
 	  child->memory_first_child = NULL;
+	  for(tmp=obj->memory_first_child; tmp; tmp = tmp->next_sibling)
+	    tmp->parent = obj;
 	}
 	break;
     }
@@ -1483,7 +1558,9 @@ hwloc___insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t cur
   return obj;
 
  putback:
-  /* Put-back OBJ children in CUR and return an error. */
+  /* OBJ cannot be inserted.
+   * Put-back OBJ children in CUR and return an error.
+   */
   if (putp)
     cur_children = putp; /* No need to try to insert before where OBJ was supposed to go */
   else
@@ -1492,12 +1569,12 @@ hwloc___insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t cur
   while ((child = obj->first_child) != NULL) {
     /* Remove from OBJ */
     obj->first_child = child->next_sibling;
-    obj->parent = cur;
-    /* Find child position in CUR, and insert. */
+    /* Find child position in CUR, and reinsert it. */
     while (*cur_children && hwloc__object_cpusets_compare_first(*cur_children, child) < 0)
       cur_children = &(*cur_children)->next_sibling;
     child->next_sibling = *cur_children;
     *cur_children = child;
+    child->parent = cur;
   }
   return NULL;
 }
@@ -1521,7 +1598,7 @@ hwloc__find_obj_covering_memory_cpuset(struct hwloc_topology *topology, hwloc_ob
 
 static struct hwloc_obj *
 hwloc__find_insert_memory_parent(struct hwloc_topology *topology, hwloc_obj_t obj,
-				 hwloc_report_error_t report_error)
+                                 const char *reason)
 {
   hwloc_obj_t parent, group, result;
 
@@ -1573,7 +1650,7 @@ hwloc__find_insert_memory_parent(struct hwloc_topology *topology, hwloc_obj_t ob
     return parent;
   }
 
-  result = hwloc__insert_object_by_cpuset(topology, parent, group, report_error);
+  result = hwloc__insert_object_by_cpuset(topology, parent, group, reason);
   if (!result) {
     /* failed to insert, fallback to larger parent */
     return parent;
@@ -1586,8 +1663,7 @@ hwloc__find_insert_memory_parent(struct hwloc_topology *topology, hwloc_obj_t ob
 /* only works for MEMCACHE and NUMAnode with a single bit in nodeset */
 static hwloc_obj_t
 hwloc___attach_memory_object_by_nodeset(struct hwloc_topology *topology, hwloc_obj_t parent,
-					hwloc_obj_t obj,
-					hwloc_report_error_t report_error)
+					hwloc_obj_t obj, const char *reason)
 {
   hwloc_obj_t *curp = &parent->memory_first_child;
   unsigned first = hwloc_bitmap_first(obj->nodeset);
@@ -1611,20 +1687,12 @@ hwloc___attach_memory_object_by_nodeset(struct hwloc_topology *topology, hwloc_o
       if (obj->type == HWLOC_OBJ_NUMANODE) {
 	if (cur->type == HWLOC_OBJ_NUMANODE) {
 	  /* identical NUMA nodes? ignore the new one */
-	  if (report_error) {
-	    char curstr[512];
-	    char objstr[512];
-	    char msg[1100];
-	    hwloc__report_error_format_obj(curstr, sizeof(curstr), cur);
-	    hwloc__report_error_format_obj(objstr, sizeof(objstr), obj);
-	    snprintf(msg, sizeof(msg), "%s and %s have identical nodesets!", objstr, curstr);
-	    report_error(msg, __LINE__);
-	  }
+          report_insert_error(obj, cur, "NUMAnodes with identical nodesets", reason);
 	  return NULL;
 	}
 	assert(cur->type == HWLOC_OBJ_MEMCACHE);
 	/* insert the new NUMA node below that existing memcache */
-	return hwloc___attach_memory_object_by_nodeset(topology, cur, obj, report_error);
+	return hwloc___attach_memory_object_by_nodeset(topology, cur, obj, reason);
 
       } else {
 	assert(obj->type == HWLOC_OBJ_MEMCACHE);
@@ -1637,7 +1705,7 @@ hwloc___attach_memory_object_by_nodeset(struct hwloc_topology *topology, hwloc_o
 	     * (depth starts from the NUMA node).
 	     * insert the new memcache below the existing one
 	     */
-	    return hwloc___attach_memory_object_by_nodeset(topology, cur, obj, report_error);
+	    return hwloc___attach_memory_object_by_nodeset(topology, cur, obj, reason);
 	}
 	/* insert the memcache above the existing memcache or numa node */
 	obj->next_sibling = cur->next_sibling;
@@ -1673,8 +1741,7 @@ hwloc___attach_memory_object_by_nodeset(struct hwloc_topology *topology, hwloc_o
  */
 struct hwloc_obj *
 hwloc__attach_memory_object(struct hwloc_topology *topology, hwloc_obj_t parent,
-			    hwloc_obj_t obj,
-			    hwloc_report_error_t report_error)
+			    hwloc_obj_t obj, const char *reason)
 {
   hwloc_obj_t result;
 
@@ -1704,7 +1771,7 @@ hwloc__attach_memory_object(struct hwloc_topology *topology, hwloc_obj_t parent,
   hwloc_bitmap_copy(obj->complete_cpuset, parent->complete_cpuset);
 #endif
 
-  result = hwloc___attach_memory_object_by_nodeset(topology, parent, obj, report_error);
+  result = hwloc___attach_memory_object_by_nodeset(topology, parent, obj, reason);
   if (result == obj) {
     /* Add the bit to the top sets, and to the parent CPU-side object */
     if (obj->type == HWLOC_OBJ_NUMANODE) {
@@ -1722,8 +1789,7 @@ hwloc__attach_memory_object(struct hwloc_topology *topology, hwloc_obj_t parent,
 /* insertion routine that lets you change the error reporting callback */
 struct hwloc_obj *
 hwloc__insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t root,
-			       hwloc_obj_t obj,
-			       hwloc_report_error_t report_error)
+			       hwloc_obj_t obj, const char *reason)
 {
   struct hwloc_obj *result;
 
@@ -1740,20 +1806,20 @@ hwloc__insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t root
 
   if (hwloc__obj_type_is_memory(obj->type)) {
     if (!root) {
-      root = hwloc__find_insert_memory_parent(topology, obj, report_error);
+      root = hwloc__find_insert_memory_parent(topology, obj, reason);
       if (!root) {
 	hwloc_free_unlinked_object(obj);
 	return NULL;
       }
     }
-    return hwloc__attach_memory_object(topology, root, obj, report_error);
+    return hwloc__attach_memory_object(topology, root, obj, reason);
   }
 
   if (!root)
     /* Start at the top. */
     root = topology->levels[0][0];
 
-  result = hwloc___insert_object_by_cpuset(topology, root, obj, report_error);
+  result = hwloc___insert_object_by_cpuset(topology, root, obj, reason);
   if (result && result->type == HWLOC_OBJ_PU) {
       /* Add the bit to the top sets */
       if (hwloc_bitmap_isset(result->cpuset, result->os_index))
@@ -1769,12 +1835,6 @@ hwloc__insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t root
 
 /* the default insertion routine warns in case of error.
  * it's used by most backends */
-struct hwloc_obj *
-hwloc_insert_object_by_cpuset(struct hwloc_topology *topology, hwloc_obj_t obj)
-{
-  return hwloc__insert_object_by_cpuset(topology, NULL, obj, hwloc_report_os_error);
-}
-
 void
 hwloc_insert_object_by_parent(struct hwloc_topology *topology, hwloc_obj_t parent, hwloc_obj_t obj)
 {
@@ -1857,6 +1917,9 @@ hwloc_topology_alloc_group_object(struct hwloc_topology *topology)
 static void hwloc_propagate_symmetric_subtree(hwloc_topology_t topology, hwloc_obj_t root);
 static void propagate_total_memory(hwloc_obj_t obj);
 static void hwloc_set_group_depth(hwloc_topology_t topology);
+static void hwloc_connect_children(hwloc_obj_t parent);
+static int hwloc_connect_levels(hwloc_topology_t topology);
+static int hwloc_connect_special_levels(hwloc_topology_t topology);
 
 hwloc_obj_t
 hwloc_topology_insert_group_object(struct hwloc_topology *topology, hwloc_obj_t obj)
@@ -1917,6 +1980,7 @@ hwloc_topology_insert_group_object(struct hwloc_topology *topology, hwloc_obj_t
       if (hwloc_bitmap_isset(nodeset, numa->os_index))
 	hwloc_bitmap_or(obj->cpuset, obj->cpuset, numa->cpuset);
   }
+  /* FIXME insert by nodeset to group NUMAs even if CPUless? */
 
   cmp = hwloc_obj_cmp_sets(obj, root);
   if (cmp == HWLOC_OBJ_INCLUDED) {
@@ -1928,12 +1992,24 @@ hwloc_topology_insert_group_object(struct hwloc_topology *topology, hwloc_obj_t
 
   if (!res)
     return NULL;
-  if (res != obj)
-    /* merged */
+
+  if (res != obj && res->type != HWLOC_OBJ_GROUP)
+    /* merged, not into a Group, nothing to update */
     return res;
 
+  /* res == obj means that the object was inserted.
+   * We need to reconnect levels, fill all its cpu/node sets,
+   * compute its total memory, group depth, etc.
+   *
+   * res != obj usually means that our new group was merged into an
+   * existing object, no need to recompute anything.
+   * However, if merging with an existing group, depending on their kinds,
+   * the contents of obj may overwrite the contents of the old group.
+   * This requires reconnecting levels, filling sets, recomputing total memory, etc.
+   */
+
   /* properly inserted */
-  hwloc_obj_add_children_sets(obj);
+  hwloc_obj_add_children_sets(res);
   if (hwloc_topology_reconnect(topology, 0) < 0)
     return NULL;
 
@@ -1945,7 +2021,7 @@ hwloc_topology_insert_group_object(struct hwloc_topology *topology, hwloc_obj_t
 #endif
     hwloc_topology_check(topology);
 
-  return obj;
+  return res;
 }
 
 hwloc_obj_t
@@ -2047,7 +2123,7 @@ hwloc_find_insert_io_parent_by_complete_cpuset(struct hwloc_topology *topology,
   hwloc_bitmap_and(cpuset, cpuset, hwloc_topology_get_topology_cpuset(topology));
   group_obj->cpuset = hwloc_bitmap_dup(cpuset);
   group_obj->attr->group.kind = HWLOC_GROUP_KIND_IO;
-  parent = hwloc__insert_object_by_cpuset(topology, largeparent, group_obj, hwloc_report_os_error);
+  parent = hwloc__insert_object_by_cpuset(topology, largeparent, group_obj, "topology:io_parent");
   if (!parent)
     /* Failed to insert the Group, maybe a conflicting cpuset */
     return largeparent;
@@ -2286,9 +2362,15 @@ hwloc__filter_bridges(hwloc_topology_t topology, hwloc_obj_t root, unsigned dept
 
     child->attr->bridge.depth = depth;
 
-    if (child->type == HWLOC_OBJ_BRIDGE
-	&& filter == HWLOC_TYPE_FILTER_KEEP_IMPORTANT
-	&& !child->io_first_child) {
+    /* remove bridges that have no child,
+     * and pci-to-non-pci bridges (pcidev) that no child either.
+     * keep NVSwitch since they may be used in NVLink matrices.
+     */
+    if (filter == HWLOC_TYPE_FILTER_KEEP_IMPORTANT
+	&& !child->io_first_child
+        && (child->type == HWLOC_OBJ_BRIDGE
+            || (child->type == HWLOC_OBJ_PCI_DEVICE && (child->attr->pcidev.class_id >> 8) == 0x06
+                && (!child->subtype || strcmp(child->subtype, "NVSwitch"))))) {
       unlink_and_free_single_object(pchild);
       topology->modified = 1;
     }
@@ -2411,13 +2493,26 @@ hwloc_compare_levels_structure(hwloc_topology_t topology, unsigned i)
   return 0;
 }
 
-/* return > 0 if any level was removed, which means reconnect is needed */
-static void
+/* return > 0 if any level was removed.
+ * performs its own reconnect internally if needed
+ */
+static int
 hwloc_filter_levels_keep_structure(hwloc_topology_t topology)
 {
   unsigned i, j;
   int res = 0;
 
+  if (topology->modified) {
+    /* WARNING: hwloc_topology_reconnect() is duplicated partially here
+     * and at the end of this function:
+     * - we need normal levels before merging.
+     * - and we'll need to update special levels after merging.
+     */
+    hwloc_connect_children(topology->levels[0][0]);
+    if (hwloc_connect_levels(topology) < 0)
+      return -1;
+  }
+
   /* start from the bottom since we'll remove intermediate levels */
   for(i=topology->nb_levels-1; i>0; i--) {
     int replacechild = 0, replaceparent = 0;
@@ -2583,6 +2678,22 @@ hwloc_filter_levels_keep_structure(hwloc_topology_t topology)
 	topology->type_depth[type] = HWLOC_TYPE_DEPTH_MULTIPLE;
     }
   }
+
+
+  if (res > 0 || topology-> modified) {
+    /* WARNING: hwloc_topology_reconnect() is duplicated partially here
+     * and at the beginning of this function.
+     * If we merged some levels, some child+parent special children lisst
+     * may have been merged, hence specials level might need reordering,
+     * So reconnect special levels only here at the end
+     * (it's not needed at the beginning of this function).
+     */
+    if (hwloc_connect_special_levels(topology) < 0)
+      return -1;
+    topology->modified = 0;
+  }
+
+  return 0;
 }
 
 static void
@@ -2900,9 +3011,9 @@ hwloc_list_special_objects(hwloc_topology_t topology, hwloc_obj_t obj)
   }
 }
 
-/* Build I/O levels */
+/* Build Memory, I/O and Misc levels */
 static int
-hwloc_connect_io_misc_levels(hwloc_topology_t topology)
+hwloc_connect_special_levels(hwloc_topology_t topology)
 {
   unsigned i;
 
@@ -3067,7 +3178,8 @@ hwloc_connect_levels(hwloc_topology_t topology)
       tmpnbobjs = realloc(topology->level_nbobjects,
 			  2 * topology->nb_levels_allocated * sizeof(*topology->level_nbobjects));
       if (!tmplevels || !tmpnbobjs) {
-	fprintf(stderr, "hwloc failed to realloc level arrays to %u\n", topology->nb_levels_allocated * 2);
+        if (hwloc_hide_errors() < 2)
+          fprintf(stderr, "hwloc: failed to realloc level arrays to %u\n", topology->nb_levels_allocated * 2);
 
 	/* if one realloc succeeded, make sure the caller will free the new buffer */
 	if (tmplevels)
@@ -3112,6 +3224,10 @@ hwloc_connect_levels(hwloc_topology_t topology)
 int
 hwloc_topology_reconnect(struct hwloc_topology *topology, unsigned long flags)
 {
+  /* WARNING: when updating this function, the replicated code must
+   * also be updated inside hwloc_filter_levels_keep_structure()
+   */
+
   if (flags) {
     errno = EINVAL;
     return -1;
@@ -3124,7 +3240,7 @@ hwloc_topology_reconnect(struct hwloc_topology *topology, unsigned long flags)
   if (hwloc_connect_levels(topology) < 0)
     return -1;
 
-  if (hwloc_connect_io_misc_levels(topology) < 0)
+  if (hwloc_connect_special_levels(topology) < 0)
     return -1;
 
   topology->modified = 0;
@@ -3251,7 +3367,7 @@ hwloc_discover(struct hwloc_topology *topology,
    * produced by hwloc_setup_pu_level()
    */
 
-  /* To be able to just use hwloc_insert_object_by_cpuset to insert the object
+  /* To be able to just use hwloc__insert_object_by_cpuset to insert the object
    * in the topology according to the cpuset, the cpuset field must be
    * initialized.
    */
@@ -3356,7 +3472,7 @@ hwloc_discover(struct hwloc_topology *topology,
     hwloc_bitmap_set(node->nodeset, 0);
     memcpy(&node->attr->numanode, &topology->machine_memory, sizeof(topology->machine_memory));
     memset(&topology->machine_memory, 0, sizeof(topology->machine_memory));
-    hwloc_insert_object_by_cpuset(topology, node);
+    hwloc__insert_object_by_cpuset(topology, NULL, node, "core:defaultnumanode");
   } else {
     /* if we're sure we found all NUMA nodes without their sizes (x86 backend?),
      * we could split topology->total_memory in all of them.
@@ -3449,28 +3565,28 @@ hwloc_discover(struct hwloc_topology *topology,
   hwloc_debug("%s", "\nRemoving empty objects\n");
   remove_empty(topology, &topology->levels[0][0]);
   if (!topology->levels[0][0]) {
-    fprintf(stderr, "Topology became empty, aborting!\n");
+    if (hwloc_hide_errors() < 2)
+      fprintf(stderr, "hwloc: Topology became empty, aborting!\n");
     return -1;
   }
   if (hwloc_bitmap_iszero(topology->levels[0][0]->cpuset)) {
-    fprintf(stderr, "Topology does not contain any PU, aborting!\n");
+    if (hwloc_hide_errors() < 2)
+      fprintf(stderr, "hwloc: Topology does not contain any PU, aborting!\n");
     return -1;
   }
   if (hwloc_bitmap_iszero(topology->levels[0][0]->nodeset)) {
-    fprintf(stderr, "Topology does not contain any NUMA node, aborting!\n");
+    if (hwloc_hide_errors() < 2)
+      fprintf(stderr, "hwloc: Topology does not contain any NUMA node, aborting!\n");
     return -1;
   }
   hwloc_debug_print_objects(0, topology->levels[0][0]);
 
-  /* Reconnect things after all these changes.
-   * Often needed because of Groups inserted for I/Os.
-   * And required for KEEP_STRUCTURE below.
-   */
-  if (hwloc_topology_reconnect(topology, 0) < 0)
-    return -1;
-
   hwloc_debug("%s", "\nRemoving levels with HWLOC_TYPE_FILTER_KEEP_STRUCTURE\n");
-  hwloc_filter_levels_keep_structure(topology);
+  if (hwloc_filter_levels_keep_structure(topology) < 0)
+    return -1;
+  /* takes care of reconnecting children/levels internally,
+   * because it needs normal levels.
+   * and it's often needed below because of Groups inserted for I/Os anyway */
   hwloc_debug_print_objects(0, topology->levels[0][0]);
 
   /* accumulate children memory in total_memory fields (only once parent is set) */
@@ -3514,6 +3630,7 @@ hwloc_topology_setup_defaults(struct hwloc_topology *topology)
   memset(topology->support.discovery, 0, sizeof(*topology->support.discovery));
   memset(topology->support.cpubind, 0, sizeof(*topology->support.cpubind));
   memset(topology->support.membind, 0, sizeof(*topology->support.membind));
+  memset(topology->support.misc, 0, sizeof(*topology->support.misc));
 
   /* Only the System object on top by default */
   topology->next_gp_index = 1; /* keep 0 as an invalid value */
@@ -3590,6 +3707,7 @@ hwloc__topology_init (struct hwloc_topology **topologyp,
   topology->support.discovery = hwloc_tma_malloc(tma, sizeof(*topology->support.discovery));
   topology->support.cpubind = hwloc_tma_malloc(tma, sizeof(*topology->support.cpubind));
   topology->support.membind = hwloc_tma_malloc(tma, sizeof(*topology->support.membind));
+  topology->support.misc = hwloc_tma_malloc(tma, sizeof(*topology->support.misc));
 
   topology->nb_levels_allocated = nblevels; /* enough for default 10 levels = Mach+Pack+Die+NUMA+L3+L2+L1d+L1i+Co+PU */
   topology->levels = hwloc_tma_calloc(tma, topology->nb_levels_allocated * sizeof(*topology->levels));
@@ -3598,6 +3716,8 @@ hwloc__topology_init (struct hwloc_topology **topologyp,
   hwloc__topology_filter_init(topology);
 
   hwloc_internal_distances_init(topology);
+  hwloc_internal_memattrs_init(topology);
+  hwloc_internal_cpukinds_init(topology);
 
   topology->userdata_export_cb = NULL;
   topology->userdata_import_cb = NULL;
@@ -3691,7 +3811,18 @@ hwloc_topology_set_flags (struct hwloc_topology *topology, unsigned long flags)
     return -1;
   }
 
-  if (flags & ~(HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED|HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM|HWLOC_TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES)) {
+  if (flags & ~(HWLOC_TOPOLOGY_FLAG_INCLUDE_DISALLOWED|HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM|HWLOC_TOPOLOGY_FLAG_THISSYSTEM_ALLOWED_RESOURCES|HWLOC_TOPOLOGY_FLAG_IMPORT_SUPPORT|HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING|HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING|HWLOC_TOPOLOGY_FLAG_DONT_CHANGE_BINDING)) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  if ((flags & (HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING|HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM)) == HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING) {
+    /* RESTRICT_TO_CPUBINDING requires THISSYSTEM for binding */
+    errno = EINVAL;
+    return -1;
+  }
+  if ((flags & (HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING|HWLOC_TOPOLOGY_FLAG_IS_THISSYSTEM)) == HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING) {
+    /* RESTRICT_TO_MEMBINDING requires THISSYSTEM for binding */
     errno = EINVAL;
     return -1;
   }
@@ -3827,7 +3958,9 @@ hwloc_topology_clear (struct hwloc_topology *topology)
 {
   /* no need to set to NULL after free() since callers will call setup_defaults() or just destroy the rest of the topology */
   unsigned l;
+  hwloc_internal_cpukinds_destroy(topology);
   hwloc_internal_distances_destroy(topology);
+  hwloc_internal_memattrs_destroy(topology);
   hwloc_free_object_and_children(topology->levels[0][0]);
   hwloc_bitmap_free(topology->allowed_cpuset);
   hwloc_bitmap_free(topology->allowed_nodeset);
@@ -3858,6 +3991,7 @@ hwloc_topology_destroy (struct hwloc_topology *topology)
   free(topology->support.discovery);
   free(topology->support.cpubind);
   free(topology->support.membind);
+  free(topology->support.misc);
   free(topology);
 }
 
@@ -3873,7 +4007,9 @@ hwloc_topology_load (struct hwloc_topology *topology)
     return -1;
   }
 
+  /* initialize envvar-related things */
   hwloc_internal_distances_prepare(topology);
+  hwloc_internal_memattrs_prepare(topology);
 
   if (getenv("HWLOC_XML_USERDATA_NOT_DECODED"))
     topology->userdata_not_decoded = 1;
@@ -3954,6 +4090,9 @@ hwloc_topology_load (struct hwloc_topology *topology)
 #endif
     hwloc_topology_check(topology);
 
+  /* Rank cpukinds */
+  hwloc_internal_cpukinds_rank(topology);
+
   /* Mark distances objs arrays as invalid since we may have removed objects
    * from the topology after adding the distances (remove_empty, etc).
    * It would be hard to actually verify whether it's needed.
@@ -3964,8 +4103,37 @@ hwloc_topology_load (struct hwloc_topology *topology)
    */
   hwloc_internal_distances_refresh(topology);
 
+  /* Same for memattrs */
+  hwloc_internal_memattrs_need_refresh(topology);
+  hwloc_internal_memattrs_refresh(topology);
+
   topology->is_loaded = 1;
 
+  if (topology->flags & HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_CPUBINDING) {
+    /* FIXME: filter directly in backends during the discovery.
+     * Only x86 does it because binding may cause issues on Windows.
+     */
+    hwloc_bitmap_t set = hwloc_bitmap_alloc();
+    if (set) {
+      err = hwloc_get_cpubind(topology, set, HWLOC_CPUBIND_STRICT);
+      if (!err)
+        hwloc_topology_restrict(topology, set, 0);
+      hwloc_bitmap_free(set);
+    }
+  }
+  if (topology->flags & HWLOC_TOPOLOGY_FLAG_RESTRICT_TO_MEMBINDING) {
+    /* FIXME: filter directly in backends during the discovery.
+     */
+    hwloc_bitmap_t set = hwloc_bitmap_alloc();
+    hwloc_membind_policy_t policy;
+    if (set) {
+      err = hwloc_get_membind(topology, set, &policy, HWLOC_MEMBIND_STRICT | HWLOC_MEMBIND_BYNODESET);
+      if (!err)
+        hwloc_topology_restrict(topology, set, HWLOC_RESTRICT_FLAG_BYNODESET);
+      hwloc_bitmap_free(set);
+    }
+  }
+
   if (topology->backend_phases & HWLOC_DISC_PHASE_TWEAK) {
     dstatus.phase = HWLOC_DISC_PHASE_TWEAK;
     hwloc_discover_by_phase(topology, &dstatus, "TWEAK");
@@ -4241,15 +4409,16 @@ hwloc_topology_restrict(struct hwloc_topology *topology, hwloc_const_bitmap_t se
   hwloc_bitmap_free(droppedcpuset);
   hwloc_bitmap_free(droppednodeset);
 
-  if (hwloc_topology_reconnect(topology, 0) < 0)
+  if (hwloc_filter_levels_keep_structure(topology) < 0) /* takes care of reconnecting internally */
     goto out;
 
   /* some objects may have disappeared, we need to update distances objs arrays */
   hwloc_internal_distances_invalidate_cached_objs(topology);
+  hwloc_internal_memattrs_need_refresh(topology);
 
-  hwloc_filter_levels_keep_structure(topology);
   hwloc_propagate_symmetric_subtree(topology, topology->levels[0][0]);
   propagate_total_memory(topology->levels[0][0]);
+  hwloc_internal_cpukinds_restrict(topology);
 
 #ifndef HWLOC_DEBUG
   if (getenv("HWLOC_DEBUG_CHECK"))
@@ -4334,6 +4503,15 @@ hwloc_topology_allow(struct hwloc_topology *topology,
   return -1;
 }
 
+int
+hwloc_topology_refresh(struct hwloc_topology *topology)
+{
+  hwloc_internal_cpukinds_rank(topology);
+  hwloc_internal_distances_refresh(topology);
+  hwloc_internal_memattrs_refresh(topology);
+  return 0;
+}
+
 int
 hwloc_topology_is_thissystem(struct hwloc_topology *topology)
 {
@@ -4628,6 +4806,9 @@ hwloc__check_misc_children(hwloc_topology_t topology, hwloc_bitmap_t gp_indexes,
 static void
 hwloc__check_object(hwloc_topology_t topology, hwloc_bitmap_t gp_indexes, hwloc_obj_t obj)
 {
+  hwloc_uint64_t total_memory;
+  hwloc_obj_t child;
+
   assert(!hwloc_bitmap_isset(gp_indexes, obj->gp_index));
   hwloc_bitmap_set(gp_indexes, obj->gp_index);
 
@@ -4685,6 +4866,18 @@ hwloc__check_object(hwloc_topology_t topology, hwloc_bitmap_t gp_indexes, hwloc_
     assert(hwloc_cache_type_by_depth_type(obj->attr->cache.depth, obj->attr->cache.type) == obj->type);
   }
 
+  /* check total memory */
+  total_memory = 0;
+  if (obj->type == HWLOC_OBJ_NUMANODE)
+    total_memory += obj->attr->numanode.local_memory;
+  for_each_child(child, obj) {
+    total_memory += child->total_memory;
+  }
+  for_each_memory_child(child, obj) {
+    total_memory += child->total_memory;
+  }
+  assert(total_memory == obj->total_memory);
+
   /* check children */
   hwloc__check_normal_children(topology, gp_indexes, obj);
   hwloc__check_memory_children(topology, gp_indexes, obj);

src/3rdparty/hwloc/src/traversal.c

@@ -1,7 +1,7 @@
 /*
  * Copyright © 2009 CNRS
- * Copyright © 2009-2019 Inria.  All rights reserved.
- * Copyright © 2009-2010 Université Bordeaux
+ * Copyright © 2009-2021 Inria.  All rights reserved.
+ * Copyright © 2009-2010, 2020 Université Bordeaux
  * Copyright © 2009-2011 Cisco Systems, Inc.  All rights reserved.
  * See COPYING in top-level directory.
  */
@@ -138,6 +138,37 @@ hwloc_obj_type_is_icache(hwloc_obj_type_t type)
   return hwloc__obj_type_is_icache(type);
 }
 
+static hwloc_obj_t hwloc_get_obj_by_depth_and_gp_index(hwloc_topology_t topology, unsigned depth, uint64_t gp_index)
+{
+  hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, depth, 0);
+  while (obj) {
+    if (obj->gp_index == gp_index)
+      return obj;
+    obj = obj->next_cousin;
+  }
+  return NULL;
+}
+
+hwloc_obj_t hwloc_get_obj_by_type_and_gp_index(hwloc_topology_t topology, hwloc_obj_type_t type, uint64_t gp_index)
+{
+  int depth = hwloc_get_type_depth(topology, type);
+  if (depth == HWLOC_TYPE_DEPTH_UNKNOWN)
+    return NULL;
+  if (depth == HWLOC_TYPE_DEPTH_MULTIPLE) {
+    for(depth=1 /* no multiple machine levels */;
+	(unsigned) depth < topology->nb_levels-1 /* no multiple PU levels */;
+	depth++) {
+      if (hwloc_get_depth_type(topology, depth) == type) {
+	hwloc_obj_t obj = hwloc_get_obj_by_depth_and_gp_index(topology, depth, gp_index);
+	if (obj)
+	  return obj;
+      }
+    }
+    return NULL;
+  }
+  return hwloc_get_obj_by_depth_and_gp_index(topology, depth, gp_index);
+}
+
 unsigned hwloc_get_closest_objs (struct hwloc_topology *topology, struct hwloc_obj *src, struct hwloc_obj **objs, unsigned max)
 {
   struct hwloc_obj *parent, *nextparent, **src_objs;
@@ -364,6 +395,8 @@ hwloc_type_sscanf(const char *string, hwloc_obj_type_t *typep,
   } else if (hwloc__type_match(string, "pcibridge", 5)) {
     type = HWLOC_OBJ_BRIDGE;
     ubtype = HWLOC_OBJ_BRIDGE_PCI;
+    /* if downstream_type can ever be non-PCI, we'll have to make strings more precise,
+     * or relax the hwloc_type_sscanf test */
 
   } else if (hwloc__type_match(string, "pcidev", 3)) {
     type = HWLOC_OBJ_PCI_DEVICE;
@@ -417,7 +450,9 @@ hwloc_type_sscanf(const char *string, hwloc_obj_type_t *typep,
       attrp->group.depth = depthattr;
     } else if (type == HWLOC_OBJ_BRIDGE && attrsize >= sizeof(attrp->bridge)) {
       attrp->bridge.upstream_type = ubtype;
-      attrp->bridge.downstream_type = HWLOC_OBJ_BRIDGE_PCI; /* nothing else so far */
+      attrp->bridge.downstream_type = HWLOC_OBJ_BRIDGE_PCI;
+      /* if downstream_type can ever be non-PCI, we'll have to make strings more precise,
+       * or relax the hwloc_type_sscanf test */
     } else if (type == HWLOC_OBJ_OS_DEVICE && attrsize >= sizeof(attrp->osdev)) {
       attrp->osdev.type = ostype;
     }
@@ -500,6 +535,9 @@ hwloc_obj_type_snprintf(char * __hwloc_restrict string, size_t size, hwloc_obj_t
     else
       return hwloc_snprintf(string, size, "%s", hwloc_obj_type_string(type));
   case HWLOC_OBJ_BRIDGE:
+    /* if downstream_type can ever be non-PCI, we'll have to make strings more precise,
+     * or relax the hwloc_type_sscanf test */
+    assert(obj->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI);
     return hwloc_snprintf(string, size, obj->attr->bridge.upstream_type == HWLOC_OBJ_BRIDGE_PCI ? "PCIBridge" : "HostBridge");
   case HWLOC_OBJ_PCI_DEVICE:
     return hwloc_snprintf(string, size, "PCI");
@@ -617,8 +655,11 @@ hwloc_obj_attr_snprintf(char * __hwloc_restrict string, size_t size, hwloc_obj_t
       } else
         *up = '\0';
       /* downstream is_PCI */
+      if (obj->attr->bridge.downstream_type == HWLOC_OBJ_BRIDGE_PCI) {
         snprintf(down, sizeof(down), "buses=%04x:[%02x-%02x]",
                  obj->attr->bridge.downstream.pci.domain, obj->attr->bridge.downstream.pci.secondary_bus, obj->attr->bridge.downstream.pci.subordinate_bus);
+      } else
+        assert(0);
       if (*up)
 	res = hwloc_snprintf(string, size, "%s%s%s", up, separator, down);
       else
@@ -654,7 +695,11 @@ hwloc_obj_attr_snprintf(char * __hwloc_restrict string, size_t size, hwloc_obj_t
     unsigned i;
     for(i=0; i<obj->infos_count; i++) {
       struct hwloc_info_s *info = &obj->infos[i];
-      const char *quote = strchr(info->value, ' ') ? "\"" : "";
+      const char *quote;
+      if (strchr(info->value, ' '))
+        quote = "\"";
+      else
+        quote = "";
       res = hwloc_snprintf(tmp, tmplen, "%s%s=%s%s%s",
 			     prefix,
 			     info->name,
@@ -673,3 +718,120 @@ hwloc_obj_attr_snprintf(char * __hwloc_restrict string, size_t size, hwloc_obj_t
 
   return ret;
 }
+
+int hwloc_bitmap_singlify_per_core(hwloc_topology_t topology, hwloc_bitmap_t cpuset, unsigned which)
+{
+  hwloc_obj_t core = NULL;
+  while ((core = hwloc_get_next_obj_covering_cpuset_by_type(topology, cpuset, HWLOC_OBJ_CORE, core)) != NULL) {
+    /* this core has some PUs in the cpuset, find the index-th one */
+    unsigned i = 0;
+    int pu = -1;
+    do {
+      pu = hwloc_bitmap_next(core->cpuset, pu);
+      if (pu == -1) {
+	/* no which-th PU in cpuset and core, remove the entire core */
+	hwloc_bitmap_andnot(cpuset, cpuset, core->cpuset);
+	break;
+      }
+      if (hwloc_bitmap_isset(cpuset, pu)) {
+	if (i == which) {
+	  /* remove the entire core except that exact pu */
+	  hwloc_bitmap_andnot(cpuset, cpuset, core->cpuset);
+	  hwloc_bitmap_set(cpuset, pu);
+	  break;
+	}
+	i++;
+      }
+    } while (1);
+  }
+  return 0;
+}
+
+hwloc_obj_t
+hwloc_get_obj_with_same_locality(hwloc_topology_t topology, hwloc_obj_t src,
+                                 hwloc_obj_type_t type, const char *subtype, const char *nameprefix,
+                                 unsigned long flags)
+{
+  if (flags) {
+    errno = EINVAL;
+    return NULL;
+  }
+
+  if (hwloc_obj_type_is_normal(src->type) || hwloc_obj_type_is_memory(src->type)) {
+    /* normal/memory type, look for normal/memory type with same sets */
+    hwloc_obj_t obj;
+
+    if (!hwloc_obj_type_is_normal(type) && !hwloc_obj_type_is_memory(type)) {
+      errno = EINVAL;
+      return NULL;
+    }
+
+    obj = NULL;
+    while ((obj = hwloc_get_next_obj_by_type(topology, type, obj)) != NULL) {
+      if (!hwloc_bitmap_isequal(src->cpuset, obj->cpuset)
+          || !hwloc_bitmap_isequal(src->nodeset, obj->nodeset))
+        continue;
+      if (subtype && (!obj->subtype || strcasecmp(subtype, obj->subtype)))
+        continue;
+      if (nameprefix && (!obj->name || hwloc_strncasecmp(nameprefix, obj->name, strlen(nameprefix))))
+        continue;
+      return obj;
+    }
+    errno = ENOENT;
+    return NULL;
+
+  } else if (hwloc_obj_type_is_io(src->type)) {
+    /* I/O device, look for PCI/OS in same PCI */
+    hwloc_obj_t pci;
+
+    if ((src->type != HWLOC_OBJ_OS_DEVICE && src->type != HWLOC_OBJ_PCI_DEVICE)
+        || (type != HWLOC_OBJ_OS_DEVICE && type != HWLOC_OBJ_PCI_DEVICE)) {
+      errno = EINVAL;
+      return NULL;
+    }
+
+    /* walk up to find the container */
+    pci = src;
+    while (pci->type == HWLOC_OBJ_OS_DEVICE)
+      pci = pci->parent;
+
+    if (type == HWLOC_OBJ_PCI_DEVICE) {
+      if (pci->type != HWLOC_OBJ_PCI_DEVICE) {
+        errno = ENOENT;
+        return NULL;
+      }
+      if (subtype && (!pci->subtype || strcasecmp(subtype, pci->subtype))) {
+        errno = ENOENT;
+        return NULL;
+      }
+      if (nameprefix && (!pci->name || hwloc_strncasecmp(nameprefix, pci->name, strlen(nameprefix)))) {
+        errno = ENOENT;
+        return NULL;
+      }
+      return pci;
+
+    } else {
+      /* find a matching osdev child */
+      assert(type == HWLOC_OBJ_OS_DEVICE);
+      /* FIXME: won't work if we ever store osdevs in osdevs */
+      hwloc_obj_t child;
+      for(child = pci->io_first_child; child; child = child->next_sibling) {
+        if (child->type != HWLOC_OBJ_OS_DEVICE)
+          /* FIXME: should never occur currently */
+          continue;
+        if (subtype && (!child->subtype || strcasecmp(subtype, child->subtype)))
+          continue;
+        if (nameprefix && (!child->name || hwloc_strncasecmp(nameprefix, child->name, strlen(nameprefix))))
+          continue;
+        return child;
+      }
+    }
+    errno = ENOENT;
+    return NULL;
+
+  } else {
+    /* nothing for Misc */
+    errno = EINVAL;
+    return NULL;
+  }
+}

src/3rdparty/libcpuid/CMakeLists.txt

@@ -1,38 +0,0 @@
-cmake_minimum_required (VERSION 2.8)
-project (cpuid C)
-
-add_definitions(/DVERSION="0.4.0")
-
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -Os")
-
-set(HEADERS
-    libcpuid.h
-    libcpuid_types.h
-    libcpuid_constants.h
-    libcpuid_internal.h
-    amd_code_t.h
-    intel_code_t.h
-    recog_amd.h
-    recog_intel.h
-    asm-bits.h
-    libcpuid_util.h
-    )
-
-set(SOURCES
-    cpuid_main.c
-    asm-bits.c
-    recog_amd.c
-    recog_intel.c
-    libcpuid_util.c
-   )
-
-if (CMAKE_CL_64)
-    enable_language(ASM_MASM)
-    set(SOURCES_ASM masm-x64.asm)
-endif()
-
-add_library(cpuid STATIC
-    ${HEADERS}
-    ${SOURCES}
-    ${SOURCES_ASM}
-    )

src/3rdparty/libcpuid/amd_code_t.h

@@ -1,39 +0,0 @@
-/*
- * Copyright 2016  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This file contains a list of internal codes we use in detection. It is
- * of no external use and isn't a complete list of AMD products.
- */
-	CODE2(OPTERON_800, 1000),
-	CODE(PHENOM),
-	CODE(PHENOM2),
-	CODE(FUSION_C),
-	CODE(FUSION_E),
-	CODE(FUSION_EA),
-	CODE(FUSION_Z),
-	CODE(FUSION_A),
-	

src/3rdparty/libcpuid/asm-bits.c

@@ -1,836 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include "libcpuid.h"
-#include "asm-bits.h"
-
-int cpuid_exists_by_eflags(void)
-{
-#if defined(PLATFORM_X64)
-	return 1; /* CPUID is always present on the x86_64 */
-#elif defined(PLATFORM_X86)
-#  if defined(COMPILER_GCC) || defined(COMPILER_CLANG)
-	int result;
-	__asm __volatile(
-		"	pushfl\n"
-		"	pop	%%eax\n"
-		"	mov	%%eax,	%%ecx\n"
-		"	xor	$0x200000,	%%eax\n"
-		"	push	%%eax\n"
-		"	popfl\n"
-		"	pushfl\n"
-		"	pop	%%eax\n"
-		"	xor	%%ecx,	%%eax\n"
-		"	mov	%%eax,	%0\n"
-		"	push	%%ecx\n"
-		"	popfl\n"
-		: "=m"(result)
-		: :"eax", "ecx", "memory");
-	return (result != 0);
-#  elif defined(COMPILER_MICROSOFT)
-	int result;
-	__asm {
-		pushfd
-		pop	eax
-		mov	ecx,	eax
-		xor	eax,	0x200000
-		push	eax
-		popfd
-		pushfd
-		pop	eax
-		xor	eax,	ecx
-		mov	result,	eax
-		push	ecx
-		popfd
-	};
-	return (result != 0);
-#  else
-	return 0;
-#  endif /* COMPILER_MICROSOFT */
-#elif defined(PLATFORM_ARM)
-  return 0;
-#else
-	return 0;
-#endif /* PLATFORM_X86 */
-}
-
-#ifdef INLINE_ASM_SUPPORTED
-/* 
- * with MSVC/AMD64, the exec_cpuid() and cpu_rdtsc() functions
- * are implemented in separate .asm files. Otherwise, use inline assembly
- */
-void exec_cpuid(uint32_t *regs)
-{
-#  if defined(COMPILER_GCC) || defined(COMPILER_CLANG)
-#	ifdef PLATFORM_X64
-	__asm __volatile(
-		"	mov	%0,	%%rdi\n"
-
-		"	push	%%rbx\n"
-		"	push	%%rcx\n"
-		"	push	%%rdx\n"
-		
-		"	mov	(%%rdi),	%%eax\n"
-		"	mov	4(%%rdi),	%%ebx\n"
-		"	mov	8(%%rdi),	%%ecx\n"
-		"	mov	12(%%rdi),	%%edx\n"
-		
-		"	cpuid\n"
-		
-		"	movl	%%eax,	(%%rdi)\n"
-		"	movl	%%ebx,	4(%%rdi)\n"
-		"	movl	%%ecx,	8(%%rdi)\n"
-		"	movl	%%edx,	12(%%rdi)\n"
-		"	pop	%%rdx\n"
-		"	pop	%%rcx\n"
-		"	pop	%%rbx\n"
-		:
-		:"m"(regs)
-		:"memory", "eax", "rdi"
-	);
-#	elif defined(PLATFORM_X86)
-	__asm __volatile(
-		"	mov	%0,	%%edi\n"
-
-		"	push	%%ebx\n"
-		"	push	%%ecx\n"
-		"	push	%%edx\n"
-		
-		"	mov	(%%edi),	%%eax\n"
-		"	mov	4(%%edi),	%%ebx\n"
-		"	mov	8(%%edi),	%%ecx\n"
-		"	mov	12(%%edi),	%%edx\n"
-		
-		"	cpuid\n"
-		
-		"	mov	%%eax,	(%%edi)\n"
-		"	mov	%%ebx,	4(%%edi)\n"
-		"	mov	%%ecx,	8(%%edi)\n"
-		"	mov	%%edx,	12(%%edi)\n"
-		"	pop	%%edx\n"
-		"	pop	%%ecx\n"
-		"	pop	%%ebx\n"
-		:
-		:"m"(regs)
-		:"memory", "eax", "edi"
-	);
-#	elif defined(PLATFORM_ARM)
-#	endif /* COMPILER_GCC */
-#else
-#  ifdef COMPILER_MICROSOFT
-	__asm {
-		push	ebx
-		push	ecx
-		push	edx
-		push	edi
-		mov	edi,	regs
-		
-		mov	eax,	[edi]
-		mov	ebx,	[edi+4]
-		mov	ecx,	[edi+8]
-		mov	edx,	[edi+12]
-		
-		cpuid
-		
-		mov	[edi],		eax
-		mov	[edi+4],	ebx
-		mov	[edi+8],	ecx
-		mov	[edi+12],	edx
-		
-		pop	edi
-		pop	edx
-		pop	ecx
-		pop	ebx
-	}
-#  else
-#    error "Unsupported compiler"
-#  endif /* COMPILER_MICROSOFT */
-#endif
-}
-#endif /* INLINE_ASSEMBLY_SUPPORTED */
-
-#ifdef INLINE_ASM_SUPPORTED
-void cpu_rdtsc(uint64_t* result)
-{
-	uint32_t low_part, hi_part;
-#if defined(COMPILER_GCC) || defined(COMPILER_CLANG)
-#ifdef PLATFORM_ARM
-  low_part = 0;
-  hi_part = 0;
-#else
-	__asm __volatile (
-		"	rdtsc\n"
-		"	mov	%%eax,	%0\n"
-		"	mov	%%edx,	%1\n"
-		:"=m"(low_part), "=m"(hi_part)::"memory", "eax", "edx"
-	);
-#endif
-#else
-#  ifdef COMPILER_MICROSOFT
-	__asm {
-		rdtsc
-		mov	low_part,	eax
-		mov	hi_part,	edx
-	};
-#  else
-#    error "Unsupported compiler"
-#  endif /* COMPILER_MICROSOFT */
-#endif /* COMPILER_GCC */
-	*result = (uint64_t)low_part + (((uint64_t) hi_part) << 32);
-}
-#endif /* INLINE_ASM_SUPPORTED */
-
-#ifdef INLINE_ASM_SUPPORTED
-void busy_sse_loop(int cycles)
-{
-#  if defined(COMPILER_GCC) || defined(COMPILER_CLANG)
-#ifndef __APPLE__
-#	define XALIGN ".balign 16\n"
-#else
-#	define XALIGN ".align 4\n"
-#endif
-#ifdef PLATFORM_ARM
-#else
-	__asm __volatile (
-		"	xorps	%%xmm0,	%%xmm0\n"
-		"	xorps	%%xmm1,	%%xmm1\n"
-		"	xorps	%%xmm2,	%%xmm2\n"
-		"	xorps	%%xmm3,	%%xmm3\n"
-		"	xorps	%%xmm4,	%%xmm4\n"
-		"	xorps	%%xmm5,	%%xmm5\n"
-		"	xorps	%%xmm6,	%%xmm6\n"
-		"	xorps	%%xmm7,	%%xmm7\n"
-		XALIGN
-		/* ".bsLoop:\n" */
-		"1:\n"
-		// 0:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 1:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 2:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 3:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 4:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 5:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 6:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 7:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 8:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		// 9:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//10:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//11:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//12:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//13:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//14:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//15:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//16:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//17:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//18:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//19:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//20:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//21:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//22:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//23:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//24:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//25:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//26:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//27:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//28:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//29:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//30:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		//31:
-		"	addps	%%xmm1, %%xmm0\n"
-		"	addps	%%xmm2, %%xmm1\n"
-		"	addps	%%xmm3, %%xmm2\n"
-		"	addps	%%xmm4, %%xmm3\n"
-		"	addps	%%xmm5, %%xmm4\n"
-		"	addps	%%xmm6, %%xmm5\n"
-		"	addps	%%xmm7, %%xmm6\n"
-		"	addps	%%xmm0, %%xmm7\n"
-		
-		"	dec	%%eax\n"
-		/* "jnz	.bsLoop\n" */
-		"	jnz	1b\n"
-		::"a"(cycles)
-	);
-#endif
-#else
-#  ifdef COMPILER_MICROSOFT
-	__asm {
-		mov	eax,	cycles
-		xorps	xmm0,	xmm0
-		xorps	xmm1,	xmm1
-		xorps	xmm2,	xmm2
-		xorps	xmm3,	xmm3
-		xorps	xmm4,	xmm4
-		xorps	xmm5,	xmm5
-		xorps	xmm6,	xmm6
-		xorps	xmm7,	xmm7
-		//--
-		align 16
-bsLoop:
-		// 0:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 1:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 2:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 3:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 4:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 5:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 6:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 7:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 8:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 9:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 10:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 11:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 12:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 13:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 14:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 15:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 16:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 17:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 18:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 19:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 20:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 21:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 22:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 23:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 24:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 25:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 26:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 27:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 28:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 29:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 30:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		// 31:
-		addps	xmm0,	xmm1
-		addps	xmm1,	xmm2
-		addps	xmm2,	xmm3
-		addps	xmm3,	xmm4
-		addps	xmm4,	xmm5
-		addps	xmm5,	xmm6
-		addps	xmm6,	xmm7
-		addps	xmm7,	xmm0
-		//----------------------
-		dec		eax
-		jnz		bsLoop
-	}
-#  else
-#    error "Unsupported compiler"
-#  endif /* COMPILER_MICROSOFT */
-#endif /* COMPILER_GCC */
-}
-#endif /* INLINE_ASSEMBLY_SUPPORTED */

src/3rdparty/libcpuid/asm-bits.h

@@ -1,71 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef __ASM_BITS_H__
-#define __ASM_BITS_H__
-#include "libcpuid.h"
-
-/* Determine Compiler: */
-#if defined(_MSC_VER)
-#if !defined(COMPILER_MICROSOFT)
-#	define COMPILER_MICROSOFT
-#endif
-#elif defined(__GNUC__)
-#if !defined(COMPILER_GCC)
-#	define COMPILER_GCC
-#endif
-#elif defined(__clang__)
-#if !defined(COMPILER_CLANG)
-#	define COMPILER_CLANG
-#endif
-#endif
-
-/* Determine Platform */
-#if defined(__x86_64__) || defined(_M_AMD64)
-#if !defined(PLATFORM_X64)
-#	define PLATFORM_X64
-#endif
-#elif defined(__i386__) || defined(_M_IX86)
-#if !defined(PLATFORM_X86)
-#	define PLATFORM_X86
-#endif
-#elif defined(__ARMEL__)
-#if !defined(PLATFORM_ARM)
-#	define PLATFORM_ARM
-#endif
-#endif
-
-/* Under Windows/AMD64 with MSVC, inline assembly isn't supported */
-#if (((defined(COMPILER_GCC) || defined(COMPILER_CLANG))) &&  \
-     (defined(PLATFORM_X64) || defined(PLATFORM_X86) || defined(PLATFORM_ARM))) || \
-	 (defined(COMPILER_MICROSOFT) && defined(PLATFORM_X86))
-#	define INLINE_ASM_SUPPORTED
-#endif
-
-int cpuid_exists_by_eflags(void);
-void exec_cpuid(uint32_t *regs);
-void busy_sse_loop(int cycles);
-
-#endif /* __ASM_BITS_H__ */

src/3rdparty/libcpuid/cpuid_main.c

@@ -1,389 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#include "libcpuid.h"
-#include "libcpuid_internal.h"
-#include "recog_intel.h"
-#include "recog_amd.h"
-#include "asm-bits.h"
-#include "libcpuid_util.h"
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-
-/* Implementation: */
-
-static int _libcpiud_errno = ERR_OK;
-
-int set_error(cpu_error_t err)
-{
-	_libcpiud_errno = (int) err;
-	return (int) err;
-}
-
-static void cpu_id_t_constructor(struct cpu_id_t* id)
-{
-	memset(id, 0, sizeof(struct cpu_id_t));
-	id->l1_data_cache = id->l1_instruction_cache = id->l2_cache = id->l3_cache = id->l4_cache = -1;
-	id->l1_assoc = id->l2_assoc = id->l3_assoc = id->l4_assoc = -1;
-	id->l1_cacheline = id->l2_cacheline = id->l3_cacheline = id->l4_cacheline = -1;
-	id->sse_size = -1;
-}
-
-/* get_total_cpus() system specific code: uses OS routines to determine total number of CPUs */
-#ifdef __APPLE__
-#include <unistd.h>
-#include <mach/clock_types.h>
-#include <mach/clock.h>
-#include <mach/mach.h>
-static int get_total_cpus(void)
-{
-	kern_return_t kr;
-	host_basic_info_data_t basic_info;
-	host_info_t info = (host_info_t)&basic_info;
-	host_flavor_t flavor = HOST_BASIC_INFO;
-	mach_msg_type_number_t count = HOST_BASIC_INFO_COUNT;
-	kr = host_info(mach_host_self(), flavor, info, &count);
-	if (kr != KERN_SUCCESS) return 1;
-	return basic_info.avail_cpus;
-}
-#define GET_TOTAL_CPUS_DEFINED
-#endif
-
-#ifdef _WIN32
-#include <windows.h>
-static int get_total_cpus(void)
-{
-	SYSTEM_INFO system_info;
-	GetSystemInfo(&system_info);
-	return system_info.dwNumberOfProcessors;
-}
-#define GET_TOTAL_CPUS_DEFINED
-#endif
-
-#if defined linux || defined __linux__ || defined __sun
-#include <sys/sysinfo.h>
-#include <unistd.h>
- 
-static int get_total_cpus(void)
-{
-	return sysconf(_SC_NPROCESSORS_ONLN);
-}
-#define GET_TOTAL_CPUS_DEFINED
-#endif
-
-#if defined __FreeBSD__ || defined __OpenBSD__ || defined __NetBSD__ || defined __bsdi__ || defined __QNX__
-#include <sys/types.h>
-#include <sys/sysctl.h>
-
-static int get_total_cpus(void)
-{
-	int mib[2] = { CTL_HW, HW_NCPU };
-	int ncpus;
-	size_t len = sizeof(ncpus);
-	if (sysctl(mib, 2, &ncpus, &len, (void *) 0, 0) != 0) return 1;
-	return ncpus;
-}
-#define GET_TOTAL_CPUS_DEFINED
-#endif
-
-#ifndef GET_TOTAL_CPUS_DEFINED
-static int get_total_cpus(void)
-{
-	static int warning_printed = 0;
-	if (!warning_printed) {
-		warning_printed = 1;
-		warnf("Your system is not supported by libcpuid -- don't know how to detect the\n");
-		warnf("total number of CPUs on your system. It will be reported as 1.\n");
-		printf("Please use cpu_id_t.logical_cpus field instead.\n");
-	}
-	return 1;
-}
-#endif /* GET_TOTAL_CPUS_DEFINED */
-
-
-static void load_features_common(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
-{
-	const struct feature_map_t matchtable_edx1[] = {
-		{  0, CPU_FEATURE_FPU },
-		{  1, CPU_FEATURE_VME },
-		{  2, CPU_FEATURE_DE },
-		{  3, CPU_FEATURE_PSE },
-		{  4, CPU_FEATURE_TSC },
-		{  5, CPU_FEATURE_MSR },
-		{  6, CPU_FEATURE_PAE },
-		{  7, CPU_FEATURE_MCE },
-		{  8, CPU_FEATURE_CX8 },
-		{  9, CPU_FEATURE_APIC },
-		{ 11, CPU_FEATURE_SEP },
-		{ 12, CPU_FEATURE_MTRR },
-		{ 13, CPU_FEATURE_PGE },
-		{ 14, CPU_FEATURE_MCA },
-		{ 15, CPU_FEATURE_CMOV },
-		{ 16, CPU_FEATURE_PAT },
-		{ 17, CPU_FEATURE_PSE36 },
-		{ 19, CPU_FEATURE_CLFLUSH },
-		{ 23, CPU_FEATURE_MMX },
-		{ 24, CPU_FEATURE_FXSR },
-		{ 25, CPU_FEATURE_SSE },
-		{ 26, CPU_FEATURE_SSE2 },
-		{ 28, CPU_FEATURE_HT },
-	};
-	const struct feature_map_t matchtable_ecx1[] = {
-		{  0, CPU_FEATURE_PNI },
-		{  1, CPU_FEATURE_PCLMUL },
-		{  3, CPU_FEATURE_MONITOR },
-		{  9, CPU_FEATURE_SSSE3 },
-		{ 12, CPU_FEATURE_FMA3 },
-		{ 13, CPU_FEATURE_CX16 },
-		{ 19, CPU_FEATURE_SSE4_1 },
-		{ 20, CPU_FEATURE_SSE4_2 },
-		{ 22, CPU_FEATURE_MOVBE },
-		{ 23, CPU_FEATURE_POPCNT },
-		{ 25, CPU_FEATURE_AES },
-		{ 26, CPU_FEATURE_XSAVE },
-		{ 27, CPU_FEATURE_OSXSAVE },
-		{ 28, CPU_FEATURE_AVX },
-		{ 29, CPU_FEATURE_F16C },
-		{ 30, CPU_FEATURE_RDRAND },
-	};
-	const struct feature_map_t matchtable_ebx7[] = {
-		{  3, CPU_FEATURE_BMI1 },
-		{  5, CPU_FEATURE_AVX2 },
-		{  8, CPU_FEATURE_BMI2 },
-	};
-	const struct feature_map_t matchtable_edx81[] = {
-		{ 11, CPU_FEATURE_SYSCALL },
-		{ 27, CPU_FEATURE_RDTSCP },
-		{ 29, CPU_FEATURE_LM },
-	};
-	const struct feature_map_t matchtable_ecx81[] = {
-		{  0, CPU_FEATURE_LAHF_LM },
-	};
-	const struct feature_map_t matchtable_edx87[] = {
-		{  8, CPU_FEATURE_CONSTANT_TSC },
-	};
-	if (raw->basic_cpuid[0][0] >= 1) {
-		match_features(matchtable_edx1, COUNT_OF(matchtable_edx1), raw->basic_cpuid[1][3], data);
-		match_features(matchtable_ecx1, COUNT_OF(matchtable_ecx1), raw->basic_cpuid[1][2], data);
-	}
-	if (raw->basic_cpuid[0][0] >= 7) {
-		match_features(matchtable_ebx7, COUNT_OF(matchtable_ebx7), raw->basic_cpuid[7][1], data);
-	}
-	if (raw->ext_cpuid[0][0] >= 0x80000001) {
-		match_features(matchtable_edx81, COUNT_OF(matchtable_edx81), raw->ext_cpuid[1][3], data);
-		match_features(matchtable_ecx81, COUNT_OF(matchtable_ecx81), raw->ext_cpuid[1][2], data);
-	}
-	if (raw->ext_cpuid[0][0] >= 0x80000007) {
-		match_features(matchtable_edx87, COUNT_OF(matchtable_edx87), raw->ext_cpuid[7][3], data);
-	}
-	if (data->flags[CPU_FEATURE_SSE]) {
-		/* apply guesswork to check if the SSE unit width is 128 bit */
-		switch (data->vendor) {
-			case VENDOR_AMD:
-				data->sse_size = (data->ext_family >= 16 && data->ext_family != 17) ? 128 : 64;
-				break;
-			case VENDOR_INTEL:
-				data->sse_size = (data->family == 6 && data->ext_model >= 15) ? 128 : 64;
-				break;
-			default:
-				break;
-		}
-		/* leave the CPU_FEATURE_128BIT_SSE_AUTH 0; the advanced per-vendor detection routines
-		 * will set it accordingly if they detect the needed bit */
-	}
-}
-
-static cpu_vendor_t cpuid_vendor_identify(const uint32_t *raw_vendor, char *vendor_str)
-{
-	int i;
-	cpu_vendor_t vendor = VENDOR_UNKNOWN;
-	const struct { cpu_vendor_t vendor; char match[16]; }
-	matchtable[NUM_CPU_VENDORS] = {
-		/* source: http://www.sandpile.org/ia32/cpuid.htm */
-		{ VENDOR_INTEL		, "GenuineIntel" },
-		{ VENDOR_AMD		, "AuthenticAMD" },
-		{ VENDOR_CYRIX		, "CyrixInstead" },
-		{ VENDOR_NEXGEN		, "NexGenDriven" },
-		{ VENDOR_TRANSMETA	, "GenuineTMx86" },
-		{ VENDOR_UMC		, "UMC UMC UMC " },
-		{ VENDOR_CENTAUR	, "CentaurHauls" },
-		{ VENDOR_RISE		, "RiseRiseRise" },
-		{ VENDOR_SIS		, "SiS SiS SiS " },
-		{ VENDOR_NSC		, "Geode by NSC" },
-	};
-
-	memcpy(vendor_str + 0, &raw_vendor[1], 4);
-	memcpy(vendor_str + 4, &raw_vendor[3], 4);
-	memcpy(vendor_str + 8, &raw_vendor[2], 4);
-	vendor_str[12] = 0;
-
-	/* Determine vendor: */
-	for (i = 0; i < NUM_CPU_VENDORS; i++)
-		if (!strcmp(vendor_str, matchtable[i].match)) {
-			vendor = matchtable[i].vendor;
-			break;
-		}
-	return vendor;
-}
-
-static int cpuid_basic_identify(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
-{
-	int i, j, basic, xmodel, xfamily, ext;
-	char brandstr[64] = {0};
-	data->vendor = cpuid_vendor_identify(raw->basic_cpuid[0], data->vendor_str);
-
-	if (data->vendor == VENDOR_UNKNOWN)
-		return set_error(ERR_CPU_UNKN);
-	basic = raw->basic_cpuid[0][0];
-	if (basic >= 1) {
-		data->family = (raw->basic_cpuid[1][0] >> 8) & 0xf;
-		data->model = (raw->basic_cpuid[1][0] >> 4) & 0xf;
-		data->stepping = raw->basic_cpuid[1][0] & 0xf;
-		xmodel = (raw->basic_cpuid[1][0] >> 16) & 0xf;
-		xfamily = (raw->basic_cpuid[1][0] >> 20) & 0xff;
-		if (data->vendor == VENDOR_AMD && data->family < 0xf)
-			data->ext_family = data->family;
-		else
-			data->ext_family = data->family + xfamily;
-		data->ext_model = data->model + (xmodel << 4);
-	}
-	ext = raw->ext_cpuid[0][0] - 0x8000000;
-	
-	/* obtain the brand string, if present: */
-	if (ext >= 4) {
-		for (i = 0; i < 3; i++)
-			for (j = 0; j < 4; j++)
-				memcpy(brandstr + i * 16 + j * 4,
-				       &raw->ext_cpuid[2 + i][j], 4);
-		brandstr[48] = 0;
-		i = 0;
-		while (brandstr[i] == ' ') i++;
-		strncpy(data->brand_str, brandstr + i, sizeof(data->brand_str));
-		data->brand_str[48] = 0;
-	}
-	load_features_common(raw, data);
-	data->total_logical_cpus = get_total_cpus();
-	return set_error(ERR_OK);
-}
-
-/* Interface: */
-
-int cpuid_get_total_cpus(void)
-{
-	return get_total_cpus();
-}
-
-int cpuid_present(void)
-{
-	return cpuid_exists_by_eflags();
-}
-
-void cpu_exec_cpuid(uint32_t eax, uint32_t* regs)
-{
-	regs[0] = eax;
-	regs[1] = regs[2] = regs[3] = 0;
-	exec_cpuid(regs);
-}
-
-void cpu_exec_cpuid_ext(uint32_t* regs)
-{
-	exec_cpuid(regs);
-}
-
-int cpuid_get_raw_data(struct cpu_raw_data_t* data)
-{
-	unsigned i;
-	if (!cpuid_present())
-		return set_error(ERR_NO_CPUID);
-	for (i = 0; i < 32; i++)
-		cpu_exec_cpuid(i, data->basic_cpuid[i]);
-	for (i = 0; i < 32; i++)
-		cpu_exec_cpuid(0x80000000 + i, data->ext_cpuid[i]);
-	for (i = 0; i < MAX_INTELFN4_LEVEL; i++) {
-		memset(data->intel_fn4[i], 0, sizeof(data->intel_fn4[i]));
-		data->intel_fn4[i][0] = 4;
-		data->intel_fn4[i][2] = i;
-		cpu_exec_cpuid_ext(data->intel_fn4[i]);
-	}
-	for (i = 0; i < MAX_INTELFN11_LEVEL; i++) {
-		memset(data->intel_fn11[i], 0, sizeof(data->intel_fn11[i]));
-		data->intel_fn11[i][0] = 11;
-		data->intel_fn11[i][2] = i;
-		cpu_exec_cpuid_ext(data->intel_fn11[i]);
-	}
-	for (i = 0; i < MAX_INTELFN12H_LEVEL; i++) {
-		memset(data->intel_fn12h[i], 0, sizeof(data->intel_fn12h[i]));
-		data->intel_fn12h[i][0] = 0x12;
-		data->intel_fn12h[i][2] = i;
-		cpu_exec_cpuid_ext(data->intel_fn12h[i]);
-	}
-	for (i = 0; i < MAX_INTELFN14H_LEVEL; i++) {
-		memset(data->intel_fn14h[i], 0, sizeof(data->intel_fn14h[i]));
-		data->intel_fn14h[i][0] = 0x14;
-		data->intel_fn14h[i][2] = i;
-		cpu_exec_cpuid_ext(data->intel_fn14h[i]);
-	}
-	return set_error(ERR_OK);
-}
-
-int cpu_ident_internal(struct cpu_raw_data_t* raw, struct cpu_id_t* data, struct internal_id_info_t* internal)
-{
-	int r;
-	struct cpu_raw_data_t myraw;
-	if (!raw) {
-		if ((r = cpuid_get_raw_data(&myraw)) < 0)
-			return set_error(r);
-		raw = &myraw;
-	}
-	cpu_id_t_constructor(data);
-	if ((r = cpuid_basic_identify(raw, data)) < 0)
-		return set_error(r);
-	switch (data->vendor) {
-		case VENDOR_INTEL:
-			r = cpuid_identify_intel(raw, data, internal);
-			break;
-		case VENDOR_AMD:
-			r = cpuid_identify_amd(raw, data, internal);
-			break;
-		default:
-			break;
-	}
-	return set_error(r);
-}
-
-int cpu_identify(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
-{
-	struct internal_id_info_t throwaway;
-	return cpu_ident_internal(raw, data, &throwaway);
-}
-
-const char* cpuid_lib_version(void)
-{
-	return VERSION;
-}

src/3rdparty/libcpuid/intel_code_t.h

@@ -1,58 +0,0 @@
-/*
- * Copyright 2016  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This file contains a list of internal codes we use in detection. It is
- * of no external use and isn't a complete list of intel products.
- */
-	CODE2(PENTIUM, 2000),
-	
-	CODE(IRWIN),
-	CODE(POTOMAC),
-	CODE(GAINESTOWN),
-	CODE(WESTMERE),
-	
-	CODE(PENTIUM_M),
-	CODE(NOT_CELERON),	
-	
-	CODE(CORE_SOLO),
-	CODE(MOBILE_CORE_SOLO),
-	CODE(CORE_DUO),
-	CODE(MOBILE_CORE_DUO),
-	
-	CODE(WOLFDALE),
-	CODE(MEROM),
-	CODE(PENRYN),
-	CODE(QUAD_CORE),
-	CODE(DUAL_CORE_HT),
-	CODE(QUAD_CORE_HT),
-	CODE(MORE_THAN_QUADCORE),
-	CODE(PENTIUM_D),
-	
-	CODE(SILVERTHORNE),
-	CODE(DIAMONDVILLE),
-	CODE(PINEVIEW),
-	CODE(CEDARVIEW),

src/3rdparty/libcpuid/libcpuid.h

@@ -1,678 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef __LIBCPUID_H__
-#define __LIBCPUID_H__
-/**
- * \file     libcpuid.h
- * \author   Veselin Georgiev
- * \date     Oct 2008
- * \version  0.4.0
- *
- * Version history:
- *
- * * 0.1.0 (2008-10-15): initial adaptation from wxfractgui sources
- * * 0.1.1 (2009-07-06): Added intel_fn11 fields to cpu_raw_data_t to handle
- *                       new processor topology enumeration required on Core i7
- * * 0.1.2 (2009-09-26): Added support for MSR reading through self-extracting
- *                       kernel driver on Win32.
- * * 0.1.3 (2010-04-20): Added support for greater more accurate CPU clock
- *                       measurements with cpu_clock_by_ic()
- * * 0.2.0 (2011-10-11): Support for AMD Bulldozer CPUs, 128-bit SSE unit size
- *                       checking. A backwards-incompatible change, since the
- *                       sizeof cpu_id_t is now different.
- * * 0.2.1 (2012-05-26): Support for Ivy Bridge, and detecting the presence of
- *                       the RdRand instruction.
- * * 0.2.2 (2015-11-04): Support for newer processors up to Haswell and Vishera.
- *                       Fix clock detection in cpu_clock_by_ic() for Bulldozer.
- *                       More entries supported in cpu_msrinfo().
- *                       *BSD and Solaris support (unofficial).
- * * 0.3.0 (2016-07-09): Support for Skylake; MSR ops in FreeBSD; INFO_VOLTAGE
- *                       for AMD CPUs. Level 4 cache support for Crystalwell
- *                       (a backwards-incompatible change since the sizeof
- *                        cpu_raw_data_t is now different).
- * * 0.4.0 (2016-09-30): Better detection of AMD clock multiplier with msrinfo.
- *                       Support for Intel SGX detection
- *                       (a backwards-incompatible change since the sizeof
- *                        cpu_raw_data_t and cpu_id_t is now different).
- */
-
-/** @mainpage A simple libcpuid introduction
- * 
- * LibCPUID provides CPU identification and access to the CPUID and RDTSC
- * instructions on the x86.
- * <p>
- * To execute CPUID, use \ref cpu_exec_cpuid <br>
- * To execute RDTSC, use \ref cpu_rdtsc <br>
- * To fetch the CPUID info needed for CPU identification, use
- *   \ref cpuid_get_raw_data <br>
- * To make sense of that data (decode, extract features), use \ref cpu_identify <br>
- * To detect the CPU speed, use either \ref cpu_clock, \ref cpu_clock_by_os,
- * \ref cpu_tsc_mark + \ref cpu_tsc_unmark + \ref cpu_clock_by_mark,
- * \ref cpu_clock_measure or \ref cpu_clock_by_ic.
- * Read carefully for pros/cons of each method. <br>
- * 
- * To read MSRs, use \ref cpu_msr_driver_open to get a handle, and then
- * \ref cpu_rdmsr for querying abilities. Some MSR decoding is available on recent
- * CPUs, and can be queried through \ref cpu_msrinfo; the various types of queries
- * are described in \ref cpu_msrinfo_request_t.
- * </p>
- */
-
-/** @defgroup libcpuid LibCPUID
- * @brief LibCPUID provides CPU identification
- @{ */
-
-/* Include some integer type specifications: */
-#include "libcpuid_types.h"
-
-/* Some limits and other constants */
-#include "libcpuid_constants.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * @brief CPU vendor, as guessed from the Vendor String.
- */
-typedef enum {
-	VENDOR_INTEL = 0,  /*!< Intel CPU */
-	VENDOR_AMD,        /*!< AMD CPU */
-	VENDOR_CYRIX,      /*!< Cyrix CPU */
-	VENDOR_NEXGEN,     /*!< NexGen CPU */
-	VENDOR_TRANSMETA,  /*!< Transmeta CPU */
-	VENDOR_UMC,        /*!< x86 CPU by UMC */
-	VENDOR_CENTAUR,    /*!< x86 CPU by IDT */
-	VENDOR_RISE,       /*!< x86 CPU by Rise Technology */
-	VENDOR_SIS,        /*!< x86 CPU by SiS */
-	VENDOR_NSC,        /*!< x86 CPU by National Semiconductor */
-	
-	NUM_CPU_VENDORS,   /*!< Valid CPU vendor ids: 0..NUM_CPU_VENDORS - 1 */
-	VENDOR_UNKNOWN = -1,
-} cpu_vendor_t;
-#define NUM_CPU_VENDORS NUM_CPU_VENDORS
-
-/**
- * @brief Contains just the raw CPUID data.
- *
- * This contains only the most basic CPU data, required to do identification
- * and feature recognition. Every processor should be identifiable using this
- * data only.
- */
-struct cpu_raw_data_t {
-	/** contains results of CPUID for eax = 0, 1, ...*/
-	uint32_t basic_cpuid[MAX_CPUID_LEVEL][4];
-
-	/** contains results of CPUID for eax = 0x80000000, 0x80000001, ...*/
-	uint32_t ext_cpuid[MAX_EXT_CPUID_LEVEL][4];
-	
-	/** when the CPU is intel and it supports deterministic cache
-	    information: this contains the results of CPUID for eax = 4
-	    and ecx = 0, 1, ... */
-	uint32_t intel_fn4[MAX_INTELFN4_LEVEL][4];
-	
-	/** when the CPU is intel and it supports leaf 0Bh (Extended Topology
-	    enumeration leaf), this stores the result of CPUID with 
-	    eax = 11 and ecx = 0, 1, 2... */
-	uint32_t intel_fn11[MAX_INTELFN11_LEVEL][4];
-	
-	/** when the CPU is intel and supports leaf 12h (SGX enumeration leaf),
-	 *  this stores the result of CPUID with eax = 0x12 and
-	 *  ecx = 0, 1, 2... */
-	uint32_t intel_fn12h[MAX_INTELFN12H_LEVEL][4];
-
-	/** when the CPU is intel and supports leaf 14h (Intel Processor Trace
-	 *  capabilities leaf).
-	 *  this stores the result of CPUID with eax = 0x12 and
-	 *  ecx = 0, 1, 2... */
-	uint32_t intel_fn14h[MAX_INTELFN14H_LEVEL][4];
-};
-
-/**
- * @brief This contains information about SGX features of the processor
- * Example usage:
- * @code
- * ...
- * struct cpu_raw_data_t raw;
- * struct cpu_id_t id;
- * 
- * if (cpuid_get_raw_data(&raw) == 0 && cpu_identify(&raw, &id) == 0 && id.sgx.present) {
- *   printf("SGX is present.\n");
- *   printf("SGX1 instructions: %s.\n", id.sgx.flags[INTEL_SGX1] ? "present" : "absent");
- *   printf("SGX2 instructions: %s.\n", id.sgx.flags[INTEL_SGX2] ? "present" : "absent");
- *   printf("Max 32-bit enclave size: 2^%d bytes.\n", id.sgx.max_enclave_32bit);
- *   printf("Max 64-bit enclave size: 2^%d bytes.\n", id.sgx.max_enclave_64bit);
- *   for (int i = 0; i < id.sgx.num_epc_sections; i++) {
- *     struct cpu_epc_t epc = cpuid_get_epc(i, NULL);
- *     printf("EPC section #%d: address = %x, size = %d bytes.\n", epc.address, epc.size);
- *   }
- * } else {
- *   printf("SGX is not present.\n");
- * }
- * @endcode
- */ 
-struct cpu_sgx_t {
-	/** Whether SGX is present (boolean) */
-	uint32_t present;
-	
-	/** Max enclave size in 32-bit mode. This is a power-of-two value:
-	 *  if it is "31", then the max enclave size is 2^31 bytes (2 GiB).
-	 */
-	uint8_t max_enclave_32bit;
-	
-	/** Max enclave size in 64-bit mode. This is a power-of-two value:
-	 *  if it is "36", then the max enclave size is 2^36 bytes (64 GiB).
-	 */
-	uint8_t max_enclave_64bit;
-	
-	/**
-	 * contains SGX feature flags. See the \ref cpu_sgx_feature_t
-	 * "INTEL_SGX*" macros below.
-	 */
-	uint8_t flags[SGX_FLAGS_MAX];
-	
-	/** number of Enclave Page Cache (EPC) sections. Info for each
-	 *  section is available through the \ref cpuid_get_epc() function
-	 */
-	int num_epc_sections;
-	
-	/** bit vector of the supported extended  features that can be written
-	 *  to the MISC region of the SSA (Save State Area)
-	 */ 
-	uint32_t misc_select;
-	
-	/** a bit vector of the attributes that can be set to SECS.ATTRIBUTES
-	 *  via ECREATE. Corresponds to bits 0-63 (incl.) of SECS.ATTRIBUTES.
-	 */ 
-	uint64_t secs_attributes;
-	
-	/** a bit vector of the bits that can be set in the XSAVE feature
-	 *  request mask; Corresponds to bits 64-127 of SECS.ATTRIBUTES.
-	 */
-	uint64_t secs_xfrm;
-};
-
-/**
- * @brief This contains the recognized CPU features/info
- */
-struct cpu_id_t {
-	/** contains the CPU vendor string, e.g. "GenuineIntel" */
-	char vendor_str[VENDOR_STR_MAX];
-	
-	/** contains the brand string, e.g. "Intel(R) Xeon(TM) CPU 2.40GHz" */
-	char brand_str[BRAND_STR_MAX];
-	
-	/** contains the recognized CPU vendor */
-	cpu_vendor_t vendor;
-	
-	/**
-	 * contain CPU flags. Used to test for features. See
-	 * the \ref cpu_feature_t "CPU_FEATURE_*" macros below.
-	 * @see Features
-	 */
-	uint8_t flags[CPU_FLAGS_MAX];
-	
-	/** CPU family */
-	int32_t family;
-	
-	/** CPU model */
-	int32_t model;
-	
-	/** CPU stepping */
-	int32_t stepping;
-	
-	/** CPU extended family */
-	int32_t ext_family;
-	
-	/** CPU extended model */
-	int32_t ext_model;
-	
-	/** Number of CPU cores on the current processor */
-	int32_t num_cores;
-	
-	/**
-	 * Number of logical processors on the current processor.
-	 * Could be more than the number of physical cores,
-	 * e.g. when the processor has HyperThreading.
-	 */
-	int32_t num_logical_cpus;
-	
-	/**
-	 * The total number of logical processors.
-	 * The same value is availabe through \ref cpuid_get_total_cpus.
-	 *
-	 * This is num_logical_cpus * {total physical processors in the system}
-	 * (but only on a real system, under a VM this number may be lower).
-	 *
-	 * If you're writing a multithreaded program and you want to run it on
-	 * all CPUs, this is the number of threads you need.
-	 *
-	 * @note in a VM, this will exactly match the number of CPUs set in
-	 *       the VM's configuration.
-	 *
-	 */
-	int32_t total_logical_cpus;
-	
-	/**
-	 * L1 data cache size in KB. Could be zero, if the CPU lacks cache.
-	 * If the size cannot be determined, it will be -1.
-	 */
-	int32_t l1_data_cache;
-	
-	/**
-	 * L1 instruction cache size in KB. Could be zero, if the CPU lacks
-	 * cache. If the size cannot be determined, it will be -1.
-	 * @note On some Intel CPUs, whose instruction cache is in fact
-	 * a trace cache, the size will be expressed in K uOps.
-	 */
-	int32_t l1_instruction_cache;
-	
-	/**
-	 * L2 cache size in KB. Could be zero, if the CPU lacks L2 cache.
-	 * If the size of the cache could not be determined, it will be -1
-	 */
-	int32_t l2_cache;
-	
-	/** L3 cache size in KB. Zero on most systems */
-	int32_t l3_cache;
-
-	/** L4 cache size in KB. Zero on most systems */
-	int32_t l4_cache;
-	
-	/** Cache associativity for the L1 data cache. -1 if undetermined */
-	int32_t l1_assoc;
-	
-	/** Cache associativity for the L2 cache. -1 if undetermined */
-	int32_t l2_assoc;
-	
-	/** Cache associativity for the L3 cache. -1 if undetermined */
-	int32_t l3_assoc;
-
-	/** Cache associativity for the L4 cache. -1 if undetermined */
-	int32_t l4_assoc;
-	
-	/** Cache-line size for L1 data cache. -1 if undetermined */
-	int32_t l1_cacheline;
-	
-	/** Cache-line size for L2 cache. -1 if undetermined */
-	int32_t l2_cacheline;
-	
-	/** Cache-line size for L3 cache. -1 if undetermined */
-	int32_t l3_cacheline;
-	
-	/** Cache-line size for L4 cache. -1 if undetermined */
-	int32_t l4_cacheline;
-
-	/**
-	 * The brief and human-friendly CPU codename, which was recognized.<br>
-	 * Examples:
-	 * @code
-	 * +--------+--------+-------+-------+-------+---------------------------------------+-----------------------+
-	 * | Vendor | Family | Model | Step. | Cache |       Brand String                    | cpu_id_t.cpu_codename |
-	 * +--------+--------+-------+-------+-------+---------------------------------------+-----------------------+
-	 * | AMD    |      6 |     8 |     0 |   256 | (not available - will be ignored)     | "K6-2"                |
-	 * | Intel  |     15 |     2 |     5 |   512 | "Intel(R) Xeon(TM) CPU 2.40GHz"       | "Xeon (Prestonia)"    |
-	 * | Intel  |      6 |    15 |    11 |  4096 | "Intel(R) Core(TM)2 Duo CPU E6550..." | "Conroe (Core 2 Duo)" |
-	 * | AMD    |     15 |    35 |     2 |  1024 | "Dual Core AMD Opteron(tm) Proces..." | "Opteron (Dual Core)" |
-	 * +--------+--------+-------+-------+-------+---------------------------------------+-----------------------+
-	 * @endcode
-	 */
-	char cpu_codename[64];
-	
-	/** SSE execution unit size (64 or 128; -1 if N/A) */
-	int32_t sse_size;
-	
-	/**
-	 * contain miscellaneous detection information. Used to test about specifics of
-	 * certain detected features. See \ref cpu_hint_t "CPU_HINT_*" macros below.
-	 * @see Hints
-	 */
-	uint8_t detection_hints[CPU_HINTS_MAX];
-	
-	/** contains information about SGX features if the processor, if present */
-	struct cpu_sgx_t sgx;
-};
-
-/**
- * @brief CPU feature identifiers
- *
- * Usage:
- * @code
- * ...
- * struct cpu_raw_data_t raw;
- * struct cpu_id_t id;
- * if (cpuid_get_raw_data(&raw) == 0 && cpu_identify(&raw, &id) == 0) {
- *     if (id.flags[CPU_FEATURE_SSE2]) {
- *         // The CPU has SSE2...
- *         ...
- *     } else {
- *         // no SSE2
- *     }
- * } else {
- *   // processor cannot be determined.
- * }
- * @endcode
- */
-typedef enum {
-	CPU_FEATURE_FPU = 0,	/*!< Floating point unit */
-	CPU_FEATURE_VME,	/*!< Virtual mode extension */
-	CPU_FEATURE_DE,		/*!< Debugging extension */
-	CPU_FEATURE_PSE,	/*!< Page size extension */
-	CPU_FEATURE_TSC,	/*!< Time-stamp counter */
-	CPU_FEATURE_MSR,	/*!< Model-specific regsisters, RDMSR/WRMSR supported */
-	CPU_FEATURE_PAE,	/*!< Physical address extension */
-	CPU_FEATURE_MCE,	/*!< Machine check exception */
-	CPU_FEATURE_CX8,	/*!< CMPXCHG8B instruction supported */
-	CPU_FEATURE_APIC,	/*!< APIC support */
-	CPU_FEATURE_MTRR,	/*!< Memory type range registers */
-	CPU_FEATURE_SEP,	/*!< SYSENTER / SYSEXIT instructions supported */
-	CPU_FEATURE_PGE,	/*!< Page global enable */
-	CPU_FEATURE_MCA,	/*!< Machine check architecture */
-	CPU_FEATURE_CMOV,	/*!< CMOVxx instructions supported */
-	CPU_FEATURE_PAT,	/*!< Page attribute table */
-	CPU_FEATURE_PSE36,	/*!< 36-bit page address extension */
-	CPU_FEATURE_PN,		/*!< Processor serial # implemented (Intel P3 only) */
-	CPU_FEATURE_CLFLUSH,	/*!< CLFLUSH instruction supported */
-	CPU_FEATURE_DTS,	/*!< Debug store supported */
-	CPU_FEATURE_ACPI,	/*!< ACPI support (power states) */
-	CPU_FEATURE_MMX,	/*!< MMX instruction set supported */
-	CPU_FEATURE_FXSR,	/*!< FXSAVE / FXRSTOR supported */
-	CPU_FEATURE_SSE,	/*!< Streaming-SIMD Extensions (SSE) supported */
-	CPU_FEATURE_SSE2,	/*!< SSE2 instructions supported */
-	CPU_FEATURE_SS,		/*!< Self-snoop */
-	CPU_FEATURE_HT,		/*!< Hyper-threading supported (but might be disabled) */
-	CPU_FEATURE_TM,		/*!< Thermal monitor */
-	CPU_FEATURE_IA64,	/*!< IA64 supported (Itanium only) */
-	CPU_FEATURE_PBE,	/*!< Pending-break enable */
-	CPU_FEATURE_PNI,	/*!< PNI (SSE3) instructions supported */
-	CPU_FEATURE_PCLMUL,	/*!< PCLMULQDQ instruction supported */
-	CPU_FEATURE_DTS64,	/*!< 64-bit Debug store supported */
-	CPU_FEATURE_MONITOR,	/*!< MONITOR / MWAIT supported */
-	CPU_FEATURE_DS_CPL,	/*!< CPL Qualified Debug Store */
-	CPU_FEATURE_VMX,	/*!< Virtualization technology supported */
-	CPU_FEATURE_SMX,	/*!< Safer mode exceptions */
-	CPU_FEATURE_EST,	/*!< Enhanced SpeedStep */
-	CPU_FEATURE_TM2,	/*!< Thermal monitor 2 */
-	CPU_FEATURE_SSSE3,	/*!< SSSE3 instructionss supported (this is different from SSE3!) */
-	CPU_FEATURE_CID,	/*!< Context ID supported */
-	CPU_FEATURE_CX16,	/*!< CMPXCHG16B instruction supported */
-	CPU_FEATURE_XTPR,	/*!< Send Task Priority Messages disable */
-	CPU_FEATURE_PDCM,	/*!< Performance capabilities MSR supported */
-	CPU_FEATURE_DCA,	/*!< Direct cache access supported */
-	CPU_FEATURE_SSE4_1,	/*!< SSE 4.1 instructions supported */
-	CPU_FEATURE_SSE4_2,	/*!< SSE 4.2 instructions supported */
-	CPU_FEATURE_SYSCALL,	/*!< SYSCALL / SYSRET instructions supported */
-	CPU_FEATURE_XD,		/*!< Execute disable bit supported */
-	CPU_FEATURE_MOVBE,	/*!< MOVBE instruction supported */
-	CPU_FEATURE_POPCNT,	/*!< POPCNT instruction supported */
-	CPU_FEATURE_AES,	/*!< AES* instructions supported */
-	CPU_FEATURE_XSAVE,	/*!< XSAVE/XRSTOR/etc instructions supported */
-	CPU_FEATURE_OSXSAVE,	/*!< non-privileged copy of OSXSAVE supported */
-	CPU_FEATURE_AVX,	/*!< Advanced vector extensions supported */
-	CPU_FEATURE_MMXEXT,	/*!< AMD MMX-extended instructions supported */
-	CPU_FEATURE_3DNOW,	/*!< AMD 3DNow! instructions supported */
-	CPU_FEATURE_3DNOWEXT,	/*!< AMD 3DNow! extended instructions supported */
-	CPU_FEATURE_NX,		/*!< No-execute bit supported */
-	CPU_FEATURE_FXSR_OPT,	/*!< FFXSR: FXSAVE and FXRSTOR optimizations */
-	CPU_FEATURE_RDTSCP,	/*!< RDTSCP instruction supported (AMD-only) */
-	CPU_FEATURE_LM,		/*!< Long mode (x86_64/EM64T) supported */
-	CPU_FEATURE_LAHF_LM,	/*!< LAHF/SAHF supported in 64-bit mode */
-	CPU_FEATURE_CMP_LEGACY,	/*!< core multi-processing legacy mode */
-	CPU_FEATURE_SVM,	/*!< AMD Secure virtual machine */
-	CPU_FEATURE_ABM,	/*!< LZCNT instruction support */
-	CPU_FEATURE_MISALIGNSSE,/*!< Misaligned SSE supported */
-	CPU_FEATURE_SSE4A,	/*!< SSE 4a from AMD */
-	CPU_FEATURE_3DNOWPREFETCH,	/*!< PREFETCH/PREFETCHW support */
-	CPU_FEATURE_OSVW,	/*!< OS Visible Workaround (AMD) */
-	CPU_FEATURE_IBS,	/*!< Instruction-based sampling */
-	CPU_FEATURE_SSE5,	/*!< SSE 5 instructions supported (deprecated, will never be 1) */
-	CPU_FEATURE_SKINIT,	/*!< SKINIT / STGI supported */
-	CPU_FEATURE_WDT,	/*!< Watchdog timer support */
-	CPU_FEATURE_TS,		/*!< Temperature sensor */
-	CPU_FEATURE_FID,	/*!< Frequency ID control */
-	CPU_FEATURE_VID,	/*!< Voltage ID control */
-	CPU_FEATURE_TTP,	/*!< THERMTRIP */
-	CPU_FEATURE_TM_AMD,	/*!< AMD-specified hardware thermal control */
-	CPU_FEATURE_STC,	/*!< Software thermal control */
-	CPU_FEATURE_100MHZSTEPS,/*!< 100 MHz multiplier control */
-	CPU_FEATURE_HWPSTATE,	/*!< Hardware P-state control */
-	CPU_FEATURE_CONSTANT_TSC,	/*!< TSC ticks at constant rate */
-	CPU_FEATURE_XOP,	/*!< The XOP instruction set (same as the old CPU_FEATURE_SSE5) */
-	CPU_FEATURE_FMA3,	/*!< The FMA3 instruction set */
-	CPU_FEATURE_FMA4,	/*!< The FMA4 instruction set */
-	CPU_FEATURE_TBM,	/*!< Trailing bit manipulation instruction support */
-	CPU_FEATURE_F16C,	/*!< 16-bit FP convert instruction support */
-	CPU_FEATURE_RDRAND,     /*!< RdRand instruction */
-	CPU_FEATURE_X2APIC,     /*!< x2APIC, APIC_BASE.EXTD, MSRs 0000_0800h...0000_0BFFh 64-bit ICR (+030h but not +031h), no DFR (+00Eh), SELF_IPI (+040h) also see standard level 0000_000Bh */
-	CPU_FEATURE_CPB,	/*!< Core performance boost */
-	CPU_FEATURE_APERFMPERF,	/*!< MPERF/APERF MSRs support */
-	CPU_FEATURE_PFI,	/*!< Processor Feedback Interface support */
-	CPU_FEATURE_PA,		/*!< Processor accumulator */
-	CPU_FEATURE_AVX2,	/*!< AVX2 instructions */
-	CPU_FEATURE_BMI1,	/*!< BMI1 instructions */
-	CPU_FEATURE_BMI2,	/*!< BMI2 instructions */
-	CPU_FEATURE_HLE,	/*!< Hardware Lock Elision prefixes */
-	CPU_FEATURE_RTM,	/*!< Restricted Transactional Memory instructions */
-	CPU_FEATURE_AVX512F,	/*!< AVX-512 Foundation */
-	CPU_FEATURE_AVX512DQ,	/*!< AVX-512 Double/Quad granular insns */
-	CPU_FEATURE_AVX512PF,	/*!< AVX-512 Prefetch */
-	CPU_FEATURE_AVX512ER,	/*!< AVX-512 Exponential/Reciprocal */
-	CPU_FEATURE_AVX512CD,	/*!< AVX-512 Conflict detection */
-	CPU_FEATURE_SHA_NI,	/*!< SHA-1/SHA-256 instructions */
-	CPU_FEATURE_AVX512BW,	/*!< AVX-512 Byte/Word granular insns */
-	CPU_FEATURE_AVX512VL,	/*!< AVX-512 128/256 vector length extensions */
-	CPU_FEATURE_SGX,	/*!< SGX extensions. Non-autoritative, check cpu_id_t::sgx::present to verify presence */
-	CPU_FEATURE_RDSEED,	/*!< RDSEED instruction */
-	CPU_FEATURE_ADX,	/*!< ADX extensions (arbitrary precision) */
-	/* termination: */
-	NUM_CPU_FEATURES,
-} cpu_feature_t;
-
-/**
- * @brief CPU detection hints identifiers
- *
- * Usage: similar to the flags usage
- */
-typedef enum {
-	CPU_HINT_SSE_SIZE_AUTH = 0,	/*!< SSE unit size is authoritative (not only a Family/Model guesswork, but based on an actual CPUID bit) */
-	/* termination */
-	NUM_CPU_HINTS,
-} cpu_hint_t;
-
-/**
- * @brief SGX features flags
- * \see cpu_sgx_t
- *
- * Usage:
- * @code
- * ...
- * struct cpu_raw_data_t raw;
- * struct cpu_id_t id;
- * if (cpuid_get_raw_data(&raw) == 0 && cpu_identify(&raw, &id) == 0 && id.sgx.present) {
- *     if (id.sgx.flags[INTEL_SGX1])
- *         // The CPU has SGX1 instructions support...
- *         ...
- *     } else {
- *         // no SGX
- *     }
- * } else {
- *   // processor cannot be determined.
- * }
- * @endcode
- */
- 
-typedef enum {
-	INTEL_SGX1,		/*!< SGX1 instructions support */
-	INTEL_SGX2,		/*!< SGX2 instructions support */
-	
-	/* termination: */
-	NUM_SGX_FEATURES,
-} cpu_sgx_feature_t;
-
-/**
- * @brief Describes common library error codes
- */
-typedef enum {
-	ERR_OK       =  0,	/*!< No error */
-	ERR_NO_CPUID = -1,	/*!< CPUID instruction is not supported */
-	ERR_NO_RDTSC = -2,	/*!< RDTSC instruction is not supported */
-	ERR_NO_MEM   = -3,	/*!< Memory allocation failed */
-	ERR_OPEN     = -4,	/*!< File open operation failed */
-	ERR_BADFMT   = -5,	/*!< Bad file format */
-	ERR_NOT_IMP  = -6,	/*!< Not implemented */
-	ERR_CPU_UNKN = -7,	/*!< Unsupported processor */
-	ERR_NO_RDMSR = -8,	/*!< RDMSR instruction is not supported */
-	ERR_NO_DRIVER= -9,	/*!< RDMSR driver error (generic) */
-	ERR_NO_PERMS = -10,	/*!< No permissions to install RDMSR driver */
-	ERR_EXTRACT  = -11,	/*!< Cannot extract RDMSR driver (read only media?) */
-	ERR_HANDLE   = -12,	/*!< Bad handle */
-	ERR_INVMSR   = -13,	/*!< Invalid MSR */
-	ERR_INVCNB   = -14,	/*!< Invalid core number */
-	ERR_HANDLE_R = -15,	/*!< Error on handle read */
-	ERR_INVRANGE = -16,	/*!< Invalid given range */
-} cpu_error_t;
-
-/**
- * @brief Internal structure, used in cpu_tsc_mark, cpu_tsc_unmark and
- *        cpu_clock_by_mark
- */
-struct cpu_mark_t {
-	uint64_t tsc;		/*!< Time-stamp from RDTSC */
-	uint64_t sys_clock;	/*!< In microsecond resolution */
-};
-
-/**
- * @brief Returns the total number of logical CPU threads (even if CPUID is not present).
- *
- * Under VM, this number (and total_logical_cpus, since they are fetched with the same code)
- * may be nonsensical, i.e. might not equal NumPhysicalCPUs*NumCoresPerCPU*HyperThreading.
- * This is because no matter how many logical threads the host machine has, you may limit them
- * in the VM to any number you like. **This** is the number returned by cpuid_get_total_cpus().
- *
- * @returns Number of logical CPU threads available. Equals the \ref cpu_id_t::total_logical_cpus.
- */
-int cpuid_get_total_cpus(void);
-
-/**
- * @brief Checks if the CPUID instruction is supported
- * @retval 1 if CPUID is present
- * @retval 0 the CPU doesn't have CPUID.
- */
-int cpuid_present(void);
-
-/**
- * @brief Executes the CPUID instruction
- * @param eax - the value of the EAX register when executing CPUID
- * @param regs - the results will be stored here. regs[0] = EAX, regs[1] = EBX, ...
- * @note CPUID will be executed with EAX set to the given value and EBX, ECX,
- *       EDX set to zero.
- */
-void cpu_exec_cpuid(uint32_t eax, uint32_t* regs);
-
-/**
- * @brief Executes the CPUID instruction with the given input registers
- * @note This is just a bit more generic version of cpu_exec_cpuid - it allows
- *       you to control all the registers.
- * @param regs - Input/output. Prior to executing CPUID, EAX, EBX, ECX and
- *               EDX will be set to regs[0], regs[1], regs[2] and regs[3].
- *               After CPUID, this array will contain the results.
- */
-void cpu_exec_cpuid_ext(uint32_t* regs);
-
-/**
- * @brief Obtains the raw CPUID data from the current CPU
- * @param data - a pointer to cpu_raw_data_t structure
- * @returns zero if successful, and some negative number on error.
- *          The error message can be obtained by calling \ref cpuid_error.
- *          @see cpu_error_t
- */
-int cpuid_get_raw_data(struct cpu_raw_data_t* data);
-
-/**
- * @brief Identifies the CPU
- * @param raw - Input - a pointer to the raw CPUID data, which is obtained
- *              either by cpuid_get_raw_data or cpuid_deserialize_raw_data.
- *              Can also be NULL, in which case the functions calls
- *              cpuid_get_raw_data itself.
- * @param data - Output - the decoded CPU features/info is written here.
- * @note The function will not fail, even if some of the information
- *       cannot be obtained. Even when the CPU is new and thus unknown to
- *       libcpuid, some generic info, such as "AMD K9 family CPU" will be
- *       written to data.cpu_codename, and most other things, such as the
- *       CPU flags, cache sizes, etc. should be detected correctly anyway.
- *       However, the function CAN fail, if the CPU is completely alien to
- *       libcpuid.
- * @note While cpu_identify() and cpuid_get_raw_data() are fast for most
- *       purposes, running them several thousand times per second can hamper
- *       performance significantly. Specifically, avoid writing "cpu feature
- *       checker" wrapping function, which calls cpu_identify and returns the
- *       value of some flag, if that function is going to be called frequently.
- * @returns zero if successful, and some negative number on error.
- *          The error message can be obtained by calling \ref cpuid_error.
- *          @see cpu_error_t
- */
-int cpu_identify(struct cpu_raw_data_t* raw, struct cpu_id_t* data);
-
-/**
- * @brief The return value of cpuid_get_epc().
- * @details
- * Describes an EPC (Enclave Page Cache) layout (physical address and size).
- * A CPU may have one or more EPC areas, and information about each is
- * fetched via \ref cpuid_get_epc.
- */ 
-struct cpu_epc_t {
-	uint64_t start_addr;
-	uint64_t length;
-};
-
-/**
- * @brief Fetches information about an EPC (Enclave Page Cache) area.
- * @param index - zero-based index, valid range [0..cpu_id_t.egx.num_epc_sections)
- * @param raw   - a pointer to fetched raw CPUID data. Needed only for testing,
- *                you can safely pass NULL here (if you pass a real structure,
- *                it will be used for fetching the leaf 12h data if index < 2;
- *                otherwise the real CPUID instruction will be used).
- * @returns the requested data. If the CPU doesn't support SGX, or if
- *          index >= cpu_id_t.egx.num_epc_sections, both fields of the returned
- *          structure will be zeros.
- */
-struct cpu_epc_t cpuid_get_epc(int index, const struct cpu_raw_data_t* raw);
-
-/**
- * @brief Returns the libcpuid version
- *
- * @returns the string representation of the libcpuid version, like "0.1.1"
- */
-const char* cpuid_lib_version(void);
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-
-/** @} */
-
-#endif /* __LIBCPUID_H__ */

src/3rdparty/libcpuid/libcpuid_constants.h

@@ -1,47 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/**
- * @File     libcpuid_constants.h
- * @Author   Veselin Georgiev
- * @Brief    Some limits and constants for libcpuid
- */
-
-#ifndef __LIBCPUID_CONSTANTS_H__
-#define __LIBCPUID_CONSTANTS_H__
-
-#define VENDOR_STR_MAX		16
-#define BRAND_STR_MAX		64
-#define CPU_FLAGS_MAX		128
-#define MAX_CPUID_LEVEL		32
-#define MAX_EXT_CPUID_LEVEL	32
-#define MAX_INTELFN4_LEVEL	8
-#define MAX_INTELFN11_LEVEL	4
-#define MAX_INTELFN12H_LEVEL	4
-#define MAX_INTELFN14H_LEVEL	4
-#define CPU_HINTS_MAX		16
-#define SGX_FLAGS_MAX		14
-
-#endif /* __LIBCPUID_CONSTANTS_H__ */

src/3rdparty/libcpuid/libcpuid_internal.h

@@ -1,107 +0,0 @@
-/*
- * Copyright 2016  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef __LIBCPUID_INTERNAL_H__
-#define __LIBCPUID_INTERNAL_H__
-/*
- * This file contains internal undocumented declarations and function prototypes
- * for the workings of the internal library infrastructure.
- */
-
-enum _common_codes_t {
-	NA = 0,
-	NC, /* No code */
-};
-
-#define CODE(x) x
-#define CODE2(x, y) x = y
-enum _amd_code_t {
-	#include "amd_code_t.h"
-};
-typedef enum _amd_code_t amd_code_t;
-
-enum _intel_code_t {
-	#include "intel_code_t.h"
-};
-typedef enum _intel_code_t intel_code_t;
-#undef CODE
-#undef CODE2
-
-struct internal_id_info_t {
-	union {
-		amd_code_t   amd;
-		intel_code_t intel;
-	} code;
-	uint64_t bits;
-	int score; // detection (matchtable) score
-};
-
-#define LBIT(x) (((long long) 1) << x)
-
-enum _common_bits_t {
-	_M_                     = LBIT(  0 ),
-	MOBILE_                 = LBIT(  1 ),
-	_MP_                    = LBIT(  2 ),
-};
-
-// additional detection bits for Intel CPUs:
-enum _intel_bits_t {
-	PENTIUM_                = LBIT( 10 ),
-	CELERON_                = LBIT( 11 ),
-	CORE_                   = LBIT( 12 ),
-	_I_                     = LBIT( 13 ),
-	_3                      = LBIT( 14 ),
-	_5                      = LBIT( 15 ),
-	_7                      = LBIT( 16 ),
-	_9                      = LBIT( 17 ),
-	XEON_                   = LBIT( 18 ),
-	ATOM_                   = LBIT( 19 ),
-};
-typedef enum _intel_bits_t intel_bits_t;
-
-enum _amd_bits_t {
-	ATHLON_      = LBIT( 10 ),
-	_XP_         = LBIT( 11 ),
-	DURON_       = LBIT( 12 ),
-	SEMPRON_     = LBIT( 13 ),
-	OPTERON_     = LBIT( 14 ),
-	TURION_      = LBIT( 15 ),
-	_LV_         = LBIT( 16 ),
-	_64_         = LBIT( 17 ),
-	_X2          = LBIT( 18 ),
-	_X3          = LBIT( 19 ),
-	_X4          = LBIT( 20 ),
-	_X6          = LBIT( 21 ),
-	_FX          = LBIT( 22 ),
-	_APU_        = LBIT( 23 ),
-};
-typedef enum _amd_bits_t amd_bits_t;
-
-
-
-int cpu_ident_internal(struct cpu_raw_data_t* raw, struct cpu_id_t* data, 
-		       struct internal_id_info_t* internal);
-
-#endif /* __LIBCPUID_INTERNAL_H__ */

src/3rdparty/libcpuid/libcpuid_types.h

@@ -1,63 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-/**
- * @File     libcpuid_types.h
- * @Author   Veselin Georgiev
- * @Brief    Type specifications for libcpuid.
- */
-
-#ifndef __LIBCPUID_TYPES_H__
-#define __LIBCPUID_TYPES_H__
-
-#if !defined(_MSC_VER) || _MSC_VER >= 1600
-#  include <stdint.h>
-#else
-/* we have to provide our own: */
-#  if !defined(__int32_t_defined)
-typedef int int32_t;
-#  endif
-
-#  if !defined(__uint32_t_defined)
-typedef unsigned uint32_t;
-#  endif
-
-typedef signed char		int8_t;
-typedef unsigned char		uint8_t;
-typedef signed short		int16_t;
-typedef unsigned short		uint16_t;
-#if (defined _MSC_VER) && (_MSC_VER <= 1300)
-	/* MSVC 6.0: no long longs ... */
-	typedef signed __int64		int64_t;
-	typedef unsigned __int64	uint64_t;
-#else
-	/* all other sane compilers: */
-	typedef signed long long   int64_t;
-	typedef unsigned long long uint64_t;
-#endif
-
-#endif
-
-#endif /* __LIBCPUID_TYPES_H__ */

src/3rdparty/libcpuid/libcpuid_util.c

@@ -1,93 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdarg.h>
-#include <string.h>
-#include <ctype.h>
-#include "libcpuid.h"
-#include "libcpuid_util.h"
-
-void match_features(const struct feature_map_t* matchtable, int count, uint32_t reg, struct cpu_id_t* data)
-{
-	int i;
-	for (i = 0; i < count; i++)
-		if (reg & (1u << matchtable[i].bit))
-			data->flags[matchtable[i].feature] = 1;
-}
-
-static int xmatch_entry(char c, const char* p)
-{
-	int i, j;
-	if (c == 0) return -1;
-	if (c == p[0]) return 1;
-	if (p[0] == '.') return 1;
-	if (p[0] == '#' && isdigit(c)) return 1;
-	if (p[0] == '[') {
-		j = 1;
-		while (p[j] && p[j] != ']') j++;
-		if (!p[j]) return -1;
-		for (i = 1; i < j; i++)
-			if (p[i] == c) return j + 1;
-	}
-	return -1;
-}
-
-int match_pattern(const char* s, const char* p)
-{
-	int i, j, dj, k, n, m;
-	n = (int) strlen(s);
-	m = (int) strlen(p);
-	for (i = 0; i < n; i++) {
-		if (xmatch_entry(s[i], p) != -1) {
-			j = 0;
-			k = 0;
-			while (j < m && ((dj = xmatch_entry(s[i + k], p + j)) != -1)) {
-				k++;
-				j += dj;
-			}
-			if (j == m) return i + 1;
-		}
-	}
-	return 0;
-}
-
-struct cpu_id_t* get_cached_cpuid(void)
-{
-	static int initialized = 0;
-	static struct cpu_id_t id;
-	if (initialized) return &id;
-	if (cpu_identify(NULL, &id))
-		memset(&id, 0, sizeof(id));
-	initialized = 1;
-	return &id;
-}
-
-int match_all(uint64_t bits, uint64_t mask)
-{
-	return (bits & mask) == mask;
-}

src/3rdparty/libcpuid/libcpuid_util.h

@@ -1,78 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-#ifndef __LIBCPUID_UTIL_H__
-#define __LIBCPUID_UTIL_H__
-
-#define COUNT_OF(array) (sizeof(array) / sizeof(array[0]))
-
-struct feature_map_t {
-	unsigned bit;
-	cpu_feature_t feature;
-};
- 
-void match_features(const struct feature_map_t* matchtable, int count,
-                    uint32_t reg, struct cpu_id_t* data);
-
-struct match_entry_t {
-	int family, model, stepping, ext_family, ext_model;
-	int ncores, l2cache, l3cache, brand_code;
-	uint64_t model_bits;
-	int model_code;
-	char name[32];
-};
-
-// returns the match score:
-int match_cpu_codename(const struct match_entry_t* matchtable, int count,
-                       struct cpu_id_t* data, int brand_code, uint64_t bits,
-                       int model_code);
-/*
- * Seek for a pattern in `haystack'.
- * Pattern may be an fixed string, or contain the special metacharacters
- * '.' - match any single character
- * '#' - match any digit
- * '[<chars>] - match any of the given chars (regex-like ranges are not
- *              supported)
- * Return val: 0 if the pattern is not found. Nonzero if it is found (actually,
- *             x + 1 where x is the index where the match is found).
- */
-int match_pattern(const char* haystack, const char* pattern);
-
-/*
- * Gets an initialized cpu_id_t. It is cached, so that internal libcpuid
- * machinery doesn't need to issue cpu_identify more than once.
- */
-struct cpu_id_t* get_cached_cpuid(void);
-
-
-/* returns true if all bits of mask are present in `bits'. */
-int match_all(uint64_t bits, uint64_t mask);
-
-/*
- * Sets the current errno
- */
-int set_error(cpu_error_t err);
-
-#endif /* __LIBCPUID_UTIL_H__ */

src/3rdparty/libcpuid/masm-x64.asm

@@ -1,359 +0,0 @@
-
-.code
-; procedure exec_cpuid
-; Signature: void exec_cpiud(uint32_t *regs)
-exec_cpuid Proc
-	push	rbx
-	push	rcx
-	push	rdx
-	push	rdi
-	
-	mov	rdi,	rcx
-	
-	mov	eax,	[rdi]
-	mov	ebx,	[rdi+4]
-	mov	ecx,	[rdi+8]
-	mov	edx,	[rdi+12]
-	
-	cpuid
-	
-	mov	[rdi],	eax
-	mov	[rdi+4],	ebx
-	mov	[rdi+8],	ecx
-	mov	[rdi+12],	edx
-	pop	rdi
-	pop	rdx
-	pop	rcx
-	pop	rbx
-	ret
-exec_cpuid endp
-
-; procedure cpu_rdtsc
-; Signature: void cpu_rdtsc(uint64_t *result)
-cpu_rdtsc Proc
-	push	rdx
-	rdtsc
-	mov	[rcx],	eax
-	mov	[rcx+4],	edx
-	pop	rdx
-	ret
-cpu_rdtsc endp
-
-; procedure busy_sse_loop
-; Signature: void busy_sse_loop(int cycles)
-busy_sse_loop Proc
-	; save xmm6 & xmm7 into the shadow area, as Visual C++ 2008
-	; expects that we don't touch them:
-	movups	[rsp + 8],	xmm6
-	movups	[rsp + 24],	xmm7
-
-	xorps	xmm0,	xmm0
-	xorps	xmm1,	xmm1
-	xorps	xmm2,	xmm2
-	xorps	xmm3,	xmm3
-	xorps	xmm4,	xmm4
-	xorps	xmm5,	xmm5
-	xorps	xmm6,	xmm6
-	xorps	xmm7,	xmm7
-	; --
-	align 16
-bsLoop:
-	; 0:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 1:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 2:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 3:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 4:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 5:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 6:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 7:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 8:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 9:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 10:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 11:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 12:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 13:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 14:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 15:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 16:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 17:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 18:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 19:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 20:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 21:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 22:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 23:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 24:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 25:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 26:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 27:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 28:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 29:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 30:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; 31:
-	addps	xmm0,	xmm1
-	addps	xmm1,	xmm2
-	addps	xmm2,	xmm3
-	addps	xmm3,	xmm4
-	addps	xmm4,	xmm5
-	addps	xmm5,	xmm6
-	addps	xmm6,	xmm7
-	addps	xmm7,	xmm0
-	; ----------------------
-	dec		ecx
-	jnz		bsLoop
-
-	; restore xmm6 & xmm7:
-	movups	xmm6,	[rsp + 8]
-	movups	xmm7,	[rsp + 24]
-	ret
-busy_sse_loop endp
-
-END

src/3rdparty/libcpuid/recog_amd.c

@@ -1,173 +0,0 @@
-/*
- * Copyright 2008  Veselin Georgiev,
- * anrieffNOSPAM @ mgail_DOT.com (convert to gmail)
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
- * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include "libcpuid.h"
-#include "libcpuid_util.h"
-#include "libcpuid_internal.h"
-#include "recog_amd.h"
-
-const struct amd_code_str { amd_code_t code; char *str; } amd_code_str[] = {
-	#define CODE(x) { x, #x }
-	#define CODE2(x, y) CODE(x)
-	#include "amd_code_t.h"
-	#undef CODE
-};
-
-struct amd_code_and_bits_t {
-	int code;
-	uint64_t bits;
-};
-
-enum _amd_model_codes_t {
-	// Only for Ryzen CPUs:
-	_1400,
-	_1500,
-	_1600,
-	_1900,
-	_2400,
-	_2500,
-	_2700,
-};
-
-static void load_amd_features(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
-{
-	const struct feature_map_t matchtable_edx81[] = {
-		{ 20, CPU_FEATURE_NX },
-		{ 22, CPU_FEATURE_MMXEXT },
-		{ 25, CPU_FEATURE_FXSR_OPT },
-		{ 30, CPU_FEATURE_3DNOWEXT },
-		{ 31, CPU_FEATURE_3DNOW },
-	};
-	const struct feature_map_t matchtable_ecx81[] = {
-		{  1, CPU_FEATURE_CMP_LEGACY },
-		{  2, CPU_FEATURE_SVM },
-		{  5, CPU_FEATURE_ABM },
-		{  6, CPU_FEATURE_SSE4A },
-		{  7, CPU_FEATURE_MISALIGNSSE },
-		{  8, CPU_FEATURE_3DNOWPREFETCH },
-		{  9, CPU_FEATURE_OSVW },
-		{ 10, CPU_FEATURE_IBS },
-		{ 11, CPU_FEATURE_XOP },
-		{ 12, CPU_FEATURE_SKINIT },
-		{ 13, CPU_FEATURE_WDT },
-		{ 16, CPU_FEATURE_FMA4 },
-		{ 21, CPU_FEATURE_TBM },
-	};
-	const struct feature_map_t matchtable_edx87[] = {
-		{  0, CPU_FEATURE_TS },
-		{  1, CPU_FEATURE_FID },
-		{  2, CPU_FEATURE_VID },
-		{  3, CPU_FEATURE_TTP },
-		{  4, CPU_FEATURE_TM_AMD },
-		{  5, CPU_FEATURE_STC },
-		{  6, CPU_FEATURE_100MHZSTEPS },
-		{  7, CPU_FEATURE_HWPSTATE },
-		/* id 8 is handled in common */
-		{  9, CPU_FEATURE_CPB },
-		{ 10, CPU_FEATURE_APERFMPERF },
-		{ 11, CPU_FEATURE_PFI },
-		{ 12, CPU_FEATURE_PA },
-	};
-	if (raw->ext_cpuid[0][0] >= 0x80000001) {
-		match_features(matchtable_edx81, COUNT_OF(matchtable_edx81), raw->ext_cpuid[1][3], data);
-		match_features(matchtable_ecx81, COUNT_OF(matchtable_ecx81), raw->ext_cpuid[1][2], data);
-	}
-	if (raw->ext_cpuid[0][0] >= 0x80000007)
-		match_features(matchtable_edx87, COUNT_OF(matchtable_edx87), raw->ext_cpuid[7][3], data);
-	if (raw->ext_cpuid[0][0] >= 0x8000001a) {
-		/* We have the extended info about SSE unit size */
-		data->detection_hints[CPU_HINT_SSE_SIZE_AUTH] = 1;
-		data->sse_size = (raw->ext_cpuid[0x1a][0] & 1) ? 128 : 64;
-	}
-}
-
-static void decode_amd_cache_info(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
-{
-	int l3_result;
-	const int assoc_table[16] = {
-		0, 1, 2, 0, 4, 0, 8, 0, 16, 0, 32, 48, 64, 96, 128, 255
-	};
-	unsigned n = raw->ext_cpuid[0][0];
-	
-	if (n >= 0x80000005) {
-		data->l1_data_cache = (raw->ext_cpuid[5][2] >> 24) & 0xff;
-		data->l1_assoc = (raw->ext_cpuid[5][2] >> 16) & 0xff;
-		data->l1_cacheline = (raw->ext_cpuid[5][2]) & 0xff;
-		data->l1_instruction_cache = (raw->ext_cpuid[5][3] >> 24) & 0xff;
-	}
-	if (n >= 0x80000006) {
-		data->l2_cache = (raw->ext_cpuid[6][2] >> 16) & 0xffff;
-		data->l2_assoc = assoc_table[(raw->ext_cpuid[6][2] >> 12) & 0xf];
-		data->l2_cacheline = (raw->ext_cpuid[6][2]) & 0xff;
-		
-		l3_result = (raw->ext_cpuid[6][3] >> 18);
-		if (l3_result > 0) {
-			l3_result = 512 * l3_result; /* AMD spec says it's a range,
-			                                but we take the lower bound */
-			data->l3_cache = l3_result;
-			data->l3_assoc = assoc_table[(raw->ext_cpuid[6][3] >> 12) & 0xf];
-			data->l3_cacheline = (raw->ext_cpuid[6][3]) & 0xff;
-		} else {
-			data->l3_cache = 0;
-		}
-	}
-}
-
-static void decode_amd_number_of_cores(struct cpu_raw_data_t* raw, struct cpu_id_t* data)
-{
-	int logical_cpus = -1, num_cores = -1;
-	
-	if (raw->basic_cpuid[0][0] >= 1) {
-		logical_cpus = (raw->basic_cpuid[1][1] >> 16) & 0xff;
-		if (raw->ext_cpuid[0][0] >= 8) {
-			num_cores = 1 + (raw->ext_cpuid[8][2] & 0xff);
-		}
-	}
-	if (data->flags[CPU_FEATURE_HT]) {
-		if (num_cores > 1) {
-			if (data->ext_family >= 23)
-				num_cores /= 2; // e.g., Ryzen 7 reports 16 "real" cores, but they are really just 8.
-			data->num_cores = num_cores;
-			data->num_logical_cpus = logical_cpus;
-		} else {
-			data->num_cores = 1;
-			data->num_logical_cpus = (logical_cpus >= 2 ? logical_cpus : 2);
-		}
-	} else {
-		data->num_cores = data->num_logical_cpus = 1;
-	}
-}
-
-int cpuid_identify_amd(struct cpu_raw_data_t* raw, struct cpu_id_t* data, struct internal_id_info_t* internal)
-{
-	load_amd_features(raw, data);
-	decode_amd_cache_info(raw, data);
-	decode_amd_number_of_cores(raw, data);
-	return 0;
-}