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         _assert(data != MAP_FAILED);
 136         uint8_t *bytes(reinterpret_cast<uint8_t *>(data));
 137
 138         maps_.push_back(Mapping_(bytes, extend));
 139         for (size_t i(0); i != extend >> Shift_; ++i)
 140             blocks_.push_back(bytes + Block_ * i);
 141     }
 142
 143     bool Truncate_(size_t capacity) {
 144         capacity = Round(capacity, Block_);
 145         int error(ftruncate(file_, capacity));
 146         _assert(error == 0);
 147         Map_(capacity);
 148         return true;
 149     }
 150
 151   public:
 152     File() :
 153         file_(-1)
 154     {
 155     }
 156
 157     File(const char *path) :
 158         file_(-1)
 159     {
 160         Open(path);
 161     }
 162
 163     ~File() {
 164         for (typename MappingVector_::const_iterator map(maps_.begin()); map != maps_.end(); ++map)
 165             munmap(map->data_, map->size_);
 166         close(file_);
 167     }
 168
 169     void Sync() {
 170         for (typename MappingVector_::const_iterator map(maps_.begin()); map != maps_.end(); ++map)
 171             msync(map->data_, map->size_, MS_SYNC);
 172     }
 173
 174     size_t Capacity() const {
 175         return blocks_.size() * Block_;
 176     }
 177
 178     void Open(const char *path) {
 179         _assert(file_ == -1);
 180         file_ = open(path, O_RDWR | O_CREAT | O_EXLOCK, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
 181         _assert(file_ != -1);
 182
 183         struct stat stat;
 184         _assert(fstat(file_, &stat) == 0);
 185
 186         size_t core(sizeof(Header) + sizeof(Base_));
 187
 188         size_t size(stat.st_size);
 189         if (size == 0) {
 190             _assert(Truncate_(core));
 191             Header_().magic_ = Magic;
 192             Size_() = core;
 193         } else {
 194             _assert(size >= core);
 195             // XXX: this involves an unneccessary call to ftruncate()
 196             _assert(Truncate_(size));
 197             _assert(Header_().magic_ == Magic);
 198             _assert(Header_().version_ == 0);
 199         }
 200     }
 201
 202     bool Reserve(size_t capacity) {
 203         if (capacity <= Capacity())
 204             return true;
 205
 206         uint8_t *block(blocks_.back());
 207         blocks_.pop_back();
 208
 209         if (Truncate_(capacity))
 210             return true;
 211         else {
 212             blocks_.push_back(block);
 213             return false;
 214         }
 215     }
 216
 217     template <typename Target_>
 218     Target_ &Get(uint32_t offset) {
 219         return *reinterpret_cast<Target_ *>(offset == 0 ? NULL : blocks_[offset >> Shift_] + (offset & Mask_));
 220     }
 221
 222     template <typename Target_>
 223     Target_ &Get(Offset<Target_> &ref) {
 224         return Get<Target_>(ref.GetOffset());
 225     }
 226
 227     Base_ *operator ->() {
 228         return &Get<Base_>(sizeof(Header));
 229     }
 230
 231     template <typename Target_>
 232     Offset<Target_> New(size_t extra = 0) {
 233         size_t size(sizeof(Target_) + extra);
 234         size = Round(size, sizeof(uintptr_t));
 235
 236         uint32_t offset;
 237         if (!Reserve(Size_() + size))
 238             offset = 0;
 239         else {
 240             offset = Size_();
 241             Size_() += size;
 242         }
 243
 244         return Offset<Target_>(offset);
 245     }
 246 };
 247
 248 }
 249
 250 #endif//CYTORE_HPP