static SharedMemory* alloc_buffer_size(const char* message, int size)
{
SharedMemory* buffer = new SharedMemory(size);
buffer->map();
memcpy(buffer->data(), message, buffer->size());
return buffer;
}
static SharedMemory* file_receive_shm(int header, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, const char* str)
{
uint32_t tid;
if (monapi_name_whereis("/servers/file", tid) != M_OK) {
return NULL;
}
MessageInfo msg;
if (Message::sendReceive(&msg, tid, header, arg1, arg2, arg3, str) != M_OK) {
return NULL;
}
if ((intptr_t)msg.arg2 < M_OK) {
int status = Message::reply(&msg);
if (status != M_OK) {
monapi_warn("%s reply failed : %s\n", __func__, monapi_error_string(status));
}
return NULL;
}
uintptr_t handle = msg.arg2;
uintptr_t size = msg.arg3;
SharedMemory* shm = new SharedMemory(handle, size);
if (shm->map(true) != M_OK) {
int status = Message::reply(&msg);
delete shm;
if (status != M_OK) {
monapi_warn("%s reply failed : %s\n", __func__, monapi_error_string(status));
}
return NULL;
} else {
int status = Message::reply(&msg);
if (status != M_OK) {
monapi_warn("%s reply failed : %s\n", __func__, monapi_error_string(status));
}
return shm;
}
}
static void test_fatfs_readdir()
{
TestFatFS fs;
FatFileSystem* fat = fs.get();
Vnode* root = fat->getRoot();
SharedMemory* cmi;
ASSERT_EQ(M_OK, fat->read_directory(root, &cmi));
ASSERT_TRUE(cmi != NULL);
int size = *(int*)cmi->data();
EXPECT_EQ(37, size);
monapi_directoryinfo* p = (monapi_directoryinfo*)&cmi->data()[sizeof(int)];
EXPECT_STR_EQ("TEST1.TXT", (const char*)CString(p[0].name));
for (int i = 0; i < size; i++) {
if (CString(p[i].name) == "SUBDIR") {
EXPECT_TRUE((p[i].attr & ATTRIBUTE_DIRECTORY) != 0);
}
}
delete cmi;
}
static bool HandleReuse(LPCTSTR lpstrCmdLine)
{
SharedMemory<HWND> sharedInstance;
try
{
sharedInstance.Open(L"ConsoleZ", syncObjNone);
}
catch(Win32Exception& ex)
{
if(ex.GetErrorCode() == ERROR_FILE_NOT_FOUND)
return false;
throw;
}
if (0 != sharedInstance.Get())
{
::SetForegroundWindow(*sharedInstance);
std::wstring commandLine = lpstrCmdLine;
commandLine += L" -cwd ";
commandLine += Helpers::EscapeCommandLineArg(Helpers::GetCurrentDirectory());
COPYDATASTRUCT cds = {0};
cds.dwData = 0;
cds.lpData = (LPVOID)commandLine.c_str();
cds.cbData = static_cast<DWORD>((commandLine.length() + 1) * sizeof(wchar_t));
::SendMessage(*sharedInstance, WM_COPYDATA, 0, (LPARAM)&cds);
return true;
}
return false;
}
SharedMemory* monapi_clipboard_get()
{
uint32_t tid ;
if (monapi_name_whereis("/servers/clipboard", tid) != M_OK) {
return NULL;
}
MessageInfo msg;
if (Message::sendReceive(&msg, tid, MSG_CLIPBOARD_GET) != M_OK) {
return NULL;
}
if ((intptr_t)msg.arg2 < M_OK) { return NULL;}
SharedMemory* ret = new SharedMemory(msg.arg2, msg.arg3);
if (ret->size() == 0) {
return ret;
}
intptr_t mapResult = ret->map(true);
if (mapResult != M_OK) {
delete ret;
monapi_warn("%s map error = %d\n", __func__, mapResult);
return NULL;
} else {
return ret;
}
}
static void test_fatfs_write_file()
{
TestFatFS fs;
FatFileSystem* fat = fs.get();
Vnode* root = fat->getRoot();
const char* FILENAME = "MY1.TXT";
Vnode* found;
ASSERT_EQ(M_OK, fat->lookup(root, FILENAME, &found, Vnode::REGULAR));
const int BUFFER_SIZE = 1029;
SharedMemory* buffer = new SharedMemory(BUFFER_SIZE);
ASSERT_EQ(M_OK, buffer->map());
memset(buffer->data(), 0, BUFFER_SIZE);
buffer->data()[0] = 0xde;
buffer->data()[BUFFER_SIZE - 1] = 0xad;
io::Context c;
c.offset = 0;
c.size = BUFFER_SIZE;
c.memory = buffer;
ASSERT_EQ(BUFFER_SIZE, fat->write(found, &c));
io::Context readContext;
SharedMemory* cmi = readAll(fat, readContext, root, FILENAME);
ASSERT_TRUE(cmi != NULL);
ASSERT_TRUE(cmi->data() != NULL);
ASSERT_EQ(BUFFER_SIZE, cmi->size());
EXPECT_TRUE(memcmp(buffer->data(), cmi->data(), BUFFER_SIZE) == 0);
}
void* SharedMemory::get(unsigned int id, unsigned int size){
SharedMemory* newSharedMemory = new SharedMemory();
int sharedMemoryId = getSharedMemoryId(id, size);
newSharedMemory->setId(id);
newSharedMemory->setSharedMemoryId(sharedMemoryId);
return newSharedMemory->attach();
}
// 経路情報を読み込み直して画像に反映する
void reloadRoute(string path)
{
cvtColor(pic, pic_tmp, CV_GRAY2BGR);
Point prePoint(-1, -1);
int x_val, y_val;
string str, x_str, y_str;
string searchWord(",");
string::size_type x_pos, y_pos;
// csで保存した経路情報の一時ファイルを読み込む
ifstream ifs(path + ".tmp");
if (ifs.fail())
{
cerr << "False" << endl;
shMem.setShMemData(false, ISINSERT);
return;
}
//ヘッダ部分をとばす
getline(ifs, str);
while (getline(ifs, str))
{
//先頭から,までの文字列をint型で取得
x_pos = str.find(searchWord);
if (x_pos != string::npos){
x_str = str.substr(0, x_pos);
x_val = stoi(x_str);
}
//xの値の後ろから,までの文字列をint型で取得
y_pos = str.find(searchWord, x_pos + 1);
if (y_pos != string::npos){
y_str = str.substr(x_pos + 1, y_pos);
y_val = stoi(y_str);
}
//取得した[x,y]を画像に反映
pic_tmp.at<Vec3b>(y_val, x_val ) = Vec3b(0, 255, 0);
circle(pic_tmp, cv::Point(x_val, y_val), 10, cv::Scalar(0, 255, 0), 3);
if (prePoint.x > 0 && prePoint.y > 0) line(pic_tmp, prePoint, Point(x_val, y_val), cv::Scalar(0, 0, 200), 3, 4);
prePoint = Point(x_val, y_val);
}
pic_col = pic_tmp.clone();
rectangle(pic_tmp, zoomPoint, Point(zoomPoint.x + zoomSize.width, zoomPoint.y + zoomSize.height), cv::Scalar(0, 0, 200), 5, 4);
imshowResize(string("Origin"), pic_tmp, Size(pic_tmp.cols / reductionRate.width, pic_tmp.rows / reductionRate.height));
// zoom画像に点を描画
pic_zoom = Mat(pic_col, Rect(zoomPoint, zoomSize));
imshow("zoom", pic_zoom);
::prePoint = prePoint;
shMem.setShMemData(false, ISCONFIRMED);
shMem.setShMemData(false, ISINSERT);
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
SharedMemory shared;
shared.read();
return a.exec();
}
__global__
void susanKernel(T* out, const T* in,
const unsigned idim0, const unsigned idim1,
const unsigned radius, const float t, const float g,
const unsigned edge)
{
const int rSqrd = radius*radius;
const int windLen = 2*radius+1;
const int shrdLen = BLOCK_X + windLen-1;
SharedMemory<T> shared;
T* shrdMem = shared.getPointer();
const unsigned lx = threadIdx.x;
const unsigned ly = threadIdx.y;
const unsigned gx = blockDim.x * blockIdx.x + lx + edge;
const unsigned gy = blockDim.y * blockIdx.y + ly + edge;
const unsigned nucleusIdx = (ly+radius)*shrdLen + lx+radius;
shrdMem[nucleusIdx] = gx<idim0 && gy<idim1 ? in[gy*idim0+gx] : 0;
T m_0 = shrdMem[nucleusIdx];
#pragma unroll
for (int b=ly, gy2=gy; b<shrdLen; b+=BLOCK_Y, gy2+=BLOCK_Y) {
int j = gy2-radius;
#pragma unroll
for (int a=lx, gx2=gx; a<shrdLen; a+=BLOCK_X, gx2+=BLOCK_X) {
int i = gx2-radius;
shrdMem[b*shrdLen+a] = (i<idim0 && j<idim1 ? in[j*idim0+i]: m_0);
}
}
__syncthreads();
if (gx < idim0 - edge && gy < idim1 - edge) {
unsigned idx = gy*idim0 + gx;
float nM = 0.0f;
#pragma unroll
for (int p=0; p<windLen; ++p) {
#pragma unroll
for (int q=0; q<windLen; ++q) {
int i = p - radius;
int j = q - radius;
int a = lx + radius + i;
int b = ly + radius + j;
if (i*i + j*j < rSqrd) {
float c = m_0;
float m = shrdMem[b * shrdLen + a];
float exp_pow = powf((m - c)/t, 6.0f);
float cM = expf(-exp_pow);
nM += cM;
}
}
}
out[idx] = nM < g ? g - nM : T(0);
}
}
void HecoDSMFinalizer::fire()
{
SharedMemory *mem;
if (!(mem = dynamic_cast<SharedMemory *>(sinkPorts()[0]->readPort()))) {
PERR("Invalid type.");
}
int *num = (int *)mem->buffer();
PINF_1("Num = " << num[0] << " " << num[1] << " " << num[2] <<
" " << num[3]);
_state = POST_RUNNING;
}
static void createFile(const char* path)
{
EXPECT_TRUE(!fileExist(path));
intptr_t id = monapi_file_open(path, FILE_CREATE);
const char* message = "Hello World\n";
SharedMemory shm = alloc_buffer(message);
monapi_file_write(id, shm, shm.size());
monapi_file_close(id);
}
intptr_t monapi_clipboard_set(const SharedMemory& shm)
{
MessageInfo msg;
uint32_t tid ;
if (monapi_name_whereis("/servers/clipboard", tid) != M_OK) {
return M_NAME_NOT_FOUND;
}
intptr_t ret = Message::sendReceive(&msg, tid, MSG_CLIPBOARD_SET, shm.handle(), shm.size());
if (ret != M_OK) {
return ret;
}
return M_OK;
}
void init_sharedMemory()
{
//Intialize imuData
memory.setRoll(0);
memory.setPitch(0);
memory.setYaw(0);
memory.U[1] = 0;
memory.U[2] = 0;
memory.U[3] = 0;
memory.U[4] = 0;
memory.isCameraRunning = 0;
memory.isCameraRecording = 1;
memory.showCameraGUI = 1;
memory.GUICloseRequest = 0;
}
ELTE_INT32 SharedMemoryMgr::CreateSharedMemory(const std::string& strResId)
{
LOG_TRACE();
INFO_PARAM1(strResId);
std::map <std::string, SharedMemory*>::iterator iter = m_sharedMemorys.find(strResId);
if(m_sharedMemorys.end() != iter)
{
return eLTE_SDK_ERR_SUCCESS;
}
SharedMemory* pSharedMemory = new SharedMemory(strResId);
if (NULL == pSharedMemory)
{
return eLTE_SDK_ERR_NULL_POINTER;
}
//初始化资源
ELTE_INT32 iRet = pSharedMemory->InitResource();
if(eLTE_SDK_ERR_SUCCESS != iRet)
{
delete pSharedMemory;
pSharedMemory = NULL;
return iRet;//lint !e438
}
//开启接受视频流线程
iRet = pSharedMemory->StartYuvFrameProcess();
if(eLTE_SDK_ERR_SUCCESS != iRet)
{
delete pSharedMemory;
pSharedMemory = NULL;
return iRet;//lint !e438
}
//开启发送视频流线程
iRet = pSharedMemory->StartRevMsg();
if(eLTE_SDK_ERR_SUCCESS != iRet)
{
delete pSharedMemory;
pSharedMemory = NULL;
return iRet;//lint !e438
}
(ELTE_VOID)m_sharedMemorys.insert(std::pair <std::string, SharedMemory*> (strResId, pSharedMemory));
return eLTE_SDK_ERR_SUCCESS;//lint !e429
}
static __global__
void histogramKernel(Param<outType> out, CParam<inType> in,
int len, int nbins, float minval, float maxval, int nBBS)
{
SharedMemory<outType> shared;
outType * shrdMem = shared.getPointer();
// offset input and output to account for batch ops
unsigned b2 = blockIdx.x / nBBS;
const inType *iptr = in.ptr + b2 * in.strides[2] + blockIdx.y * in.strides[3];
outType *optr = out.ptr + b2 * out.strides[2] + blockIdx.y * out.strides[3];
int start = (blockIdx.x-b2*nBBS) * THRD_LOAD * blockDim.x + threadIdx.x;
int end = minimum((start + THRD_LOAD * blockDim.x), len);
float step = (maxval-minval) / (float)nbins;
// If nbins > max shared memory allocated, then just use atomicAdd on global memory
bool use_global = nbins > MAX_BINS;
// Skip initializing shared memory
if (!use_global) {
for (int i = threadIdx.x; i < nbins; i += blockDim.x)
shrdMem[i] = 0;
__syncthreads();
}
for (int row = start; row < end; row += blockDim.x) {
int idx = isLinear ? row : ((row % in.dims[0]) + (row / in.dims[0])*in.strides[1]);
int bin = (int)((iptr[idx] - minval) / step);
bin = (bin < 0) ? 0 : bin;
bin = (bin >= nbins) ? (nbins-1) : bin;
if (use_global) {
atomicAdd((optr + bin), 1);
} else {
atomicAdd((shrdMem + bin), 1);
}
}
// No need to write to global if use_global is true
if (!use_global) {
__syncthreads();
for (int i = threadIdx.x; i < nbins; i += blockDim.x) {
atomicAdd((optr + i), shrdMem[i]);
}
}
}
void* SharedMemory::create(unsigned int id, unsigned int size){
SharedMemory* newSharedMemory = new SharedMemory();
key_t key = ftok(PATH, id);
if (key == -1) {
notifyError(id, "create - ftok");
exit(EXIT_FAILURE);
}
else {
int sharedMemoryId = shmget(key, size, IPC_CREAT | IPC_EXCL | 0660);
if (sharedMemoryId == -1) {
notifyError(id, "create - shmget");
exit(EXIT_FAILURE);
}
newSharedMemory->setId(id);
newSharedMemory->setSharedMemoryId(sharedMemoryId);
}
return newSharedMemory->attach();
}
// 左クリックで経路座標を選択
void coodClick(int event, int x, int y, int flag, void* )
{
// マウスイベントを取得
switch (event) {
case cv::EVENT_MOUSEMOVE:
break;
case cv::EVENT_LBUTTONDOWN:
// クリックされた座標をグローバル変数に保存
xy[0] = x;
xy[1] = y;
// 座標を共有メモリに保存
shMem.setShMemData(true, ISCOODDECISION);
shMem.setShMemData(x + zoomPoint.x, COOD_X);
shMem.setShMemData(y + zoomPoint.y, COOD_Y);
// 座標に点を打つ(確定ではないので一時画像に挿入して表示)
pic_tmp = pic_zoom.clone();
pic_tmp.at<Vec3b>(xy[1], xy[0]) = Vec3b(150, 50, 200);
circle(pic_tmp, Point(xy[0], xy[1]), 4, Scalar(150, 50, 200), 2);
imshow("zoom", pic_tmp);
break;
case cv::EVENT_RBUTTONDOWN:
break;
case cv::EVENT_MBUTTONDOWN:
break;
case cv::EVENT_LBUTTONUP:
break;
case cv::EVENT_RBUTTONUP:
break;
case cv::EVENT_MBUTTONUP:
break;
case cv::EVENT_LBUTTONDBLCLK:
break;
case cv::EVENT_RBUTTONDBLCLK:
break;
case cv::EVENT_MBUTTONDBLCLK:
break;
}
}
SharedMemory* monapi_call_file_decompress_bz2(const SharedMemory& shm)
{
uint32_t tid;
if (monapi_name_whereis("/servers/file", tid) != M_OK) {
return NULL;
}
MessageInfo msg;
if (Message::sendReceive(&msg, tid, MSG_FILE_DECOMPRESS_BZ2, shm.handle(), shm.size()) != M_OK) {
return NULL;
}
if (msg.arg2 == 0) return NULL;
SharedMemory* ret = new SharedMemory(msg.arg2, msg.arg3);
if (ret->map(true) != M_OK) {
delete ret;
return NULL;
} else {
return ret;
}
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "shm_writer");
ros::NodeHandle nh;
//SharedMemory<double>::Ptr shm = SharedMemory<double>::Ptr(new SharedMemory<double>("shm"));
SharedMemory<double> shm = SharedMemory<double>("shm");
ros::Rate r(1000.0);
double data = 0;
while(ros::ok())
{
shm.write(data);
data += 0.001;
std::cout << data << std::endl;
r.sleep();
}
return 0;
}
void TcpServer::send_data(SharedMemory& data) {
try
{
write(
socket_,
boost::asio::buffer(data.data(), data.size()),
boost::asio::transfer_at_least(data.size()));
}
catch (std::exception& e){
printf("client disconnected\n");
accept_connection();
}
// async_write(
// socket_,
// boost::asio::buffer(data.data(), data.size()),
// boost::asio::transfer_at_least(data.size()),
// boost::bind(&TcpServer::handle_writer, this,
// boost::asio::placeholders::error,
// boost::asio::placeholders::bytes_transferred,
// data));
}
intptr_t monapi_file_write(uint32_t fileID, const SharedMemory& mem, uint32_t size)
{
MessageInfo msg;
uint32_t tid;
if (monapi_name_whereis("/servers/file", tid) != M_OK) {
return M_NAME_NOT_FOUND;
}
int ret = Message::sendReceive(&msg, tid, MSG_FILE_WRITE, fileID, size, mem.handle());
if (ret != M_OK) {
return ret;
}
return msg.arg2;
}
SharedMemory* monapi_call_file_decompress_bz2_file(const char* file, MONAPI_BOOL prompt)
{
uint32_t tid;
if (monapi_name_whereis("/servers/file", tid) != M_OK) {
return NULL;
}
MessageInfo msg;
if (Message::sendReceive(&msg, tid, MSG_FILE_DECOMPRESS_BZ2_FILE, prompt, 0, 0, file) != M_OK)
{
return NULL;
}
if (msg.arg2 == 0) return NULL;
SharedMemory* shm = new SharedMemory(msg.arg2, msg.arg3);
if (shm->map(true) != M_OK) {
delete shm;
return NULL;
} else {
return shm;
}
}
void ConsoleHandler::StartShellProcessAsAdministrator
(
const wstring& strSyncName,
const wstring& strShell,
const wstring& strInitialDir,
const wstring& strInitialCmd
)
{
SharedMemory<DWORD> pid;
pid.Open(strSyncName, syncObjBoth);
UserCredentials userCredentials;
PROCESS_INFORMATION pi = {0, 0, 0, 0};
CreateShellProcess(
strShell,
strInitialDir,
userCredentials,
strInitialCmd,
L"",
pi
);
*pid.Get() = pi.dwProcessId;
::SetEvent(pid.GetReqEvent());
// wait for shared objects creation
if (::WaitForSingleObject(pid.GetRespEvent(), 10000) == WAIT_TIMEOUT)
throw ConsoleException(boost::str(boost::wformat(Helpers::LoadString(IDS_ERR_DLL_INJECTION_FAILED)) % L"timeout"));
// inject our hook DLL into console process
if (!InjectHookDLL(pi))
throw ConsoleException(boost::str(boost::wformat(Helpers::LoadString(IDS_ERR_DLL_INJECTION_FAILED)) % L"?"));
// resume the console process
::ResumeThread(pi.hThread);
::CloseHandle(pi.hThread);
}
void TestIpc2(void) {
using namespace vislib::sys;
Semaphore sem(TEST_IPC_SEM_NAME);
Semaphore endSem(TEST_IPC_END_SEM_NAME);
SharedMemory shMem;
AssertNoException("Open shared memory.", shMem.Open(TEST_IPC_SHMEM_NAME,
SharedMemory::READ_WRITE, SharedMemory::OPEN_ONLY,
TEST_IPC_SHMEM_SIZE));
AssertTrue("Shared memory is open.", shMem.IsOpen());
if (shMem.IsOpen()) {
sem.Lock();
AssertEqual("Shared memory content.", *shMem.As<char>(), 'v');
*shMem.As<char>() = '2';
sem.Unlock();
}
// Signal that process has finished.
Console::Flush();
endSem.Unlock();
}
static void test_fatfs_write_file_overwrite()
{
TestFatFS fs;
FatFileSystem* fat = fs.get();
Vnode* root = fat->getRoot();
const char* FILENAME = "MY1.TXT";
Vnode* found;
ASSERT_EQ(M_OK, fat->lookup(root, FILENAME, &found, Vnode::REGULAR));
const int BUFFER_SIZE = 10;
SharedMemory* buffer = new SharedMemory(BUFFER_SIZE);
ASSERT_EQ(M_OK, buffer->map());
memset(buffer->data(), 0, BUFFER_SIZE);
for (int i = 0; i < BUFFER_SIZE; i++) {
buffer->data()[i] = i;
}
io::Context c;
c.offset = 513;
c.size = BUFFER_SIZE;
c.memory = buffer;
ASSERT_EQ(BUFFER_SIZE, fat->write(found, &c));
io::Context readContext;
SharedMemory* cmi = readAll(fat, readContext, root, FILENAME);
ASSERT_TRUE(cmi != NULL);
ASSERT_TRUE(cmi->data() != NULL);
EXPECT_EQ(0xde, cmi->data()[0]);
EXPECT_EQ(0xad, cmi->data()[cmi->size() -1]);
for (int i = 0; i < BUFFER_SIZE; i++) {
EXPECT_EQ(i, cmi->data()[513 + i]);
}
}
int main( ) {
SharedMemory * shm = new SharedMemory(PATH, SHM_PLAT, sizeof (struct plate), "shmstat");
shm->get();
struct plate * plate = (struct plate*) shm->attach();
std::stringstream status;
Semaphore * mutex = new Semaphore(PATH, SEM_MUTEX, "shmstat");
mutex->get();
mutex->wait();
status << "RobotsA: " << plate->activeRobotsA << std::endl;
status << "RobotsB: " << plate->activeRobotsB << std::endl;
status << "Dispositivos: " << plate->storedAmount << std::endl;
for (int i = 0; i < ROBOT_AMOUNT; i++)
{
status << "A" << i << ": " << msgRobot( plate->statusA[i] ) << ", " << msgWait( plate->statusE[i] ) << std::endl;
status << "B" << i << ": " << msgRobot( plate->statusB[i] ) << std::endl;
}
for (int i = 0; i < PLAT_SIZE; i++)
{
status << i << ": " << msgSlot(plate->slots[i].state) << ", " << msgDisp(plate->slots[i].dispositive.status) << std::endl;
}
mutex->post();
write(fileno(stdout),status.str().c_str(),status.str().size());
shm->dettach();
}
SharedMemory* monapi_call_file_decompress_st5_file(const char* file, MONAPI_BOOL prompt)
{
uint32_t tid;
if (monapi_name_whereis("/servers/file", tid) != M_OK) {
return NULL;
}
MessageInfo msg;
if (Message::sendReceive(&msg, tid, MSG_FILE_DECOMPRESS_ST5_FILE, prompt, 0, 0, file) != M_OK)
{
return NULL;
}
if (msg.arg2 == 0) {
int status = Message::reply(&msg);
if (status != M_OK) {
monapi_warn("%s reply failed : %s\n", __func__, monapi_error_string(status));
}
return NULL;
}
SharedMemory* shm = new SharedMemory(msg.arg2, msg.arg3);
if (shm->map(true) != M_OK) {
delete shm;
int status = Message::reply(&msg);
if (status != M_OK) {
monapi_warn("%s reply failed : %s\n", __func__, monapi_error_string(status));
}
return NULL;
} else {
int status = Message::reply(&msg);
if (status != M_OK) {
monapi_warn("%s reply failed : %s\n", __func__, monapi_error_string(status));
}
return shm;
}
}
TEST(SharedMemoryTest, ShareFork) {
bool was_child = false;
{
SharedMemory memory;
EXPECT_TRUE(memory.get_block() == nullptr);
EXPECT_TRUE(memory.is_null());
std::string meta_path = base_path() + std::string("_share_fork");
COERCE_ERROR(memory.alloc(meta_path, 1ULL << 21, 0));
memory.get_block()[3] = 42;
pid_t pid = ::fork();
if (pid == -1) {
memory.mark_for_release();
ASSERT_ND(false);
EXPECT_TRUE(false);
} else if (pid == 0) {
// child
SharedMemory memory_child;
memory_child.attach(meta_path);
EXPECT_FALSE(memory_child.is_null());
EXPECT_EQ(1ULL << 21, memory_child.get_size());
EXPECT_EQ(meta_path, memory_child.get_meta_path());
EXPECT_NE(0, memory_child.get_shmid());
EXPECT_NE(0, memory_child.get_shmkey());
EXPECT_EQ(0, memory_child.get_numa_node());
EXPECT_EQ(42, memory_child.get_block()[3]);
EXPECT_FALSE(memory.is_owned());
was_child = true;
} else {
// parent
int status;
pid_t result = ::waitpid(pid, &status, 0);
EXPECT_EQ(pid, result);
EXPECT_EQ(0, status);
}
memory.release_block();
}
if (was_child) {
::_exit(0); // otherwise, it goes on to execute the following tests again.
}
}
void
do_child(unsigned int child_id, QASharedMemoryHeader *header)
{
cout << "Child " << child_id << " is alive" << endl;
// This will attach to the existing shmem segment,
// use ipcs to check
SharedMemory *sr = new SharedMemory(MAGIC_TOKEN, header,
/* read only */ false,
/* create */ false,
/* destroy */ false);
int *mc = (int *)sr->memptr();
cout << "Child " << child_id << " entering loop" << endl;
while ( ! quit ) {
int m;
m = mc[1]; m++;
//cout << "Child: sleeping" << endl;
usleep(12932);
//cout << "Child: wasting time" << endl;
WASTETIME;
//cout << "Child: done wasting time, setting to " << m << endl;
// mc[1] = m;
cout << "Child " << child_id << ": locking (read)" << endl;
sr->lock_for_read();
cout << "Child " << child_id << ": locked (read)" << endl;
m = mc[0]; m++;
usleep(23419);
WASTETIME;
cout << "Child " << child_id << ": unlocking (read)" << endl;
sr->unlock();
cout << "Child " << child_id << ": locking (write)" << endl;
sr->lock_for_write();
cout << "Child " << child_id << ": locked (write)" << endl;
mc[0] = m;
cout << "Child " << child_id << ": unlocking (write)" << endl;
sr->unlock();
//cout << "Child: unlocked" << endl;
// std::cout << "Child " << child_id << ": unprotected: " << mc[1] << " protected: " << mc[0] << endl;
usleep(1231);
}
cout << "Child " << child_id << " exiting" << endl;
delete sr;
}
