只是想知道共享内存的关键是文件名还是 inode。
我有一个名为 .last 的文件,它只是一个指向名为 YYYYMMDDHHMMSS 的文件的硬链接。
一个目录看起来像这样:
20110101143000
.last
Run Code Online (Sandbox Code Playgroud)
.last 只是到 20110101143000 的硬链接。
一段时间后,创建了一个新文件
20110101143000
20110622083000
.last
Run Code Online (Sandbox Code Playgroud)
然后我们删除 .last,并重新创建它以引用新文件。
我们的软件在这些更新期间持续运行,使用 MAP_SHARED 映射 .last 文件。处理完文件后,软件可能会将其缓存几分钟,而不是取消映射。在一台物理服务器上,有 12-24 个软件实例同时运行。不同的实例通常会同时映射同一个文件。我的问题是:
linux 是使用文件名来锁定共享内存,还是使用 inode?
鉴于这种情况:
如果 linux 使用 inode,那么 proc A 和 B 将看到映射到不同文件的不同内存块,这就是我们想要的。如果 linux 使用文件名,那么 A 和 B 都会看到映射到新文件的相同内存块。B 没问题,但是当分片块中的内存发生变化时,A 崩溃了。
有谁知道它实际上是如何工作的?我要测试,但如果结果是基于名称的,除非有人知道诀窍,否则我就完蛋了。
谢谢!
我试图自己解决这个问题,但我不能.所以我想得到你的建议.
我正在写这样的内核代码.VGA是GTX 580.
xxxx <<< blockNum, threadNum, SharedSize >>> (... threadNum ...)
(note. SharedSize is set 2*threadNum)
__global__ void xxxx(..., int threadNum, ...)
{
extern __shared__ int shared[];
int* sub_arr = &shared[0];
int* sub_numCounting = &shared[threadNum];
...
}
Run Code Online (Sandbox Code Playgroud)
我的程序每个块创建大约1085个块和1024个线程.
(我正在尝试处理巨大的数组)
所以每个块的共享内存大小是8192(1024*2*4)字节,对吧?
我想通过使用cudaDeviceProp,我可以在GTX 580上的每个块的共享内存中使用最大49152bytes.
而且我知道GTX 580有16个处理器,可以在处理器上实现线程块.
但我的程序出错.(8192bytes <49152bytes)
我在内核中使用"printf"来查看是否运行良好但是几个块不运行.(虽然我创建了1085个块,但实际上只有50~100个块可以运行.)
我想知道在同一个处理器上运行的块是否共享相同的共享内存地址.(如果没有,为共享内存分配其他内存?)
我无法理解每个块的共享内存的最大大小意味着什么.
给我建议.
调用时ipcs -a,key列和id列有什么区别?
这是ipcs命令的示例输出:
ipcs -a
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x00000000 0 ybaumes 600 393216 2 dest
0x00000000 65537 ybaumes 700 8124648 2 dest
0x00000000 3932163 ybaumes 700 169376 2 dest
0x00000000 3604485 ybaumes 600 393216 2 dest
Run Code Online (Sandbox Code Playgroud) 我试图了解在不同进程之间共享相同数据源的最有效和耗费更少内存的方法.
想象一下以下代码,简化了我的问题.
import pandas as pd
import numpy as np
from multiprocessing import Pool
# method #1
def foo(i): return data[i]
if __name__ == '__main__':
data = pd.Series(np.array(range(100000)))
pool = Pool(2)
print pool.map(foo,[10,134,8,1])
# method #2
def foo((data,i)): return data[i]
if __name__ == '__main__':
data = pd.Series(np.array(range(100000)))
pool = Pool(2)
print pool.map(foo,[(data,10),(data,134),(data,8),(data,1)])
Run Code Online (Sandbox Code Playgroud)
在第一种方法中,将使用全局变量(在Windows上不起作用,仅在Linux/OSX上),然后由函数访问.在第二种方法中,我将"数据"作为参数的一部分传递.
就过程中使用的内存而言,两种方法之间会有区别吗?
# method #3
def foo((data,i)): return data[i]
if __name__ == '__main__':
data = pd.Series(np.array(range(100000)))
pool = Pool(2)
# reduce the size of the argument passed
data1 …Run Code Online (Sandbox Code Playgroud) 我在C中的结构中有一个链表,或者我认为.结构是:
//Structure of the domain list
typedef struct domains *domain_list;
struct domains{
char *domain;
domain_list next;
}domains_node;
//Structure of the configuration of the server
typedef struct{
int n_threads;
domain_list domain_list;
char* local_domain;
char* named_pipe_statistics;
}server_config;
Run Code Online (Sandbox Code Playgroud)
我试图在共享内存中输入它们,我确信结构很好,但我不知道链表是否正确(使用全局变量):
//Initialize shared memory
if((config_shmid = shmget(IPC_PRIVATE, sizeof(server_config), IPC_CREAT|0777)) < 0){
perror("Error in config shmid\n");
exit(1);
}
if((config = (server_config*)shmat(config_shmid, NULL, 0)) == (server_config *)-1){
perror("Error in config shmat\n");
exit(1);
}
if((config_domain_shmid = shmget(IPC_PRIVATE, sizeof(struct domains), IPC_CREAT|0777)) < 0){
perror("Error in domain_list config shmid\n");
exit(1); …Run Code Online (Sandbox Code Playgroud) 我有这个代码:
from multiprocessing import Pool, Manager
import numpy as np
l = Manager().list()
def f(args):
a, b = args
l.append((a, b))
data = [(1,2), (3,4), (5,6)]
with Pool() as p:
p.map(f, data)
x, y = np.transpose(l)
# do something with x and y...
Run Code Online (Sandbox Code Playgroud)
实际上,数据是一个有很多值的数组,转置操作很长,很耗内存。
我想要的是将“a”和“b”直接附加到列表 x 和 y 以避免转置操作。重要的是输出保持数据中的对应关系,如下所示:[[1,3,5], [2,4,6]]
这样做的明智方法是什么?
我正在尝试使用共享内存制作一个简单的通信器。
它应该能够写入一些文本并将其保存在共享内存中。
有人可以向我解释为什么我会出错:
对“shm_open”
collect2 的未定义引用:错误:ld 返回 1 个退出状态
我试图为两个程序创建 Makefile 以进行编译,但我仍然遇到错误。
这是我现在正在使用的代码:
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <errno.h>
#define TEXT_SIZE 512
int i;
struct shared_data
{
int data;
char some_text[TEXT_SIZE];
};
int main()
{
struct shared_data *ptr;
const char *shm_name = "comunicator";
int shm_fd;
shm_fd = shm_open(shm_name, O_CREAT | O_RDWR, 0666);
ftruncate(shm_fd, sizeof(struct shared_data));
ptr = mmap(0, sizeof(struct shared_data), PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
if (ptr …Run Code Online (Sandbox Code Playgroud) 我将一些数据存储在多个进程使用的共享内存数组中。在某些时候,我想扩大阵列。
假设进程之间已经有同步机制
最初,进程 1 将创建段,进程 2 将打开它。
过程1
shm_open() O_CREAT
ftruncate()
mmap() MAP_SHARED
过程2
shm_open()
mmap()
在某一时刻,一个进程想要扩大数组并调整共享段的大小。
处理 1 次调用
ftruncate()
mremap() MREMAP_MAYMOVE
是否应该通知进程 2 调整大小并调用mremap()更新它自己的虚拟地址?
如果必须通知进程 2,我正在考虑使用一些元数据打开第二个共享内存段,例如表的容量和互斥锁。每个进程最初从共享内存中存储表的容量,并在每个操作中根据共享内存元数据值检查本地值。如果值已更改,它将调用mremap()
如果mremap()在调整大小后必须在每个进程上调用,这是一种正确的方法吗?
我有一个 C++ 应用程序,它通过共享内存将数据发送到 python 函数。这ctypes在 Python 中非常有效,例如双精度和浮点数。现在,我需要cv::Mat在函数中添加一个。
我的代码目前是:
//H
#include <iostream>
#include <opencv2\core.hpp>
#include <opencv2\highgui.hpp>
struct TransferData
{
double score;
float other;
int num;
int w;
int h;
int channels;
uchar* data;
};
#define C_OFF 1000
void fill(TransferData* data, int run, uchar* frame, int w, int h, int channels)
{
data->score = C_OFF + 1.0;
data->other = C_OFF + 2.0;
data->num = C_OFF + 3;
data->w = w;
data->h = h;
data->channels = channels;
data->data = …Run Code Online (Sandbox Code Playgroud) 我有两个 C++ 进程,它们通过内存映射的 Single-Producer Single-Consumer (SPSC) double buffer 进行通信。这些进程只能在 Linux/Intel x86-64 上运行。语义是生产者填充前缓冲区,然后交换指针并更新计数器,让消费者知道它可以memcpy()后缓冲区。所有共享状态都存储在 mmapped 区域开头的标题块中。
int _fd;
volatile char *_mappedBuffer;
...
_fd = shm_open("/dev/shm/ipc_buffer", O_CREAT | O_TRUNC | O_RDWR, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
...
_mappedBuffer = static_cast<char *>(mmap(nullptr, _shmFileSizeBytes, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_NORESERVE | MAP_POPULATE, _fd, 0));
Run Code Online (Sandbox Code Playgroud)
生产者需要一个StoreStore屏障来确保在计数器增量之前交换是可见的,这在 x86 上应该是隐式的,具有回写 (WB) 内存:
void produce() {
...
// swap pointers
char *tmp = _frontBuffer;
_frontBuffer= _backBuffer; …Run Code Online (Sandbox Code Playgroud)