My Project
Public Member Functions | Data Fields | Static Public Attributes
vspace::internals::VMem Struct Reference

#include <vspace.h>

Public Member Functions

VSeg segment (vaddr_t vaddr)
 
size_t segment_no (vaddr_t vaddr)
 
vaddr_t vaddr (size_t segno, segaddr_t addr)
 
segaddr_t segaddr (vaddr_t vaddr)
 
Blockblock_ptr (vaddr_t vaddr)
 
void ensure_is_mapped (vaddr_t vaddr)
 
void * to_ptr (vaddr_t vaddr)
 
size_t filesize ()
 
Status init (int fd)
 
Status init ()
 
Status init (const char *path)
 
void deinit ()
 
void * mmap_segment (int seg)
 
void add_segment ()
 

Data Fields

MetaPagemetapage
 
int fd
 
FILE * file_handle
 
int current_process
 
vaddr_tfreelist
 
VSeg segments [MAX_SEGMENTS]
 
ProcessChannel channels [MAX_PROCESS]
 

Static Public Attributes

static VMem vmem_global
 

Detailed Description

Definition at line 251 of file vspace.h.

Member Function Documentation

◆ add_segment()

void vspace::internals::VMem::add_segment ( )

Definition at line 109 of file vspace.cc.

109  {
110  int seg = metapage->segment_count++;
112  void *map_addr = mmap_segment(seg);
113  segments[seg] = VSeg(map_addr);
114  Block *top = block_ptr(seg * SEGMENT_SIZE);
115  top->next = freelist[LOG2_SEGMENT_SIZE];
116  top->prev = VADDR_NULL;
118 }
const vaddr_t VADDR_NULL
Definition: vspace.h:84
static const size_t SEGMENT_SIZE
Definition: vspace.h:91
static const size_t METABLOCK_SIZE
Definition: vspace.h:87
static const int LOG2_SEGMENT_SIZE
Definition: vspace.h:88
void * mmap_segment(int seg)
Definition: vspace.cc:95
Block * block_ptr(vaddr_t vaddr)
Definition: vspace.h:274
MetaPage * metapage
Definition: vspace.h:253
vaddr_t * freelist
Definition: vspace.h:257
VSeg segments[MAX_SEGMENTS]
Definition: vspace.h:258

◆ block_ptr()

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

Definition at line 274 of file vspace.h.

274  {
275  if (vaddr == VADDR_NULL)
276  return NULL;
277  return (Block *) (segment(vaddr).base + segaddr(vaddr));
278  }
#define NULL
Definition: omList.c:12
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
unsigned char * base
Definition: vspace.h:234

◆ deinit()

void vspace::internals::VMem::deinit ( )

Definition at line 74 of file vspace.cc.

74  {
75  if (file_handle) {
76  fclose(file_handle);
77  file_handle = NULL;
78  } else {
79  close(fd);
80  }
81  munmap(metapage, METABLOCK_SIZE);
82  metapage = NULL;
83  current_process = -1;
84  freelist = NULL;
85  for (int i = 0; i < MAX_SEGMENTS; i++) {
86  if (segments[i].base) munmap(segments[i].base, SEGMENT_SIZE);
87  segments[i] = NULL;
88  }
89  for (int i = 0; i < MAX_PROCESS; i++) {
90  close(channels[i].fd_read);
91  close(channels[i].fd_write);
92  }
93 }
int i
Definition: cfEzgcd.cc:132
char N base
Definition: ValueTraits.h:144
static const size_t MAX_SEGMENTS
Definition: vspace.h:90
static const int MAX_PROCESS
Definition: vspace.h:86
ProcessChannel channels[MAX_PROCESS]
Definition: vspace.h:259

◆ ensure_is_mapped()

void vspace::internals::VMem::ensure_is_mapped ( vaddr_t  vaddr)
inline

Definition at line 279 of file vspace.h.

279  {
280  int seg = vaddr >> LOG2_SEGMENT_SIZE;
281  if (segments[seg].base != NULL)
282  return;
283  segments[seg] = mmap_segment(seg);
284  }

◆ filesize()

size_t vspace::internals::VMem::filesize ( )

Definition at line 23 of file vspace.cc.

23  {
24  struct stat stat;
25  fstat(fd, &stat);
26  return stat.st_size;
27 }

◆ init() [1/3]

Status vspace::internals::VMem::init ( )

Definition at line 52 of file vspace.cc.

52  {
53  FILE *fp = tmpfile();
54  Status result = init(fileno(fp));
55  if (!result.ok())
56  return result;
57  current_process = 0;
58  file_handle = fp;
59  metapage->process_info[0].pid = getpid();
60  return Status(ErrNone);
61 }
CanonicalForm fp
Definition: cfModGcd.cc:4102
return result
Definition: facAbsBiFact.cc:75
ProcessInfo process_info[MAX_PROCESS]
Definition: vspace.h:180
@ ErrNone
Definition: vspace.h:43

◆ init() [2/3]

Status vspace::internals::VMem::init ( const char *  path)

Definition at line 63 of file vspace.cc.

63  {
64  int fd = open(path, O_RDWR | O_CREAT, 0600);
65  if (fd < 0)
66  return Status(ErrFile);
67  init(fd);
68  lock_metapage();
69  // TODO: enter process in meta table
71  return Status(ErrNone);
72 }
void unlock_metapage()
Definition: vspace.cc:310
void lock_metapage()
Definition: vspace.cc:306
@ ErrFile
Definition: vspace.h:45
int status int void size_t count int const void size_t count open
Definition: si_signals.h:73

◆ init() [3/3]

Status vspace::internals::VMem::init ( int  fd)

Definition at line 29 of file vspace.cc.

29  {
30  this->fd = fd;
31  for (int i = 0; i < MAX_SEGMENTS; i++)
32  segments[i] = VSeg(NULL);
33  for (int i = 0; i < MAX_PROCESS; i++) {
34  int channel[2];
35  if (pipe(channel) < 0) {
36  for (int j = 0; j < i; j++) {
37  close(channels[j].fd_read);
38  close(channels[j].fd_write);
39  }
40  return Status(ErrOS);
41  }
42  channels[i].fd_read = channel[0];
43  channels[i].fd_write = channel[1];
44  }
45  lock_metapage();
46  init_metapage(filesize() == 0);
49  return Status(ErrNone);
50 }
int j
Definition: facHensel.cc:110
vaddr_t freelist[LOG2_SEGMENT_SIZE+1]
Definition: vspace.h:178
void init_metapage(bool create)
Definition: vspace.cc:314
@ ErrOS
Definition: vspace.h:47

◆ mmap_segment()

void * vspace::internals::VMem::mmap_segment ( int  seg)

Definition at line 95 of file vspace.cc.

95  {
96  lock_metapage();
97  void *map = mmap(NULL, SEGMENT_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd,
99  if (map == MAP_FAILED) {
100  // This is an "impossible to proceed from here, because system state
101  // is impossible to proceed from" situation, so we abort the program.
102  perror("mmap");
103  abort();
104  }
105  unlock_metapage();
106  return map;
107 }
CanonicalForm map(const CanonicalForm &primElem, const Variable &alpha, const CanonicalForm &F, const Variable &beta)
map from to such that is mapped onto
Definition: cf_map_ext.cc:504

◆ segaddr()

segaddr_t vspace::internals::VMem::segaddr ( vaddr_t  vaddr)
inline

Definition at line 269 of file vspace.h.

269  {
270  if (vaddr == VADDR_NULL)
271  return SEGADDR_NULL;
272  return vaddr & SEGMENT_MASK;
273  }
static const size_t SEGMENT_MASK
Definition: vspace.h:92
const segaddr_t SEGADDR_NULL
Definition: vspace.h:83

◆ segment()

VSeg vspace::internals::VMem::segment ( vaddr_t  vaddr)
inline

Definition at line 260 of file vspace.h.

260  {
261  return segments[vaddr >> LOG2_SEGMENT_SIZE];
262  }

◆ segment_no()

size_t vspace::internals::VMem::segment_no ( vaddr_t  vaddr)
inline

Definition at line 263 of file vspace.h.

263  {
264  return vaddr >> LOG2_SEGMENT_SIZE;
265  }

◆ to_ptr()

void* vspace::internals::VMem::to_ptr ( vaddr_t  vaddr)
inline

Definition at line 285 of file vspace.h.

285  {
286  if (vaddr == VADDR_NULL)
287  return NULL;
289  return segment(vaddr).ptr(segaddr(vaddr));
290  }
void ensure_is_mapped(vaddr_t vaddr)
Definition: vspace.h:279
void * ptr(segaddr_t addr)
Definition: vspace.h:242

◆ vaddr()

vaddr_t vspace::internals::VMem::vaddr ( size_t  segno,
segaddr_t  addr 
)
inline

Definition at line 266 of file vspace.h.

266  {
267  return (segno << LOG2_SEGMENT_SIZE) | addr;
268  }

Field Documentation

◆ channels

ProcessChannel vspace::internals::VMem::channels[MAX_PROCESS]

Definition at line 259 of file vspace.h.

◆ current_process

int vspace::internals::VMem::current_process

Definition at line 256 of file vspace.h.

◆ fd

int vspace::internals::VMem::fd

Definition at line 254 of file vspace.h.

◆ file_handle

FILE* vspace::internals::VMem::file_handle

Definition at line 255 of file vspace.h.

◆ freelist

vaddr_t* vspace::internals::VMem::freelist

Definition at line 257 of file vspace.h.

◆ metapage

MetaPage* vspace::internals::VMem::metapage

Definition at line 253 of file vspace.h.

◆ segments

VSeg vspace::internals::VMem::segments[MAX_SEGMENTS]

Definition at line 258 of file vspace.h.

◆ vmem_global

VMem vspace::internals::VMem::vmem_global
static

Definition at line 252 of file vspace.h.


The documentation for this struct was generated from the following files: