<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
   "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=UTF-8">

<style type="text/css">

body { color: #000000; background-color: #FFFFFF; }
del { text-decoration: line-through; color: #8B0040; }
ins { text-decoration: underline; color: #005100; }
dfn { font-style: italic; font-weight: bold; color: #004020; }
li { margin: 0 0 1ex 0; }

p.example { margin-left: 2em; }
pre.example { margin-left: 2em; }
div.example { margin-left: 2em; }

code.extract { background-color: #F5F6A2; }
pre.extract {
    margin-left: 2em; background-color: #F5F6A2;
    border: 1px solid #E1E28E;
}

div.clarification {
    margin-left: 1em; margin-right: 2em; color: #000040; background-color: #F8F8F8;
    border-left: 5px solid #FA8258; padding-left: 1.5em;
    padding-top: 1px; padding-bottom: 1px;
    margin-top: 1px; margin-bottom: 1px;
}
span.clarification { margin-left: 0; margin-right: 0; color: #000040; background-color: #F8F8F8; }

p.toc {
    margin-left: 2em;
    line-height: 1.2;
}

p.function { }
.attribute { margin-left: 2em; }
.attribute dt { float: left; font-style: italic;
  padding-right: 1ex; }
.attribute dd { margin-left: 0em; }

blockquote.std { color: #000000; background-color: #F1F1F1;
  border: 1px solid #D1D1D1;
  padding-left: 0.5em; padding-right: 0.5em; }
blockquote.stddel { text-decoration: line-through;
  color: #000000; background-color: #FFEBFF;
  border: 1px solid #ECD7EC;
  padding-left: 0.5em; padding-right: 0.5em; }

blockquote.stdins { text-decoration: underline;
  color: #000000; background-color: #C8FFC8;
  border: 1px solid #B3EBB3; padding: 0.5em; }

table { border: 1px solid black; border-spacing: 0px;
  margin-left: auto; margin-right: auto; }
th { text-align: left; vertical-align: top;
  padding-left: 0.8em; border: none; }
td { text-align: left; vertical-align: top;
  padding-left: 0.8em; border: none; }

</style>

<title>Towards meaningful fancy pointers</title>
</head>
<body>

<b>Document number:</b> P0773R0 <br>
<b>Date:</b> 2017-10-05 <br>
<b>Project:</b> ISO JTC1/SC22/WG21, Programming Language C++ <br>
<b>Audience:</b> Library Evolution Working Group <br>
<b>Reply to:</b> Arthur O'Dwyer &lt;arthur.j.odwyer@gmail.com&gt;, Bob Steagall &lt;bob.steagall.cpp@gmail.com&gt; <br>

<h1>Towards meaningful fancy pointers</h1>

<p class="toc">
<a href="#Summary">Summary. Intended reading order.</a><br>
<a href="#Objects">Objects and values. A handle is a value that points to an object. Casting.</a><br>
<a href="#Storage">Storage representation.</a><br>
<a href="#Allocator">An allocator is a handle to a memory resource.</a><br>
<a href="#Pointer">Pointer values may be dereferenceable and/or deallocatable.</a><br>
<a href="#Purposes">Purposes of fancy pointer types.</a><br>
&nbsp;&nbsp;&nbsp;&nbsp;<a href="#A">Scenario A. "Offset" pointers with a modified bit-level representation.</a><br>
&nbsp;&nbsp;&nbsp;&nbsp;<a href="#B">Scenario B. Small-data-area "near" pointers.</a><br>
&nbsp;&nbsp;&nbsp;&nbsp;<a href="#C">Scenario C. High-memory-area "far" pointers.</a><br>
&nbsp;&nbsp;&nbsp;&nbsp;<a href="#D">Scenario D. "Fat" pointers carrying metadata for dereference-time.</a><br>
&nbsp;&nbsp;&nbsp;&nbsp;<a href="#E">Scenario E. "Segmented" pointers carrying metadata for deallocate-time.</a><br>
<a href="#Any">Is any kind of fancy pointer compatible with C++?</a><br>
<a href="#Requirements">Requirements on fancy pointer types if <i>fancy-pointer-support</i> were adopted.</a><br>
<a href="#basic_string"><code>basic_string</code> requires trivial default constructibility.</a><br>
<a href="#Iterators">Appendix. Representation-awareness of container and iterator types, in some present-day library implementations.</a><br>
<a href="#References">Appendix. References and further reading.</a><br>
<a href="#Acknowledgments">Acknowledgments.</a><br>
</p>


<h2><a name="Summary">Summary. Intended reading order.</a></h2>

<p>
This is a position paper explaining my take on fancy pointers in C++.
Indented, grayed paragraphs represent "clarifications" that should be skipped on your first reading.
</p>

<div class="clarification"><p>
For example, this grayed paragraph should be skipped on your first reading.
</p></div>
<div>&nbsp;</div>

<p>
I contend that the Standard's current wording related to fancy pointer types is so vague and unconstraining
as to be effectively meaningless. For example, the table in [allocator.requirements] requires that the
fancy pointer <code>p</code> passed to <code>deallocate</code> "shall be a value returned by an earlier call
to <code>allocate</code>...", but the Standard lacks any formal notion of what it means to preserve the "value"
of a fancy pointer. (In this paper's Scenarios C, D, and E, casting the allocated fancy pointer to
<i>native pointer</i> type and then back to fancy pointer type is not a value-preserving operation.)
Some operations on allocators seem to have implicit requirements; for example, <code>allocate_shared</code>
implicitly requires that fancy pointers be convertible to native pointers. Some vendors' container
implementations require things of fancy pointer types beyond the Standard; for example, <code>basic_string</code>
usually requires that its pointer type be trivially constructible.
</p>

<p>
This paper tries to start a discussion of formal semantics for "fancy pointer" types in C++, and
what it means for a container or algorithm to be "allocator-aware."
</p>

<div class="clarification">
<p>
I propose a taxonomy of fancy pointer types into five not-mutually-exclusive categories, along the axes of
<i>storage representation</i>, <i>addressable range</i>, and <i>carried metadata</i>.
</p>
<ul>
    <li>
(A) Fancy pointers with a different bit-level representation than native pointers: <b>offset</b> pointers.
This is explicitly supported today. Many types (std::vector) work already; some non-container types
(std::shared_ptr) do not work.
    </li>
    <li>
(B) Fancy pointers addressing a narrower range of memory (a Small Data Area): <b>near</b> pointers.
This is plausible. Some containers (std::vector) implicitly work already; some (std::list) work only in
certain runtime situations.
    </li>
    <li>
(C) Fancy pointers addressing a wider range of memory: <b>far</b> pointers.
This turns out to be impossible in C++ because every object must have a native address.
    </li>
    <li>
(D) Augmented fancy pointers whose metadata affects arithmetic: <b>fat</b> pointers.
This is plausible but expensive, and not worth the implementation effort for vendors.
    </li>
    <li>
(E) Augmented fancy pointers whose metadata affects only deallocation: <b>segmented</b> pointers.
This is plausible. Some containers (std::vector) work already; some (std::list) require only
trivial modifications; some (std::shared_ptr) require major fixes.
    </li>
</ul>
<p>
I propose two self-consistent future directions for fancy pointers. In one direction,
we keep the status quo that no scenario except (A) is supported, and perhaps move toward
separation of the <i>pointer storage type</i> from the <i>allocation mechanism</i>.
In my preferred direction, we require that vendors support scenarios (B) and (E) as well
as (A).
</p>

<p>
In the sections that follow, I will lay out the case for these recommendations.
</p>
</div>


<h2><a name="Objects">Objects and values. A handle is a value that points to an object. Casting.</a></h2>

<p>
By <dfn>object</dfn> I mean something like we see in object-oriented programming: an <i>object</i> has
a unique identity, and this identity is preserved even as the internal state of the object is mutated.
Objects with different identities are never interchangeable.
In C++, an object is often represented in code by a C++ variable or piece of memory, in which case the
object's identity is tantamount to that variable's memory address. However, there also exist objects
that are not variables. For example, "the program call stack" could be considered an object; it is
mutated whenever a function is called or returns. "The heap" is another object; it is mutated by
<code>operator new</code> and <code>operator delete</code>.
</p>

<p>
By <dfn>value</dfn> I mean something like we see in "value semantics": a <i>value</i> is an almost
Platonic ideal, such as <code>5</code> or <code>"hello"</code>. Values can exist independently of any
particular storage. Identical values are interchangeable; saying that value <code>a</code> is equal to
value <code>b</code> is tantamount to saying that value <code>a</code> <i>is</i> value <code>b</code>.
</p>

<div class="clarification"><p>
Sometimes we say that an object "has a value," or refer to an object's state as "its value." I will
try not to do either of those things in this paper.
</p></div>

<p>
By <dfn>handle</dfn> I mean a value representing the identity of an <i>object</i>.
You cannot have two different objects with the same identity, but you can have two copies of a handle
— two handles — that refer to the same object. Handles that refer to the same object are "equal,"
and thus (philosophically speaking) interchangeable.
</p>

<div class="clarification"><p>
In C++, a <i>handle</i> is often represented in code by (the value of) a C++ native pointer.
A handle does nothing but identify an object; therefore a handle can be copied; therefore a handle
does not "own" its referent.
</p></div>

<p>
A <dfn>type</dfn> is essentially a set of values. In C++ we usually say that a value "has a type,"
but in this case I'm being more Platonic. Suppose I make a type <code>digit</code> which is
the set of values 0 through 9; and I make another type <code>evendigit</code> which is
the set of values 0,2,4,6,8. The value 4 belongs to both types; the value 4 is representable
in both types.
</p>

<div class="clarification"><p>
This definition of <i>type</i> is problematic in C++ because we are used to strong static typing,
where a value really <i>does</i> "have a type." We want to say that the value 4 is representable
in both <code>digit</code> and <code>evendigit</code> — that <code>digit(4)</code> and
<code>evendigit(4)</code> represent "the same value," even though they have different C++ types
and may not even be comparable via <code>operator==</code>. Therefore, C++ introduces the idea
of <i>casting</i>.
</p></div>

<p>
A value of type A may be <dfn>cast to</dfn> type B. The result is a value
of type B which nevertheless is in some abstract sense <i>the same</i> as the value of type A.
Value-sameness is preserved through casting operations, when possible. If the source value
is not representable in the destination type, then value-sameness cannot be preserved; such
a cast might be prohibited by the language, or it might just throw away some parts of the value.
</p>

<div class="clarification"><p>
For example, casting the value <code>3.00</code> from <code>double</code> to <code>int</code>
and back will preserve its value, because the value "3" is representable in both types.
Casting the value <code>3.14</code> from <code>double</code> to <code>int</code> and back
will preserve part of its value but throw away some of it. In C++, "casting" of the kind
we're talking about is usually represented via <code>static_cast</code>.
</p></div>

<p>
If a type T is the Cartesian product of types U and V, <i>and</i> there is a natural mapping
from T to U, we say that T is an <dfn>augmented type</dfn> with respect to U.
<i>Casting</i> an augmented type T to its corresponding non-augmented type U throws away the
"V part" of the T value but preserves the "U part." Casting from U to T may be possible,
but will fail to correctly reconstitute the "V part" of the data. I will use the term
<dfn>metadata</dfn> to refer to the "V part" of the data, the part that is thrown away
when casting to the non-augmented type.
</p>

<div class="clarification"><p>
For example, <code>double</code> is more or less an augmented type with respect to <code>int</code>.
Casting the value <code>3.14</code> from <code>double</code> to <code>int</code>
will preserve the <code>int</code> part of its value but throw away the fractional part.
(When considering <code>double</code> as an augmented <code>int</code>, the fractional part
is the <i>metadata</i>.)
Casting from <code>int</code> back to the augmented type <code>double</code> is possible,
but will reconstitute the metadata as ".00" instead of the correct ".14".
</p>

<p>
Most well-known product types, such as <code>std::tuple&lt;U,V&gt;</code>, are not really
augmented types because there is no "natural" mapping from <code>std::tuple&lt;U,V&gt;</code>
to <code>U</code>. In C++ terms, <code>static_cast</code>'ing from <code>std::tuple&lt;U,V&gt;</code>
to <code>U</code> will not compile. But the following <code>Augmented&lt;U, Meta&gt;</code> is
definitely an <i>augmented type</i> with respect to <code>U</code>:
</p>
<pre>
    template&lt;class U, class Meta&gt;
    struct Augmented {
        U u_;
        Meta meta_;
        Augmented(U u, Meta m) : u_(u), meta_(m) {}
        operator U() const { return u_; }
    };
</pre>

<p>
In C++, a derived type is often an augmented type with respect to its public base type(s).
Casting from derived to base results in <i>slicing</i> away of the "non-base parts" of the instance,
but preserves the "base parts." If casting from derived to base is forbidden (for example by
deleting the base type's copy constructor), then the derived type is <i>not</i> an augmented type
with respect to the base type.
</p>
</div>


<h2><a name="Storage">Storage representation.</a></h2>

<p>
In C++, a type defines not only a set of <i>values</i> but also a mapping from values to
bit-level <dfn>storage representations</dfn>. (For example, while I consider <code>(double)3</code> and
<code>(int)3</code> to be the same <i>value</i>, they have different bit-level <i>storage representations</i>
when they are stored into memory as part of a C++ object.)
</p>

<p>
In some programming systems the most important thing about a C++ type is not its range of possible values
but its mapping from values to <i>storage representations</i>.
</p>

<div class="clarification"><p>
An example of significant <i>storage representation</i> is <code>boost::interprocess::offset_ptr&lt;T&gt;</code>,
which has the same range of values as the native pointer type <code>T*</code> but a different bit-level storage
representation. Since <code>(T*)(&x)</code> and <code>offset_ptr&lt;T&gt;(&x)</code> are the same <i>value</i>,
we should expect that they can be interconverted using <code>static_cast</code>.
In fact, under Boost 1.64, <code>static_cast&lt;offset_ptr&lt;T&gt;&gt;((T*){})</code> is accepted but
<code>static_cast&lt;int*&gt;(offset_ptr&lt;T&gt;{})</code> is ill-formed. I believe this is a defect in the
current implementation of <code>boost::interprocess::offset_ptr</code>.
</p></div>


<h2><a name="Allocator">An allocator is a handle to a memory resource.</a></h2>

<p>
A <dfn>memory resource</dfn> is an object that affords two functions: <i>allocation</i> and <i>deallocation</i>
of memory chunks. How it does that is irrelevant for our purposes. An allocation mechanism must somehow
yield a <i>handle</i> that uniquely identifies the allocated memory chunk; the corresponding
deallocation mechanism must accept that same <i>handle</i> as input.
</p>

<div class="clarification"><p>
Instances of types derived from <code>std::pmr::memory_resource</code> are memory resources.
Instances of <code>boost::interprocess::segment_manager_base</code> are also memory resources.
But another well-known memory resource is just "the heap." "The heap" doesn't exist as a concrete C++ object,
but it still affords <i>allocation</i> via <code>operator new</code> and <i>deallocation</i>
via <code>operator delete</code>. Therefore I say that "the heap" is a <i>memory resource</i> as well.
</p></div>

<p>
An <dfn>allocator</dfn> is a handle to a memory resource. By this definition, an instance of
<code>std::allocator&lt;T&gt;</code> is an allocator, because it is a handle to "the heap."
An instance of <code>std::pmr::memory_resource*</code> also is an allocator, because it is a handle
to a <code>std::pmr::memory_resource</code>. (Recall that a <i>handle</i> is a value that
uniquely identifies an object.)
</p>

<p>
In order to enable generic programming with allocators, the STL introduced the <code>Allocator</code>
concept. This is a standardized interface that must be provided by any type that is going to be
used as the allocator of an STL container. A type that models <code>Allocator</code> must provide
actual <i>member functions</i> named <code>allocate</code> and <code>deallocate</code>. For example,
the type <code>std::pmr::memory_resource*</code> does not model <code>Allocator</code>, but
the type <code>std::pmr::polymorphic_allocator&lt;T&gt;</code> does model <code>Allocator</code>.
</p>

<div class="clarification"><p>
In C++ there is actually a whole family of concepts <code>Allocator&lt;T&gt;</code> each associated
with allocating and deallocating C++ objects of type <code>T</code>. However, it is implicitly
required that I can <i>cast</i> an object of type <code>some_allocator&lt;T&gt;</code> to type
<code>some_allocator&lt;U&gt;</code>. Casting alters type without altering value; that is,
casting a handle in this way produces a new handle which uniquely identifies the same
memory resource.
</p></div>

<p>
Determining the appropriate destination type for a cast is called <dfn>rebinding</dfn>.
C++ implicitly requires that if <code>x</code> (of type <code>X</code>
modeling <code>Allocator&lt;T&gt;</code>) is a handle to some memory resource <i>m</i>,
then after the variable definition <code>auto y = static_cast&lt;std::allocator_traits&lt;X&gt;::rebind_alloc&lt;U&gt;&gt;(x)</code>,
<code>y</code> (of type <code>Y</code> modeling <code>Allocator&lt;U&gt;</code>)
is a handle to that same memory resource <i>m</i>.
</p>

<div class="clarification"><p>
This definition of rebinding is compatible with "slab allocator"-style memory resources, where
<code>SlabAllocator&lt;int32_t&gt;::allocate</code> and <code>SlabAllocator&lt;int64_t&gt;::allocate</code>
allocate chunks out of different, non-overlapping slabs of memory. A single <i>memory resource</i>
then consists of a single <i>complete set</i> of slabs. The important thing is that we must
be able to take a handle to this <i>memory resource</i> and cast it around without affecting its
<i>value</i> (that is, the identity of the memory resource to which it refers).
</p>
<pre>
    SlabResource mr1;
    auto a32 = SlabAllocator&lt;int32_t&gt;(&mr1);  // get a handle to the memory resource
    auto b64 = SlabAllocator&lt;int64_t&gt;(a32);  // cast that handle to a new C++ type
    auto c32 = SlabAllocator&lt;int32_t&gt;(b64);  // cast the handle back to the original type
    // At this point, a32 and c32 must both identify memory resource "mr1".
    // c32 is NOT ALLOWED to identify a different memory resource "mr2".
    // c32 is NOT ALLOWED to identify no memory resource (e.g. to have become "null" or otherwise unusable).
    // a32 and c32, being the same value in the same C++ type, must be truly interchangeable.
</pre>
</div>

<p>
The foregoing definitions imply that allocators are cheap to copy. Making a copy of an allocator does
not make a copy of the underlying memory resource. Allocators are rebindable and castable: you can
change the C++ type of an allocator instance without changing its fundamental value. These rules should
be familiar because this is also how C++ treats <i>iterators</i> and <i>pointers</i>: handles,
cheap to copy, castable.
</p>

<div class="clarification"><p>
We can create an allocator <i>type</i> which has many possible <i>values</i>: for example,
<code>std::pmr::polymorphic_allocator</code>. We can also create an allocator type whose set of
possible values has only one member: for example, <code>std::allocator</code> is an allocator
type whose only possible value is "the identity of 'the heap'." Since the set of possible values
has size 1, an instance of the type contains log(1) = 0 bits of information and thus
<code>std::is_empty_v&lt;std::allocator&lt;T&gt;&gt;</code>.
Casting an <code>std::allocator&lt;T&gt;</code>
to <code>std::allocator&lt;U&gt;</code> preserves its value, in that the value resulting from the
cast continues to identify "the heap."
</p></div>


<h2><a name="Pointer">Pointer values may be dereferenceable and/or deallocatable.</a></h2>

<p>
A <dfn>native pointer</dfn> is a value of a native pointer type.
A <dfn>native pointer type</dfn> is a C++ type of the form <code>T*</code> where <code>T</code>
is an object type. For the purposes of this paper, we don't care about function pointers or
member pointers, because those aren't suitable subjects for allocation and deallocation.
</p>

<p>
A <dfn>pointer</dfn> is a handle that satisfies specific syntactic constraints; it must afford
(many of) the same operations as a C++ native pointer. Specifically, the following operations
must be supported:
<pre>
    decltype(p){}                 (value-initialization must create a null value)
    p == nullptr, if (p), !p      (comparison against null)
    p == p, p != p                (comparison against another pointer value of the same type)
    *p                            (dereference)
</pre>
Native pointers also support the <dfn>pointer arithmetic</dfn> operations, which is to say,
native pointers model the <code>RandomAccessIterator</code> concept:
<pre>
    ++p, p++, --p, p--            (bidirectional mutation)
    p += i, p -= i                (random-access mutation)
    p + i, i + p, p - i           (random-access construction)
    p - p                         (random-access difference)
    p < p, p <= p, p > p, p >= p  (random-access inequality comparison)
    p[i]                          (random-access dereference)
</pre>
</p>

<p>
A <dfn>fancy pointer</dfn> is a pointer that is not a native pointer.
A <dfn>fancy pointer type</dfn> is a C++ type all of whose values are fancy pointers.
When I need to refer to an example C++ fancy pointer type, I will use names such as
<code>FancyPtrInt</code> (for a pointer whose values identify objects of type <code>int</code>)
or <code>FancyPtrT</code> (for a pointer whose values identify objects of type <code>T</code>).
</p>

<div class="clarification"><p>
Fancy pointer types are described in [allocator.requirements]/5 as types modeling both
<code>NullablePointer</code> and <code>RandomAccessIterator</code>; that is, in today's C++, a
fancy pointer type must provide pointer arithmetic.
I will argue that fancy pointer types have no philosophical need to provide pointer arithmetic.
</p></div>

<p>
Some pointer values are <dfn>dereferenceable</dfn> and some are not.
</p>

<p>
<dfn>Null</dfn> is a specific pointer value. Every pointer type contains the value <i>null</i>.
Casting the null value preserves its value. The null value is never dereferenceable.
</p>

<div class="clarification"><p>
In the native pointer type <code>int*</code>, we can construct non-dereferenceable values in at least
the following ways:
</p>
<pre>
    int arr[10];
    int *p1 = nullptr;   // the null pointer is never dereferenceable
    int *p2 = arr + 10;  // a "one-past-the-end" pointer is not dereferenceable
</pre>
<p>
There are also ways to have an object <code>p</code> of type <code>int*</code> where the behavior
of <code>*p</code> is undefined, such as
</p>
<pre>
    int *p3 = new int; delete p3;  // a deallocated pointer is not dereferenceable
    int *p4;                       // an uninitialized pointer is not dereferenceable
</pre>
<p>
but these examples are not interesting in the context of this paper. Philosophically it is arguable
that these examples treat <code>p3</code> and <code>p4</code> as <i>stateful objects</i>, and that
the names <code>p3</code> and <code>p4</code> do not identify pointer <i>values</i> at all.
In this paper I am concerned with pointer values like <code>p1</code> and <code>p2</code>; I do not
consider <code>p3</code> and <code>p4</code> to be relevant.
</p></div>

<p>
Some pointer values are <dfn>deallocatable</dfn> (with respect to a given memory resource) and some
are not. Any pointer value successfully returned from the <i>allocation</i> mechanism of a
memory resource <code>mr</code> is deallocatable with respect to <code>mr</code>.
</p>

<div class="clarification"><p>
Many <i>dereferenceable</i> pointers will not be <i>deallocatable</i>. (For example, any pointer
identifying a non-allocated object will not be deallocatable by any allocator. Also, a pointer
allocated by memory resource A is unlikely to be deallocatable by memory resource B.)
Some <i>deallocatable</i> pointers will not be <i>dereferenceable</i>. (For example, the native pointer
returned from <code>malloc(0)</code> on some implementations is deallocatable with respect to
<code>malloc()/free()</code> but not dereferenceable.)
</p></div>


<h2><a name="Purposes">Purposes of fancy pointer types.</a></h2>

<p>
What are the possible motivations for fancy pointer types?
Why might a programmer desire a pointer type that is different from any native pointer type?
Here are five scenarios I consider plausible.
</p>


<h3><a name="A">Scenario A. "Offset" pointers with a modified bit-level representation.</a></h3>

<p>
Some programming systems use <dfn>offset pointers</dfn>, which are equivalent
to native pointers but whose bit-level storage representation is different. For example, the storage
representation of a <code>boost::interprocess::offset_ptr</code> identifying an object <code>x</code>
is the memory address of <code>x</code> minus the address of the <code>offset_ptr</code> itself.
</p>

<div class="clarification"><p>
This means that the storage representation of a <code>boost::interprocess::offset_ptr</code> object depends
on the object's own memory address. <code>offset_ptr</code> objects are not trivially copyable. Yet, at the
Platonic level, <code>offset_ptr</code> can be said to have the same set of possible <i>values</i>
as a native pointer type.
</p>

<p>
The benefit of <code>boost::interprocess::offset_ptr</code> is that if a memory region is mapped
into the address space of two different processes, then every <code>offset_ptr</code> residing in the
mapped region will identify the same object no matter which process is asking — as long as the
identified object <i>also</i> resides in the mapped region.
</p></div>

<p>
Can we use <i>offset fancy pointer types</i> to enable safe sharing of memory regions?
</p>

<p>
<b>Yes; but the requirements on vendors are unclear, and there are pitfalls for the programmer.</b>
</p>

<p>
A C++ object type is <dfn>representation-aware</dfn> if its object representation stores handles
to allocated memory only in objects of the appropriate fancy pointer type. Instances of
<i>representation-aware</i> types instantiated with <code>boost::interprocess::offset_ptr</code>
can safely be stored in shared memory segments; instances of <i>non-representation-aware</i>
types cannot safely be stored in shared memory segments.
</p>

<p>
The following standard types are required or expected to be <i>representation-aware</i>:
</p>
<ul>
    <li>Allocator-aware container types. (But libstdc++'s containers break this rule.)</li>
    <li>Container "node handle" types.</li>
    <li><code>basic_string</code>. <span class="clarification">
The usual "small string optimization" does not affect <i>representation-awareness</i>.
In both libc++ and libstdc++, the relevant type-pun involves the representation of the <code>size_t capacity</code>
member, not the representation of the allocated <code>data</code> pointer.
</span></li>
    <li><code>unique_ptr</code>.</li>
</ul>


<p>
The following standard types are, in practice, <i>not</i> representation-aware:
</p>
<ul>
    <li>Container "iterator" types. (See <a href="#Iterators">Representation-awareness of iterators</a>.)</li>
    <li><code>shared_ptr</code>. <span class="clarification">
But <code>boost::interprocess::shared_ptr</code> is. An instance of <code>boost::interprocess::shared_ptr&lt;T,A,D&gt;</code>
holds fancy pointers (of type rebound from <code>allocator_traits&lt;A&gt;::pointer</code>) to the controlled object
and to the control block.
</span></li>
    <li><code>packaged_task</code>, <code>promise</code> and <code>future</code>.</li>
    <li><code>function</code> and <code>any</code>.</li>
    <li><code>lock_guard</code>, <code>unique_lock</code>, <code>string_view</code>, etc.</li>
    <li><code>pmr::polymorphic_allocator</code>. <span class="clarification">
But <code>boost::interprocess::allocator</code> is. An instance of <code>boost::interprocess::allocator&lt;T,MR&gt;</code>
holds a fancy pointer (of type rebound from <code>MR::void_pointer</code>) to the underlying memory resource of
type <code>MR</code>(typically <code>boost::interprocess::segment_manager</code>).
</span></li>
    <li>Any polymorphic class type — for example <code>pmr::memory_resource</code>, <code>ostream</code>, etc. —
    because of the vptr.</li>
</ul>

<p>
The <i>representation-awareness</i> of a C++ class type is orthogonal to its memory allocation strategy.
</p>

<div class="clarification"><p>
For example, <code>shared_ptr</code> requires allocation (and supports allocation with an allocator via
<code>allocate_shared</code>) but <code>shared_ptr</code> is not representation-aware.
Vice versa, <code>boost::interprocess::allocator</code> is representation-aware (it contains a non-static
data member of fancy pointer type) but not allocator-aware (the fancy pointer is not obtained via
<code>allocator_traits&lt;A&gt;::pointer</code> for any type <code>A</code>, and does not point to an
allocation).
</p>

<p>
It is a shame that the standard <i>representation-aware</i> types inherit their storage type from
<code>allocator_traits&lt;A&gt;::pointer</code> instead of from a separate template parameter <code>P</code>.
I don't see how to fix this without breaking ABI and requiring a lot of work from vendors.
A small step in this direction would be to add an allocator adaptor <code>std::storage_allocator_adaptor&lt;P,A&gt;</code>
identical to <code>A</code> except that its <code>pointer</code> typedef is
<code>pointer_traits&lt;P&gt;::rebind&lt;A::value_type&gt;</code>. This would ease using
<code>offset_ptr</code> with representation-aware containers; but not help with types that were
not already representation-aware, such as <code>shared_ptr</code>.
</p></div>

<p>
The programmer is responsible for discovering whether any given C++ type is <i>representation-aware</i>. There is
no programmatic way to determine the <i>representation-awareness</i> of a given type. The consequence of
wrongly guessing that a type is <i>representation-aware</i> is typically a segfault.
</p>

<p>
There are three alternatives applicable to the current situation:
</p>
<ol>
    <li>
        Offset fancy pointer types are allowed, but difficult to use safely.
        (The current solution.)
    </li>
    <li>
        Offset fancy pointer types are not allowed. The Standard removes support
        for <code>boost::interprocess::offset_ptr</code>. This solution breaks
        existing code.
    </li>
    <li>
        Offset fancy pointer types become more fully supported.
        Many additional standard types gain <i>representation-awareness</i>; for example,
        <code>std::shared_ptr</code> gains a template parameter controlling the
        type of its internal pointers. This solution requires vendors to do a
        lot of new work, and breaks ABI compatibility. This solution does not address
        the fundamental problem that there is no programmatic way to determine or
        ensure the <i>representation-awareness</i> of a given type.
    </li>
    <li>
        The pointer type associated with the <i>object representation</i> of a class
        is somehow divorced from the pointer type associated with the allocation mechanism.
        Each allocator-aware type gains a template parameter <code>P</code> controlling
        the type of its internal pointers, in addition to the old template parameter
        <code>A</code> controlling its allocation mechanism. This solution requires
        vendors to do a lot of new work, and breaks ABI compatibility. This solution
        again does not address the fundamental problem that there is no programmatic way
        to determine or ensure the <i>representation-awareness</i> of a given type.
    </li>
</ol>
</p>

<p>
In my opinion, solution (1), the de-facto solution today, is the only tenable solution.
Solution (4) is philosophically attractive but does not make any headway on the fundamental
problem and therefore offers no benefit at present.
We are left with solution (1): <b>Offset fancy pointer types are allowed, but difficult to use safely.</b>
</p>


<h3><a name="B">Scenario B. Small-data-area "near" pointers.</a></h3>

<p>
Some programmers deal in memory "arenas" that are much smaller than the entire range of main memory.
The programmer may wish to use a C++ pointer type that reflects that smaller range of possible
pointer values. Since this pointer type contains fewer than (address-space) values, its representation
in memory requires fewer than log(address-space) bits. For example, a pointer type that can hold
one of only 32,767 distinct addresses (or <i>null</i>) philosophically ought to require only
log(32768) = 15 bits of storage per pointer. A C++ fancy pointer type with fewer value bits than a
native pointer is called a <dfn>near fancy pointer</dfn>.
</p>

<div class="clarification"><p>
On a 32-bit microcontroller, the programmer might define a frequently used list container like this:
</p>
<pre>
    #include &lt;list&gt;
    #include &lt;memory_resource&gt;

    // Reserve representation 0x0000 for "null".
    std::pmr::monotonic_buffer_resource g_smallData((void*)0x0001, 32767, std::pmr::null_memory_resource());

    int main() {
        std::pmr::list&lt;int32_t&gt; widgets(&g_smallData);

        widgets.push_back(1);
    }
</pre>
<p>
Any allocations made by <code>widgets</code> always reside within the "small data area,"
addresses 0x00000001 through 0x00007FFF. This means that in principle, each pointer should
consume only 16 bits of memory footprint. Since each list node contains two
pointers, this would be a savings of 4 bytes per node, allowing us to fit twice as many
list elements into the small data area as we could naively fit.
</p>

<p>
The Standard Library doesn't provide a fancy-pointer version of <code>memory_resource</code>, but
we can easily roll our own. We'd create a near fancy pointer type like this:
</p>
<pre>
    template&lt;class T&gt;
    class NearPtr {
        int16_t ptr_ = 0;
    public:
        NearPtr() = default;
        NearPtr(std::nullptr_t) {}
        explicit NearPtr(T *p) : ptr_((int16_t)(intptr_t)p) {}
        T& operator*() const {
            return *(T*)(intptr_t)ptr_;
        }

        template&lt;class U&gt;
        explicit NearPtr(const NearPtr&lt;U&gt;&amp; rhs) : ptr_(rhs.ptr_) {}
    };

    // Reserve representation 0x0000 for "null".
    std::pmr::monotonic_buffer_resource g_smallData((void*)0x0001, 32767, std::pmr::null_memory_resource());

    template&lt;class T&gt;
    struct NearAllocator {
        using value_type = T;
        using pointer = NearPtr&lt;T&gt;;
        using void_pointer = NearPtr&lt;void&gt;;

        pointer allocate(size_t n) {
            void *vp = g_smallData.allocate(n * sizeof(T), alignof(T));
            return static_cast&lt;pointer&gt;(static_cast&lt;void_pointer&gt;(vp));
        }
        void deallocate(pointer p, size_t n) {
            g_smallData.deallocate(static_cast&lt;void*&gt;(static_cast&lt;T*&gt;(p)), n * sizeof(T), alignof(T));
        }
    };

    int main() {
        std::list&lt;int32_t, NearAllocator&lt;int32_t&gt;&gt; widgets;

        widgets.push_back(1);
    }
</pre>
</div>

<p>
Can we use <i>near fancy pointer</i> types to address objects that are located in a "small" fixed subset of main memory?
</p>

<p>
<b>Yes; but there are practical limitations.</b>
</p>

<p>
<i>Near fancy pointer</i> types (such as the <code>NearPtr</code> above) are no problem for
these standard containers: <code>deque</code>, <code>forward_list</code>, <code>vector</code>.
But these other standard containers <i>will</i> have technical difficulties with near fancy pointers:
<code>list</code>, <code>map</code>, <code>set</code>, <code>unordered_set</code>, <code>unordered_map</code>.
These containers have trouble because their natural implementation requires a linked list
where most nodes in the linked list are allocated (i.e. fancy pointers identifying objects in
the "small data area") and some "sentinel node" is not (i.e. the sentinel node is not located
in the "small data area" and thus is not addressable by the near fancy pointer type).
</p>

<p>
Containers with this difficulty shall be called <dfn>sentinel-node containers</dfn>.
</p>

<div display="block" align="center">
<img src="data:image/png;base64,
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
" width="40%" display="inline"></img>
<img src="data:image/png;base64,
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
" width="40%" display="inline"></img>
</div>

<p>
An implementation of <code>std::list</code> where the sentinel node is allocated (rather than being part of
the container instance's member data) is not a <i>sentinel-node container</i>.
</p>

<p>
We have the following possible solutions to this problem:
<ol>
    <li>
        Near fancy pointer types are just not allowed.
        <span class="clarification">(This is the reference solution.
        Any solution less appealing than this one can be summarily dismissed.)</span>
    </li>
    <li>
        Near fancy pointer types are not allowed for <i>sentinel-node containers</i>, but
        are allowed for other containers. The Standard would have to specify for each
        container whether it was list-like or not.
    </li>
    <li>
        Sentinel-node containers use only native pointers for addressing.
        These native pointers are cast back to fancy pointers at deallocation time.
        This solution loses the memory-footprint benefit we were hoping to get
        from using fancy pointers. This solution is incompatible with Scenarios A and E.
        (Therefore this solution is summarily dismissed.)
    </li>
    <li>
        Each node of a sentinel-node container holds an extra bit indicating whether the node
        is allocated (in which case it is identified by a fancy pointer) or non-allocated
        (in which case it is identified by a native pointer).
        This solution loses the memory-footprint benefit we were hoping to get
        from using fancy pointers. This solution is incompatible with Scenario A.
        (Therefore this solution is summarily dismissed.)
    </li>
    <li>
        Near fancy pointer types are allowed for sentinel-node containers, but if the container
        cannot statically detect that its <code>pointer</code> type is wide enough to access
        all of main memory, then the container will switch to an implementation where the
        sentinel node is allocated using the same mechanism as other nodes.
        <span>This solution essentially requires that vendors provide two implementations
        of each sentinel-node container: one for efficiency and one for use with near fancy
        pointers.</span>
    </li>
    <li>
        Near fancy pointer types are allowed for sentinel-node containers, but if the container
        itself, or any subobject thereof, cannot be addressed with (a rebinding of) its own
        <code>pointer</code> type, then the behavior is undefined.
        <span class="clarification">This solution does not require any new work from vendors,
        but it does introduce a new source of undefined behavior.</span>
        <div class="clarification"><pre>
int main() {
    using L = std::list&lt;int32_t, NearAllocator&lt;int32_t&gt;&gt;;

    L alpha = std::make_shared&lt;L&gt;();  // undefined behavior
    auto beta = std::make_shared&lt;L&gt;();  // undefined behavior
    auto gamma = std::allocate_shared&lt;L&gt;(NearAllocator&lt;L&gt;());  // OK!
}
        </pre></div>
    </li>
</ol>
</p>

<p>
In my opinion, solutions (1), (2), and (6) are all tenable. Solution (1) is the de-facto
solution today: <b>Near fancy pointer types are just not allowed.</b>
</p>


<h3><a name="C">Scenario C. High-memory-area "far" pointers.</a></h3>

<p>
Let <dfn>main memory</dfn> be defined as the set of all object addresses addressable by
C++ native pointer types. Some programmers deal in objects that are not located in main memory.
</p>

<div class="clarification"><p>
A historical example is the 80286, where 16-bit native pointers could identify only the
memory addresses between 0x0000 and 0xFFFF, but the computer itself had additional memory
ranging from address 0x1'0000 to address 0xF'FFFF, and some models had a "high memory area"
between 0x10'0000 and 0x10'FFEF. These additional addresses were not addressable with native
pointers such as <code>int*</code>. Compilers of the day provided additional built-in types
such as <code>far int*</code>, where <code>sizeof(far int*) &gt; sizeof(int*)</code>.
</p>

<p>
A possible future example is objects residing in some location which
<i>is not memory-mapped into the current process's virtual address space</i>.
Today this is unlikely to be a real problem for 64-bit address spaces — we just take
anything we care about (including the OS kernel, and also GPU memory if I understand correctly)
and map it into the current process's address space. It might be a problem looking forward
into the future of enormous (>18 exabytes?) non-volatile storage, or more likely looking
downward into the domain of 32-bit and 16-bit microcontrollers with smaller main memories.
</p></div>

<p>
Can we use fancy pointer types to address objects that are not located in main memory?
</p>

<p>
<b>No, we cannot use fancy pointer types to address objects that aren't located in main memory.</b>
</p>

<div class="clarification"><p>
Every fancy pointer type must provide an <code>operator*</code> that returns a reference to
an object. That is, we must have a function definition along these lines:
</p>
<pre>
    struct FancyPtrInt {
        int& FancyPtrInt::operator*() const {
            // some magic goes here
        }
        // ...
    };
</pre>
<p>
The expression <code>*fancyp</code> returns a reference to its identified object as type <code>int&</code>.
So its identified object must be addressable by a native pointer value — namely,
<code>std::addressof(*fancyp)</code>. Therefore, this attempt to use fancy pointers to address objects
outside main memory has failed.
</p></div>


<h3><a name="D">Scenario D. "Fat" pointers carrying metadata for dereference-time.</a></h3>

<p>
Some programming systems use "fat pointers" which are <i>augmented</i> versions of native pointers.
The <i>metadata</i> part of a fat pointer communicates the size of the original allocation so that
dereferences can be bounds-checked, and/or the type of the original allocation so that dereferences
can be type-checked.
</p>

<div class="clarification"><p>
For example, here is one possible "fat" fancy pointer type.
</p>
<pre>
    template&lt;class T&gt;
    class FatPtr {
        char *base_ = nullptr;
        int cur_ = 0;
        int max_ = 1;
    public:
        FatPtr() = default;
        FatPtr(std::nullptr_t) {}
        explicit FatPtr(T *p, int n) : base_((char*)p), max_(n * sizeof (T)) {}

        template&lt;class U&gt;
        explicit FatPtr(const FatPtr&lt;U&gt;&amp; rhs) :
            base_(rhs.base_), cur_(rhs.cur_), max_(rhs.max_) {
            if (cur_ % sizeof(T) != 0) throw "misaligned";
        }

        T& operator*() const {
            if (base_ == nullptr) {
                throw "null";
            } else if (cur_ &lt; 0 || max_ &lt;= cur_) {
                throw "out of bounds";
            } else if (cur_ % sizeof(T) != 0) {
                throw "misaligned";
            } else {
                return *(T*)(base_ + cur_);
            }
        }

        auto& operator++() {
            if (base_ == nullptr) throw "null";
            if (max_ &lt;= cur_ + sizeof(T)) throw "out of bounds";
            cur_ += sizeof(T);
            return *this;
        }

        // ...
    };

    template&lt;class T&gt;
    struct FatAllocator {
        using value_type = T;
        using pointer = FatPtr&lt;T&gt;;
        using void_pointer = FatPtr&lt;void&gt;;

        pointer allocate(size_t n) {
            T *p = std::allocator&lt;T&gt;().allocate(n);
            return pointer(p, n);
        }
        void deallocate(pointer p, size_t n) {
            if (p.cur_ != 0) throw "deallocating non-allocated pointer";
            std::allocator&lt;T&gt;().deallocate(p, n);
        }
    };
</pre>
<p>
This fat-pointer type plays well with list-like containers because its range of values includes all
of main memory.
</p></div>

<p>
In order to get the benefit of bounds-checking, the container must do pointer arithmetic only on
<code>FatPtr</code> values losslessly derived from the originally allocated <code>FatPtr</code>.
</p>

<div class="clarification">
<p>
In order to get the benefit of <i>type</i>-checking, the container must dereference only
<code>FatPtr</code> values losslessly derived from the originally allocated <code>FatPtr</code>, which
again implies doing pointer arithmetic only on <code>FatPtr</code>.
This will generally have a performance cost, especially in debug mode.
Worse, if we use fat pointers <i>only</i> for safety-checking, there will be no benefit to counter
the performance cost, unless the standard container itself has bugs.
</p>

<p>
The fat-pointer scenario is the only scenario in this paper where it makes sense to do pointer arithmetic
on fancy pointers. In every other case, it is equivalent — and generally more efficient, especially
in debug mode — to do pointer arithmetic only on native pointers.
</p>
</div>

<p>
Can we use <i>fat fancy pointer</i> types to bounds-check each access to an allocation?
</p>

<p>
<b>Yes; but I think it is not worth the performance cost.</b>
</p>

<p>
We have the following possible solutions to this problem:
<ol>
    <li>
        Fat fancy pointer types are technically permitted, but may be sliced to native pointers
        at any time. Every fancy pointer type is required to model <code>RandomAccessIterator</code>;
        containers may use either fancy pointers or native pointers for pointer arithmetic.
        <span class="clarification">This is the de-facto and most conservative solution.</span>
    </li>
    <li>
        Fat fancy pointer types are fully supported. Every fancy pointer type is required to model
        <code>RandomAccessIterator</code>. Containers must do pointer arithmetic only on fancy pointers
        derived from the original allocation.
        <span class="clarification">This solution has a performance cost in debug mode.
        This solution also has the cost that
        it transforms the <i>de-jure</i> requirement (that fancy pointer types model
        <code>RandomAccessIterator</code>) into a <i>de-facto</i> requirement. User-defined
        fancy pointer types that do not model all of <code>RandomAccessIterator</code> may stop working
        if this solution is implemented. This solution requires vendors to do a lot of new work.</span>
    </li>
    <li>
        Fat fancy pointer types are supported; but containers are required to use them for pointer-arithmetic
        only in the implementations of functions which might have undesirable behavior if done with
        native pointers. <span class="clarification">For example, the bounds-checked <code>vector::at</code>
        could use either native or fancy pointer arithmetic, but the unchecked <code>vector::operator[]</code>
        must dereference a fancy pointer losslessly derived from the original allocation.
        The Standard would have to specify "fancy" or "native" arithmetic for each container
        member function. This solution requires vendors to do some new work.</span>
    </li>
    <li>
        Fat fancy pointers are explicitly unsupported. Fancy pointers are no longer required to
        model <code>RandomAccessIterator</code> at all. Containers must slice fancy pointers
        to native pointers before performing any operation other than comparison, dereference,
        or deallocation. <span class="clarification">This solution requires vendors to do some new work.</a>
    </li>
</ol>
</p>

<p>
In my opinion, solutions (1), (3), and (4) are tenable. Solution (2) has too many practical disadvantages:
breaks working code, hurts performance, requires work from vendors. I claim that solution (4) is the best:
<b>Fat pointers should remain unsupported. Fancy pointer types should no longer be
required to model <code>RandomAccessIterator</code>.</b>
</p>


<h3><a name="E">Scenario E. "Segmented" pointers carrying metadata for deallocate-time.</a></h3>

<p>
Some programming systems use <i>augmented</i> pointers similar to Scenario D, but whose
<i>metadata</i> is used only by the deallocation mechanism. For example, a memory resource
managing several memory "segments" might store the identity of the current segment in the
allocated pointer, so that the pointer can be returned to the correct segment at deallocation
time. Because of this example, I call such fancy pointers <dfn>segmented pointers</dfn>.
</p>

<div class="clarification"><p>
For example, here is one possible "segmented" fancy pointer type.
<a href="https://github.com/Quuxplusone/from-scratch/blob/master/include/scratch/bits/containers/segmented-allocator.h"
>A full implementation is available on my GitHub under the name
<code>scratch::pmr::segmented_resource</code>.</a>
</p>
<pre>
    class Segment;

    template&lt;class T&gt;
    class SegmentedPtr {
        T *ptr_ = nullptr;
        Segment *seg_ = nullptr;
    public:
        SegmentedPtr() = default;
        SegmentedPtr(std::nullptr_t) {}
        explicit SegmentedPtr(T *p, Segment *seg) : ptr_(p), seg_(seg) {}

        template&lt;class U&gt;
        explicit SegmentedPtr(const SegmentedPtr&lt;U&gt;&amp; rhs) :
            ptr_(rhs.ptr_), seg_(rhs.seg_) {}

        auto segment() const { return seg_; }
        T& operator*() const { return *ptr_; }
        auto& operator++() { ++ptr_; return *this; }

        // ...

        static auto pointer_to(T& r) { return SegmentedPtr(&r, nullptr); }
    };

    class Segment {
        char buffer[10000];
        int index = 0;
        int freed = 0;
    public:
        bool can_allocate(size_t bytes) {
            return (sizeof buffer - index) >= bytes;
        }
        auto allocate(size_t bytes) {
            index += bytes;
            void *p = &buffer[index - bytes];
            return SegmentedPtr&lt;void&gt;(p, this);
        }
        void deallocate(void *, size_t bytes) {
            freed += bytes;
            if (freed == index) {
                index = freed = 0;
            }
        }
    };

    class SegmentedResource {
        std::list&lt;Segment&gt; m_segments;
    public:
        SegmentedPtr&lt;void&gt; allocate(size_t bytes, size_t align) {
            assert(align <= alignof(std::max_align_t));
            bytes += -bytes % alignof(std::max_align_t);
            assert(bytes <= 10000);

            for (auto&& seg : m_segments) {
                if (seg.can_allocate(bytes)) {
                    return seg.allocate(bytes);
                }
            }
            return m_segments.emplace_back().allocate(bytes);
        }
        void deallocate(SegmentedPtr&lt;void&gt; p, size_t bytes, size_t) {
            bytes += -bytes % alignof(std::max_align_t);
            p.segment()->deallocate(static_cast&lt;void*&gt;(p), bytes);
        }
    };

    template&lt;class T&gt;
    class SegmentedAllocator {
        SegmentedResource *mr_;
    public:
        using value_type = T;
        using pointer = SegmentedPtr&lt;T&gt;;

        SegmentedAllocator(SegmentedResource *mr): mr_(mr) {}

        pointer allocate(size_t n) {
            return pointer(mr_->allocate(n * sizeof(T), alignof(T)));
        }
        void deallocate(pointer p, size_t n) {
            return mr_->deallocate(p, n * sizeof(T), alignof(T));
        }
    };

    int main() {
        SegmentedResource mr;
        std::list&lt;int, SegmentedAllocator&lt;int&gt;&gt; widgets(&mr);

        widgets.push_back(1);
    }
</pre>
<p>
The important line is this one, in <code>SegmentedResource::deallocate</code>:
</p>
<pre>
            p.segment()->deallocate(static_cast&lt;void*&gt;(p), bytes);
</pre>
<p>
This line returns <code>p</code>'s memory to the segment from which it was originally allocated.
If the identity of that segment were not part of <code>p</code>'s metadata, this code would
not work. If <code>p</code>'s metadata had been sliced away prior to deallocation (that is,
if the pointer passed to the deallocation mechanism were not losslessly derived from the original
allocation), this code would not work.
</p>

<p>
If the programmer cannot rely on the container to deallocate a pointer losslessly derived from the
original allocation, then the programmer cannot use this kind of segmented memory resource.
</p>
</div>

<p>
Can we use <i>segmented pointer</i> types to hold metadata used at deallocation time?
</p>

<p>
<b>Yes, we can; it has practical difficulties, but I believe it is worth implementing.</b>
</p>

<p>
The problems in this case are not with the containers. No vendor's containers actually
support segmented pointers today, due to needless overuse of slicing expressions such as
<code>std::pointer_traits&lt;P&gt;::pointer_to(std::addressof(*q))</code>; but adjusting those
expressions to non-slicing expressions such as <code>static_cast&lt;P&gt;(q)</code> can be done
mechanically. Some vendors' containers (e.g. libc++) already use fancy pointer types internally
(in order to support Scenario A), so no ABI-breaking changes to class layouts would be required
in order to support segmented pointers. Other vendors (e.g. libstdc++) use native pointer types
internally, and thus even to support Scenario A would involve ABI-breaking changes for them.
</p>

<p>
Even libc++ has ABI problems with the allocator-aware non-containers:
<code>promise</code>, <code>shared_ptr</code>, and <code>packaged_task</code>. These
types have shared states that may be allocated with an allocator. Their current
implementations generally do not preserve a copy of the allocated <i>pointer</i> — only
a copy of the allocator itself.
</p>

<div class="clarification"><p>
For example, libc++'s <code>promise(allocator_arg, _Alloc)</code> looks effectively like this:
</p>
<pre>
    template&lt;class _Rp, class _Alloc&gt;
    class __assoc_state_alloc : public __assoc_state&lt;_Rp&gt;
    {
        _Alloc __alloc_;
        void __on_zero_shared() noexcept override {
            using _Al = typename __allocator_traits_rebind&lt;_Alloc, __assoc_state_alloc>::type;
            using _ATraits = allocator_traits&lt;_Al>;
            using _PTraits = pointer_traits&lt;typename _ATraits::pointer>;
            _Al __a(__alloc_);
            this->~__assoc_state_alloc();
            __a.deallocate(std::pointer_traits&lt;_P&gt;::pointer_to(*this), 1);
        }
 public:
        explicit __assoc_state_alloc(const _Alloc& __a)
            : __alloc_(__a) {}
    };

    template&lt;class _Rp>
    template&lt;class _Alloc>
    promise&lt;_Rp>::promise(allocator_arg_t, const _Alloc& __a0)
    {
        using _State = __assoc_state_alloc&lt;_Rp, _Alloc>;
        using _A2 = typename __allocator_traits_rebind&lt;_Alloc, _State>::type;
        using _D2 = __allocator_destructor&lt;_A2>;
        _A2 __a(__a0);
        unique_ptr&lt;_State, _D2> __hold(__a.allocate(1), _D2(__a, 1));
        ::new(static_cast&lt;void*>(std::addressof(*__hold.get()))) _State(__a0);
        __state_ = std::addressof(*__hold.release());
    }
</pre>
<p>
The argument to <code>__a.deallocate</code> is the direct result of <code>pointer_to</code>;
that is, it will fail to correctly reconstitute the metadata that was lost in the conversion
from fancy pointer <code>__hold.get()</code> to native pointer <code>this</code>.
To make this code work with segmented pointers, the <code>__assoc_state_alloc</code> struct
must store a copy of the originally allocated pointer.
</p></div>

<p>
We have the following possible solutions to this problem:
<ol>
    <li>
        Segmented pointer types are not allowed. Fancy pointers may be sliced to native pointers
        at any time, which means their metadata cannot be used for deallocation. This is the de-facto
        solution.
    </li>
    <li>
        Segmented pointer types are fully supported. Every allocator-aware type
        is required to use for deallocation a fancy pointer derived from the
        corresponding original allocation. This solution requires vendors to do a lot of new work.
    </li>
    <li>
        Segmented pointer types are supported by some allocator-aware types, and not
        supported by others. The Standard dictates which allocator-aware types are
        <dfn>segmented-allocator-aware</dfn>. This solution requires specification work
        from the Committee, plus some work from vendors, and leaves the situation confusing
        for users. (Therefore this solution is summarily dismissed.)
    </li>
</ol>
</p>

<p>
In my opinion, solutions (1) and (2) are tenable.
</p>


<h2><a name="Any">Is any kind of fancy pointer compatible with C++?</a></h2>

<p>
We have seen that there are five plausible scenarios for fancy-pointer usage in C++.<br>
Scenario (A), offset pointers, has only one tenable solution, "continue to partly support."<br>
Scenario (B), near pointers, has three possible solutions of which the de-facto one is "do not support."<br>
Scenario (C), far pointers, was proven impossible to support.<br>
Scenario (D), fat pointers, has three possible solutions of which the de-facto one is "do not support."<br>
Scenario (E), segmented pointers, has two possible solutions of which the de-facto one
is "do not support."
</p>

<p>
If we adopt the de-facto solution in all scenarios, our conclusion is that only Scenario (A)
is tenable, and therefore we may want to explore ways to separate <i>storage type</i> from
<i>allocation mechanism</i>; we also may want to explore ways to determine the <i>representation-awareness</i>
of a type at compile time.
</p>

<p>
If we are willing to force some work on vendors, my preferred solutions would be
A-1 (continue the status quo on offset pointers), B-6 (support near pointers, with undefined behavior
for certain uses of list-like containers); D-1 (do not support fat pointers),
E-2 (fully support segmented pointers). I will refer to this set of solutions as
<dfn>fancy-pointer-support</dfn>.
</p>


<h2><a name="Requirements">Requirements on fancy pointer types if <i>fancy-pointer-support</i> were adopted.</a></h2>

<p>
Solution B-6 requires only that it be possible to cast a native pointer-to-<code>Base</code>
(to a subobject of a list-like container; therefore, non-null) into a <i>dereferenceable</i>
fancy pointer-to-<code>Base</code>. This requirement is translated into C++ terms via the
standard trait <code>std::pointer_traits&lt;FancyPtrT&gt;::pointer_to(T& r)</code>.
</p>

<div class="clarification"><p>
The reason we must use <code>std::pointer_traits&lt;FancyPtrT&gt;::pointer_to(T& r)</code>
rather than the simpler <code>static_cast&lt;FancyPtrT&gt;(T*)</code> is that there may not
be any natural mapping from <code>T*</code> values onto <code>FancyPtrT</code> values.
In scenario (B), some values of <code>T*</code> do not have an image in <code>FancyPtrT</code>.
In scenario (E), the operation requires us to invent the metadata part of a <code>FancyPtrT</code> value.
In both cases a mapping is possible, but it is not a <i>natural</i> mapping, and thus must
not be represented in C++ by <code>static_cast</code>.
</p>

<p>
It is a shame that the signature of <code>pointer_to</code> takes <code>T&</code>, thus
requiring that the input native pointer be <i>dereferenceable</i>. This means there is
no generic way to get the fancy-pointer value corresponding to a one-past-the-end pointer;
and the generic way to get a fancy null pointer is <code>FancyPtrT{}</code> rather than
<code>pointer_to(nullptr)</code>. This does not seem to be a problem for containers in
practice.
</p>

<p>
If scenario (A), offset pointers, is the only scenario in play, then
<code>static_cast&lt;FancyPtrT&gt;(T*)</code> is perhaps an appropriate way to get the
storage representation of a native pointer. Scenario (B), near pointers, is also relevant
to storage representation.
</p></div>

<p>
Solution E-2 requires that it be possible to losslessly cast a fancy
pointer-to-<code>Derived</code> into a fancy-pointer-to-<code>Base</code>, and also vice versa.
(Here <code>Base</code> represents a possibly-terminal node of a list-like container, and
<code>Derived</code> represents a non-terminal node.) The most natural way to express casting
in C++ is via <code>static_cast</code>.
</p>

<p>
As long as fancy pointer types are permitted by the Standard, container implementations
will also require that it be possible to cast a fancy pointer-to-<code>T</code> into
a native pointer-to-<code>T</code>. The most natural way to express casting in C++ is via
<code>static_cast</code>. Therefore we should require that every fancy pointer type
support casting to its corresponding native pointer type.
</p>

<div class="clarification">
<p>
Today, container implementations say <code>std::addressof(*fancyPtrT)</code> instead of
<code>static_cast&lt;T*&gt;(fancyPtrT)</code>. The latter is more philosophically appropriate.
The former also has the potential problem that it can be used only for <i>dereferenceable</i>
pointer values. <code>std::addressof(*fancyPtrT)</code> cannot safely be used
when <code>fancyPtrT == nullptr</code>. This does not seem to be a problem for containers
in practice.
</p>
<p>
Also, <code>std::addressof(*fancyPtrT)</code> cannot safely be used when <code>fancyPtrT</code>
represents a "one-past-the-end" fancy pointer value; but such values arise only via fancy pointer
arithmetic.
</p>
</div>

<p>
If we forbid <i>fat pointers</i>, then no container implementation will ever require fancy
pointer arithmetic. Therefore we should drop the requirement that fancy pointer types
model <code>RandomAccessIterator</code>. This may require some work from vendors, to replace
expressions such as <code>fancyPtrT[k]</code> with <code>static_cast&lt;T*&gt;(fancyPtrT)[k]</code>.
</p>

<div class="clarification">
<p>
In my preferred solution (support A, B, and E but not D), every STL container needs
to follow these rules:
</p>
<ol>
    <li>
        Any dereferenceable pointer stored "within" the container must be stored as a
        fancy pointer. (Required by A; wanted by B.)
    </li>
    <li>
        A dereferenceable pointer stored "outside" the container, such as in an iterator,
        may be stored as a fancy pointer or as a native pointer. (Relevant to A.)
    </li>
    <li>
        Whenever you get a pointer from allocate(), hang onto it. You will never be able to
        reconstruct its metadata if you lose it. (Required by E.)
    </li>
    <li>
        Assume that metadata is preserved via the fancy pointer type's special member functions,
        and via casting from one fancy pointer type to a rebound version of that type
        (e.g. <code>static_cast&lt;FancyPtrT>(fancyPtrU)</code>).
        (This proposes a resolution to LWG 2260.)
        Do not assume that metadata is preserved via any other operations. (Required by E.)
    </li>
    <li>
        Assume that <code>static_cast&lt;T*>(fancyPtrT)</code> is a correct slicing expression.
        Prefer to avoid <code>std::addressof(*fancyPtrT)</code>, which isn't going to work if
        <code>fancyPtrT</code> is not a <i>dereferenceable</i> value. (Required by A, B, and E.)
    </li>
    <li>
        Assume that <code>std::pointer_traits&lt;FancyPtrT&gt;::pointer_to(t)</code> returns a
        <i>dereferenceable</i> pointer, but not a <i>deallocatable</i> one. Do not assume that
        <code>static_cast&lt;FancyPtrT&gt;(std::addressof(t))</code> compiles;
        <code>FancyPtrT</code> might not have a one-argument constructor. (Required by E.)
    </li>
    <li>
        Assume that the fancy pointer type models <code>NullablePointer</code>. (Construction
        from and comparison to <code>nullptr</code> ought to be supported.)
    </li>
    <li>
        Do not assume that the fancy pointer type models <code>RandomAccessIterator</code>.
        For example, do not rely on <code>operator++</code>, <code>operator[]</code>, or
        <code>operator&lt;</code>. Slice to <code>T*</code> before attempting these operations.
        (Improves the performance and usability of A, B, and E. Precludes D.)
    </li>
</ol>
</div>

<h2><a name="basic_string"><code>basic_string</code> requires trivial default constructibility.</a></h2>

<p>
The <code>basic_string</code> implementations of libc++ and MSVC implicitly require that their
allocator's <code>pointer</code> type be trivially default constructible and trivially destructible <a
href="https://bugs.llvm.org/show_bug.cgi?id=20508">(libc++ bug 20508)</a>.
The Standard should either explicitly specify these requirements in [string.require], or else
the implementations of <code>basic_string</code> should be fixed to avoid implicitly depending
on trivial constructibility and destructibility of the <code>pointer</code> type.
</p>


<div class="clarification">
<h2><a name="Iterators">Appendix. Representation-awareness of container and iterator types, in some present-day library implementations.</a></h2>

<p>
The following table shows, for various container classes <code>C</code> across various common library
implementations, the compatibility of <code>C</code> with <code>boost::interprocess::offset_ptr</code>.
This demonstrates the current state of my Scenario A (<i>offset pointers</i>) across these implementations.
</p>

<table>
<tr><th></th>                 <th>libc++</th><th>GNU</th><th>MSVC</th><th>Boost.Container</th></tr>
<tr><th>deque</th>               <td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>
<tr><th>forward_list (slist)</th><td>Yes</td><td>No </td><td>Yes</td><td>Yes</td></tr>
<tr><th>list</th>                <td>Yes</td><td>No </td><td>Yes</td><td>Yes</td></tr>
<tr><th>map (etc.)</th>          <td>Yes</td><td>No </td><td>Yes</td><td>Yes</td></tr>
<tr><th>unordered_map (etc.)</th><td>Yes</td><td>No </td><td>Yes</td><td>   </td></tr>
<tr><th>flat_map (etc.)</th>     <td>   </td><td>   </td><td>   </td><td>Yes</td></tr>
<tr><th>vector</th>              <td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>
<tr><th>basic_string</th>        <td>X  </td><td>Yes</td><td>X  </td><td>Yes</td></tr>
</table>

<p>
The "X" entries for <code>basic_string</code> indicate that the libraries require trivial constructibility,
which <code>offset_ptr</code> does not have; but if the library vendors patched this one bug, then the
libraries would be able to support <code>offset_ptr</code> with no further patches (as far as I know).
</p>

<p>
The following table shows, for various container classes <code>C</code> across various common library
implementations, the compatibility of <code>C::iterator</code> with <code>boost::interprocess::offset_ptr</code>.
This demonstrates the current state of my Scenario A (<i>offset pointers</i>) across these implementations.
</p>

<table>
<tr><th></th>                          <th>libc++</th><th>GNU</th><th>MSVC</th><th>Boost.Container</th></tr>
<tr><th>deque iterator</th>               <td>Yes</td><td>Yes</td><td>No </td><td>Yes</td></tr>
<tr><th>forward_list (slist) iterator</th><td>Yes</td><td>No </td><td>Yes</td><td>Yes</td></tr>
<tr><th>list iterator</th>                <td>Yes</td><td>No </td><td>Yes</td><td>Yes</td></tr>
<tr><th>map (etc.) iterator</th>          <td>Yes</td><td>No </td><td>Yes</td><td>Yes</td></tr>
<tr><th>unordered_map (etc.) iterator</th><td>Yes</td><td>No </td><td>Yes</td><td>   </td></tr>
<tr><th>flat_map (etc.) iterator</th>     <td>   </td><td>   </td><td>   </td><td>Yes</td></tr>
<tr><th>vector iterator</th>              <td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>
<tr><th>basic_string iterator</th>        <td>Yes</td><td>Yes</td><td>Yes</td><td>Yes</td></tr>
</table>

<p>
GNU <code>forward_list</code>, <code>list</code>, <code>map</code>, and <code>unordered_map</code> iterators
each hold a raw pointer to an allocated list node.
MSVC <code>deque</code>'s iterator holds a raw pointer to the deque itself, and an integer offset.
</p>
</div>


<div>&nbsp;</div>
<div class="clarification">
<h2><a name="References">Appendix. References and further reading.</a></h2>

<dl>

<dd>
Boost.Interprocess <code>offset_ptr</code> documentation.
<a href="https://www.boost.org/doc/libs/1_65_0/doc/html/interprocess/offset_ptr.html">
https://www.boost.org/doc/libs/1_65_0/doc/html/interprocess/offset_ptr.html</a>
</dd>

<dd>
Lance Diduck. N2486 "Alternative Allocators and Standard Containers." December 2007.
<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2486.pdf">
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2486.pdf</a>
</dd>

<dd>
Nevin Liber. N3884 "Contiguous Iterators: A Refinement of Random-Access Iterators." January 2014.
<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3884.pdf">
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3884.pdf</a>
</dd>

<dd>
Doug Judd. "Why <code>pointer_traits</code> was introduced in C++11." September 2015.
<a href="http://blog.nuggetwheat.org/index.php/2015/09/01/why-pointer_traits-was-introduced-in-c11/">
http://blog.nuggetwheat.org/index.php/2015/09/01/why-pointer_traits-was-introduced-in-c11/</a>
</dd>

<dd>
Thomas Köppe. "A visitor's guide to C++ allocators." September 2016.
<a href="https://rawgit.com/google/cxx-std-draft/allocator-paper/allocator_user_guide.html">
https://rawgit.com/google/cxx-std-draft/allocator-paper/allocator_user_guide.html</a>
</dd>

<dd>
Arthur O'Dwyer. "pointer-traits.md." August 2017.
<a href="https://github.com/Quuxplusone/from-scratch/blob/master/include/scratch/bits/traits-classes/pointer-traits.md">
https://github.com/Quuxplusone/from-scratch/blob/master/include/scratch/bits/traits-classes/pointer-traits.md</a>
</dd>

<dd>
Jonathan Wakely. LWG 2260 "Missing requirement for Allocator::pointer." Opened 2013-05-14, last modified 2017-07-30.
<a href="https://timsong-cpp.github.io/lwg-issues/2260">
https://timsong-cpp.github.io/lwg-issues/2260</a>
</dd>

<br>
<dd>
The most current revision of P0773 "Towards Meaningful Fancy Pointers" is available at
<a href="https://quuxplusone.github.io/draft/fancy-pointers.html">
https://quuxplusone.github.io/draft/fancy-pointers.html</a>
</dd>

</dl>
</div>

<div>&nbsp;</div>
<div class="clarification">
<h2><a name="Acknowledgments">Acknowledgments.</a></h2>

<p>
Thanks to Alfredo Correa for identifying many confusing passages in drafts of this paper.
</p>
</div>

</body>
</html>
