MirrorBufferSet.cc

Go to the documentation of this file.

//=============================================================================
//  $Id: MirrorBufferSet.cc,v 1.1 2006/06/12 20:21:44 gallen Exp $
//-----------------------------------------------------------------------------
//  A set of "mirrored" buffers
//=============================================================================

#include "common_priv.h"
#include "MirrorBufferSet.h"

#define MirrorBufferSet_SUPPORTED 1

#include <unistd.h>

#if defined(_POSIX_SHARED_MEMORY_OBJECTS)
    #define MBS_USE_POSIX_SHM 1
#if !defined(__linux__)
    #define _POSIX_C_SOURCE 199309
#endif
    #include <string.h>
    #include <errno.h>
#else
    #define MBS_USE_POSIX_SHM 0
//  #warning POSIX shared memory objects not supported
#endif

//-----------------------------------------------------------------------------
int MirrorBufferSet::Supported(void)
//-----------------------------------------------------------------------------
{
    #if !MirrorBufferSet_SUPPORTED
        return eNotSupported;
    #endif

    #if MBS_USE_POSIX_SHM
        return eSupportedPosixShm;
    #else
        return eSupportedTmpFile;
    #endif
}


#if MirrorBufferSet_SUPPORTED


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <assert.h>
#include <stdexcept>
#include <sys/mman.h>
#include <string.h>
#include <string>
#include <vector>


#ifndef MAP_FAILED
    // not defined in AIX, HPUX
    #define MAP_FAILED      ((void*)-1)
#endif

#ifndef MAP_NORESERVE
    // not defined in AIX, IRIX, LinuxPPC
    #define MAP_NORESERVE   (0)
#endif

std::string StrError(int error) {
    static const char UNKNOWN_ERROR[] = "Unknown error";
    std::vector<char> errstr(256, '\0');
    do {
#if defined(__APPLE__)
        // if __APPLE__ strerror_r is declared to return an int
        int err = strerror_r(error, &errstr[0], errstr.size());
        if (err == 0) {
            return &errstr[0];
        } else {
            if (errno == ERANGE) {
                errstr.resize(2*errstr.size(), '\0');
            } else {
                return UNKNOWN_ERROR;
            }
        }
#else
        char *str = strerror_r(error, &errstr[0], errstr.size());

        // Wierdness with different versions of strerror... From the man page:
        //
        //  The strerror() and strerror_r() functions return the appropriate
        //  error description string, or an "Unknown error nnn" message if the
        //  error number is unknown.
        //
        //  The XSI-compliant strerror_r() function returns 0 on success; on
        //  error, -1 is returned and errno is set to indicate the error.
        //
        // So str can be ether an error code OR a pointer to the error
        // string...  wierdness.

        if (str == (char*)-1) {
            if (errno == ERANGE) {
                errstr.resize(2*errstr.size(), '\0');
            } else {
                 return UNKNOWN_ERROR;
            }
        } else if (str == 0) {
            return &errstr[0];
        } else {
            return str;
        }
#endif
    } while (true);
}


// on AIX and HPUX, this compiles, but give a runtime error from mmap()
// on IRIX, this works, although shm_open is not quite POSIX compliant


//-----------------------------------------------------------------------------
//  flags and definitions for debugging printouts
//-----------------------------------------------------------------------------
#ifndef MirrorBufferSet_VERBOSITY
#define MirrorBufferSet_VERBOSITY 0
#endif

#if MirrorBufferSet_VERBOSITY >= 1
    #define fprintf1(p) fprintf p
#else
    #define fprintf1(p)
#endif

#if MirrorBufferSet_VERBOSITY >= 2
    #define fprintf2(p) fprintf p
#else
    #define fprintf2(p)
#endif


//-----------------------------------------------------------------------------
MirrorBufferSet::MirrorBufferSet(ulong bufferSz, ulong mirrorSz, int nBuffers)
//-----------------------------------------------------------------------------
:   bufferBase(0),
    bufferSize(bufferSz),
    mirrorSize(mirrorSz),
    numBuffers(nBuffers)
{
    fileName[0] = 0;
    ulong pageSize = PageSize();

    // if bufferSize or mirrorSize are not a multiple of pageSize, round them up
    if (bufferSize % pageSize) {
        bufferSize += pageSize - (bufferSize % pageSize);
    }
    if (mirrorSize % pageSize) {
        mirrorSize += pageSize - (mirrorSize % pageSize);
    }

#if 1
    // do a sanity check for our math
    if ( bufferSize % pageSize)
        fprintf(stderr, "### Error: bufferSize = %lu is not a multiple of pageSize = %lu\n",
            bufferSize, pageSize);
    if ( mirrorSize % pageSize)
        fprintf(stderr, "### Error: mirrorSize = %lu is not a multiple of pageSize = %lu\n",
            mirrorSize, pageSize);
#endif

    int fd = GetFileDescriptor();

    // make the file large enough
    ulong numBytes = (bufferSize+mirrorSize) * numBuffers;
    if ( ftruncate(fd, numBytes) ) {
        perror("ftruncate");
        close(fd);
        throw std::runtime_error(StrError(errno));
    }

    // map the entire buffer space, so there will be enough space reserved
    fprintf1((stderr,"MirrorBufferSet: reserving %lu bytes for mapping ", numBytes));
    caddr_t baseAddr = (caddr_t) mmap(0, numBytes, PROT_READ|PROT_WRITE, 
            MAP_SHARED|MAP_NORESERVE, fd, (off_t)0);
    if (baseAddr == MAP_FAILED) {
        fprintf1((stderr,"failed\n"));
        perror("mmap");
        close(fd);
        throw std::runtime_error(StrError(errno));
    }
    bufferBase = baseAddr;
    fprintf1((stderr,"[%p - %p)\n", (void*)baseAddr, (void*)(baseAddr+numBytes)));
    fprintf1((stderr,"MirrorBufferSet: file \"%s\" is %d bytes\n",
        fileName, (int)(bufferSize*numBuffers)));

    // now map each of the individual buffers twice
    for (int buf=0; buf<numBuffers; buf++) {
        // once for the buffer
        caddr_t theAddr     = baseAddr+buf*(bufferSize+mirrorSize);
        size_t  theSize     = bufferSize;
        off_t  theOffset   = buf*bufferSize;
        fprintf2((stderr,"mapping 0x%06lX bytes @ offset 0x%06lX ", (long unsigned)theSize, (long unsigned)theOffset));
        caddr_t addr = (caddr_t) mmap(theAddr, theSize, PROT_READ|PROT_WRITE,
            MAP_SHARED|MAP_FIXED|MAP_NORESERVE, fd, theOffset);
        if (addr == MAP_FAILED) {
            fprintf2((stderr,"failed\n"));
            perror("mmap");
            close(fd);
            throw std::runtime_error(StrError(errno));
        }
        fprintf2((stderr,"to [%p - %p)\n", (void*)theAddr, (void*)(theAddr+theSize)));
        if (addr!=theAddr) {
            fprintf(stderr, "### Error: mapped to 0x%p instead of 0x%p\n",
                addr, theAddr );
            close(fd);
            throw std::runtime_error(StrError(errno));
        }

        // and again for the mirror
        theAddr     +=bufferSize;
        theSize     = mirrorSize;
        fprintf2((stderr,"mapping 0x%06lX bytes @ offset 0x%06lX ", (long unsigned)theSize, (long unsigned)theOffset));
        addr = (caddr_t) mmap(theAddr, theSize, PROT_READ|PROT_WRITE,
            MAP_SHARED|MAP_FIXED|MAP_NORESERVE, fd, theOffset);
        if (addr == MAP_FAILED) {
            fprintf2((stderr,"failed\n"));
            perror("mmap");
            close(fd);
            throw std::runtime_error(StrError(errno));
        }
        fprintf2((stderr,"to [%p - %p)\n", (void*)theAddr, (void*)(theAddr+theSize)));
        if (addr!=theAddr) {
            fprintf(stderr, "### Error: mapped to 0x%p instead of 0x%p\n", addr, theAddr );
            close(fd);
            throw std::runtime_error(StrError(errno));
        }
    }

    // close the file
    if ( close(fd) ) {
        perror("close");
    }
}


//-----------------------------------------------------------------------------
int MirrorBufferSet::GetFileDescriptor(void)
//-----------------------------------------------------------------------------
{
    // get a temporary file name
#if MBS_USE_POSIX_SHM
    unsigned i = 0;
    while (true) {
        sprintf(fileName, "/MirrorBufferSet-%u", i);
        #if defined(OS_IRIX) || defined(OS_HPUX)
        // these platforms don't do shm_open as defined in the spec 
        tmpnam(fileName);
        fprintf2((stderr,"tmpnam returned \"%s\"\n",fileName));
        #endif
        fprintf2((stderr,"calling shm_open with \"%s\"\n",fileName));
        int fd = shm_open(fileName,O_RDWR|O_CREAT|O_EXCL,0600);
        if (fd < 0) {
            if (errno == EEXIST) {
                ++i;
            } else{
                fprintf(stderr, "shm_open \"%s\": ", fileName);
                perror(0);
                return -1;
            }
        } else {
            // remove the shared memory object
            if ( shm_unlink(fileName) ) {
                fprintf(stderr, "### shm_unlink(\"%s\") failed: ", fileName);
                perror(0);
            }
            return fd;
        }
    }
#else
    sprintf(fileName, "/tmp/MirrorBufferSet-XXXXXX");
    int fd = mkstemp(fileName);
    // remove the temporary file
    if ( unlink(fileName) ) {
        fprintf(stderr, "### unlink(\"%s\") failed: ", fileName);
        perror(0);
    }
    return fd;
#endif
}


//-----------------------------------------------------------------------------
MirrorBufferSet::~MirrorBufferSet(void)
//-----------------------------------------------------------------------------
{
    if (!bufferBase) return;

    // unmap the file
    if ( munmap((caddr_t)bufferBase, (bufferSize+mirrorSize)*numBuffers) ) {
        perror("munmap");
    }
    fprintf2((stderr,"unmapped- \"%s\" [%p - %p), %lu bytes\n",
        fileName, bufferBase,
        (void*)((char*)bufferBase+((bufferSize+mirrorSize)*numBuffers)),
        ((bufferSize+mirrorSize)*numBuffers)));
}


//-----------------------------------------------------------------------------
unsigned long MirrorBufferSet::PageSize(void)
//-----------------------------------------------------------------------------
{
#ifdef __APPLE__
    return getpagesize();
#else
    return sysconf(_SC_PAGESIZE);
#endif
}


#endif