My Project
Data Structures | Typedefs | Enumerations | Functions | Variables
vspace::internals Namespace Reference

Data Structures

struct  Block
 
class  FastLock
 
struct  MetaPage
 
class  Mutex
 
struct  ProcessChannel
 
struct  ProcessInfo
 
struct  refcount_t
 
struct  VMem
 
struct  VSeg
 

Typedefs

typedef size_t segaddr_t
 
typedef size_t vaddr_t
 
typedef int ipc_signal_t
 

Enumerations

enum  SignalState { Waiting = 0 , Pending = 1 , Accepted = 2 }
 

Functions

static void lock_allocator ()
 
static void unlock_allocator ()
 
static void print_freelists ()
 
void vmem_free (vaddr_t vaddr)
 
vaddr_t vmem_alloc (size_t size)
 
void init_flock_struct (struct flock &lock_info, size_t offset, size_t len, bool lock)
 
void lock_file (int fd, size_t offset, size_t len)
 
void unlock_file (int fd, size_t offset, size_t len)
 
void lock_metapage ()
 
void unlock_metapage ()
 
void init_metapage (bool create)
 
static void lock_process (int processno)
 
static void unlock_process (int processno)
 
static ProcessInfoprocess_info (int processno)
 
bool send_signal (int processno, ipc_signal_t sig, bool lock)
 
ipc_signal_t check_signal (bool resume, bool lock)
 
void accept_signals ()
 
ipc_signal_t wait_signal (bool lock)
 
void drop_pending_signals ()
 
Blockblock_ptr (vaddr_t vaddr)
 
static int find_level (size_t size)
 
static segaddr_t find_buddy (segaddr_t addr, int level)
 
static vaddr_t allocated_ptr_to_vaddr (void *ptr)
 

Variables

size_t config [4] = { METABLOCK_SIZE, MAX_PROCESS, SEGMENT_SIZE, MAX_SEGMENTS }
 
const segaddr_t SEGADDR_NULL = ~(segaddr_t) 0
 
const vaddr_t VADDR_NULL = ~(segaddr_t) 0
 
static const int MAX_PROCESS = 64
 
static const size_t METABLOCK_SIZE = 128 * 1024
 
static const int LOG2_SEGMENT_SIZE = 28
 
static const int LOG2_MAX_SEGMENTS = 10
 
static const size_t MAX_SEGMENTS = 1 << LOG2_MAX_SEGMENTS
 
static const size_t SEGMENT_SIZE = 1 << LOG2_SEGMENT_SIZE
 
static const size_t SEGMENT_MASK = (SEGMENT_SIZE - 1)
 
static VMemvmem = VMem::vmem_global
 

Data Structure Documentation

◆ vspace::internals::MetaPage

struct vspace::internals::MetaPage

Definition at line 175 of file vspace.h.

Data Fields
FastLock allocator_lock
size_t config_header[4]
vaddr_t freelist[LOG2_SEGMENT_SIZE+1]
ProcessInfo process_info[MAX_PROCESS]
int segment_count

◆ vspace::internals::ProcessChannel

struct vspace::internals::ProcessChannel

Definition at line 192 of file vspace.h.

Data Fields
int fd_read
int fd_write

◆ vspace::internals::ProcessInfo

struct vspace::internals::ProcessInfo

Definition at line 166 of file vspace.h.

Data Fields
pid_t pid
ipc_signal_t signal
SignalState sigstate

Typedef Documentation

◆ ipc_signal_t

Definition at line 148 of file vspace.h.

◆ segaddr_t

Definition at line 79 of file vspace.h.

◆ vaddr_t

Definition at line 81 of file vspace.h.

Enumeration Type Documentation

◆ SignalState

Enumerator
Waiting 
Pending 
Accepted 

Definition at line 160 of file vspace.h.

160 {
161 Waiting = 0,
162 Pending = 1,
163 Accepted = 2,
164};

Function Documentation

◆ accept_signals()

void vspace::internals::accept_signals ( )

Definition at line 407 of file vspace.cc.

407 {
411}
static ProcessInfo & process_info(int processno)
Definition: vspace.cc:343
static void unlock_process(int processno)
Definition: vspace.cc:337
static void lock_process(int processno)
Definition: vspace.cc:331
static VMem & vmem
Definition: vspace.h:300

◆ allocated_ptr_to_vaddr()

static vaddr_t vspace::internals::allocated_ptr_to_vaddr ( void *  ptr)
inlinestatic

Definition at line 362 of file vspace.h.

362 {
363 char *addr = (char *) ptr - sizeof(Block);
364 vaddr_t info = ((Block *) addr)->prev;
365 int seg = info & (MAX_SEGMENTS - 1);
366 unsigned char *segstart = vmem.segments[seg].base;
367 size_t offset = (unsigned char *) ptr - segstart;
368 return (seg << LOG2_SEGMENT_SIZE) | offset;
369}
const ExtensionInfo & info
< [in] sqrfree poly
STATIC_VAR int offset
Definition: janet.cc:29
size_t vaddr_t
Definition: vspace.h:81
static const size_t MAX_SEGMENTS
Definition: vspace.h:90
static const int LOG2_SEGMENT_SIZE
Definition: vspace.h:88
VSeg segments[MAX_SEGMENTS]
Definition: vspace.h:258
unsigned char * base
Definition: vspace.h:234

◆ block_ptr()

Block * vspace::internals::block_ptr ( vaddr_t  vaddr)
inline

Definition at line 302 of file vspace.h.

302 {
303 return vmem.block_ptr(vaddr);
304}
Block * block_ptr(vaddr_t vaddr)
Definition: vspace.h:274

◆ check_signal()

ipc_signal_t vspace::internals::check_signal ( bool  resume,
bool  lock 
)

Definition at line 370 of file vspace.cc.

370 {
372 if (lock)
375 switch (sigstate) {
376 case Waiting:
377 case Pending: {
379 char buf[1];
380 if (lock && sigstate == Waiting) {
382 while (read(fd, buf, 1) != 1) {
383 }
385 } else {
386 while (read(fd, buf, 1) != 1) {
387 }
388 }
391 = resume ? Waiting : Accepted;
392 if (lock)
394 break;
395 }
396 case Accepted:
398 if (resume)
400 if (lock)
402 break;
403 }
404 return result;
405}
return result
Definition: facAbsBiFact.cc:75
fq_nmod_t buf
Definition: facHensel.cc:101
int status read
Definition: si_signals.h:59
int status int fd
Definition: si_signals.h:59
ProcessChannel channels[MAX_PROCESS]
Definition: vspace.h:259

◆ drop_pending_signals()

void vspace::internals::drop_pending_signals ( )

◆ find_buddy()

static segaddr_t vspace::internals::find_buddy ( segaddr_t  addr,
int  level 
)
inlinestatic

Definition at line 355 of file vspace.h.

355 {
356 return addr ^ (1 << level);
357}
int level(const CanonicalForm &f)

◆ find_level()

static int vspace::internals::find_level ( size_t  size)
inlinestatic

Definition at line 346 of file vspace.h.

346 {
347 int level = 0;
348 while ((1 << (level + 8)) <= size)
349 level += 8;
350 while ((1 << level) < size)
351 level++;
352 return level;
353}
int size(const CanonicalForm &f, const Variable &v)
int size ( const CanonicalForm & f, const Variable & v )
Definition: cf_ops.cc:600

◆ init_flock_struct()

void vspace::internals::init_flock_struct ( struct flock &  lock_info,
size_t  offset,
size_t  len,
bool  lock 
)

Definition at line 285 of file vspace.cc.

286 {
287 lock_info.l_start = offset;
288 lock_info.l_len = len;
289 lock_info.l_pid = 0;
290 lock_info.l_type = lock ? F_WRLCK : F_UNLCK;
291 lock_info.l_whence = SEEK_SET;
292}
#define SEEK_SET
Definition: mod2.h:113

◆ init_metapage()

void vspace::internals::init_metapage ( bool  create)

Definition at line 314 of file vspace.cc.

314 {
315 if (create)
316 ftruncate(vmem.fd, METABLOCK_SIZE);
317 vmem.metapage = (MetaPage *) mmap(
318 NULL, METABLOCK_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, vmem.fd, 0);
319 if (create) {
320 memcpy(vmem.metapage->config_header, config, sizeof(config));
321 for (int i = 0; i <= LOG2_SEGMENT_SIZE; i++) {
323 }
326 } else {
327 assert(memcmp(vmem.metapage->config_header, config, sizeof(config)) != 0);
328 }
329}
#define NULL
Definition: auxiliary.h:104
int i
Definition: cfEzgcd.cc:132
NodeM * create()
Definition: janet.cc:757
const vaddr_t VADDR_NULL
Definition: vspace.h:84
vaddr_t freelist[LOG2_SEGMENT_SIZE+1]
Definition: vspace.h:178
static const size_t METABLOCK_SIZE
Definition: vspace.h:87
size_t config[4]
Definition: vspace.cc:13
internals::Mutex FastLock
Definition: vspace.h:1005
MetaPage * metapage
Definition: vspace.h:253
#define assert(A)
Definition: svd_si.h:3
#define metapageaddr(field)
Definition: vspace.cc:20

◆ lock_allocator()

static void vspace::internals::lock_allocator ( )
static

Definition at line 159 of file vspace.cc.

◆ lock_file()

void vspace::internals::lock_file ( int  fd,
size_t  offset,
size_t  len 
)

Definition at line 294 of file vspace.cc.

294 {
295 struct flock lock_info;
296 init_flock_struct(lock_info, offset, len, true);
297 fcntl(fd, F_SETLKW, &lock_info);
298}
void init_flock_struct(struct flock &lock_info, size_t offset, size_t len, bool lock)
Definition: vspace.cc:285

◆ lock_metapage()

void vspace::internals::lock_metapage ( )

Definition at line 306 of file vspace.cc.

306 {
307 lock_file(vmem.fd, 0);
308}
void lock_file(int fd, size_t offset, size_t len)
Definition: vspace.cc:294

◆ lock_process()

static void vspace::internals::lock_process ( int  processno)
static

Definition at line 331 of file vspace.cc.

◆ print_freelists()

static void vspace::internals::print_freelists ( )
static

Definition at line 167 of file vspace.cc.

167 {
168 for (int i = 0; i <= LOG2_SEGMENT_SIZE; i++) {
169 vaddr_t vaddr = vmem.freelist[i];
170 if (vaddr != VADDR_NULL) {
171 printf("%2d: %ld", i, vaddr);
172 vaddr_t prev = block_ptr(vaddr)->prev;
173 if (prev != VADDR_NULL) {
174 printf("(%ld)", prev);
175 }
176 assert(block_ptr(vaddr)->prev == VADDR_NULL);
177 for (;;) {
178 vaddr_t last_vaddr = vaddr;
179 Block *block = block_ptr(vaddr);
180 vaddr = block->next;
181 if (vaddr == VADDR_NULL)
182 break;
183 printf(" -> %ld", vaddr);
184 vaddr_t prev = block_ptr(vaddr)->prev;
185 if (prev != last_vaddr) {
186 printf("(%ld)", prev);
187 }
188 }
189 printf("\n");
190 }
191 }
192 fflush(stdout);
193}
Block * block_ptr(vaddr_t vaddr)
Definition: vspace.h:302
#define block
Definition: scanner.cc:666
vaddr_t * freelist
Definition: vspace.h:257

◆ process_info()

static ProcessInfo & vspace::internals::process_info ( int  processno)
static

Definition at line 343 of file vspace.cc.

343 {
344 return vmem.metapage->process_info[processno];
345}
ProcessInfo process_info[MAX_PROCESS]
Definition: vspace.h:180

◆ send_signal()

bool vspace::internals::send_signal ( int  processno,
ipc_signal_t  sig,
bool  lock 
)

Definition at line 347 of file vspace.cc.

347 {
348 if (lock)
349 lock_process(processno);
350 if (process_info(processno).sigstate != Waiting) {
351 unlock_process(processno);
352 return false;
353 }
354 if (processno == vmem.current_process) {
355 process_info(processno).sigstate = Accepted;
356 process_info(processno).signal = sig;
357 } else {
358 process_info(processno).sigstate = Pending;
359 process_info(processno).signal = sig;
360 int fd = vmem.channels[processno].fd_write;
361 char buf[1] = { 0 };
362 while (write(fd, buf, 1) != 1) {
363 }
364 }
365 if (lock)
366 unlock_process(processno);
367 return true;
368}
int status int void size_t count write
Definition: si_signals.h:67

◆ unlock_allocator()

static void vspace::internals::unlock_allocator ( )
static

Definition at line 163 of file vspace.cc.

◆ unlock_file()

void vspace::internals::unlock_file ( int  fd,
size_t  offset,
size_t  len 
)

Definition at line 300 of file vspace.cc.

300 {
301 struct flock lock_info;
302 init_flock_struct(lock_info, offset, len, false);
303 fcntl(fd, F_SETLKW, &lock_info);
304}

◆ unlock_metapage()

void vspace::internals::unlock_metapage ( )

Definition at line 310 of file vspace.cc.

310 {
311 unlock_file(vmem.fd, 0);
312}
void unlock_file(int fd, size_t offset, size_t len)
Definition: vspace.cc:300

◆ unlock_process()

static void vspace::internals::unlock_process ( int  processno)
static

Definition at line 337 of file vspace.cc.

337 {
340 + sizeof(ProcessInfo) * vmem.current_process);
341}

◆ vmem_alloc()

vaddr_t vspace::internals::vmem_alloc ( size_t  size)

Definition at line 243 of file vspace.cc.

243 {
245 size_t alloc_size = size + offsetof(Block, data);
246 int level = find_level(alloc_size);
247 int flevel = level;
248 while (flevel < LOG2_SEGMENT_SIZE && vmem.freelist[flevel] == VADDR_NULL)
249 flevel++;
250 if (vmem.freelist[flevel] == VADDR_NULL) {
252 }
254 while (flevel > level) {
255 // get and split a block
256 vaddr_t blockaddr = vmem.freelist[flevel];
257 assert((blockaddr & ((1 << flevel) - 1)) == 0);
258 Block *block = vmem.block_ptr(blockaddr);
259 vmem.freelist[flevel] = block->next;
260 if (vmem.freelist[flevel] != VADDR_NULL)
262 vaddr_t blockaddr2 = blockaddr + (1 << (flevel - 1));
263 Block *block2 = vmem.block_ptr(blockaddr2);
264 flevel--;
265 block2->next = vmem.freelist[flevel];
266 block2->prev = blockaddr;
267 block->next = blockaddr2;
268 block->prev = VADDR_NULL;
269 // block->prev == VADDR_NULL already.
270 vmem.freelist[flevel] = blockaddr;
271 }
274 vaddr_t vaddr = vmem.freelist[level];
275 vaddr_t result = vaddr + offsetof(Block, data);
276 vmem.freelist[level] = block->next;
277 if (block->next != VADDR_NULL)
279 block->mark_as_allocated(vaddr, level);
281 memset(block->data, 0, size);
282 return result;
283}
static void lock_allocator()
Definition: vspace.cc:159
static int find_level(size_t size)
Definition: vspace.h:346
static void unlock_allocator()
Definition: vspace.cc:163
void ensure_is_mapped(vaddr_t vaddr)
Definition: vspace.h:279

◆ vmem_free()

void vspace::internals::vmem_free ( vaddr_t  vaddr)

Definition at line 195 of file vspace.cc.

195 {
197 vaddr -= offsetof(Block, data);
198 vmem.ensure_is_mapped(vaddr);
199 size_t segno = vmem.segment_no(vaddr);
200 VSeg seg = vmem.segment(vaddr);
201 segaddr_t addr = vmem.segaddr(vaddr);
202 int level = seg.block_ptr(addr)->level();
203 assert(!seg.is_free(addr));
204 while (level < LOG2_SEGMENT_SIZE) {
205 segaddr_t buddy = find_buddy(addr, level);
206 Block *block = seg.block_ptr(buddy);
207 // is buddy free and at the same level?
208 if (!block->is_free() || block->level() != level)
209 break;
210 // remove buddy from freelist.
211 Block *prev = vmem.block_ptr(block->prev);
212 Block *next = vmem.block_ptr(block->next);
213 block->data[0] = level;
214 if (prev) {
215 assert(prev->next == vmem.vaddr(segno, buddy));
216 prev->next = block->next;
217 } else {
218 // head of freelist.
219 assert(vmem.freelist[level] == vmem.vaddr(segno, buddy));
220 vmem.freelist[level] = block->next;
221 }
222 if (next) {
223 assert(next->prev == vmem.vaddr(segno, buddy));
224 next->prev = block->prev;
225 }
226 // coalesce block with buddy
227 level++;
228 if (buddy < addr)
229 addr = buddy;
230 }
231 // Add coalesced block to free list
232 Block *block = seg.block_ptr(addr);
233 block->prev = VADDR_NULL;
234 block->next = vmem.freelist[level];
235 block->mark_as_free(level);
236 vaddr_t blockaddr = vmem.vaddr(segno, addr);
237 if (block->next != VADDR_NULL)
238 vmem.block_ptr(block->next)->prev = blockaddr;
239 vmem.freelist[level] = blockaddr;
241}
ListNode * next
Definition: janet.h:31
static segaddr_t find_buddy(segaddr_t addr, int level)
Definition: vspace.h:355
size_t segaddr_t
Definition: vspace.h:79
size_t segment_no(vaddr_t vaddr)
Definition: vspace.h:263
VSeg segment(vaddr_t vaddr)
Definition: vspace.h:260
vaddr_t vaddr(size_t segno, segaddr_t addr)
Definition: vspace.h:266
segaddr_t segaddr(vaddr_t vaddr)
Definition: vspace.h:269
Block * block_ptr(segaddr_t addr)
Definition: vspace.h:235
bool is_free(segaddr_t addr)
Definition: vspace.h:238

◆ wait_signal()

ipc_signal_t vspace::internals::wait_signal ( bool  lock)

Definition at line 413 of file vspace.cc.

413 {
414 return check_signal(true, lock);
415}
ipc_signal_t check_signal(bool resume, bool lock)
Definition: vspace.cc:370

Variable Documentation

◆ config

size_t vspace::internals::config = { METABLOCK_SIZE, MAX_PROCESS, SEGMENT_SIZE, MAX_SEGMENTS }

Definition at line 12 of file vspace.cc.

◆ LOG2_MAX_SEGMENTS

const int vspace::internals::LOG2_MAX_SEGMENTS = 10
static

Definition at line 89 of file vspace.h.

◆ LOG2_SEGMENT_SIZE

const int vspace::internals::LOG2_SEGMENT_SIZE = 28
static

Definition at line 88 of file vspace.h.

◆ MAX_PROCESS

const int vspace::internals::MAX_PROCESS = 64
static

Definition at line 86 of file vspace.h.

◆ MAX_SEGMENTS

const size_t vspace::internals::MAX_SEGMENTS = 1 << LOG2_MAX_SEGMENTS
static

Definition at line 90 of file vspace.h.

◆ METABLOCK_SIZE

const size_t vspace::internals::METABLOCK_SIZE = 128 * 1024
static

Definition at line 87 of file vspace.h.

◆ SEGADDR_NULL

const segaddr_t vspace::internals::SEGADDR_NULL = ~(segaddr_t) 0

Definition at line 83 of file vspace.h.

◆ SEGMENT_MASK

const size_t vspace::internals::SEGMENT_MASK = (SEGMENT_SIZE - 1)
static

Definition at line 92 of file vspace.h.

◆ SEGMENT_SIZE

const size_t vspace::internals::SEGMENT_SIZE = 1 << LOG2_SEGMENT_SIZE
static

Definition at line 91 of file vspace.h.

◆ VADDR_NULL

const vaddr_t vspace::internals::VADDR_NULL = ~(segaddr_t) 0

Definition at line 84 of file vspace.h.

◆ vmem

VMem& vspace::internals::vmem = VMem::vmem_global
static

Definition at line 300 of file vspace.h.