UT_SharedMemoryManager.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_SharedMemoryManager.h ( UT Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __UT_SharedMemoryManager__
#define __UT_SharedMemoryManager__

#include "UT_API.h"

#include "UT_Map.h"
#include "UT_StringMap.h"
#include "UT_SpinLock.h"

class SYS_SharedMemory;

class UT_API UT_SharedMemoryManager
{
public:
    static UT_SharedMemoryManager &get();

    // Creates a new memory block with the given identifier and size and marks
    // it as being used. Returns false if the given key already exists
    // in the shared memory pool or the constructed memory block is invlaid,
    // true otherwise.
    bool                add(const char *key, const char *id, int64_t size);

    // Retrieves an existing memory block, or creates an empty one and marks
    // it as being used.
    SYS_SharedMemory    *get(const char *key);

    // Returns true if a shared memory block mapping to the given key exists
    // in the shared memory pool, false otherwise.
    bool                contains(const char *key);

    // Mark all shared memory blocks with keys matching the pattern as being
    // unused. If a block is retrieved with get() it gets marked as used. Any
    // blocks remaining unused after an operation can be erased by calling
    // erase() with 'only_unused' set to true.
    void                 setUnused(const char *pattern);

    // Destroys all shared memory blocks with keys matching the given pattern.
    // 
    void                 erase(const char *pattern, bool only_unused = false);

    // Exit callback to destroy all known shared memory blocks, so they don't
    // linger on-disk or in page file after the owning process dies.
    static void exitCallback(void *);
private:
     UT_SharedMemoryManager();

     UT_SharedMemoryManager(const UT_SharedMemoryManager &) = delete;
     UT_SharedMemoryManager &operator=(const UT_SharedMemoryManager &) = delete;

    // Finds a list of keys matching the pattern. If all keys match the pattern
    // the array is empty but the function still returns true.
    bool                find(const char *pattern, UT_Array<const char *> &keys);
    
    static UT_SpinLock            theInstanceLock;
    static UT_SharedMemoryManager *theInstance;

    struct ut_AutoSharedMemory
    {
        ut_AutoSharedMemory() : mySharedMemory(0), myUsed(false) {}
        ~ut_AutoSharedMemory();

        ut_AutoSharedMemory(const ut_AutoSharedMemory &) = delete;
        ut_AutoSharedMemory &operator=(const ut_AutoSharedMemory &) = delete;
        
        SYS_SharedMemory        *mySharedMemory;
        bool                     myUsed;
    };

    typedef UT_StringMap<ut_AutoSharedMemory>    ut_SharedMemPool;

    ut_SharedMemPool            mySharedMemPool;
};

#endif // __UT_SharedMemoryManager__