Boost logo

Boost :

Subject: Re: [boost] [Block Pointer] Update
From: Phil Bouchard (philippeb8_at_[hidden])
Date: 2016-03-10 19:47:11

On 03/09/2016 11:28 PM, Phil Bouchard wrote:
> Hi,
> - So I've restructured all the code in the correct namespaces
> boost::smart_ptr & boost::smart_ptr::detail:
> - I am now using another smart pointer to refer to proxies because it is
> safer but the code is 15% slower than without it (now ~= shared_ptr<>):
> make:
> auto_ptr: 26211292 ns
> shared_ptr: 27291607 ns
> block_ptr: 61097868 ns
> new:
> auto_ptr: 23240569 ns
> shared_ptr: 48016207 ns
> block_ptr: 55554121 ns

Note that it is possible & easy to use the fast_pool_allocator to
allocate objects just by using the following line in benchmark.cpp:

worker_new< boost::block_ptr<int>, fastblock<int> >();


And this way block_ptr<> will be 5% faster than shared_ptr<>:

auto_ptr: 25673501 ns
shared_ptr: 26853061 ns
block_ptr: 61874962 ns

auto_ptr: 22326728 ns
shared_ptr: 47143526 ns
block_ptr: 45007803 ns

This is an unfair comparison but my point is using this fast allocator
can be done easily.

> - Because of the removal of the proxy optimization there is a new
> caveat; if you assign an rvalue (temporary pointer on the stack) to a
> pointer on the heap (opposite of normal heap object assigned to stack
> pointer) then there the behavior will be undefined. I am looking to fix
> it or throw an exception but for now it's better not to use rvalues when
> assigning to pointer living on the heap as such:

I fixed the problem and now the correct way to use the pointer is by
passing around a proxy explicitly:

block_ptr<neuron_sight> t100 = new block<neuron_sight>("I eat ([a-z]+)
then drink ([a-z]+)");
t100->sub_[0].second = block_ptr<neuron_sight>(t100.proxy(), new
t100->sub_[1].second = block_ptr<neuron_sight>(t100.proxy(), new


I will fix make_block<>() to follow this syntax but this is how things
should be done. Another useful example is by defining the internals of
a container:

struct list {
     list() {}
     void clear() {
     void insert() {
         if(root.get() == 0) {
             root = new block<node>();
         } else {
             root->next = block_ptr<node>(root.proxy(), new
block<node>()); //<- Correct way
             root->next->prior = root;
             root = root->next;
     block_ptr<node> root;


The explicit proxy states where a set of allocations should be defined
as unique. That set can be merged with another set.


Boost list run by bdawes at, gregod at, cpdaniel at, john at