Citizen.cc

Go to the documentation of this file.

// -*- LSST-C++ -*-

/* 
 * LSST Data Management System
 * Copyright 2008, 2009, 2010 LSST Corporation.
 * 
 * This product includes software developed by the
 * LSST Project (http://www.lsst.org/).
 *
 * 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 3 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 LSST License Statement and 
 * the GNU General Public License along with this program.  If not, 
 * see <http://www.lsstcorp.org/LegalNotices/>.
 */
 

#include <ctype.h>

#include <cerrno>
#include <iostream>
#include <memory>

#include <boost/format.hpp>

#include "lsst/daf/base/Citizen.h"
#include "lsst/pex/exceptions.h"
#include "lsst/utils/Demangle.h"

namespace dafBase = lsst::daf::base;

namespace {

template <typename T>
class ThreadPrivate {
public:
    ThreadPrivate(T const& t) : _init(t) {
        int ret = pthread_key_create(&_key, del);
        if (ret != 0) {
            throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
                              "Could not create key");
        }
    };
    T& getRef(void) {
        T* d = reinterpret_cast<T*>(pthread_getspecific(_key));
        if (d == 0) {
            d = new T(_init);
            pthread_setspecific(_key, d);
        }
        return *d;
    };

private:
    pthread_key_t _key;
    T _init;

    static void del(void* data) {
        T* d = reinterpret_cast<T*>(data);
        delete d;
    };
};

static ThreadPrivate<dafBase::Citizen::memId> perThreadId(1);
static ThreadPrivate<bool> perThreadPersistFlag(false);

class RwLock {
public:
    RwLock(void) {
        int ret = pthread_rwlock_init(&_lock, 0);
        if (ret != 0) {
            throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
                              "Could not create Citizen lock");
        }
    };
    void lock(void) {
        int ret = pthread_rwlock_wrlock(&_lock);
        if (ret != 0) {
            throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
                              "Could not acquire Citizen write lock");
        }
    };
    bool rdlock(void) {
        int ret = pthread_rwlock_rdlock(&_lock);
        if (ret == 0) return true;
        if (ret == EDEADLK) return false;
        throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
                          "Could not acquire Citizen read lock");
    };
    void unlock(void) {
        int ret = pthread_rwlock_unlock(&_lock);
        if (ret != 0) {
            throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
                              "Could not release Citizen lock");
        }
    };

private:
    pthread_rwlock_t _lock;
};

static RwLock citizenLock;

class ReadGuard {
public:
    ReadGuard(RwLock& lock) : _lock(lock) {
        _mustUnlock = _lock.rdlock();
    };
    ~ReadGuard(void) {
        if (_mustUnlock) _lock.unlock();
    };

private:
    RwLock& _lock;
    bool _mustUnlock;
};

class WriteGuard {
public:
    WriteGuard(RwLock& lock) : _lock(lock) {
        _lock.lock();
    };
    ~WriteGuard(void) {
        _lock.unlock();
    };

private:
    RwLock& _lock;
};

} // anonymous namespace

//
// \brief A class that is instantiated once during startup
//
// The main purpose of CitizenInit is to provide a place to set
// breakpoints to setup memory debugging; see discussion on trac
//
class CitizenInit {
public:
    CitizenInit() : _dummy(1) { }
private:
    volatile int _dummy;
};
 
CitizenInit one;
//
// Con/Destructors
//
dafBase::Citizen::memId dafBase::Citizen::_addCitizen(Citizen const* c) {
    memId cid = _nextMemIdAndIncrement();
    WriteGuard guard(citizenLock);
    if (_shouldPersistCitizens()) {
        _persistentCitizens[c] = std::make_pair(cid, pthread_self());
    } else {
        _activeCitizens[c] = std::make_pair(cid, pthread_self());
    }
    if (cid == _newId) {
        _newId += _newCallback(cid);
    }
    return cid;
}

dafBase::Citizen::Citizen(std::type_info const& type) :
    _sentinel(magicSentinel),
    _CitizenId(_addCitizen(this)),
    _typeName(type.name()) {
}

dafBase::Citizen::Citizen(Citizen const& citizen) :
    _sentinel(magicSentinel),
    _CitizenId(_addCitizen(this)),
    _typeName(citizen._typeName) {
}

dafBase::Citizen::~Citizen() {
    {
        WriteGuard guard(citizenLock);
        if (_CitizenId == _deleteId) {
            _deleteId += _deleteCallback(this);
        }
    }

    (void)_hasBeenCorrupted();  // may execute callback
    _sentinel = 0x0000dead;     // In case we have a dangling pointer

    bool corrupt = false;
    {
        WriteGuard guard(citizenLock);
        size_t nActive = _activeCitizens.erase(this);
        corrupt = nActive > 1 ||
            (nActive == 0 && _persistentCitizens.erase(this) != 1);
    }
    if (corrupt) {
        (void)_corruptionCallback(this);
    }
}

//
// The main purpose of this routine is as a place to set
// breakpoints to setup memory debugging; see discussion on trac
//
int dafBase::Citizen::init() {
    volatile int dummy = 1;
    return dummy;
}

/******************************************************************************/
//
// Return (some) private state
//
dafBase::Citizen::memId dafBase::Citizen::getId() const {
    return _CitizenId;
}

dafBase::Citizen::memId dafBase::Citizen::getNextMemId() {
    return _nextMemId();
}

dafBase::Citizen::memId dafBase::Citizen::_nextMemId() {
    return perThreadId.getRef();
}

dafBase::Citizen::memId dafBase::Citizen::_nextMemIdAndIncrement() {
    return perThreadId.getRef()++;
}

//
std::string dafBase::Citizen::repr() const {
    return boost::str(boost::format("%d: %08x %s")
                      % _CitizenId
                      % this
                      % lsst::utils::demangleType(_typeName)
                     );
}

void dafBase::Citizen::markPersistent(void) {
    WriteGuard guard(citizenLock);
    _persistentCitizens[this] = _activeCitizens[this];
    _activeCitizens.erase(this);
}


//
//
//
int dafBase::Citizen::census(
    int,                                //<! the int argument allows overloading
    memId startingMemId                 
    ) {
    if (startingMemId == 0) {              // easy
        ReadGuard guard(citizenLock);
        return _activeCitizens.size();
    }

    int n = 0;
    ReadGuard guard(citizenLock);
    for (table::iterator cur = _activeCitizens.begin();
         cur != _activeCitizens.end(); cur++) {
        if (cur->first->_CitizenId >= startingMemId) {
            n++;
        }
    }

    return n;    
}
//
//
void dafBase::Citizen::census(
    std::ostream &stream,               
    memId startingMemId                 
    ) {
    ReadGuard guard(citizenLock);

    std::unique_ptr<std::vector<Citizen const*> const> leaks(Citizen::census());

    for (std::vector<Citizen const *>::const_iterator citizen = leaks->begin(), end = leaks->end();
         citizen != end; ++citizen) {
        if ((*citizen)->getId() >= startingMemId) {
            stream << (*citizen)->repr() << "\n";
        }
    }
}

/************************************************************************************************************/
namespace {
bool cmpId(dafBase::Citizen const *a, dafBase::Citizen const *b)
{
    return a->getId() < b->getId();
}
} 

//
//
//
std::vector<dafBase::Citizen const*> const* dafBase::Citizen::census() {
    std::vector<Citizen const*>* vec =
        new std::vector<Citizen const*>(0);
    ReadGuard guard(citizenLock);
    vec->reserve(_activeCitizens.size());

    for (table::iterator cur = _activeCitizens.begin();
         cur != _activeCitizens.end(); cur++) {
        vec->push_back(dynamic_cast<Citizen const*>(cur->first));
    }
        
    std::sort(vec->begin(), vec->end(), cmpId);

    return vec;
}


bool dafBase::Citizen::_hasBeenCorrupted() const {
    if (_sentinel == static_cast<int>(magicSentinel)) {
        return false;
    }

    (void)_corruptionCallback(this);
    return true;
}

bool dafBase::Citizen::hasBeenCorrupted() {
    ReadGuard guard(citizenLock);
    for (table::iterator cur = _activeCitizens.begin();
         cur != _activeCitizens.end(); cur++) {
        if (cur->first->_hasBeenCorrupted()) {
            return true;
        }
    }
    for (table::iterator cur = _persistentCitizens.begin();
         cur != _persistentCitizens.end(); cur++) {
        if (cur->first->_hasBeenCorrupted()) {
            return true;
        }
    }

    return false;
}


//
dafBase::Citizen::memId dafBase::Citizen::setNewCallbackId(
    Citizen::memId id                   
    ) {
    WriteGuard guard(citizenLock);
    Citizen::memId oldId = _newId;
    _newId = id;

    return oldId;
}

dafBase::Citizen::memId dafBase::Citizen::setDeleteCallbackId(
    Citizen::memId id                   
    ) {
    WriteGuard guard(citizenLock);
    Citizen::memId oldId = _deleteId;
    _deleteId = id;

    return oldId;
}

//


dafBase::Citizen::memNewCallback dafBase::Citizen::setNewCallback(
    Citizen::memNewCallback func 
    ) {
    Citizen::memNewCallback old = _newCallback;
    _newCallback = func;

    return old;
}

dafBase::Citizen::memCallback dafBase::Citizen::setDeleteCallback(
    Citizen::memCallback func           
    ) {
    Citizen::memCallback old = _deleteCallback;
    _deleteCallback = func;

    return old;
}
    
dafBase::Citizen::memCallback dafBase::Citizen::setCorruptionCallback(
    Citizen::memCallback func 
                                                   ) {
    Citizen::memCallback old = _corruptionCallback;
    _corruptionCallback = func;

    return old;
}
    

dafBase::Citizen::memId defaultNewCallback(
                                           dafBase::Citizen::memId const cid 
                                 ) {
    static int dId = 0;             // how much to incr memId
    std::cerr << boost::format("Allocating memId %d\n") % cid;

    return dId;
}

dafBase::Citizen::memId defaultDeleteCallback(dafBase::Citizen const* ptr 
                                    ) {
    static int dId = 0;             // how much to incr memId
    std::cerr << boost::format("Deleting memId %s\n") % ptr->repr();

    return dId;
}

dafBase::Citizen::memId defaultCorruptionCallback(dafBase::Citizen const* ptr 
                              ) {
    throw LSST_EXCEPT(lsst::pex::exceptions::MemoryError,
                      str(boost::format("Citizen \"%s\" is corrupted") % ptr->repr()));

    return ptr->getId();                // NOTREACHED
}

bool& dafBase::Citizen::_shouldPersistCitizens(void) {
    return perThreadPersistFlag.getRef();
}

//
// Initialise static members
//
dafBase::Citizen::memId dafBase::Citizen::_newId = 0;
dafBase::Citizen::memId dafBase::Citizen::_deleteId = 0;
dafBase::Citizen::table dafBase::Citizen::_activeCitizens;
dafBase::Citizen::table dafBase::Citizen::_persistentCitizens;

dafBase::Citizen::memNewCallback dafBase::Citizen::_newCallback = defaultNewCallback;
dafBase::Citizen::memCallback dafBase::Citizen::_deleteCallback = defaultDeleteCallback;
dafBase::Citizen::memCallback dafBase::Citizen::_corruptionCallback = defaultCorruptionCallback;


dafBase::PersistentCitizenScope::PersistentCitizenScope() {
    Citizen::_shouldPersistCitizens() = true;
}

dafBase::PersistentCitizenScope::~PersistentCitizenScope() {
    Citizen::_shouldPersistCitizens() = false;
}