SGReferencedData.h

Go to the documentation of this file.

/*
 * 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.
 *
 * Copyright (C) 2012 Soeren Sonnenburg
 */
#ifndef __SGREFERENCED_DATA_H__
#define __SGREFERENCED_DATA_H__

#include <shogun/io/SGIO.h>
#include <shogun/base/Parallel.h>

#ifdef HAVE_PTHREAD
#include <pthread.h>
#endif

struct refcount_t 
{
    int32_t rc;
#ifdef HAVE_PTHREAD

    PTHREAD_LOCK_T lock;
#endif
};

namespace shogun
{
class SGReferencedData
{
    public:
        SGReferencedData(bool ref_counting=true) : m_refcount(NULL)
        { 
            if (ref_counting)
            {
                m_refcount = SG_CALLOC(refcount_t, 1);
                PTHREAD_LOCK_INIT(&m_refcount->lock);
            }

            ref();
        }

        SGReferencedData(const SGReferencedData &orig)
            : m_refcount(orig.m_refcount)
        {
            ref();
        }

        SGReferencedData& operator= (const SGReferencedData &orig)
        {
            if (this == &orig)
                return *this;

            unref();
            copy_data(orig);
            copy_refcount(orig);
            ref();
            return *this;
        }

        virtual ~SGReferencedData()
        {
        }

        int32_t ref_count()
        {
            if (m_refcount == NULL)
                return -1;

#ifdef HAVE_PTHREAD
            PTHREAD_LOCK(&m_refcount->lock);
#endif
            int32_t c = m_refcount->rc;
#ifdef HAVE_PTHREAD
            PTHREAD_UNLOCK(&m_refcount->lock);
#endif 

#ifdef DEBUG_SGVECTOR
            SG_SGCDEBUG("ref_count(): refcount %d, data %p\n", c, this);
#endif
            return c;
        }

    protected:
        void copy_refcount(const SGReferencedData &orig)
        {
            m_refcount=orig.m_refcount;
        }

        int32_t ref()
        {
            if (m_refcount == NULL)
            {
                return -1;
            }

#ifdef HAVE_PTHREAD
            PTHREAD_LOCK(&m_refcount->lock);
#endif
            int32_t c = ++(m_refcount->rc);
#ifdef HAVE_PTHREAD
            PTHREAD_UNLOCK(&m_refcount->lock);
#endif 
#ifdef DEBUG_SGVECTOR
            SG_SGCDEBUG("ref() refcount %ld data %p increased\n", c, this);
#endif
            return c;
        }

        int32_t unref()
        {
            if (m_refcount == NULL)
            {
                init_data();
                m_refcount=NULL;
                return -1;
            }

#ifdef HAVE_PTHREAD
            PTHREAD_LOCK(&m_refcount->lock);
#endif
            int32_t c = --(m_refcount->rc);
#ifdef HAVE_PTHREAD
            PTHREAD_UNLOCK(&m_refcount->lock);
#endif 
            if (c<=0)
            {
#ifdef DEBUG_SGVECTOR
                SG_SGCDEBUG("unref() refcount %d data %p destroying\n", c, this);
#endif
                free_data();
#ifdef HAVE_PTHREAD
            PTHREAD_LOCK_DESTROY(&m_refcount->lock);
#endif
                SG_FREE(m_refcount);
                m_refcount=NULL;
                return 0;
            }
            else
            {
#ifdef DEBUG_SGVECTOR
                SG_SGCDEBUG("unref() refcount %d data %p decreased\n", c, this);
#endif
                init_data();
                m_refcount=NULL;
                return c;
            }
        }

        virtual void copy_data(const SGReferencedData &orig)=0;

        virtual void init_data()=0;

        virtual void free_data()=0;

    private:

        refcount_t* m_refcount;
};
}
#endif // __SGREFERENCED_DATA_H__