Valkka  0.17.0
OpenSource Video Management
Macros | Functions
sharedmem.cpp File Reference

Posix shared memory segment server/client management, shared memory ring buffer synchronized using posix semaphores. More...

#include "tools.h"
#include "sharedmem.h"
#include "numpy_no_import.h"
Include dependency graph for sharedmem.cpp:

Macros

#define server_init(CLASSNAME, TYPENAME)
 
#define client_init(CLASSNAME, TYPENAME)
 
#define server_close(CLASSNAME, TYPENAME)
 
#define client_close(CLASSNAME, TYPENAME)
 
#define copy_meta_from(CLASSNAME, TYPENAME)
 
#define copy_meta_to(CLASSNAME, TYPENAME)
 

Functions

 server_init (SimpleSharedMemSegment, std::size_t)
 
 client_init (SimpleSharedMemSegment, std::size_t)
 
 server_close (SimpleSharedMemSegment, std::size_t)
 
 client_close (SimpleSharedMemSegment, std::size_t)
 
 copy_meta_from (SimpleSharedMemSegment, std::size_t)
 
 copy_meta_to (SimpleSharedMemSegment, std::size_t)
 
 server_init (RGB24SharedMemSegment, RGB24Meta)
 
 client_init (RGB24SharedMemSegment, RGB24Meta)
 
 server_close (RGB24SharedMemSegment, RGB24Meta)
 
 client_close (RGB24SharedMemSegment, RGB24Meta)
 
 copy_meta_from (RGB24SharedMemSegment, RGB24Meta)
 
 copy_meta_to (RGB24SharedMemSegment, RGB24Meta)
 

Detailed Description

Posix shared memory segment server/client management, shared memory ring buffer synchronized using posix semaphores.

Author
Sampsa Riikonen
Date
2017
Version
0.17.0

Macro Definition Documentation

◆ client_close

#define client_close (   CLASSNAME,
  TYPENAME 
)
Value:
void CLASSNAME::clientClose() { \
} \

◆ client_init

#define client_init (   CLASSNAME,
  TYPENAME 
)
Value:
bool CLASSNAME::clientInit() { \
int fd, fd_;\
fd = shm_open(payload_name.c_str(), O_RDONLY, 0400);\
fd_= shm_open(meta_name.c_str(), O_RDONLY, 0400);\
if (fd == -1 or fd_==-1) {\
/* perror("valkka_core: sharedmem.cpp: SharedMemSegment::clientInit: shm_open failed"); */\
/* exit(2); */\
return false;\
}\
/* std::cout << "got shmem" << std::endl; */\
ptr =mmap(0, n_bytes, PROT_READ, MAP_SHARED, fd, 0);\
ptr_ =mmap(0, sizeof(TYPENAME), PROT_READ, MAP_SHARED, fd_, 0);\
if (ptr == MAP_FAILED or ptr_ == MAP_FAILED) {\
std::cout << "valkka_core: sharedmem.cpp: SharedMemSegment::clientInit: mmap failed" << std::endl;\
/* perror("valkka_core: sharedmem.cpp: SharedMemSegment::clientInit: mmap failed"); */\
/* exit(2);*/\
return false;\
}\
payload = (uint8_t*) ptr;\
meta = (TYPENAME*) ptr_;\
close(fd);\
close(fd_);\
/*std::cout << "Client reserved " << sizeof(TYPENAME) << "bytes" << std::endl;*/\
return true;\
};\

◆ copy_meta_from

#define copy_meta_from (   CLASSNAME,
  TYPENAME 
)
Value:
void CLASSNAME::copyMetaFrom(void *meta_) { \
*meta = *((TYPENAME*)(meta_)); \
}\

◆ copy_meta_to

#define copy_meta_to (   CLASSNAME,
  TYPENAME 
)
Value:
void CLASSNAME::copyMetaTo(void *meta_) { \
*((TYPENAME*)(meta_)) = *meta; \
}\

◆ server_close

#define server_close (   CLASSNAME,
  TYPENAME 
)
Value:
void CLASSNAME::serverClose() { \
if (munmap(ptr, n_bytes)!=0 or munmap(ptr_, sizeof(TYPENAME)!=0)) { \
perror("valkka_core: sharedmem.cpp: CLASSNAME::serverClose: munmap failed"); \
exit(2); \
} \
if (shm_unlink(payload_name.c_str())!=0 or shm_unlink(meta_name.c_str())!=0) { \
perror("valkka_core: sharedmem.cpp: CLASSNAME::serverClose: shm_unlink failed"); \
/*exit(2);*/ \
} \
} \

◆ server_init

#define server_init (   CLASSNAME,
  TYPENAME 
)
Value:
void CLASSNAME::serverInit() {\
int fd, fd_, r, r_;\
shm_unlink(payload_name.c_str());\
shm_unlink(meta_name.c_str());\
fd = shm_open(payload_name.c_str(),O_CREAT | O_EXCL | O_TRUNC | O_RDWR, 0600);\
fd_= shm_open(meta_name.c_str(), O_CREAT | O_EXCL | O_TRUNC | O_RDWR, 0600);\
if (fd == -1 or fd_==-1) {\
perror("valkka_core: sharedmem.cpp: SharedMemSegment::serverInit: shm_open failed");\
exit(2);\
}\
/* std::cout << "got shmem" << std::endl; */\
r = ftruncate(fd, n_bytes);\
r_= ftruncate(fd_,n_bytes);\
if (r != 0 or r_ !=0) {\
perror("valkka_core: sharedmem.cpp: SharedMemSegment::serverInit: ftruncate failed");\
exit(2);\
}\
ptr = mmap(0, n_bytes, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);\
ptr_= mmap(0, sizeof(TYPENAME), PROT_READ | PROT_WRITE, MAP_SHARED, fd_, 0);\
if (ptr == MAP_FAILED or ptr_ == MAP_FAILED) {\
perror("valkka_core: sharedmem.cpp: SharedMemSegment::serverInit: mmap failed");\
exit(2);\
}\
payload = (uint8_t*) ptr;\
meta = (TYPENAME*) ptr_;\
close(fd);\
close(fd_);\
/*std::cout << "Server reserved " << sizeof(TYPENAME) << "bytes" << std::endl;*/\
};\