MemoryMappedFile.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.
 *
 * Written (W) 2009 Soeren Sonnenburg
 * Copyright (C) 2009 Fraunhofer Institute FIRST and Max-Planck-Society
 */

#ifndef __MEMORYMAPPEDFILE_H__
#define __MEMORYMAPPEDFILE_H__

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

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>

namespace shogun
{
template <class T> class CMemoryMappedFile : public CSGObject
{
    public:
        CMemoryMappedFile() :CSGObject()
        {
            SG_UNSTABLE("CMemoryMappedFile::CMemoryMappedFile()",
                        "\n");

            fd = 0;
            length = 0;
            address = NULL;
            rw = 'r';
            last_written_byte = 0;

            set_generic<T>();
        }

        CMemoryMappedFile(const char* fname, char flag='r', int64_t fsize=0)
        : CSGObject()
        {
            REQUIRE(flag=='w' || flag=='r', "Only 'r' and 'w' flags are allowed")

            last_written_byte=0;
            rw=flag;

            int open_flags=O_RDONLY;
            int mmap_prot=PROT_READ;
            int mmap_flags=MAP_PRIVATE;

            if (rw=='w')
            {
                open_flags=O_RDWR | O_CREAT;
                mmap_prot=PROT_READ|PROT_WRITE;
                mmap_flags=MAP_SHARED;
            }

            fd = open(fname, open_flags, S_IRWXU | S_IRWXG | S_IRWXO);
            if (fd == -1)
                SG_ERROR("Error opening file\n")

            if (rw=='w' && fsize)
            {
                uint8_t byte=0;
                if (lseek(fd, fsize, SEEK_SET) != fsize || write(fd, &byte, 1) != 1)
                    SG_ERROR("Error creating file of size %ld bytes\n", fsize)
            }

            struct stat sb;
            if (fstat(fd, &sb) == -1)
                SG_ERROR("Error determining file size\n")

            length = sb.st_size;
            address = mmap(NULL, length, mmap_prot, mmap_flags, fd, 0);
            if (address == MAP_FAILED)
                SG_ERROR("Error mapping file")

                set_generic<T>();
        }

        virtual ~CMemoryMappedFile()
        {
            munmap(address, length);
            if (rw=='w' && last_written_byte && ftruncate(fd, last_written_byte) == -1)

            {
                close(fd);
                SG_ERROR("Error Truncating file to %ld bytes\n", last_written_byte)
            }
            close(fd);
        }

        inline T* get_map()
        {
            return (T*) address;
        }

        uint64_t get_length()
        {
            return length/sizeof(T);
        }

        uint64_t get_size()
        {
            return length;
        }

        char* get_line(uint64_t& len, uint64_t& offs)
        {
            char* s = (char*) address;
            for (uint64_t i=offs; i<length; i++)
            {
                if (s[i] == '\n')
                {
                    char* line=&s[offs];
                    len=i-offs;
                    offs=i+1;
                    return line;
                }
            }

            len=0;
            offs=length;
            return NULL;
        }

        void write_line(const char* line, uint64_t len, uint64_t& offs)
        {
            char* s = ((char*) address) + offs;
            if (len+1+offs > length)
                SG_ERROR("Writing beyond size of file\n")

            for (uint64_t i=0; i<len; i++)
                s[i] = line[i];

            s[len]='\n';
            offs+=length+1;
            last_written_byte=offs-1;
        }

        inline void set_truncate_size(uint64_t sz=0)
        {
            last_written_byte=sz;
        }

        int32_t get_num_lines()
        {
            char* s = (char*) address;
            int32_t linecount=0;
            for (uint64_t i=0; i<length; i++)
            {
                if (s[i] == '\n')
                    linecount++;
            }

            return linecount;
        }

        inline T operator[](uint64_t index) const
        {
          return ((T*)address)[index];
        }

        inline T operator[](int32_t index) const
        {
          return ((T*)address)[index];
        }

        virtual const char* get_name() const { return "MemoryMappedFile"; }

    protected:
        int fd;
        uint64_t length;
        void* address;
        char rw;

        uint64_t last_written_byte;
};
}
#endif