casgarbage.cc

Go to the documentation of this file.

//
//  Copyright (c) 2006 by Rafael Ostertag
//
//  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
//
//
// $Id: casgarbage.cc,v 1.11 2006/12/31 00:48:15 rafi Exp $
//

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_TIME_H
#include <time.h>
#endif

#include <iostream>


#include <algorithm>
#include <functional>

#include "casobject.h"
#include "casgarbage.h"

extern "C" void*
    CASGarbage_thread_wrapper ( void *object ) {
    CASGarbage *ptr = ( CASGarbage* ) object;
    return ptr->Trasher();
}

// Private methods
// ----------------------------------------------------------------------------

void
CASGarbage::CreateTrasherThread() {
    // Make sure the thread has not been created already.
    if ( trasher_thread_created == true ) {
        return;
    }

    // Initialize the thread attribute
    int retval = pthread_attr_init ( &pattr );
    CheckRetVal ( retval, std::string ( "pthread_attr_init()" ) );
    // Creates the thread
    retval = pthread_create ( &tid, &pattr, CASGarbage_thread_wrapper, this );
    CheckRetVal ( retval, std::string ( "pthread_create()" ) );

    // Indicate the creation of the thread.
    trasher_thread_created = true;
}

void
CASGarbage::TerminateTrasherThread() {
    // Make sure a thread has been created
    if ( trasher_thread_created == false ) {
        return;
    }

    // Signal the thread the end of his life
    time_to_die = true;

    // Signal the trasher thread
    int retval = pthread_cond_broadcast ( &cond_var );
    CheckRetVal ( retval, std::string ( "pthread_cond_broadcast()" ) );

    // Wait for the thread to complete and exit
    retval = pthread_join ( tid, NULL );
    CheckRetVal ( retval, std::string ( "pthread_join()" ) );

    // Destroy Thread Attribute
    retval = pthread_attr_destroy ( &pattr );
    CheckRetVal ( retval, std::string ( "pthread_attr_destroy()" ) );

    // Indicate
    trasher_thread_created = false;

}

void
CASGarbage::RemoveDuplicate() {
    if ( list.size() == 0 ) {
        return;
    }

    std::sort ( list.begin(), list.end(), CASGarbageSort_Cmp() );

    std::vector<CASObject*>::iterator ip =
        std::unique ( list.begin(), list.end() );

    list.erase ( ip, list.end() );
}

void
CASGarbage::CheckRetVal ( int rv, std::string fname ) {
    switch ( rv ) {
    case 0:
        break;
    case ENOMEM:
        // This could get complicated, because there is no memory
        throw ECASGarbageThread_ENOMEM ( fname );
    case EAGAIN:
        throw ECASGarbageThread_EAGAIN ( fname );
    case EINVAL:
        throw ECASGarbageThread_EINVAL ( fname );
    case ESRCH:
        throw ECASGarbageThread_ESRCH ( fname, tid );
    case EDEADLK:
        throw ECASGarbageThread_EDEADLK ( fname );
    default:
        throw ECASGarbageThread_UNKNOWN ( fname );
    }
}

// ----------------------------------------------------------------------------


// Protected methods
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------


// Constructors & Destructor
// ----------------------------------------------------------------------------

CASGarbage::CASGarbage() : min_casobjects ( 200 ),
        time_to_die ( false ),
        trasher_thread_created ( false ) {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# CASGarbage::CASGarbage()" << std::endl;
#endif
    // Initialize the Mutex Attribute
    int retval = pthread_mutexattr_init ( &mutex_attr );
    CheckRetVal ( retval, std::string ( "pthread_mutexattr_init()" ) );

    // Set the Mutex sharing
    retval = pthread_mutexattr_setpshared ( &mutex_attr, PTHREAD_PROCESS_PRIVATE );
    CheckRetVal ( retval, std::string ( "pthread_mutexattr_setpshared()" ) );

    // Set the Mutex type
    retval = pthread_mutexattr_settype ( &mutex_attr, PTHREAD_MUTEX_ERRORCHECK );
    CheckRetVal ( retval, std::string ( "pthread_mutexattr_settype()" ) );

    // Create the Mutex
    retval = pthread_mutex_init ( &mutex, &mutex_attr );
    CheckRetVal ( retval, std::string ( "pthread_mutex_init()" ) );

    // Create the conditional variable.
    retval = pthread_cond_init ( &cond_var, NULL );
    CheckRetVal ( retval, std::string ( "pthread_cond_init()" ) );
}

CASGarbage::~CASGarbage() {
#ifdef SHOWCONSTRUCTOR
    std::cerr << "# CASGarbage::~CASGarbage()" << std::endl;
#endif

    TerminateTrasherThread();

    // Clean up for the last time. The trasher thread might left
    // objects undestroyed since the threshold for cleaning up was not
    // reached.
    RemoveDuplicate();
    std::for_each ( list.begin(),
                    list.end(),
                    CASDestroyObject() );

    // Destroy Mutex
    int retval = pthread_mutex_destroy ( &mutex );
    CheckRetVal ( retval, std::string ( "phtread_mutex_destroy()" ) );

    // Destroy Mutex Attribute
    retval = pthread_mutexattr_destroy ( &mutex_attr );
    CheckRetVal ( retval, std::string ( "pthread_mutexattr_destroy()" ) );

    // Destroy conditional variable
    retval = pthread_cond_destroy ( &cond_var );
    CheckRetVal ( retval, std::string ( "pthread_cond_destroy()" ) );

}

CASGarbage::CASGarbage ( const CASGarbage &wdc ) : min_casobjects ( 0 ) {
    throw EDoesNotApply();
}

// ----------------------------------------------------------------------------

// Public Methods
// ----------------------------------------------------------------------------

void*
CASGarbage::Trasher() {
    int retval = pthread_mutex_lock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );

    while ( time_to_die != true ) {
        if ( list.size() > min_casobjects ) {
            RemoveDuplicate();

            std::for_each ( list.begin(),
                            list.end(),
                            CASDestroyObject() );
            list.clear();
        }

        retval = pthread_cond_wait ( &cond_var, &mutex );
        CheckRetVal ( retval, std::string ( "pthread_cond_wait()" ) );
    }

    retval = pthread_mutex_unlock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_unlock()" ) );

    pthread_exit ( 0 );
    return NULL;
}

void
CASGarbage::Put ( CASObject *o ) {
    checkptr ( o );

    CreateTrasherThread();

    // Acquire the mutex
    int retval = pthread_mutex_lock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );
    // Push the value on the list
    list.push_back ( o );

    retval = pthread_mutex_unlock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );

    retval = pthread_cond_broadcast ( &cond_var );
    CheckRetVal ( retval, std::string ( "pthread_cond_broadcast()" ) );
}

void
CASGarbage::Put ( const std::vector<CASObject*> &v ) {

    CreateTrasherThread();

    // Acquire the mutex
    int retval = pthread_mutex_lock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );
    // Push the values on the list
    std::vector<CASObject*>::const_iterator it = v.begin();
    while ( it != v.end() ) {
        list.push_back ( *it );
        it++;
    }

    retval = pthread_mutex_unlock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );

    retval = pthread_cond_broadcast ( &cond_var );
    CheckRetVal ( retval, std::string ( "pthread_cond_broadcast()" ) );
}

void
CASGarbage::Put ( const std::list<CASObject*> &l ) {

    CreateTrasherThread();

    // Acquire the mutex
    int retval = pthread_mutex_lock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );
    // Push the values on the list
    std::list<CASObject*>::const_iterator it = l.begin();
    while ( it != l.end() ) {
        list.push_back ( *it );
        it++;
    }

    retval = pthread_mutex_unlock ( &mutex );
    CheckRetVal ( retval, std::string ( "pthread_mutex_lock()" ) );

    retval = pthread_cond_broadcast ( &cond_var );
    CheckRetVal ( retval, std::string ( "pthread_cond_broadcast()" ) );
}

// ----------------------------------------------------------------------------

// Operators
// ----------------------------------------------------------------------------
CASGarbage &
CASGarbage::operator= ( const CASGarbage &wdc ) {
    throw EDoesNotApply();
}
// ----------------------------------------------------------------------------

---