tpzautopointer.h

Go to the documentation of this file.

#ifndef TPZAUTOPOINTER_H
#define TPZAUTOPOINTER_H

#include "pz_pthread.h"

#define AP_MUTEX_ARRAY_SZ 512

/* Define PROFILE_AP_MUTEXES if you want to profile the autopointer mutexes use. */
//#define PROFILE_AP_MUTEXES

#ifdef PROFILE_AP_MUTEXES
extern uint64_t ap_mutex_accesses[];
#endif

#define AP_MUTEX_HASH_1         \
addr = (addr >> 32) ^ addr;   \
addr = (addr >> 16) ^ addr;   \
addr = (addr >> 8)  ^ addr;   \
addr = (addr >> 4)  ^ addr;   \
i = (unsigned) (addr % AP_MUTEX_ARRAY_SZ)

#define AP_MUTEX_HASH_2         \
addr = (addr >> 8)  ^ addr;   \
addr = (addr >> 4)  ^ addr;   \
i = (unsigned) (addr % AP_MUTEX_ARRAY_SZ)

extern pthread_mutex_t gAutoPointerMutexArray[];
inline pthread_mutex_t* get_ap_mutex(void* obj)
{
                unsigned i;
                uint64_t addr = (uint64_t) obj;
                //  AP_MUTEX_HASH_1;
                AP_MUTEX_HASH_2;
#ifdef PROFILE_AP_MUTEXES
                ap_mutex_accesses[i]++;
#endif
                return &(gAutoPointerMutexArray[i]);
}

#include <stdlib.h>



template<class T>
class TPZAutoPointer {
    
                template<class T2>
    struct TPZReference
    {
        T2 *fPointer;
        int *fCounter;
        
        TPZReference()
        {
            fPointer = nullptr;
            fCounter = new int;
            (*fCounter) = 1;
        }
        
        TPZReference(T2 *pointer)
        {
            fPointer = pointer;
            fCounter = new int;
            (*fCounter) = 1;
        }
        
        ~TPZReference()
        {
            if(fPointer) {
                delete fPointer;
            }
            fPointer = nullptr;
            if(fCounter) {
                delete fCounter;
            }
            fCounter = nullptr;
        }
        
        void ReallocForNuma(int node_id)
        {
            // -2: Do not realloc
            // -1: Realloc to the node that is currently running this thread.
            // node_id>=0 : Realloc to node_id
            
            if (node_id == -2) return;
            
            //TODO: Currently relying on first-touch policy to implement case -1
            
            T2* old = fPointer;
            fPointer = (T2*) fPointer->Clone();
            delete old;
        }
        

        bool Increment()
        {
            if(PZ_PTHREAD_MUTEX_LOCK(get_ap_mutex((void*) this), __PRETTY_FUNCTION__))
                return false;
            (*fCounter)++;
            PZ_PTHREAD_MUTEX_UNLOCK(get_ap_mutex((void*) this), __PRETTY_FUNCTION__);
            return true;
        }
        bool Decrease()
        {
            bool should_delete = false;
            if(PZ_PTHREAD_MUTEX_LOCK(get_ap_mutex((void*) this), __PRETTY_FUNCTION__))
                return false;
            (*fCounter)--;
            
            if((*fCounter) <= 0) should_delete = true;
            
            PZ_PTHREAD_MUTEX_UNLOCK(get_ap_mutex((void*) this), __PRETTY_FUNCTION__);
            if(should_delete)
            {
                delete this;
            }
            return true;
        }
        
    };
    
                TPZReference<T> *fRef;
    
public:
                TPZAutoPointer()
                {
                                fRef = new TPZReference<T>();
                }
    
                ~TPZAutoPointer()
                {
            if (fRef){
                                fRef->Decrease();
            }
                }
    
                TPZAutoPointer(T *obj)
                {
                                fRef = new TPZReference<T>(obj);
                }
    
                TPZAutoPointer(const TPZAutoPointer<T> &copy)
                {
                                fRef = copy.fRef;
                                fRef->Increment();
                }
        
                TPZAutoPointer &operator=(TPZAutoPointer<T> &&copy){
            if (fRef) {
                fRef->Decrease();
            }
            fRef = copy.fRef;
            copy.fRef = nullptr;
            return *this;
        }
        
                TPZAutoPointer &operator=(const TPZAutoPointer<T> &copy)
                {
                                if(copy.fRef == fRef) return *this;
                                copy.fRef->Increment();
                                fRef->Decrease();
                                fRef = copy.fRef;
                                return *this;
                }
    
                operator T&()
                {
                                return *(fRef->fPointer);
                }
        
                T& operator *() const
                {
                                return *(fRef->fPointer);
                }
        
                T& operator *()
                {
                                return *(fRef->fPointer);
                }
    
                T *operator->() const
                {
                                return fRef->fPointer;
                }
                T *operator->()
                {
                                return fRef->fPointer;
                }
    
                void ReallocForNuma(int node)
                {
                                fRef->ReallocForNuma(node);
                }
    
                operator bool() const{
                                return (this->fRef->fPointer != nullptr);
                }
                operator bool() {
                                return fRef->fPointer != nullptr;
                }
    
                int Count() const
                {
                                return *(fRef->fCounter);
                }
                int Count()
                {
                                return *(fRef->fCounter);
                }
    template<typename R, typename T2>
    friend TPZAutoPointer<R> TPZAutoPointerDynamicCast(TPZAutoPointer<T2> in);
};
        
template<typename R, typename T>
TPZAutoPointer<R> TPZAutoPointerDynamicCast(TPZAutoPointer<T> in) {
    TPZAutoPointer<R> rv;
    R* p;
    if ( (p = dynamic_cast<R*> (in.operator->())) ) {
        rv.fRef->fPointer = dynamic_cast<R*> (in.fRef->fPointer);
                                delete rv.fRef->fCounter;
                                rv.fRef->fCounter = in.fRef->fCounter;
        rv.fRef->Increment();
    }
    return rv;
}

#endif