标签: shared-memory

我必须构建一个概念,使用共享内存或tcp套接字编程概念在两台计算机之间进行通信.我会怎么做呢？是否可以在客户端服务器架构中实现共享内存？我该如何解决？

我想写共享内存,然后将内容转储到win32 api中的文件.目前我有这个代码:

HANDLE hFile, hMapFile;
  LPVOID lpMapAddress;

  hFile = CreateFile("input.map",
  GENERIC_READ | GENERIC_WRITE,
  0,
  NULL,
  OPEN_EXISTING,
  FILE_ATTRIBUTE_NORMAL,
  NULL);

  hMapFile = CreateFileMapping(hFile,
  NULL,
  PAGE_READWRITE,
  0,
  0,
  TEXT("SharedObject"));

  lpMapAddress = MapViewOfFile(hMapFile,
  FILE_MAP_ALL_ACCESS,
  0,
  0,
  0);

  sprintf(MapViewOfFile, "<output 1>");

  UnmapViewOfFile(lpMapAddress);
  CloseHandle(hFile);
  CloseHandle(hMapFile);

但是,第31行(sprintf调用)给出错误:

error: cannot convert `void*(*)(void*, DWORD, DWORD, DWORD, DWORD)' 
to `char*' for argument `1' to `int sprintf(char*, const char*, ...)'

我已经尝试将lpMapAddress转换为LPTSTR,但它没有任何效果.我究竟做错了什么？或者有更好的方法吗？

我计划在服务器(C++)和客户端(C#应用程序)之间实现boost的共享内存.只有读取器和一个写入器,数据共享(读和写)的频率是每毫秒数千个时间.

涉及的风险是什么？

共享内存给我带来了困难,GDB没有太多帮助.我已经分配了32KB的共享内存,并且我曾经shmat将它转换为指向struct包含A)a bool和B的对象的队列,包含一个std::string,三个ints和一个对象的队列bool,以及各种方法.(我不知道这个俄罗斯套娃结构是否应该如何做,但这是我所知道的唯一方法.使用消息队列不是一种选择,我需要使用多个进程.)

将一个对象推入队列可以正常工作,但是当我尝试推送一个对象时,程序会冻结.没有错误消息,没有任何消息.是什么导致了这个？我怀疑这是缺乏记忆,但如果是,我需要多少钱？

编辑:如果我不清楚 - 队列中的对象是一个类,其中描述了五个数据成员.

编辑2:我更改了队列的条目类,以便它不使用std::string.(令人尴尬的是,我能够用原语表示数据.)程序仍然在第二次推送()时冻结.

编辑3:我尝试front()在第一个队列之后立即从同一个队列中调用push(),它也冻结了程序.但是,检查队列bool 外部的值是否正常,因此队列本身有问题.

EDIT 4:作为实验,我加入std::queue<int>到struct我使用的共享存储器.它显示了相同的行为 - push()工作一次,然后front()冻结.所以我用于队列项的类也不是问题.

这个问题表明我不太可能解决这个问题std::queue.是这样吗？我应该boost像它说的那样使用吗？(就我而言,我正在执行shmget()并shmat()在父进程中尝试让两个子进程进行通信,因此它略有不同.)

编辑5:其他子进程在调用时也会冻结front().信号量确保在第一次push()调用后发生这种情况.

我正在使用共享内存(由C提供的shmget系统调用)从RCpp程序内部分配共享内存.这里因为我没有使用与R的内存管理相关的标准Calloc功能,我应该注意哪些危险？R的内存管理是否会将shmget分配的空间视为可用空间并尝试过度写入任何内容？如果是这种情况,可以采取哪些措施来避免这种情况？

谢谢Vineeth

你知道为什么这个C代码以"分段错误"结束吗？

#include <semaphore.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>


#define NAMESEM "/mysem"

int main(int argc, char* argv) {
 sem_t* sem;
 int fd = shm_open(NAMESEM, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0);

 ftruncate(fd, sizeof(sem_t));

 sem = mmap(NULL, sizeof(sem_t), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

 sem_init(sem, 1, 0);

 sem_wait(sem);

 return 0;
}

我已经关注了这里发现的所有相关内容,但似乎sem_init()生成了一个分段错误,我不知道为什么.我用指针犯了一些错误吗？

我有一个应用程序生成相当多的数据,我希望它可供另一个C++应用程序访问.平台是RHEL5,g ++如果重要的话.

以前,我这样做的方法是将数据写入/ dev/shm(基本上是一个linux内存驱动器),然后让另一个应用程序从那里读取它.

然而,这似乎是非常低效的,因为有一个流,然后是一个ifstream,并将数据重新加载到内存中.此外,将数据作为文本文件存储在内存中似乎需要更多的空间而不仅仅是将其保存为内存(尽管我不是100%确定这是真的).

我要分享的数据是以.的形式

vector< vector<struct> > mydata;

我希望其他应用程序能够做类似的事情

mydata.at(ii).back()

检索它需要的数据.实际上mydata中会有相当多的数据.如果我要将它打印成CSV格式文件,它可能是10GB.我正在处理的服务器有24GB的内存,应该足以处理这个问题.

此外,当第一个应用程序在mydata中添加更多条目时,会发生这种检索(因此可能存在潜在的竞争条件？).

在C++中有没有办法共享vector <vector> mydata; 两个申请之间？如果是这样,最好的实现是什么？如果可能的话,我宁愿避免使用第三方库.

我有一个单线程Python程序,我想修改它以使用它运行的服务器上的所有32个处理器.正如我所设想的那样,每个工作进程都会从队列中接收其作业并将其输出提交到队列.但是,要完成其工作,每个工作进程都需要只读访问复杂的内存中数据结构 - 许多千兆字节的dicts和彼此链接的对象.在python中,有没有一种简单的方法来共享这个数据结构,而不为每个工作进程复制它？

谢谢.

我正在实现一个服务于多个客户端的服务器,我需要一些服务器的变量在共享内存中,以便客户端实际看到另一个客户端最终编辑的内容.

我试着环顾四周,但我不明白是否有任何方法可以通过使用fork()实现这一点,或者我完全需要改变我处理客户端的方式.特别是我不知道我是否应该实现管道进程或线程.另外,更简单的方法是什么？

这是我在main中声明int var之后的代码:

while(1) {
        printf("Waiting connection...\n");
        if ((connfd = accept(listenfd, (struct sockaddr *) NULL, NULL)) < 0) {
            perror("Accept Error");
            exit(1);
        }

        if ((pid = fork()) == 0) {
            close (listenfd);
            printf("Variable: %d\n", var); // var = 0
            var = 1;
            printf("Variable: %d\n", var); // var = 1
            exit(0);
        }

        close(connfd);
    }

当我与另一个客户端连接时,我再次看到var = 0,因为子进程生成了父进程的副本.

尝试在main()之外使用静态或声明全局变量,但据我所知,它没有任何效果.

我在样本C程序(RHEL 6)中获取可用的共享内存区域时遇到了困难.它应该是非常基本的,所以我不确定我做错了什么,但是当我分配内存区域时,它似乎最初是可访问的.但是,当我从初始化函数返回时,内存区域不再可访问,当我尝试访问内存区域时,我得到了段错误.

我试过通过GDB运行它,所有我看到的是我试图做这个memcpy的行上的段错误:

memcpy(ptr, &x, sizeof(x));

这可能是我看不出的一些小问题!谢谢.

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <stdio.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <errno.h>


void* shared_mem[2];

int init(int *memAddress);

int main() {

  if(init((int*)&shared_mem[0]) < 0) {
    printf("Error initializing, exiting\n");
    exit(1);
  }

  int *ptr=shared_mem[0];

  int x=278;
  memcpy(ptr, &x, sizeof(x));
  printf("data written to memAddress: %d\n", shared_mem[0]);

}

// Initialize shared memory region and insert test data
int init(int *memAddress) {
    key_t key = 234324;
    int size = sizeof(int);
    static const unsigned int flags …