Boost logo

Boost :

From: Slawomir Lisznianski (slisznianski_at_[hidden])
Date: 2004-02-07 13:31:59

I apologize if my observation has already been discussed and course agreed.

When using Boost with multi-threaded programs, shared_ptr synchronizes
access to internal usage count variable. I understand the rationale for
guarding the shared resource as default behavior in MT environment,
however I think users might appreciate the ability to override it.

Currently, users either ignore, or are unaware of, performance cost
imposed by locking, or choose, with all it's implications, an option of
using non-owning observer of an object owned by shared_ptr.

During tests involving manipulations of shared_ptr variables similar to
those performed by algorithms on container elements – their copying and
removal – a significant overhead was measured. During tests, care was
taken to assure that timing did not include creation of new objects
managed by shared_ptrs nor their destruction.

One way to customize the shared_ptr without breaking existing code would
be to introduce an optional template parameter stating locking policy.

Attached you will find test code used on a win32 platform that produced
the following results on Intel Pentium 4 2.66Mhz single processor
machine. Each line represents separate testing iteration, so averages
can be calculated:

Elapsed time: 845605 microseconds
Elapsed time: 817763 microseconds
Elapsed time: 802840 microseconds
Elapsed time: 790676 microseconds
Elapsed time: 790839 microseconds
Elapsed time: 793012 microseconds
Elapsed time: 790474 microseconds
Elapsed time: 788396 microseconds
Elapsed time: 794611 microseconds
Elapsed time: 792640 microseconds
Press any key

Elapsed time: 87914 microseconds
Elapsed time: 87753 microseconds
Elapsed time: 88958 microseconds
Elapsed time: 86546 microseconds
Elapsed time: 86437 microseconds
Elapsed time: 86520 microseconds
Elapsed time: 86433 microseconds
Elapsed time: 88519 microseconds
Elapsed time: 86420 microseconds
Elapsed time: 87535 microseconds
Press any key

The time overhead mentioned above is meant to serve as an example from a
particular win32 platform. Results will vary across platforms and
hardware configurations.


Slawomir Lisznianski; [ ]

 * Copyright (C) 2003-2004
 * Slawomir Lisznianski <slisznianski_at_[hidden]>
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation. Slawomir Lisznianski makes no
 * representations about the suitability of this software for any
 * purpose. It is provided "as is" without express or implied warranty.

#include <string>
#include <iostream>
#include <stdexcept>

#include <boost/shared_ptr.hpp>

#include <Windows.h>

// VC++ 6 library doesn't define it.
std::ostream& operator<<(std::ostream& os, __int64 i )
  char buf[20];
  sprintf(buf,"%I64d", i );
  os << buf;
  return os;

struct Timer
  Timer(std::ostream& out) :
      if (!::QueryPerformanceFrequency(&_M_frequency))
        throw std::runtime_error("Unable to retrieve frequency of the high-resolution performance counter.");
      if (!::QueryPerformanceCounter(&_M_startEvent))
        throw std::runtime_error("Unable to retrieve value of the high-resolution performance counter.");

    if (!::QueryPerformanceCounter(&_M_endEvent))
          _M_out << "Unable to retrieve value of the high-resolution performance counter.";
      LONGLONG elapsedTicks__ = _M_endEvent.QuadPart - _M_startEvent.QuadPart;
      double elapsedTime__ = 0;
      _M_out << "Elapsed time: ";
      if (_M_frequency.QuadPart > 1000000)
        elapsedTime__ = (elapsedTicks__ / (_M_frequency.QuadPart / 1000000));
        _M_out << elapsedTime__ << " microseconds" << std::endl;
      else if (_M_frequency.QuadPart > 1000)
        elapsedTime__ = (elapsedTicks__ / (_M_frequency.QuadPart / 1000));
        _M_out << elapsedTime__ << " miliseconds" << std::endl;
        _M_out << elapsedTicks__ << " ticks (tick: 1/" << _M_frequency.QuadPart << " of second)" << std::endl;

  std::ostream& _M_out;
  LARGE_INTEGER _M_startEvent;
  LARGE_INTEGER _M_endEvent;
  LARGE_INTEGER _M_frequency;

void run()
  boost::shared_ptr<int> ptrA__(new int(0)), ptrB__, ptrC__;
  Timer timer__(std::cout);
  for (int i=0; i<4000000; ++i)
    ptrB__ = ptrA__;
    ptrC__ = ptrB__;

main(int, char**)
  std::cout << "BOOST_HAS_THREADS is: ";
#if !defined(BOOST_HAS_THREADS)
  std::cout << "FALSE" << std::endl;
  std::cout << "TRUE" << std::endl;
  for (int i=0; i<10; ++i)
  } catch (std::exception& e)
  { std::cerr << e.what() << std::endl; }
  return 0;

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