]>
Commit | Line | Data |
---|---|---|
7a8635c9 JF |
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 | ||
7a8635c9 JF |
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 | ||
6d7126ae JF |
85 | struct Block { |
86 | Cytore::Offset<void> reserved_; | |
87 | }; | |
88 | ||
7a8635c9 JF |
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_; | |
cf9903af JF |
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_; | |
7a8635c9 JF |
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)); | |
cf9903af JF |
135 | uint8_t *bytes(reinterpret_cast<uint8_t *>(data)); |
136 | ||
137 | maps_.push_back(Mapping_(bytes,extend)); | |
7a8635c9 | 138 | for (size_t i(0); i != extend >> Shift_; ++i) |
cf9903af | 139 | blocks_.push_back(bytes + Block_ * i); |
7a8635c9 JF |
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() { | |
cf9903af JF |
161 | for (typename MappingVector_::const_iterator map(maps_.begin()); map != maps_.end(); ++map) |
162 | munmap(map->data_, map->size_); | |
7a8635c9 JF |
163 | close(file_); |
164 | } | |
165 | ||
cf9903af JF |
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 | ||
7a8635c9 JF |
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 |