Cytore.hpp

   1 // Copyright Notice (GNU Affero GPL) {{{
   2 /* Cyndir - (Awesome) Memory Mapped Dictionary
   3  * Copyright (C) 2010  Jay Freeman (saurik)
   4 */
   5
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as
   9  * published by the Free Software Foundation, either version 3 of the
  10  * License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  19 */
  20 // }}}
  21
  22 #ifndef CYTORE_HPP
  23 #define CYTORE_HPP
  24
  25 #include <fcntl.h>
  26
  27 #include <sys/mman.h>
  28 #include <sys/stat.h>
  29
  30 #include <cstdio>
  31 #include <cstdlib>
  32
  33 #include <errno.h>
  34 #include <stdint.h>
  35 #include <unistd.h>
  36
  37 #define _assert(test) do \
  38     if (!(test)) { \
  39         fprintf(stderr, "_assert(%d:%s)@%s:%u[%s]\n", errno, #test, __FILE__, __LINE__, __FUNCTION__); \
  40         exit(-1); \
  41     } \
  42 while (false)
  43
  44 namespace Cytore {
  45
  46 static const uint32_t Magic = 'cynd';
  47
  48 struct Header {
  49     uint32_t magic_;
  50     uint32_t version_;
  51     uint32_t size_;
  52     uint32_t reserved_;
  53 };
  54
  55 template <typename Target_>
  56 class Offset {
  57   private:
  58     uint32_t offset_;
  59
  60   public:
  61     Offset() :
  62         offset_(0)
  63     {
  64     }
  65
  66     Offset(uint32_t offset) :
  67         offset_(offset)
  68     {
  69     }
  70
  71     Offset &operator =(uint32_t offset) {
  72         offset_ = offset;
  73         return *this;
  74     }
  75
  76     uint32_t GetOffset() const {
  77         return offset_;
  78     }
  79
  80     bool IsNull() const {
  81         return offset_ == 0;
  82     }
  83 };
  84
  85 struct Block {
  86     Cytore::Offset<void> reserved_;
  87 };
  88
  89 template <typename Type_>
  90 static _finline Type_ Round(Type_ value, Type_ size) {
  91     Type_ mask(size - 1);
  92     return value + mask & ~mask;
  93 }
  94
  95 template <typename Base_>
  96 class File {
  97   private:
  98     static const unsigned Shift_ = 17;
  99     static const size_t Block_ = 1 << Shift_;
 100     static const size_t Mask_ = Block_ - 1;
 101
 102   private:
 103     int file_;
 104
 105     typedef std::vector<uint8_t *> BlockVector_;
 106     BlockVector_ blocks_;
 107
 108     struct Mapping_ {
 109         uint8_t *data_;
 110         size_t size_;
 111
 112         Mapping_(uint8_t *data, size_t size) :
 113             data_(data),
 114             size_(size)
 115         {
 116         }
 117     };
 118
 119     typedef std::vector<Mapping_> MappingVector_;
 120     MappingVector_ maps_;
 121
 122     Header &Header_() {
 123         return *reinterpret_cast<Header *>(blocks_[0]);
 124     }
 125
 126     uint32_t &Size_() {
 127         return Header_().size_;
 128     }
 129
 130     void Map_(size_t size) {
 131         size_t before(blocks_.size() * Block_);
 132         size_t extend(size - before);
 133
 134         void *data(mmap(NULL, extend, PROT_READ | PROT_WRITE, MAP_FILE | MAP_SHARED, file_, before));
 135         uint8_t *bytes(reinterpret_cast<uint8_t *>(data));
 136
 137         maps_.push_back(Mapping_(bytes,extend));
 138         for (size_t i(0); i != extend >> Shift_; ++i)
 139             blocks_.push_back(bytes + Block_ * i);
 140     }
 141
 142     void Truncate_(size_t capacity) {
 143         capacity = Round(capacity, Block_);
 144         ftruncate(file_, capacity);
 145         Map_(capacity);
 146     }
 147
 148   public:
 149     File() :
 150         file_(-1)
 151     {
 152     }
 153
 154     File(const char *path) :
 155         file_(-1)
 156     {
 157         Open(path);
 158     }
 159
 160     ~File() {
 161         for (typename MappingVector_::const_iterator map(maps_.begin()); map != maps_.end(); ++map)
 162             munmap(map->data_, map->size_);
 163         close(file_);
 164     }
 165
 166     void Sync() {
 167         for (typename MappingVector_::const_iterator map(maps_.begin()); map != maps_.end(); ++map)
 168             msync(map->data_, map->size_, MS_SYNC);
 169     }
 170
 171     size_t Capacity() const {
 172         return blocks_.size() * Block_;
 173     }
 174
 175     void Open(const char *path) {
 176         _assert(file_ == -1);
 177         file_ = open(path, O_RDWR | O_CREAT | O_EXLOCK, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 178
 179         struct stat stat;
 180         fstat(file_, &stat);
 181
 182         size_t core(sizeof(Header) + sizeof(Base_));
 183
 184         size_t size(stat.st_size);
 185         if (size == 0) {
 186             Truncate_(core);
 187             Header_().magic_ = Magic;
 188             Size_() = core;
 189         } else {
 190             _assert(size >= core);
 191             Truncate_(size);
 192             _assert(Header_().magic_ == Magic);
 193             _assert(Header_().version_ == 0);
 194         }
 195     }
 196
 197     void Reserve(size_t capacity) {
 198         if (capacity <= Capacity())
 199             return;
 200         blocks_.pop_back();
 201         Truncate_(capacity);
 202     }
 203
 204     template <typename Target_>
 205     Target_ &Get(uint32_t offset) {
 206         return *reinterpret_cast<Target_ *>(blocks_[offset >> Shift_] + (offset & Mask_));
 207     }
 208
 209     template <typename Target_>
 210     Target_ &Get(Offset<Target_> &ref) {
 211         return Get<Target_>(ref.GetOffset());
 212     }
 213
 214     Base_ *operator ->() {
 215         return &Get<Base_>(sizeof(Header));
 216     }
 217
 218     template <typename Target_>
 219     Offset<Target_> New(size_t extra = 0) {
 220         size_t size(sizeof(Target_) + extra);
 221         size = Round(size, sizeof(uintptr_t));
 222         Reserve(Size_() + size);
 223         uint32_t offset(Size_());
 224         Size_() += size;
 225         return Offset<Target_>(offset);
 226     }
 227 };
 228
 229 }
 230
 231 #endif//CYTORE_HPP