VuoHeap.cc

Go to the documentation of this file.

 
#include "VuoHeap.h"
#include <dispatch/dispatch.h>
#include <dlfcn.h>
#include <sys/errno.h>
#include <sys/mman.h>
#include <map>
#include <set>
#include <sstream>
#include <iomanip>
using namespace std;
#include "VuoLog.h"
#include "VuoRuntime.h"
 
static set<const void *> *VuoHeap_trace;    
 
void sendErrorWrapper(const char *message)
{
#ifdef VUOHEAP_TRACE
    fprintf(stderr, "%s\n", message);
    VuoLog_backtrace();
#endif
 
    VuoSendErrorType *vuoSendError = (VuoSendErrorType *) dlsym(RTLD_SELF, "vuoSendError");  // for running composition in separate process as executable or in current process
    if (! vuoSendError)
        vuoSendError = (VuoSendErrorType *) dlsym(RTLD_DEFAULT, "vuoSendError");  // for running composition in separate process as dynamic libraries
 
    pthread_key_t *vuoCompositionStateKey = (pthread_key_t *) dlsym(RTLD_SELF, "vuoCompositionStateKey");
    if (! vuoCompositionStateKey)
        vuoCompositionStateKey = (pthread_key_t *) dlsym(RTLD_DEFAULT, "vuoCompositionStateKey");
 
    void *compositionState = NULL;
    if (vuoCompositionStateKey)
        compositionState = pthread_getspecific(*vuoCompositionStateKey);
 
    if (vuoSendError && compositionState)
        vuoSendError((VuoCompositionState *)compositionState, message);
    else
        VUserLog("%s", message);
}
 
#ifdef VUOHEAP_TRACEALL
 
static bool VuoHeap_isComposition(void)
{
    static bool isComposition = false;
    static dispatch_once_t once = 0;
    dispatch_once(&once, ^{
        isComposition = dlsym(RTLD_DEFAULT, "vuoCompositionStateKey");
    });
    return isComposition;
}
#endif
 
typedef struct
{
    int referenceCount;
    DeallocateFunctionType deallocateFunction;
 
    const char *file;
    unsigned int line;
    const char *function;
    const char *variable;
} VuoHeapEntry;
 
static map<const void *, VuoHeapEntry> *referenceCounts;  
static set<const void *> *singletons;  
static unsigned int *referenceCountsSemaphore = 0;  
 
static inline void VuoHeap_lock(void)
{
    while (1)
    {
        for (int i = 0; i < 10000; ++i)
            if (__sync_bool_compare_and_swap(referenceCountsSemaphore, 0, 1))
                return;
 
        sched_yield();
    }
}
 
static inline void VuoHeap_unlock(void)
{
    __sync_synchronize();
    *referenceCountsSemaphore = 0;
}
 
bool VuoHeap_isPointerReadable(const void *pointer)
{
    // Round down to the beginning of `pointer`'s heap page.
    // Assume getpagesize() returns a power-of-two; subtracting 1 turns it into a bitmask.
    int pageSize = getpagesize();
    long heapPageMask = ~((long)pageSize-1);
    long heapPage = (long)pointer & heapPageMask;
 
    // Try to load the page into core.
    mlock((void *)heapPage, pageSize);
    munlock((void *)heapPage, pageSize);
 
    // Check whether the page was successfully loaded into core.
    char pageStatus[1];
    if (mincore((void *)heapPage, pageSize, pageStatus) == 0)
        return pageStatus[0] & MINCORE_INCORE;
 
    else
        return false;
}
 
static void VuoHeap_makeSafePointerSummary(char *summary, const void *pointer)
{
    if (VuoHeap_isPointerReadable(pointer)
     && VuoHeap_isPointerReadable((char *)pointer + 15))
    {
        // Page(s) are valid, so output the pointer's first 16 printable characters.
        char *pointerAsChar = (char *)pointer;
        for (int i = 0; i < 16; ++i)
            if (isprint(pointerAsChar[i]))
                summary[i] = pointerAsChar[i];
            else
                summary[i] = '_';
        summary[16] = 0;
    }
    else
        strlcpy(summary, "(not allocated)", 17);
}
 
static char *VuoHeap_makeDescription(VuoHeapEntry e)
{
    const char *format = "%s:%d :: %s() :: %s";
    int size = snprintf(NULL, 0, format,  e.file, e.line, e.function, e.variable);
    char *description = (char *)malloc(size+1);
    snprintf(description, size+1, format, e.file, e.line, e.function, e.variable);
    return description;
}
 
static void __attribute__((constructor(101))) VuoHeap_init()
{
    referenceCounts = new map<const void *, VuoHeapEntry>;
    singletons = new set<const void *>;
    VuoHeap_trace = new set<const void *>;
    referenceCountsSemaphore = (unsigned int *)malloc(sizeof(unsigned int));
    *referenceCountsSemaphore = 0;
 
#ifdef VUOHEAP_TRACE
    VUserLog("table=%p", referenceCounts);
#endif
 
#if 0
    // Periodically dump the referenceCounts table, to help find leaks.
    const double dumpInterval = 5.0; // seconds
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, DISPATCH_TIMER_STRICT, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
    dispatch_source_set_timer(timer, dispatch_walltime(NULL,0), NSEC_PER_SEC*dumpInterval, NSEC_PER_SEC*dumpInterval);
    dispatch_source_set_event_handler(timer, ^{
                                          fprintf(stderr, "\n\n\n\n\nreferenceCounts:\n");
                                          VuoHeap_lock();
                                          for (map<const void *, VuoHeapEntry>::iterator i = referenceCounts->begin(); i != referenceCounts->end(); ++i)
                                          {
                                              const void *heapPointer = i->first;
                                              char pointerSummary[17];
                                              VuoHeap_makeSafePointerSummary(pointerSummary, heapPointer);
                                              char *description = VuoHeap_makeDescription(i->second);
                                              fprintf(stderr, "\t% 3d refs to %p \"%s\", registered at %s\n", i->second.referenceCount, heapPointer, pointerSummary, description);
                                              free(description);
                                          }
                                          VuoHeap_unlock();
                                      });
    dispatch_resume(timer);
#endif
}
 
void VuoHeap_report(void)
{
    VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
    VuoHeap_lock();
    VUOLOG_PROFILE_END(referenceCountsSemaphore);
    {
 
    if (! referenceCounts->empty())
    {
        ostringstream errorMessage;
        errorMessage << "On reference table " << referenceCounts
                     << ", VuoRelease was not called enough times for:" << endl;
        for (map<const void *, VuoHeapEntry>::iterator i = referenceCounts->begin(); i != referenceCounts->end(); ++i)
        {
            const void *heapPointer = i->first;
            char pointerSummary[17];
            VuoHeap_makeSafePointerSummary(pointerSummary, heapPointer);
            char *description = VuoHeap_makeDescription(i->second);
            errorMessage << "\t" << setw(3) << i->second.referenceCount << " refs to " << heapPointer << " \"" << pointerSummary << "\", registered at " << description << endl;
            free(description);
        }
        sendErrorWrapper(errorMessage.str().c_str());
    }
 
    }
    VuoHeap_unlock();
}
 
int VuoRegisterF(const void *heapPointer, DeallocateFunctionType deallocate, const char *file, unsigned int linenumber, const char *func, const char *pointerName)
{
    if (! heapPointer)
        return -1;
 
    bool isAlreadyReferenceCounted;
    int updatedCount;
 
    VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
    VuoHeap_lock();
    VUOLOG_PROFILE_END(referenceCountsSemaphore);
    {
 
#ifdef VUOHEAP_TRACE
#ifdef VUOHEAP_TRACEALL
        if (VuoHeap_isComposition())
#else
        if (VuoHeap_trace->find(heapPointer) != VuoHeap_trace->end())
#endif
        {
            fprintf(stderr, "table=%p  VuoRegister(%p)  %s\n", referenceCounts, heapPointer, pointerName);
            VuoLog_backtrace();
        }
#endif
 
        map<const void *, VuoHeapEntry>::iterator i = referenceCounts->find(heapPointer);
        isAlreadyReferenceCounted = (i != referenceCounts->end());
        if (! isAlreadyReferenceCounted)
        {
            updatedCount = 0;
            (*referenceCounts)[heapPointer] = (VuoHeapEntry){updatedCount, deallocate, file, linenumber, func, pointerName};
        }
        else
            updatedCount = i->second.referenceCount;
 
    }
    VuoHeap_unlock();
 
    if (isAlreadyReferenceCounted)
    {
        ostringstream errorMessage;
        char *description = VuoHeap_makeDescription((VuoHeapEntry){0, NULL, file, linenumber, func, pointerName});
        errorMessage << "On reference table " << referenceCounts
                     << ", VuoRegister was called more than once for " << heapPointer
                     << " " << description;
        free(description);
        sendErrorWrapper(errorMessage.str().c_str());
    }
 
    return updatedCount;
}
 
int VuoRegisterSingletonF(const void *heapPointer, const char *file, unsigned int linenumber, const char *func, const char *pointerName)
{
    if (! heapPointer)
        return -1;
 
    bool isAlreadyReferenceCounted;
 
    VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
    VuoHeap_lock();
    VUOLOG_PROFILE_END(referenceCountsSemaphore);
    {
 
#ifdef VUOHEAP_TRACE
#ifdef VUOHEAP_TRACEALL
        if (VuoHeap_isComposition())
#else
        if (VuoHeap_trace->find(heapPointer) != VuoHeap_trace->end())
#endif
        {
            fprintf(stderr, "table=%p  VuoRegisterSingleton(%p)  %s\n", referenceCounts, heapPointer, pointerName);
            VuoLog_backtrace();
        }
#endif
 
        // Remove the singleton from the main reference-counting table, if it exists there.
        // Enables reclassifying a pointer that was already VuoRegister()ed.
        referenceCounts->erase(heapPointer);
 
        // Add the singleton to the singleton table.
        isAlreadyReferenceCounted = (singletons->find(heapPointer) != singletons->end());
        if (! isAlreadyReferenceCounted)
            singletons->insert(heapPointer);
    }
    VuoHeap_unlock();
 
    if (isAlreadyReferenceCounted)
    {
        ostringstream errorMessage;
        char *description = VuoHeap_makeDescription((VuoHeapEntry){0, NULL, file, linenumber, func, pointerName});
        errorMessage << "On reference table " << referenceCounts
                     << ", VuoRegisterSingleton was called more than once for " << heapPointer
                     << " " << description;
        free(description);
        sendErrorWrapper(errorMessage.str().c_str());
    }
 
    return isAlreadyReferenceCounted ? 1 : 0;
}
 
extern "C" int VuoRetainF(const void *heapPointer, const char *file, unsigned int linenumber, const char *func)
{
    return VuoRetain(heapPointer);
}
 
int VuoRetain(const void *heapPointer)
{
    if (! heapPointer)
        return -1;
 
    int updatedCount = -1;
    bool foundSingleton = false;
    VuoHeapEntry entry;
 
    VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
    VuoHeap_lock();
    VUOLOG_PROFILE_END(referenceCountsSemaphore);
    {
        map<const void *, VuoHeapEntry>::iterator i = referenceCounts->find(heapPointer);
 
#ifdef VUOHEAP_TRACE
#ifdef VUOHEAP_TRACEALL
        if (VuoHeap_isComposition())
#else
        if (VuoHeap_trace->find(heapPointer) != VuoHeap_trace->end())
#endif
        {
            fprintf(stderr, "table=%p  VuoRetain(%p)  %s\n", referenceCounts, heapPointer, (i != referenceCounts->end()) ? i->second.variable : "");
            VuoLog_backtrace();
        }
#endif
 
        if (i != referenceCounts->end())
            updatedCount = ++(i->second.referenceCount);
        else
            foundSingleton = singletons->find(heapPointer) != singletons->end();
        entry = i->second;
 
    }
    VuoHeap_unlock();
 
    if (updatedCount == -1 && !foundSingleton)
    {
        char pointerSummary[17];
        VuoHeap_makeSafePointerSummary(pointerSummary, heapPointer);
        ostringstream errorMessage;
        errorMessage << "On reference table " << referenceCounts
                     << ", VuoRetain was called for unregistered pointer " << heapPointer
                     << " \"" << pointerSummary << "\"";
        sendErrorWrapper(errorMessage.str().c_str());
    }
 
    return updatedCount;
}
 
extern "C" int VuoReleaseF(const void *heapPointer, const char *file, unsigned int linenumber, const char *func)
{
    return VuoRelease(heapPointer);
}
 
int VuoRelease(const void *heapPointer)
{
    if (! heapPointer)
        return -1;
 
    int updatedCount = -1;
    bool foundSingleton = false;
    bool isRegisteredWithoutRetain = false;
    DeallocateFunctionType deallocate = NULL;
 
    VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
    VuoHeap_lock();
    VUOLOG_PROFILE_END(referenceCountsSemaphore);
    {
        map<const void *, VuoHeapEntry>::iterator i = referenceCounts->find(heapPointer);
 
#ifdef VUOHEAP_TRACE
#ifdef VUOHEAP_TRACEALL
        if (VuoHeap_isComposition())
#else
        if (VuoHeap_trace->find(heapPointer) != VuoHeap_trace->end())
#endif
        {
            fprintf(stderr, "table=%p  VuoRelease(%p)  %s\n", referenceCounts, heapPointer, (i != referenceCounts->end()) ? i->second.variable : "");
            VuoLog_backtrace();
        }
#endif
 
        if (i != referenceCounts->end())
        {
            if (i->second.referenceCount == 0)
            {
                isRegisteredWithoutRetain = true;
            }
            else
            {
                updatedCount = --(i->second.referenceCount);
 
                if (updatedCount == 0)
                {
                    deallocate = i->second.deallocateFunction;
                    referenceCounts->erase(heapPointer);
                }
            }
        }
        else
            foundSingleton = singletons->find(heapPointer) != singletons->end();
 
    }
    VuoHeap_unlock();
 
    if (updatedCount == 0)
    {
#ifdef VUOHEAP_TRACE
#ifdef VUOHEAP_TRACEALL
        if (VuoHeap_isComposition())
        {
#else
        if (VuoHeap_trace->find(heapPointer) != VuoHeap_trace->end())
        {
            VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
            VuoHeap_lock();
            VUOLOG_PROFILE_END(referenceCountsSemaphore);
            {
                VuoHeap_trace->erase(heapPointer);
            }
            VuoHeap_unlock();
#endif
            fprintf(stderr, "table=%p  VuoDeallocate(%p)\n", referenceCounts, heapPointer);
//          VuoLog_backtrace();
        }
#endif
 
        deallocate((void *)heapPointer);
    }
    else if (updatedCount == -1 && !foundSingleton)
    {
        char pointerSummary[17];
        VuoHeap_makeSafePointerSummary(pointerSummary, heapPointer);
        ostringstream errorMessage;
        errorMessage << "On reference table " << referenceCounts
                     << ", VuoRelease was called for "
                     << (isRegisteredWithoutRetain ? "unretained" : "unregistered")
                     << " pointer " << heapPointer
                     << " \"" << pointerSummary << "\"";
        sendErrorWrapper(errorMessage.str().c_str());
    }
 
    return updatedCount;
}
 
const char * VuoHeap_getDescription(const void *heapPointer)
{
    map<const void *, VuoHeapEntry>::iterator i = referenceCounts->find(heapPointer);
    if (i != referenceCounts->end())
        return VuoHeap_makeDescription(i->second);
 
    return strdup("(pointer was not VuoRegister()ed)");
}
 
void VuoHeap_addTrace(const void *heapPointer)
{
    VUOLOG_PROFILE_BEGIN(referenceCountsSemaphore);
    VuoHeap_lock();
    VUOLOG_PROFILE_END(referenceCountsSemaphore);
    {
        VuoHeap_trace->insert(heapPointer);
    }
    VuoHeap_unlock();
}