我正在尝试使用POSIX共享内存和POSIX信号量构建客户端服务器应用程序.我是否必须将信号量放在共享内存段中,或者信号量是否只是全局变量？我希望遵守POSIX惯例.
Lib1[dll]
{
class A
{
static int i=0;
}
}
Program1[exe] have reference to Lib1
{
Class B
{
main()
{
A.i = 5;
}
}
}
Program2 [exe] have reference to Lib1
{
Class C
{
main()
{
A.i = 5;
}
}
}
如果Program1和Program2同时执行,它们是否可能引用Lib1的单个实例,并且Program1中对Ai的静态变量所做的更改可用于Program2,反之亦然,
关于使用共享内存我有两个问题.我正在使用CreateFileMapping在两个进程之间创建共享内存区域.
1)我知道我需要在从CreateFileMapping或OpenFileMapping调用返回的每个句柄上调用CloseHandle以释放内存.我的问题是,如果使用共享内存的程序退出而不调用CloseHandle,那么所有句柄是否都会被Windows XP/7解除分配？IE - 使用mem的所有进程关闭后是否有可能发生内存泄漏？
2)我使用MapViewofFile获取指向mem的指针.在一个实例中,我假设共享内存将始终存在于方法的上下文中.所以我已经将MapViewOfFile的返回值保存为指针并关闭了mem的句柄,我只是使用指向共享内存的指针(但仍然锁定对它的访问).这样安全,还是每次访问共享内存时都应该调用MapViewOfFile？
谢谢,
伊恩
这是一个简单的问题,但在阅读之后我为什么需要内存屏障？我很困惑.
在下面的示例中,假设不同的线程重复调用Increment和Counter:
class Foo{
int _counter=0;
public int Counter
{
get { return _counter; }
}
public void Increment()
{
Interlocked.Increment(ref _counter);
}
}
对不起,如果我误解了为什么我需要内存屏障？但似乎这表明上述课程在阅读_counter的价值时可能无法提供新鲜度保证.重复访问Counter属性的线程是否会永远停留在旧的Counter值(因为它缓存在寄存器中)？
在return _counter;必要之前是内存屏障还是锁？
c# multithreading thread-safety shared-memory memory-barriers
当我这样做:
myProgram.h
myProgram.c
struct PipeShm
{
// all my fields
// more
// ...
};
struct PipeShm myPipe = { /* initialization for all fields */ };
struct PipeShm * sharedPipe = &myPipe;
void func()
{
sharedPipe = mmap (NULL, sizeof * sharedPipe, PROT_READ | PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS, -1, 0);
}
当我mmap指针时sharedPipe,如果我main()从myProgram代码中调用任何方法,那么所有进程是否会共享我与myPipestruct 共享的确切共享内存？
或者每个新创建的孩子都会拥有myPipe自己的新生儿？
问候
编辑:
这是在我阅读了评论和答案之后:现在进行了更改,并且仅在我分配之后才初始化段的值:
#include "my_pipe.h"
struct PipeShm * sharedPipe = NULL;
int shm_pipe_init()
{ …我对来自NVidia的2份文件感到困惑."CUDA最佳实践"描述了共享存储器在存储体中组织,并且通常在32位模式下,每4个字节是一个存储体(这就是我所理解的).但是,"使用CUDA进行并行前缀求和(扫描)"(此处提供:http://http.developer.nvidia.com/GPUGems3/gpugems3_ch39.html)详细说明了由于存储库冲突,应如何在扫描算法中添加填充.
对我来说问题是,这个算法的基本类型是float,它的大小是4个字节.因此,每个浮动都是银行,没有银行冲突.
所以我的理解是正确的 - 即如果你使用4*N字节类型,你不必担心银行冲突,因为根据定义,没有？如果不是,我应该如何理解它(何时使用填充)？
我正在尝试实现一个JIT编译器(我有非常讨厌的爱好).
我想有一个主进程保留一些持久变量,第二个进程(刚刚编译)进行一些计算,可以访问和写入持久变量.
第二个进程可以更改并重新编译,但持久变量必须在第二个进程的两次执行之间保持相同.
我的第一个问题是:共享内存是否适合它？(另外在性能方面,因为我希望执行尽可能快.)
我的第二个问题是:如果我使用shm_overview.7中描述的共享内存,在我看来,任何其他具有相同uid的进程都可以访问它.我该怎样预防呢？我希望只有上述两个进程才能访问此共享内存.
我正在学习共享内存并创建了这个示例程序来测试
//IPC - Shared Memory
#include<stdio.h>
#include<stdlib.h>
#include<linux/ipc.h>
#include<linux/msg.h>
#include<linux/shm.h>
int main(int argc, char* argv[])
{
printf("setting up shared memory\n");
key_t ipc_key;
int shmid;
int pid;
ipc_key = ftok(".",'b');
if((shmid=shmget(ipc_key, 32, IPC_CREAT|0666))==-1)
{
printf("error creating shared memory\n");
exit(1);
}
printf("shared memory created with id %d\n",shmid);
//fork a child process
pid = fork();
printf("fork result %d\n",pid);
if(pid==0)
{
//child process
//attach the shared memory
int* shm_add_child = (int*)shmat(shmid, 0,0);
printf("child attached to shared mem at address %p\n",(void*)shm_add_child);
while(1)
{
printf("%d\n",*shm_add_child);
printf("a\n"); …我有这个程序真的很慢.分析揭示了XGetImage中的瓶颈(不是我不能在循环中调用XGetImage).在阅读推荐的解决方案时,请调用XShmGetImage,但文档真的很糟糕.
我正在寻找如何调用XShmCreateImage,XShmGetImage和XShmSetImage的简单示例代码.
深度分析肯定会使XGetImage成为根本瓶颈而不是XPutImage(是的,我知道调用XFlush使分析准确),因此我可能会得出结论,对内存分配器的隐式调用实际上是缓慢但没有XGetImage的变体这让我传递一个预分配的XImage,除了XShmGetImage.无论如何,Shm功能的使用可能会进一步提高.
我对派生生成的父进程和子进程之间的共享内存有问题。我知道如何使用此处所述的原始类型的共享内存。
虽然我不知道如何共享包含可通过malloc分配的指针的结构。
例如，假设我从先前的链接中获取了以下代码，并进行了一些修改。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/file.h>
#include <sys/mman.h>
#include <sys/wait.h>
typedef struct Data {
char * name;
} Data;
void error_and_die(const char *msg) {
perror(msg);
exit(EXIT_FAILURE);
}
int main(int argc, char *argv[]) {
int r;
const char *memname = "sample";
const size_t region_size = sysconf(_SC_PAGE_SIZE);
int fd = shm_open(memname, O_CREAT | O_TRUNC | O_RDWR, 0666);
if (fd == -1)
error_and_die("shm_open");
r = ftruncate(fd, region_size);
if (r != 0)
error_and_die("ftruncate");
Data * …