push v0.6.18 version

third_party/parallel-hashmap/.github/FUNDING.yml

+github: greg7mdp

third_party/parallel-hashmap/.github/workflows/linux.yml

+name: Linux
+
+on:
+  push:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        compiler: [g++, clang++]
+        flags: [-std=c++11, -std=c++17]
+        optimize: [-O2]
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2.0.0
+    - name: Build and test
+      env:
+        CXX: ${{ matrix.compiler }}
+        CXXFLAGS: ${{ matrix.flags }} ${{ matrix.optimize }}
+      run: |
+        mkdir build && cd build && cmake -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -DCMAKE_BUILD_TYPE=Release .. && cmake --build . && make test

third_party/parallel-hashmap/.github/workflows/macos.yml

+name: MacOS
+
+on:
+  push:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [macos-latest]
+        compiler: [g++, clang++]
+        flags: [-std=c++11, -std=c++17]
+        optimize: [-O2]
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2.0.0
+    - name: Build and test
+      env:
+        CXX: ${{ matrix.compiler }}
+        CXXFLAGS: ${{ matrix.flags }} ${{ matrix.optimize }}
+      run: |
+        mkdir build && cd build && cmake -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -DCMAKE_BUILD_TYPE=Release .. && cmake --build . && make test

third_party/parallel-hashmap/.github/workflows/windows.yml

+name: Windows
+
+on:
+  push:
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [windows-latest]
+        flags: ["/std:c++11", "/std:c++latest"]
+        optimize: [/O2]
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2.0.0
+    - name: Build and test
+      env:
+        CXX: ${{ matrix.compiler }}
+        CXXFLAGS: ${{ matrix.flags }} ${{ matrix.optimize }}
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: |
+        cmake -Bbuild -DCMAKE_VERBOSE_MAKEFILE:BOOL=ON -DCMAKE_BUILD_TYPE=Release && cmake --build build --target ALL_BUILD && cmake --build build --target RUN_TESTS

third_party/parallel-hashmap/.gitignore

+VagrantFile
+benchmark/build
+benchmark/output
+benchmark/charts.html
+build*
+.vagrant
+**/.vscode
+TAGS

third_party/parallel-hashmap/CMakeLists.txt

+cmake_minimum_required(VERSION 3.8)
+
+list (APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
+
+include(DetectVersion)
+
+cmake_policy(SET CMP0048 NEW)                    ## set VERSION as documented by the project() command.
+cmake_policy(SET CMP0076 NEW)                    ## accept new policy
+set(CMAKE_CXX_STANDARD 11)                       ## compile with C++11 support
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+project(phmap VERSION ${DETECTED_PHMAP_VERSION} LANGUAGES CXX)
+
+set(PHMAP_DIR parallel_hashmap)
+set(PHMAP_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/${PHMAP_DIR}/phmap.h 
+                  ${CMAKE_CURRENT_SOURCE_DIR}/${PHMAP_DIR}/phmap_base.h 
+                  ${CMAKE_CURRENT_SOURCE_DIR}/${PHMAP_DIR}/phmap_bits.h 
+                  ${CMAKE_CURRENT_SOURCE_DIR}/${PHMAP_DIR}/phmap_utils.h 
+                  ${CMAKE_CURRENT_SOURCE_DIR}/${PHMAP_DIR}/phmap_config.h)
+
+set(CMAKE_SUPPRESS_REGENERATION true)            ## suppress ZERO_CHECK project
+
+include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+include(helpers)
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}")
+
+add_library(${PROJECT_NAME} INTERFACE)
+
+target_sources(${PROJECT_NAME} INTERFACE ${PHMAP_HEADERS})
+
+target_include_directories(
+     ${PROJECT_NAME} INTERFACE
+     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
+     $<INSTALL_INTERFACE:include>)
+
+install(
+    DIRECTORY ${PROJECT_SOURCE_DIR}/${PHMAP_DIR}/
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PHMAP_DIR})
+
+install(TARGETS ${PROJECT_NAME}
+        EXPORT ${PROJECT_NAME}-targets)
+
+export(EXPORT ${PROJECT_NAME}-targets
+       FILE "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake")
+
+## ------------------------- building tests and examples -------------
+option(PHMAP_BUILD_TESTS    "Whether or not to build the tests"    ON)
+option(PHMAP_BUILD_EXAMPLES "Whether or not to build the examples" ON)
+
+if(MSVC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /bigobj")
+endif()
+
+if (PHMAP_BUILD_TESTS)
+
+    include(cmake/DownloadGTest.cmake)
+    include_directories(${PROJECT_SOURCE_DIR})
+
+    check_target(gtest)
+    check_target(gtest_main)
+    check_target(gmock)
+
+    enable_testing()
+
+    ## ---------------- regular hash maps ----------------------------
+    phmap_cc_test(NAME compressed_tuple SRCS "tests/compressed_tuple_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME container_memory SRCS "tests/container_memory_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME hash_policy_testing SRCS "tests/hash_policy_testing_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME node_hash_policy SRCS "tests/node_hash_policy_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME raw_hash_set SRCS "tests/raw_hash_set_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME raw_hash_set_allocator SRCS "tests/raw_hash_set_allocator_test.cc"
+                  DEPS gmock_main)
+
+    ## ---------------- regular hash maps ----------------------------
+    phmap_cc_test(NAME flat_hash_set SRCS "tests/flat_hash_set_test.cc"
+                  COPTS "-DUNORDERED_SET_CXX17" DEPS gmock_main)
+
+    phmap_cc_test(NAME flat_hash_map SRCS "tests/flat_hash_map_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME node_hash_map SRCS "tests/node_hash_map_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME node_hash_set SRCS "tests/node_hash_set_test.cc"
+                  COPTS "-DUNORDERED_SET_CXX17" DEPS  gmock_main)
+
+    ## --------------- parallel hash maps -----------------------------------------------
+    phmap_cc_test(NAME parallel_flat_hash_map SRCS "tests/parallel_flat_hash_map_test.cc"
+                  COPTS "-DUNORDERED_MAP_CXX17" DEPS gmock_main)
+
+    phmap_cc_test(NAME parallel_flat_hash_set SRCS "tests/parallel_flat_hash_set_test.cc"
+                  COPTS "-DUNORDERED_SET_CXX17" DEPS gmock_main)
+
+    phmap_cc_test(NAME parallel_node_hash_map SRCS "tests/parallel_node_hash_map_test.cc"
+                  DEPS gmock_main)
+
+    phmap_cc_test(NAME parallel_node_hash_set SRCS "tests/parallel_node_hash_set_test.cc"
+                  COPTS "-DUNORDERED_SET_CXX17" DEPS  gmock_main)
+
+    phmap_cc_test(NAME parallel_flat_hash_map_mutex SRCS "tests/parallel_flat_hash_map_mutex_test.cc"
+                  COPTS "-DUNORDERED_MAP_CXX17" DEPS gmock_main)
+
+    phmap_cc_test(NAME dump_load SRCS "tests/dump_load_test.cc"
+                  COPTS "-DUNORDERED_MAP_CXX17" DEPS gmock_main)
+
+    phmap_cc_test(NAME erase_if SRCS "tests/erase_if_test.cc"
+                  COPTS "-DUNORDERED_MAP_CXX17" DEPS gmock_main)
+
+    ## --------------- btree -----------------------------------------------
+    phmap_cc_test(NAME btree SRCS "tests/btree_test.cc"
+                  CLOPTS "-w" DEPS gmock_main)
+
+
+endif()
+
+if (PHMAP_BUILD_EXAMPLES)
+    if(NOT MSVC)
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -Wextra -Wcast-align -Wcast-qual -Wdisabled-optimization -Winit-self -Wlogical-op -Wmissing-include-dirs -Woverloaded-virtual -Wredundant-decls -Wshadow -Wstrict-null-sentinel  -Wswitch-default -Wno-unused -Wno-unknown-warning-option -Wno-gnu-zero-variadic-macro-arguments")
+    else()
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4 /Zc:__cplusplus")
+    endif()
+
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads REQUIRED)
+
+    add_executable(ex_allmaps examples/allmaps.cc phmap.natvis)
+    add_executable(ex_basic examples/basic.cc phmap.natvis)
+    add_executable(ex_bench examples/bench.cc phmap.natvis)
+    add_executable(ex_emplace examples/emplace.cc phmap.natvis)
+    if (MSVC)
+        add_executable(ex_lazy_emplace_l examples/lazy_emplace_l.cc phmap.natvis)
+    endif()
+    add_executable(ex_serialize examples/serialize.cc phmap.natvis)
+    target_include_directories(ex_serialize PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/../cereal/include>)
+    add_executable(ex_hash_std examples/hash_std.cc phmap.natvis)
+    add_executable(ex_hash_value examples/hash_value.cc phmap.natvis)
+    add_executable(ex_two_files examples/f1.cc examples/f2.cc phmap.natvis)
+    add_executable(ex_insert_bench examples/insert_bench.cc phmap.natvis)
+    add_executable(ex_knucleotide examples/knucleotide.cc phmap.natvis)
+    add_executable(ex_dump_load examples/dump_load.cc phmap.natvis)
+    add_executable(ex_btree examples/btree.cc phmap.natvis)
+    add_executable(ex_matt examples/matt.cc phmap.natvis)
+
+    target_link_libraries(ex_knucleotide Threads::Threads)
+    target_link_libraries(ex_bench Threads::Threads)
+endif()
+

third_party/parallel-hashmap/LICENSE

+
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       https://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

third_party/parallel-hashmap/README.md

+
+<img src="https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/phash.png?raw=true" width="120" align="middle"> 
+
+# The Parallel Hashmap  
+
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache-yellow.svg)](https://opensource.org/licenses/Apache-2.0) [![Linux](https://github.com/greg7mdp/parallel-hashmap/actions/workflows/linux.yml/badge.svg)](https://github.com/greg7mdp/parallel-hashmap/actions/workflows/linux.yml)  [![MacOS](https://github.com/greg7mdp/parallel-hashmap/actions/workflows/macos.yml/badge.svg)](https://github.com/greg7mdp/parallel-hashmap/actions/workflows/macos.yml) [![Windows](https://github.com/greg7mdp/parallel-hashmap/actions/workflows/windows.yml/badge.svg)](https://github.com/greg7mdp/parallel-hashmap/actions/workflows/windows.yml) 
+
+## Overview
+
+This repository aims to provide a set of excellent **hash map** implementations, as well as a **btree** alternative to std::map and std::set, with the following characteristics: 
+
+- **Header only**: nothing to build, just copy the `parallel_hashmap` directory to your project and you are good to go.
+
+- **drop-in replacement** for `std::unordered_map`, `std::unordered_set`, `std::map` and `std::set`
+
+- Compiler with **C++11 support** required, **C++14 and C++17 APIs are provided (such as `try_emplace`)**
+
+- **Very efficient**, significantly faster than your compiler's unordered map/set or Boost's, or than [sparsepp](https://github.com/greg7mdp/sparsepp)
+
+- **Memory friendly**: low memory usage, although a little higher than [sparsepp](https://github.com/greg7mdp/sparsepp)
+
+- Supports **heterogeneous lookup**
+
+- Easy to **forward declare**: just include `phmap_fwd_decl.h` in your header files to forward declare Parallel Hashmap containers [note: this does not work currently for hash maps with pointer keys]
+
+- **Dump/load** feature: when a `flat` hash map stores data that is `std::trivially_copyable`, the table can be dumped to disk and restored as a single array, very efficiently, and without requiring any hash computation. This is typically about 10 times faster than doing element-wise serialization to disk, but it will use 10% to 60% extra disk space. See `examples/serialize.cc`. _(flat hash map/set only)_
+
+- **Tested** on Windows (vs2015 & vs2017, vs2019, Intel compiler 18 and 19), linux (g++ 4.8.4, 5, 6, 7, 8, clang++ 3.9, 4.0, 5.0) and MacOS (g++ and clang++) - click on travis and appveyor icons above for detailed test status.
+
+- Automatic support for **boost's hash_value()** method for providing the hash function (see `examples/hash_value.h`). Also default hash support for `std::pair` and `std::tuple`.
+
+- **natvis** visualization support in Visual Studio _(hash map/set only)_
+
+@byronhe kindly provided this [Chinese translation](https://byronhe.com/post/2020/11/10/parallel-hashmap-btree-fast-multi-thread-intro/) of the README.md.
+
+
+## Fast *and*  memory friendly
+
+Click here [For a full writeup explaining the design and benefits of the Parallel Hashmap](https://greg7mdp.github.io/parallel-hashmap/).
+
+The hashmaps and btree provided here are built upon those open sourced by Google in the Abseil library. The hashmaps use closed hashing, where values are stored directly into a memory array, avoiding memory indirections. By using parallel SSE2 instructions, these hashmaps are able to look up items by checking 16 slots in parallel,  allowing the implementation to remain fast even when the table is filled up to 87.5% capacity.
+
+> **IMPORTANT:** This repository borrows code from the [abseil-cpp](https://github.com/abseil/abseil-cpp) repository, with modifications, and may behave differently from the original. This repository is an independent work, with no guarantees implied or provided by the authors. Please visit [abseil-cpp](https://github.com/abseil/abseil-cpp) for the official Abseil libraries.
+
+## Installation
+
+Copy the parallel_hashmap directory to your project. Update your include path. That's all.
+
+If you are using Visual Studio, you probably want to add `phmap.natvis` to your projects. This will allow for a clear display of the hash table contents in the debugger.
+
+> A cmake configuration files (CMakeLists.txt) is provided for building the tests and examples. Command for building and running the tests is: `mkdir build && cd build && cmake -DPHMAP_BUILD_TESTS=ON -DPHMAP_BUILD_EXAMPLES=ON .. && cmake --build . && make test`
+
+## Example
+
+```c++
+#include <iostream>
+#include <string>
+#include <parallel_hashmap/phmap.h>
+
+using phmap::flat_hash_map;
+ 
+int main()
+{
+    // Create an unordered_map of three strings (that map to strings)
+    flat_hash_map<std::string, std::string> email = 
+    {
+        { "tom",  "tom@gmail.com"},
+        { "jeff", "jk@gmail.com"},
+        { "jim",  "jimg@microsoft.com"}
+    };
+ 
+    // Iterate and print keys and values 
+    for (const auto& n : email) 
+        std::cout << n.first << "'s email is: " << n.second << "\n";
+ 
+    // Add a new entry
+    email["bill"] = "bg@whatever.com";
+ 
+    // and print it
+    std::cout << "bill's email is: " << email["bill"] << "\n";
+ 
+    return 0;
+}
+```
+
+## Various hash maps and their pros and cons
+
+The header `parallel_hashmap/phmap.h` provides the implementation for the following eight hash tables:
+- phmap::flat_hash_set
+- phmap::flat_hash_map
+- phmap::node_hash_set
+- phmap::node_hash_map
+- phmap::parallel_flat_hash_set
+- phmap::parallel_flat_hash_map
+- phmap::parallel_node_hash_set
+- phmap::parallel_node_hash_map
+
+The header `parallel_hashmap/btree.h` provides the implementation for the following btree-based ordered containers:
+- phmap::btree_set
+- phmap::btree_map
+- phmap::btree_multiset
+- phmap::btree_multimap
+
+The btree containers are direct ports from Abseil, and should behave exactly the same as the Abseil ones, modulo small differences (such as supporting std::string_view instead of absl::string_view, and being forward declarable).
+
+When btrees are mutated, values stored within can be moved in memory. This means that pointers or iterators to values stored in btree containers can be invalidated when that btree is modified. This is a significant difference with `std::map` and `std::set`, as the std containers do offer a guarantee of pointer stability. The same is true for the 'flat' hash maps and sets.
+
+The full types with template parameters can be found in the [parallel_hashmap/phmap_fwd_decl.h](https://raw.githubusercontent.com/greg7mdp/parallel-hashmap/master/parallel_hashmap/phmap_fwd_decl.h) header, which is useful for forward declaring the Parallel Hashmaps when necessary.
+
+**Key decision points for hash containers:**
+
+- The `flat` hash maps will move the keys and values in memory. So if you keep a pointer to something inside a `flat` hash map, this pointer may become invalid when the map is mutated. The `node` hash maps don't, and should be used instead if this is a problem.
+
+- The `flat` hash maps will use less memory, and usually be faster than the `node` hash maps, so use them if you can. the exception is when the values inserted in the hash map are large (say more than 100 bytes [*needs testing*]) and costly to move.
+
+- The `parallel` hash maps are preferred when you have a few hash maps that will store a very large number of values. The `non-parallel` hash maps are preferred if you have a large number of hash maps, each storing a relatively small number of values.
+
+- The benefits of the `parallel` hash maps are:  
+   a. reduced peak memory usage (when resizing), and  
+   b. multithreading support (and inherent internal parallelism)
+
+**Key decision points for btree containers:**
+
+Btree containers are ordered containers, which can be used as alternatives to `std::map` and `std::set`. They store multiple values in each tree node, and are therefore more cache friendly and use significantly less memory.
+
+Btree containers will usually be preferable to the default red-black trees of the STL, except when:
+- pointer stability or iterator stability is required
+- the value_type is large and expensive to move
+
+When an ordering is not needed, a hash container is typically a better choice than a btree one.
+
+## Changes to Abseil's hashmaps
+
+- The default hash framework is std::hash, not absl::Hash. However, if you prefer the default to be the Abseil hash framework, include the Abseil headers before `phmap.h` and define the preprocessor macro `PHMAP_USE_ABSL_HASH`.
+
+- The `erase(iterator)` and `erase(const_iterator)` both return an iterator to the element following the removed element, as does the std::unordered_map. A non-standard `void _erase(iterator)` is provided in case the return value is not needed.
+
+- No new types, such as `absl::string_view`, are provided. All types with a `std::hash<>` implementation are supported by phmap tables (including `std::string_view` of course if your compiler provides it).
+
+- The Abseil hash tables internally randomize a hash seed, so that the table iteration order is non-deterministic. This can be useful to prevent *Denial Of Service*  attacks when a hash table is used for a customer facing web service, but it can make debugging more difficult. The *phmap* hashmaps by default do **not** implement this randomization, but it can be enabled by adding `#define PHMAP_NON_DETERMINISTIC 1` before including the header `phmap.h` (as is done in raw_hash_set_test.cc).
+
+- Unlike the Abseil hash maps, we do an internal mixing of the hash value provided. This prevents serious degradation of the hash table performance when the hash function provided by the user has poor entropy distribution. The cost in performance is very minimal, and this helps provide reliable performance even with *imperfect* hash functions. 
+
+
+## Memory usage
+
+|  type                 |    memory usage   | additional *peak* memory usage when resizing  |
+|-----------------------|-------------------|-----------------------------------------------|
+| flat tables           | ![flat_mem_usage](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/flat_mem_usage.png?raw=true) | ![flat_peak_usage](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/flat_peak.png?raw=true) |
+| node tables           | ![node_mem_usage](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/node_mem_usage.png?raw=true) | ![node_peak_usage](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/node_peak.png?raw=true) |
+| parallel flat tables  | ![flat_mem_usage](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/flat_mem_usage.png?raw=true) | ![parallel_flat_peak](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/parallel_flat_peak.png?raw=true) |
+| parallel node tables  | ![node_mem_usage](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/node_mem_usage.png?raw=true) | ![parallel_node_peak](https://github.com/greg7mdp/parallel-hashmap/blob/master/html/img/parallel_node_peak.png?raw=true) |
+
+
+- *size()* is the number of values in the container, as returned by the size() method
+- *load_factor()* is the ratio: `size() / bucket_count()`. It varies between 0.4375 (just after the resize) to 0.875 (just before the resize). The size of the bucket array doubles at each resize.
+- the value 9 comes from `sizeof(void *) + 1`, as the *node* hash maps store one pointer plus one byte of metadata for each entry in the bucket array.
+- flat tables store the values, plus one byte of metadata per value), directly into the bucket array, hence the `sizeof(C::value_type) + 1`.
+- the additional peak memory usage (when resizing) corresponds the the old bucket array (half the size of the new one, hence the 0.5), which contains the values to be copied to the new bucket array, and which is freed when the values have been copied.
+- the *parallel* hashmaps, when created with a template parameter N=4, create 16 submaps. When the hash values are well distributed, and in single threaded mode, only one of these 16 submaps resizes at any given time, hence the factor `0.03` roughly equal to `0.5 / 16`
+
+## Iterator invalidation for hash containers
+
+The rules are the same as for `std::unordered_map`, and are valid for all the phmap hash containers:
+
+
+|    Operations	                            | Invalidated                |
+|-------------------------------------------|----------------------------|
+| All read only operations, swap, std::swap | Never                      |
+| clear, rehash, reserve, operator=         | Always                     |
+| insert, emplace, emplace_hint, operator[] | Only if rehash triggered   |
+| erase                                     | Only to the element erased |
+
+## Iterator invalidation for btree containers
+
+Unlike for `std::map` and `std::set`, any mutating operation may invalidate existing iterators to btree containers.
+
+
+|    Operations	                            | Invalidated                |
+|-------------------------------------------|----------------------------|
+| All read only operations, swap, std::swap | Never                      |
+| clear, operator=                          | Always                     |
+| insert, emplace, emplace_hint, operator[] | Yes                        |
+| erase                                     | Yes                        |
+
+## Example 2 - providing a hash function for a user-defined class
+
+In order to use a flat_hash_set or flat_hash_map, a hash function should be provided. This can be done with one of the following methods:
+
+- Provide a hash functor via the HashFcn template parameter
+
+- As with boost, you may add a `hash_value()` friend function in your class. 
+
+For example:
+ 
+```c++
+#include <parallel_hashmap/phmap_utils.h> // minimal header providing phmap::HashState()
+#include <string>
+using std::string;
+
+struct Person
+{
+    bool operator==(const Person &o) const
+    { 
+        return _first == o._first && _last == o._last && _age == o._age; 
+    }
+
+    friend size_t hash_value(const Person &p)
+    {
+        return phmap::HashState().combine(0, p._first, p._last, p._age);
+    }
+
+    string _first;
+    string _last;
+    int    _age;
+};
+```
+
+- Inject a specialization of `std::hash` for the class into the "std" namespace. We provide a convenient and small header `phmap_utils.h` which allows to easily add such specializations.
+
+For example:
+
+### file "Person.h"
+
+```c++
+#include <parallel_hashmap/phmap_utils.h> // minimal header providing phmap::HashState()
+#include <string>
+using std::string;
+
+struct Person
+{
+    bool operator==(const Person &o) const
+    { 
+        return _first == o._first && _last == o._last && _age == o._age; 
+    }
+
+    string _first;
+    string _last;
+    int    _age;
+};
+
+namespace std
+{
+    // inject specialization of std::hash for Person into namespace std
+    // ----------------------------------------------------------------
+    template<> struct hash<Person>
+    {
+        std::size_t operator()(Person const &p) const
+        {
+            return phmap::HashState().combine(0, p._first, p._last, p._age);
+        }
+    };
+}
+```
+
+The `std::hash` specialization for `Person` combines the hash values for both first and last name and age, using the convenient phmap::HashState() function, and returns the combined hash value. 
+
+### file "main.cpp"
+
+```c++
+#include "Person.h"   // defines Person  with std::hash specialization
+
+#include <iostream>
+#include <parallel_hashmap/phmap.h>
+
+int main()
+{
+    // As we have defined a specialization of std::hash() for Person,
+    // we can now create sparse_hash_set or sparse_hash_map of Persons
+    // ----------------------------------------------------------------
+    phmap::flat_hash_set<Person> persons = 
+        { { "John", "Mitchell", 35 },
+          { "Jane", "Smith",    32 },
+          { "Jane", "Smith",    30 },
+        };
+
+    for (auto& p: persons)
+        std::cout << p._first << ' ' << p._last << " (" << p._age << ")" << '\n';
+
+}
+```
+
+
+## Thread safety
+
+Parallel Hashmap containers follow the thread safety rules of the Standard C++ library. In Particular:
+
+- A single phmap hash table is thread safe for reading from multiple threads. For example, given a hash table A, it is safe to read A from thread 1 and from thread 2 simultaneously.
+
+- If a single hash table is being written to by one thread, then all reads and writes to that hash table on the same or other threads must be protected. For example, given a hash table A, if thread 1 is writing to A, then thread 2 must be prevented from reading from or writing to A. 
+
+- It is safe to read and write to one instance of a type even if another thread is reading or writing to a different instance of the same type. For example, given hash tables A and B of the same type, it is safe if A is being written in thread 1 and B is being read in thread 2.
+
+- The *parallel* tables can be made internally thread-safe for concurrent read and write access, by providing a synchronization type (for example [std::mutex](https://en.cppreference.com/w/cpp/thread/mutex)) as the last template argument. Because locking is performed at the *submap* level, a high level of concurrency can still be achieved. Read access can be done safely using `if_contains()`, which passes a reference value to the callback while holding the *submap* lock. Similarly, write access can be done safely using `modify_if`, `try_emplace_l` or `lazy_emplace_l`. However, please be aware that iterators or references returned by standard APIs are not protected by the mutex, so they cannot be used reliably on a hash map which can be changed by another thread.
+
+- Examples on how to use various mutex types, including boost::mutex, boost::shared_mutex and absl::Mutex can be found in `examples/bench.cc`
+
+
+## Using the Parallel Hashmap from languages other than C++
+
+While C++ is the native language of the Parallel Hashmap, we welcome bindings making it available for other languages. One such implementation has been created for Python and is described below:
+
+- [GetPy - A Simple, Fast, and Small Hash Map for Python](https://github.com/atom-moyer/getpy): GetPy is a thin and robust binding to The Parallel Hashmap (https://github.com/greg7mdp/parallel-hashmap.git) which is the current state of the art for minimal memory overhead and fast runtime speed. The binding layer is supported by PyBind11 (https://github.com/pybind/pybind11.git) which is fast to compile and simple to extend. Serialization is handled by Cereal (https://github.com/USCiLab/cereal.git) which supports streaming binary serialization, a critical feature for the large hash maps this package is designed to support.
+
+## Acknowledgements
+
+Many thanks to the Abseil developers for implementing the swiss table and btree data structures (see [abseil-cpp](https://github.com/abseil/abseil-cpp)) upon which this work is based, and to Google for releasing it as open-source. 

third_party/parallel-hashmap/benchmark/BENCHMARK.md

+# parallel-hashmap
+
+How to run these benchmarks
+===========================
+
+These bencharks were run on windows using Visual Studio 2017, in a cygwin window with the VC++ 2017 compiler env vars (add something like this in your Cygwin.bat:
+
+CALL "C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvars64.bat"
+
+Running them on linux would require Makefile changes.
+
+To build and run the tests, just update the path to the abseil libraries in the makefile, and run make. 
+
+Your charts are now in charts.html.
+
+

third_party/parallel-hashmap/benchmark/Makefile

+CXX=CL -EHsc -DNDEBUG -Fo$@ -O2
+#CXX=CL -EHsc -g -debug -Zi  -Fo$@
+#CXX=g++ -ggdb -O2 -lm -std=c++11 -DNDEBUG 
+
+ABSEIL_LIBS=absl_bad_optional_access.lib absl_bad_variant_access.lib absl_base.lib absl_demangle_internal.lib absl_hash.lib absl_int128.lib absl_internal_bad_any_cast_impl.lib absl_internal_city.lib absl_internal_civil_time.lib absl_internal_debugging_internal.lib absl_internal_graphcycles_internal.lib absl_internal_hashtablez_sampler.lib absl_internal_malloc_internal.lib absl_internal_spinlock_wait.lib absl_internal_strings_internal.lib absl_internal_throw_delegate.lib absl_internal_time_zone.lib absl_optional.lib absl_raw_hash_set.lib absl_stacktrace.lib absl_strings.lib absl_symbolize.lib absl_synchronization.lib absl_time.lib
+
+PROGS       = stl_unordered_map sparsepp phmap abseil_flat abseil_parallel_flat phmap_flat
+BUILD_PROGS = $(addprefix build/,$(PROGS))
+SIZE        = 100000000
+ABSEIL      = ../../abseil-cpp
+PHMAP_SRC   = ../parallel_hashmap
+
+all: test
+
+builddir: 
+	@if [ ! -d build ]; then mkdir build; fi
+
+build/stl_unordered_map: bench.cc Makefile
+	$(CXX) -DSTL_UNORDERED -I.. bench.cc -o $@
+
+build/sparsepp: bench.cc Makefile
+	$(CXX) -DSPARSEPP -I.. -I../../sparsepp bench.cc -o $@
+
+build/phmap: bench.cc Makefile $(PHMAP_SRC)/phmap.h
+	$(CXX) -DPHMAP -I.. -I$(ABSEIL) bench.cc /MD -o $@ /link /LIBPATH:$(ABSEIL)/build/lib ${ABSEIL_LIBS}
+
+build/phmap_flat: bench.cc Makefile $(PHMAP_SRC)/phmap.h
+	$(CXX) -DPHMAP_FLAT -I.. bench.cc /MD -o $@ 
+
+build/abseil_flat: bench.cc Makefile
+	$(CXX) -DABSEIL_FLAT -I.. -I$(ABSEIL) bench.cc /MD -o $@ /link /LIBPATH:$(ABSEIL)/build/lib ${ABSEIL_LIBS}
+
+build/abseil_parallel_flat: bench.cc Makefile
+	$(CXX) -DABSEIL_PARALLEL_FLAT -I.. -I $(ABSEIL) bench.cc /MD -o $@ /link /LIBPATH:$(ABSEIL)/build/lib ${ABSEIL_LIBS}
+
+build/emplace: emplace.cc Makefile $(PHMAP_SRC)/phmap.h
+	$(CXX) -DABSEIL_FLAT -I.. -I$(ABSEIL) emplace.cc /MD -o $@ /link /LIBPATH:$(ABSEIL)/build/lib ${ABSEIL_LIBS}
+
+progs:	$(BUILD_PROGS)
+
+test: builddir progs
+	-rm -f output
+	#./build/stl_unordered_map $(SIZE) random >> output
+	#./build/sparsepp    $(SIZE) random >> output
+	./build/abseil_flat  $(SIZE) random >> output
+	#./build/phmap_flat   $(SIZE) random >> output
+	./build/phmap        $(SIZE) random >> output
+	./build/abseil_parallel_flat $(SIZE) random >> output
+	python make_chart_data.py < output
+
+test_cust: 
+	-rm -f output
+	#./build/abseil_flat $(SIZE) random >> output
+	#./build/sparsepp    $(SIZE) random >> output
+	./build/abseil_parallel_flat_5 $(SIZE) random >> output
+	./build/abseil_parallel_flat $(SIZE) random >> output
+	python make_chart_data.py < output
+
+chart:
+	python make_chart_data.py < output
+
+clean:
+	-rm -fr output build

third_party/parallel-hashmap/benchmark/bench.py

+import sys, os, subprocess, signal
+
+programs = [
+    'stl_unordered_map',
+    'abseil_flat',
+    'abseil_parallel_flat'
+]
+
+test_size   = 1
+minkeys     = 0
+maxkeys     = 1000
+interval    = 100
+best_out_of = 1
+
+if test_size == 2:
+    multiplier = 1000 * 1000
+    maxkeys  = 500
+    best_out_of = 3
+    
+elif test_size == 1:
+    multiplier = 100 * 1000
+    interval = 200
+else:
+    multiplier = 10 * 1000
+
+# and use nice/ionice
+# and shut down to the console
+# and swapoff any swap files/partitions
+
+outfile = open('output', 'w')
+
+if len(sys.argv) > 1:
+    benchtypes = sys.argv[1:]
+else:
+    benchtypes = ( 'random', 'lookup', 'delete',)
+    #benchtypes = (  'lookup', )
+
+for benchtype in benchtypes:
+    nkeys = minkeys * multiplier
+    while nkeys <= (maxkeys * multiplier):
+        for program in programs:
+            fastest_attempt = 1000000
+            fastest_attempt_data = ''
+
+            for attempt in range(best_out_of):
+                proc = subprocess.Popen(['./build/'+program, str(nkeys), benchtype], stdout=subprocess.PIPE)
+
+                # wait for the program to fill up memory and spit out its "ready" message
+                try:
+                    runtime = float(proc.stdout.readline().strip())
+                except:
+                    runtime = 0
+
+                ps_proc = subprocess.Popen(['ps up %d | tail -n1' % proc.pid], shell=True, stdout=subprocess.PIPE)
+                #nbytes = int(ps_proc.stdout.read().split()[4]) * 1024
+                #ps_proc.wait()
+                nbytes = 1000000
+
+                os.kill(proc.pid, signal.SIGKILL)
+                proc.wait()
+
+                if nbytes and runtime: # otherwise it crashed
+                    line = ','.join(map(str, [benchtype, nkeys, program, nbytes, "%0.6f" % runtime]))
+
+                    if runtime < fastest_attempt:
+                        fastest_attempt = runtime
+                        fastest_attempt_data = line
+
+            if fastest_attempt != 1000000:
+                print >> outfile, fastest_attempt_data
+                print fastest_attempt_data
+
+        nkeys += interval * multiplier