Florent Rougon
a9ec3be2fd
This automatically makes SGSharedPtr more efficient when used in
standard containers (among others). See below for the benchmark details.
Mark as 'noexcept' (after checking it's legitimate!) the SGSharedPtr and
SGReferenced methods required for SGSharedPtr's move constructor and
move assignment operator to be guaranteed 'noexcept'.
Benchmark
---------
I measured a 25 % speedup with g++ 6.3.0 on Linux amd64, CFLAGS=-Wall -O2
as compared to commit 18f0484249 (which is
just before my changes to SGSharedPtr.hxx) on the following test code,
called with:
nbIterations = 3000000
minSize = 0
maxSize = 200
------------------------------------------------------------------------
static std::default_random_engine randomNumbersGenerator;
class SGReferencedTestClass : public SGReferenced
{ int i; };
void SGSharedPtr_perfTest(std::size_t nbIterations,
std::size_t minSize, std::size_t maxSize)
{
using Ref = SGSharedPtr<SGReferencedTestClass>;
std::uniform_int_distribution<std::size_t> sizeDist(minSize, maxSize);
auto randomSize = std::bind(sizeDist, randomNumbersGenerator);
std::chrono::time_point<std::chrono::system_clock> start, end;
start = std::chrono::system_clock::now();
std::vector<Ref> v;
for (std::size_t i=0; i < nbIterations; i++) {
v = std::vector<Ref>{}; // start anew
for (std::size_t j=0; j < randomSize(); j++) {
auto p = Ref(new SGReferencedTestClass());
v.emplace_back(std::move(p));
}
std::shuffle(v.begin(), v.end(), randomNumbersGenerator);
std::sort(v.begin(), v.end());
}
end = std::chrono::system_clock::now();
std::chrono::duration<double> elapsedSecs = end - start;
std::cout << elapsedSecs.count() << "\n"; // duration in seconds
}
------------------------------------------------------------------------
Basically, these gains can be explained by the fact that copying an
SGSharedPtr requires to test SGReferenced::ref, increase the refcount,
and then when the object is destroyed, test again SGReferenced::ref,
decrease the refcount and test it in order to maybe delete. With the
move constructor and move assignment operator, copying the argument is
never necessary: its raw pointer can be swapped with the one contained
in *this, which is very fast. For the move constructor, this is all that
is needed; move assignment just needs one reset() call after that in
order to release the resource from the moved-from shared pointer.
58 lines
1.9 KiB
C++
58 lines
1.9 KiB
C++
/* -*-c++-*-
|
|
*
|
|
* Copyright (C) 2005-2006 Mathias Froehlich
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*
|
|
*/
|
|
|
|
#ifndef SGReferenced_HXX
|
|
#define SGReferenced_HXX
|
|
|
|
#include "SGAtomic.hxx"
|
|
|
|
/// Base class for all reference counted SimGear objects
|
|
/// Classes derived from this one are meant to be managed with
|
|
/// the SGSharedPtr class.
|
|
///
|
|
/// For more info see SGSharedPtr. For using weak references see
|
|
/// SGWeakReferenced.
|
|
|
|
class SGReferenced {
|
|
public:
|
|
SGReferenced(void) : _refcount(0u)
|
|
{}
|
|
/// Do not copy reference counts. Each new object has it's own counter
|
|
SGReferenced(const SGReferenced&) : _refcount(0u)
|
|
{}
|
|
/// Do not copy reference counts. Each object has it's own counter
|
|
SGReferenced& operator=(const SGReferenced&)
|
|
{ return *this; }
|
|
|
|
static unsigned get(const SGReferenced* ref)
|
|
{ if (ref) return ++(ref->_refcount); else return 0; }
|
|
static unsigned put(const SGReferenced* ref) noexcept
|
|
{ if (ref) return --(ref->_refcount); else return 0; }
|
|
static unsigned count(const SGReferenced* ref)
|
|
{ if (ref) return ref->_refcount; else return 0; }
|
|
static bool shared(const SGReferenced* ref)
|
|
{ if (ref) return 1u < ref->_refcount; else return false; }
|
|
|
|
private:
|
|
mutable SGAtomic _refcount;
|
|
};
|
|
|
|
#endif
|