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/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 std::bad_alloc();
        }
    };
    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 std::bad_alloc();
        }
    };
    void lock(void) {
        int ret = pthread_rwlock_wrlock(&_lock);
        if (ret != 0) {
            throw std::bad_alloc();
        }
    };
    bool rdlock(void) {
        int ret = pthread_rwlock_rdlock(&_lock);
        if (ret == 0) return true;
        if (ret == EDEADLK) return false;
        throw std::bad_alloc();
    };
    void unlock(void) {
        int ret = pthread_rwlock_unlock(&_lock);
        if (ret != 0) {
            throw std::bad_alloc();
        }
    };

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(); }
}  // namespace

//
//
//
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 std::bad_alloc();

    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; }