Document boost::core::memory_resource

.drone.jsonnet

@@ -0,0 +1,370 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "core";
+
+local triggers =
+{
+    branch: [ "master", "develop", "feature/*" ]
+};
+
+local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
+local asan = { ASAN: '1' };
+
+local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "linux",
+        arch: arch
+    },
+    steps:
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'set -e',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+            ] +
+            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
+            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "exec",
+    trigger: triggers,
+    platform: {
+        "os": "darwin",
+        "arch": arch
+    },
+    node: {
+        "os": osx_version
+    },
+    steps: [
+        {
+            name: "everything",
+            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
+            commands:
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local windows_pipeline(name, image, environment, arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "windows",
+        arch: arch
+    },
+    "steps":
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'cmd /C .drone\\\\drone.bat ' + library,
+            ]
+        }
+    ]
+};
+
+[
+    linux_pipeline(
+        "Linux 14.04 GCC 4.4",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
+        "g++-4.4",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.6 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.6-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.7 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.7-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.8* 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.9 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
+        "g++-4.9-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5* 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+        "g++-6-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+        "g++-8-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.5",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
+        "clang-3.5",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        "clang-12",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        "clang-13",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 UBSAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
+    ),
+
+    windows_pipeline(
+        "Windows VS2015 msvc-14.0",
+        "cppalliance/dronevs2015",
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2017 msvc-14.1",
+        "cppalliance/dronevs2017",
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2019 msvc-14.2",
+        "cppalliance/dronevs2019",
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2022 msvc-14.3",
+        "cppalliance/dronevs2022:1",
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+    ),
+]

.drone/drone.bat

@@ -0,0 +1,23 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py -I examples %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker

.drone/drone.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+set -ex
+
+DRONE_BUILD_DIR=$(pwd)
+
+BOOST_BRANCH=develop
+if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+
+cd ..
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
+python tools/boostdep/depinst/depinst.py -I examples $LIBRARY
+./bootstrap.sh
+./b2 -d0 headers
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}

.github/workflows/ci.yml

@@ -32,82 +32,95 @@ jobs:
           # Linux, gcc
           - toolset: gcc-4.4
             cxxstd: "98,0x"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.4
+              - g++-4.4-multilib
             sources:
               - "ppa:ubuntu-toolchain-r/test"
           - toolset: gcc-4.6
             cxxstd: "03,0x"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.6
+              - g++-4.6-multilib
             sources:
               - "ppa:ubuntu-toolchain-r/test"
           - toolset: gcc-4.7
             cxxstd: "03,11"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.7
+              - g++-4.7-multilib
           - toolset: gcc-4.8
             cxxstd: "03,11"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-4.8
+              - g++-4.8-multilib
           - toolset: gcc-4.9
             cxxstd: "03,11"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-4.9
+              - g++-4.9-multilib
           - toolset: gcc-5
             cxxstd: "03,11,14,1z"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:16.04
             install:
-              - g++-5
+              - g++-5-multilib
           - toolset: gcc-6
             cxxstd: "03,11,14,1z"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-6
+              - g++-6-multilib
           - toolset: gcc-7
             cxxstd: "03,11,14,17"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-7
+              - g++-7-multilib
           - toolset: gcc-8
             cxxstd: "03,11,14,17,2a"
+            address-model: 32,64
             os: ubuntu-latest
             container: ubuntu:18.04
             install:
-              - g++-8
+              - g++-8-multilib
           - toolset: gcc-9
             cxxstd: "03,11,14,17,2a"
+            address-model: 32,64
             os: ubuntu-20.04
             install:
-              - g++-9
+              - g++-9-multilib
           - toolset: gcc-10
             cxxstd: "03,11,14,17,20"
+            address-model: 32,64
             os: ubuntu-20.04
             install:
-              - g++-10
+              - g++-10-multilib
           - toolset: gcc-11
             cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
             os: ubuntu-22.04
             install:
-              - g++-11
+              - g++-11-multilib
           - toolset: gcc-12
             cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
             os: ubuntu-22.04
             install:
-              - g++-12
+              - g++-12-multilib
           - name: UBSAN
             toolset: gcc-12
             cxxstd: "03,11,14,17,20,23"
@@ -266,6 +279,9 @@ jobs:
           - toolset: clang
             cxxstd: "03,11,14,17,2a"
             os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-12
 
     timeout-minutes: 120
     runs-on: ${{matrix.os}}
@@ -456,6 +472,10 @@ jobs:
             then
                 B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
             fi
+            if [ -n "${{matrix.address-model}}" ]
+            then
+                B2_ARGS+=("address-model=${{matrix.address-model}}")
+            fi
             if [ -n "${{matrix.linkflags}}" ]
             then
                 B2_ARGS+=("linkflags=${{matrix.linkflags}}")
@@ -530,6 +550,7 @@ jobs:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
+          - os: macos-12
 
     runs-on: ${{matrix.os}}
 
@@ -576,6 +597,7 @@ jobs:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
+          - os: macos-12
 
     runs-on: ${{matrix.os}}
 
@@ -632,6 +654,7 @@ jobs:
           - os: ubuntu-20.04
           - os: ubuntu-22.04
           - os: macos-11
+          - os: macos-12
 
     runs-on: ${{matrix.os}}
 

appveyor.yml

@@ -29,6 +29,11 @@ environment:
 
     # clang-win 32 bit fails to link with "unable to load mspdbcore.dll (error code: 126)"
 
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      ADDRMD: 64
+      CXXSTD: 14,17,latest
+
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       TOOLSET: clang-win
       ADDRMD: 64

doc/alignof.qbk

@@ -0,0 +1,33 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:alignof alignof]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/alignof.hpp>]
+
+The header `<boost/core/alignof.hpp>` defines the macro `BOOST_CORE_ALIGNOF`,
+a portable equivalent of the `alignof` operator from C++11.
+
+[section Example]
+
+``
+#include <boost/core/alignof.hpp>
+#include <cstddef>
+
+constexpr std::size_t alignment_of_double = BOOST_CORE_ALIGNOF(double);
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/changes.qbk

@@ -16,6 +16,12 @@
   or C++ standard library type traits instead.
 * Marked `boost::ref` member functions and associated methods with `noexcept`.
 * Marked `boost::swap` function with `noexcept`, depending on whether the type supports a non-throwing swap operation.
+* Added [link core.launder `boost::core::launder`], a portable implementation of `std::launder`.
+* Added [link core.alignof `BOOST_CORE_ALIGNOF`], a portable implementation of `alignof`.
+* Added [link core.max_align `boost::core::max_align_t`], a portable equivalent of `std::max_align_t`, and
+  `boost::core::max_align`, the alignment of `max_align_t`.
+* Added [link core.memory_resource `boost::core::memory_resource`], a portable equivalent of `std::pmr::memory_resource`
+  from C++17.
 
 [endsect]
 

doc/core.qbk

@@ -41,6 +41,7 @@ criteria for inclusion is that the utility component be:
 [include changes.qbk]
 
 [include addressof.qbk]
+[include alignof.qbk]
 [include allocator_access.qbk]
 [include allocator_traits.qbk]
 [include bit.qbk]
@@ -55,7 +56,10 @@ criteria for inclusion is that the utility component be:
 [include first_scalar.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
+[include launder.qbk]
 [include lightweight_test.qbk]
+[include max_align.qbk]
+[include memory_resource.qbk]
 [include no_exceptions_support.qbk]
 [include noinit_adaptor.qbk]
 [include noncopyable.qbk]

doc/launder.qbk

@@ -0,0 +1,39 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:launder launder]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/launder.hpp>]
+
+The header `<boost/core/launder.hpp>` defines the function
+`void boost::core::launder()`, a portable implementation of
+`std::launder`.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+template<class T> T* launder( T* p );
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/max_align.qbk

@@ -0,0 +1,42 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:max_align max_align]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/max_align.hpp>]
+
+The header `<boost/core/max_align.hpp>` defines the type
+`boost::core::max_align_t`, a portable equivalent of
+`std::max_align_t`, and the constant `boost::core::max_align`,
+the alignment of `max_align_t`.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+union max_align_t;
+
+constexpr std::size_t max_align = alignof(max_align_t);
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]

doc/memory_resource.qbk

@@ -0,0 +1,139 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:memory_resource memory_resource]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/memory_resource.hpp>]
+
+The header `<boost/core/memory_resource.hpp>` defines the class
+`boost::core::memory_resource`, a portable equivalent of
+`std::pmr::memory_resource` from C++17.
+
+This is not a complete implementation of the standard `<memory_resource>`
+header; for such, one should use Boost.Container. The abstract base class
+is only provided by Core so that Boost libraries that provide and take
+advantage of PMR facilities such as concrete implementations of memory
+resources, or implementations of `polymorphic_allocator`, can interoperate.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+class memory_resource
+{
+public:
+
+    virtual ~memory_resource() = default;
+
+    [[nodiscard]] void* allocate( std::size_t bytes, std::size_t alignment = max_align );
+    void deallocate( void* p, std::size_t bytes, std::size_t alignment = max_align );
+
+    bool is_equal( memory_resource const & other ) const noexcept;
+
+private:
+
+    virtual void* do_allocate( std::size_t bytes, std::size_t alignment ) = 0;
+    virtual void do_deallocate( void* p, std::size_t bytes, std::size_t alignment ) = 0;
+
+    virtual bool do_is_equal( memory_resource const& other ) const noexcept = 0;
+};
+
+inline bool operator==( memory_resource const& a, memory_resource const& b ) noexcept;
+inline bool operator!=( memory_resource const& a, memory_resource const& b ) noexcept;
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[section `allocate`]
+
+`[[nodiscard]] void* allocate( std::size_t bytes, std::size_t alignment = max_align );`
+
+* *Returns:* `do_allocate( bytes, alignment )`.
+* *Remarks:* Implicitly creates objects in the returned region of storage.
+
+[endsect]
+
+[section `deallocate`]
+
+`void deallocate( void* p, std::size_t bytes, std::size_t alignment = max_align );`
+
+* *Effects:* `do_deallocate( bytes, alignment )`.
+
+[endsect]
+
+[section `is_equal`]
+
+`bool is_equal( memory_resource const& other ) const noexcept;`
+
+* *Returns:* `do_is_equal( other )`.
+
+[endsect]
+
+[section `do_allocate`]
+
+`void* do_allocate( std::size_t bytes, std::size_t alignment ) = 0;`
+
+* *Remarks:* A derived class should implement this member function to return
+  a pointer to allocated storage of size at least `bytes` and alignment at
+  least `alignment`.
+* *Throws:* An appropriate exception (by convention `std::bad_alloc` or
+  derived) when storage with the specified size and alignment could not be
+  obtained.
+
+[endsect]
+
+[section `do_deallocate`]
+
+`void do_deallocate( void* p, std::size_t bytes, std::size_t alignment ) = 0;`
+
+* *Remarks:* A derived class should implement this member function to deallocate
+  a region of storage previously allocated by `do_allocate`.
+* *Throws:* Nothing.
+
+[endsect]
+
+[section `do_is_equal`]
+
+`bool do_is_equal( memory_resource const& other ) const noexcept = 0;`
+
+* *Remarks:* A derived class shall implement this function to return `true` if
+  memory allocated from `*this` can be deallocated from `other` and vice-versa,
+  otherwise `false`.
+
+[endsect]
+
+[section `operator==`]
+
+`bool operator==( memory_resource const& a, memory_resource const& b ) noexcept;`
+
+* *Returns:* `&a == &b || a.is_equal( b )`.
+
+[endsect]
+
+[section `operator!=`]
+
+`bool operator!=( memory_resource const& a, memory_resource const& b ) noexcept;`
+
+* *Returns:* `!( a == b )`.
+
+[endsect]
+
+[endsect]
+
+[endsect]

include/boost/core/alignof.hpp

@@ -0,0 +1,57 @@
+#ifndef BOOST_CORE_ALIGNOF_HPP_INCLUDED
+#define BOOST_CORE_ALIGNOF_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF)
+
+#define BOOST_CORE_ALIGNOF alignof
+
+#elif defined(__GNUC__)
+
+#define BOOST_CORE_ALIGNOF __alignof__
+
+#elif defined(_MSC_VER)
+
+#define BOOST_CORE_ALIGNOF __alignof
+
+#else
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+template<class T> struct alignof_helper
+{
+    char x;
+    T t;
+};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#if defined(__GNUC__)
+// ignoring -Wvariadic-macros with #pragma doesn't work under GCC
+# pragma GCC system_header
+#endif
+
+#define BOOST_CORE_ALIGNOF(...) offsetof( ::boost::core::detail::alignof_helper<__VA_ARGS__>, t );
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_ALIGNOF_HPP_INCLUDED

include/boost/core/detail/lwt_unattended.hpp

@@ -30,9 +30,18 @@ inline void lwt_unattended()
 # pragma warning(push)
 # pragma warning(disable: 4996)
 
+# if defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# endif
+
     // disable message box on crash
     ::_seterrormode( /*SEM_NOGPFAULTERRORBOX*/ 0x0002 );
 
+# if defined(__clang__)
+#  pragma clang diagnostic pop
+# endif
+
 # pragma warning(pop)
 
 #endif

include/boost/core/launder.hpp

@@ -0,0 +1,55 @@
+#ifndef BOOST_CORE_LAUNDER_HPP_INCLUDED
+#define BOOST_CORE_LAUNDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_launder)
+#  define BOOST_CORE_HAS_BUILTIN_LAUNDER
+# endif
+#endif
+
+#if (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && !defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+# include <new>
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+#if defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+
+template<class T> T* launder( T* p )
+{
+    return __builtin_launder( p );
+}
+
+#elif (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && defined(__cpp_lib_launder)
+
+template<class T> T* launder( T* p )
+{
+    return std::launder( p );
+}
+
+#else
+
+template<class T> T* launder( T* p )
+{
+    return p;
+}
+
+#endif
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_LAUNDER_HPP_INCLUDED

include/boost/core/max_align.hpp

@@ -0,0 +1,82 @@
+#ifndef BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
+#define BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/alignof.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
+
+// BOOST_CORE_HAS_FLOAT128
+
+#if defined(BOOST_HAS_FLOAT128)
+
+# define BOOST_CORE_HAS_FLOAT128
+
+#elif defined(__SIZEOF_FLOAT128__)
+
+# define BOOST_CORE_HAS_FLOAT128
+
+#elif defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 404) && defined(__i386__)
+
+# define BOOST_CORE_HAS_FLOAT128
+
+#endif
+
+// max_align_t, max_align
+
+namespace boost
+{
+namespace core
+{
+
+union max_align_t
+{
+    char c;
+    short s;
+    int i;
+    long l;
+
+#if !defined(BOOST_NO_LONG_LONG)
+
+    boost::long_long_type ll;
+
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+    boost::int128_type i128;
+
+#endif
+
+    float f;
+    double d;
+    long double ld;
+
+#if defined(BOOST_CORE_HAS_FLOAT128)
+
+    __float128 f128;
+
+#endif
+
+    void* p;
+    void (*pf) ();
+
+    int max_align_t::* pm;
+    void (max_align_t::*pmf)();
+};
+
+BOOST_CONSTEXPR_OR_CONST std::size_t max_align = BOOST_CORE_ALIGNOF( max_align_t );
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_MAX_ALIGN_HPP_INCLUDED

include/boost/core/memory_resource.hpp

@@ -0,0 +1,108 @@
+#ifndef BOOST_CORE_MEMORY_RESOURCE_HPP_INCLUDED
+#define BOOST_CORE_MEMORY_RESOURCE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/max_align.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+// Define our own placement new to avoid the inclusion of <new>
+// (~9K extra lines) at Ion Gaztanhaga's request.
+//
+// We can use our own because [intro.object] p13 says:
+//
+// Any implicit or explicit invocation of a function named `operator new`
+// or `operator new[]` implicitly creates objects in the returned region of
+// storage and returns a pointer to a suitable created object.
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+struct placement_new_tag {};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+inline void* operator new( std::size_t, void* p, boost::core::detail::placement_new_tag )
+{
+    return p;
+}
+
+inline void operator delete( void*, void*, boost::core::detail::placement_new_tag )
+{
+}
+
+namespace boost
+{
+namespace core
+{
+
+class memory_resource
+{
+public:
+
+#if defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
+
+    virtual ~memory_resource() {}
+
+#else
+
+    virtual ~memory_resource() = default;
+
+#endif
+
+    BOOST_ATTRIBUTE_NODISCARD void* allocate( std::size_t bytes, std::size_t alignment = max_align )
+    {
+        // https://github.com/boostorg/container/issues/199
+        // https://cplusplus.github.io/LWG/issue3471
+
+        return ::operator new( bytes, do_allocate( bytes, alignment ), core::detail::placement_new_tag() );
+    }
+
+    void deallocate( void* p, std::size_t bytes, std::size_t alignment = max_align )
+    {
+        do_deallocate( p, bytes, alignment );
+    }
+
+    bool is_equal( memory_resource const & other ) const BOOST_NOEXCEPT
+    {
+        return do_is_equal( other );
+    }
+
+private:
+
+    virtual void* do_allocate( std::size_t bytes, std::size_t alignment ) = 0;
+    virtual void do_deallocate( void* p, std::size_t bytes, std::size_t alignment ) = 0;
+
+    virtual bool do_is_equal( memory_resource const & other ) const BOOST_NOEXCEPT = 0;
+};
+
+inline bool operator==( memory_resource const& a, memory_resource const& b ) BOOST_NOEXCEPT
+{
+    return &a == &b || a.is_equal( b );
+}
+
+inline bool operator!=( memory_resource const& a, memory_resource const& b ) BOOST_NOEXCEPT
+{
+    return !( a == b );
+}
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_MEMORY_RESOURCE_HPP_INCLUDED

test/Jamfile.v2

@@ -352,5 +352,12 @@ run-fail verbose_terminate_handler_fail.cpp : : : <exception-handling>off : verb
 run-fail verbose_terminate_handler_fail.cpp : : : <rtti>off : verbose_terminate_handler_fail_nr ;
 run-fail verbose_terminate_handler_fail.cpp : : : <exception-handling>off <rtti>off : verbose_terminate_handler_fail_nxr ;
 
+run launder_test.cpp ;
+
+run alignof_test.cpp ;
+run max_align_test.cpp ;
+
+run memory_resource_test.cpp ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;

test/alignof_test.cpp

@@ -0,0 +1,98 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/alignof.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
+
+template<class T> struct struct_of
+{
+    T t;
+};
+
+template<class T> union union_of
+{
+    T t;
+};
+
+template<class T> void test2()
+{
+    BOOST_TEST_EQ( BOOST_CORE_ALIGNOF(T), boost::alignment_of<T>::value );
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF)
+
+    BOOST_TEST_EQ( BOOST_CORE_ALIGNOF(T), alignof(T) );
+
+#endif
+}
+
+template<class T> void test()
+{
+    test2<T>();
+    test2<T[2]>();
+    test2< struct_of<T> >();
+    test2< union_of<T> >();
+}
+
+struct X
+{
+};
+
+int main()
+{
+    test<char>();
+    test<short>();
+    test<int>();
+    test<long>();
+
+#if !defined(BOOST_NO_LONG_LONG)
+# if !( defined(__GNUC__) && defined(__i386__) )
+
+    // g++ -m32 has alignof(long long) = 8, but boost::alignment_of<long long>::value = 4
+    test<boost::long_long_type>();
+
+# endif
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+    test<boost::int128_type>();
+
+#endif
+
+    test<float>();
+
+#if !( defined(__GNUC__) && defined(__i386__) )
+
+    // g++ -m32 has alignof(double) = 8, but boost::alignment_of<double>::value = 4
+    test<double>();
+
+#endif
+
+    test<long double>();
+
+#if defined(BOOST_HAS_FLOAT128)
+
+    test<__float128>();
+
+#endif
+
+    test<void*>();
+    test<void(*)()>();
+
+#if !defined(_MSC_VER)
+
+    // under MSVC, alignof is 8, boost::alignment_of is 4
+    // under clang-cl, alignof is 4, boost::alignment_of is 8 (!)
+
+    test<int X::*>();
+
+#endif
+
+    test<void (X::*)()>();
+
+    return boost::report_errors();
+}

test/alloc_construct_cxx11_test.cpp

@@ -72,6 +72,7 @@ int main()
     BOOST_TEST_EQ(p->value(), 2);
     boost::alloc_destroy(a, p);
     BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 1);
     return boost::report_errors();
 }
 #else

test/launder_test.cpp

@@ -0,0 +1,34 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/launder.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <new>
+
+struct X
+{
+    int v_;
+
+    explicit X( int v = 0 ): v_( v ) {}
+};
+
+int main()
+{
+    X x;
+
+    typedef X const CX;
+
+    ::new( &x ) CX( 1 );
+    X const* px1 = &x;
+
+    BOOST_TEST_EQ( px1->v_, 1 );
+
+    ::new( &x ) CX( 2 );
+    X const* px2 = boost::core::launder( px1 );
+
+    BOOST_TEST_EQ( px1, px2 );
+    BOOST_TEST_EQ( px2->v_, 2 );
+
+    return boost::report_errors();
+}

test/max_align_test.cpp

@@ -0,0 +1,70 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/max_align.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
+
+#if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 40900
+# define BOOST_NO_STD_MAX_ALIGN_T
+#endif
+
+struct X
+{
+};
+
+int main()
+{
+    BOOST_TEST_EQ( boost::core::max_align, boost::alignment_of<boost::core::max_align_t>::value );
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<char>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<short>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<int>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<long>::value );
+
+#if !defined(BOOST_NO_LONG_LONG)
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<boost::long_long_type>::value );
+
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<boost::int128_type>::value );
+
+#endif
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<float>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<double>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<long double>::value );
+
+#if defined(BOOST_CORE_HAS_FLOAT128)
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<__float128>::value );
+
+#endif
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<void*>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<void(*)()>::value );
+
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<int X::*>::value );
+    BOOST_TEST_GE( boost::core::max_align, boost::alignment_of<void (X::*)()>::value );
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF) && !defined(BOOST_NO_STD_MAX_ALIGN_T)
+# if defined(BOOST_LIBSTDCXX_VERSION) && BOOST_LIBSTDCXX_VERSION < 70000
+
+    // libstdc++ 7 adds __float128 to std::max_align_t, but we always have it
+    BOOST_TEST_GE( boost::core::max_align, alignof( std::max_align_t ) );
+
+# else
+
+    BOOST_TEST_EQ( boost::core::max_align, alignof( std::max_align_t ) );
+
+# endif
+#endif
+
+    return boost::report_errors();
+}

test/memory_resource_test.cpp

@@ -0,0 +1,141 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/memory_resource.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <new>
+#include <cstddef>
+
+static bool do_allocate_called;
+static std::size_t do_allocate_bytes;
+static std::size_t do_allocate_alignment;
+
+static bool do_deallocate_called;
+static void* do_deallocate_p;
+static std::size_t do_deallocate_bytes;
+static std::size_t do_deallocate_alignment;
+
+struct R1: public boost::core::memory_resource
+{
+    void* do_allocate( std::size_t bytes, std::size_t alignment )
+    {
+        do_allocate_called = true;
+        do_allocate_bytes = bytes;
+        do_allocate_alignment = alignment;
+
+        return ::operator new( bytes );
+    }
+
+    void do_deallocate( void* p, std::size_t bytes, std::size_t alignment )
+    {
+        do_deallocate_called = true;
+        do_deallocate_p = p;
+        do_deallocate_bytes = bytes;
+        do_deallocate_alignment = alignment;
+
+        ::operator delete( p );
+    }
+
+    bool do_is_equal( memory_resource const & /*other*/ ) const BOOST_NOEXCEPT
+    {
+        return true;
+    }
+};
+
+struct R2: public boost::core::memory_resource
+{
+    void* do_allocate( std::size_t bytes, std::size_t /*alignment*/ )
+    {
+        return ::operator new( bytes );
+    }
+
+    void do_deallocate( void* p, std::size_t /*bytes*/, std::size_t /*alignment*/ )
+    {
+        ::operator delete( p );
+    }
+
+    bool do_is_equal( memory_resource const & other ) const BOOST_NOEXCEPT
+    {
+        return this == &other;
+    }
+};
+
+int main()
+{
+    {
+        R1 r1;
+
+        do_allocate_called = false;
+        do_allocate_bytes = 0;
+        do_allocate_alignment = 0;
+
+        void* p = r1.allocate( 31 );
+
+        BOOST_TEST( do_allocate_called );
+        BOOST_TEST_EQ( do_allocate_bytes, 31 );
+        BOOST_TEST_EQ( do_allocate_alignment, boost::core::max_align );
+
+        do_deallocate_called = false;
+        do_deallocate_p = 0;
+        do_deallocate_bytes = 0;
+        do_deallocate_alignment = 0;
+
+        r1.deallocate( p, 31 );
+
+        BOOST_TEST( do_deallocate_called );
+        BOOST_TEST_EQ( do_deallocate_p, p );
+        BOOST_TEST_EQ( do_deallocate_bytes, 31 );
+        BOOST_TEST_EQ( do_deallocate_alignment, boost::core::max_align );
+    }
+
+    {
+        R1 r1;
+
+        do_allocate_called = false;
+        do_allocate_bytes = 0;
+        do_allocate_alignment = 0;
+
+        void* p = r1.allocate( 1, 8 );
+
+        BOOST_TEST( do_allocate_called );
+        BOOST_TEST_EQ( do_allocate_bytes, 1 );
+        BOOST_TEST_EQ( do_allocate_alignment, 8 );
+
+        do_deallocate_called = false;
+        do_deallocate_p = 0;
+        do_deallocate_bytes = 0;
+        do_deallocate_alignment = 0;
+
+        r1.deallocate( p, 1, 8 );
+
+        BOOST_TEST( do_deallocate_called );
+        BOOST_TEST_EQ( do_deallocate_p, p );
+        BOOST_TEST_EQ( do_deallocate_bytes, 1 );
+        BOOST_TEST_EQ( do_deallocate_alignment, 8 );
+    }
+
+    {
+        R1 r1;
+        R1 r2;
+
+        BOOST_TEST( r1 == r1 );
+        BOOST_TEST_NOT( r1 != r1 );
+
+        BOOST_TEST( r1 == r2 );
+        BOOST_TEST_NOT( r1 != r2 );
+    }
+
+    {
+        R2 r1;
+        R2 r2;
+
+        BOOST_TEST( r1 == r1 );
+        BOOST_TEST_NOT( r1 != r1 );
+
+        BOOST_TEST_NOT( r1 == r2 );
+        BOOST_TEST( r1 != r2 );
+    }
+
+    return boost::report_errors();
+}