我正在尝试写入然后从使用打开的文件描述符中读取shm_open。它在 Linux 上按我的预期工作，但在 macOS 上却不行（特别是 macOS Monterey 12.5 21G72）。这是代码：
#include <stdio.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
int main(int argc, const char * argv[]) {
int fd = shm_open("/example", O_CREAT|O_RDWR, S_IRUSR|S_IWUSR);
if (fd < 0) {
printf("shm_open() failed %s (%d)\n", strerror(errno), errno);
return 1;
}
const char *buf = "hello world";
unsigned long len = strlen(buf);
ssize_t ret = write(fd, buf, len);
if (ret < 0) {
printf("write() failed %s (%d)\n", strerror(errno), …在尝试了解内置包multiprocessing和Pytorch 的multiprocessing包时，我观察到两者之间存在不同的行为。我觉得这很奇怪，因为Pytorch 的包与内置包完全兼容。
具体来说，我指的是进程之间共享变量的方式。在 Pytorch 中，张量通过 inplace 操作移动到共享内存share_memory_()。另一方面，通过使用shared_memory模块，我们可以得到与内置包相同的结果。
我很难理解两者之间的区别在于，使用内置版本，我们必须显式访问启动进程内的共享内存块。然而，我们不需要使用 Pytorch 版本这样做。
这是一个Pytorch的玩具示例，显示了这一点：
import time
import torch
# the same behavior happens when importing:
# import multiprocessing as mp
import torch.multiprocessing as mp
def get_time(s):
return round(time.time() - s, 1)
def foo(a):
# wait ~1sec to print the value of the tensor.
time.sleep(1.0)
with lock:
#-------------------------------------------------------------------
# WITHOUT explicitely accessing the shared memory block, we can observe …我想知道 - 除了授权程序之外,是否有任何已知技术可以控制对共享内存对象的访问？
例如,假设我创建了一个用于程序P的共享内存段,由Q访问,并使其成为读写.我可以使用Q访问它,因为我已经给它(Q)执行此操作所需的权限(作为具有组的特定用户运行等).
但是,我猜测有些人可能会从程序R中访问这个共享内存 - 只需附加到它并修改它.要停止这一点,你可以让内存段只读 - 但现在程序R仍然可以读取内存中的内容.
我的问题是部分 -
有没有办法,
a)只允许Q访问共享内存？
b)确定读取是否由除Q以外的人完成 - 谁做了？[这甚至可能吗？]对于奖励积分,这可以跨平台完成吗？[可能没有,但没有伤害尝试:)]
在什么情况下流氓程序可以附加到共享内存？我认为一种方法是,如果用户能够利用OS漏洞并成为启动该程序的用户.还有其他人？
如果我运行shm_get_var(),它会返回一个"引用",将数据保存在共享内存中吗？
我想在共享内存中保留一个大小约为50MB的数组,这样它就可以被多个进程使用,而不必保留这个50MB数组的多个副本.如果共享内存不是答案,有没有人有另一个想法？
有人能为我提供链接或片段,其中PHP进程写入内存并且Java进程从共享内存中读取吗？
谢谢你的精彩答案.
编辑问题:假设我在这样的PHP中创建一个共享内存
<?php
$shm_key = ftok(__FILE__, 't');
$shm_id = shmop_open($shm_key, "c", 0644, 100);
$shm_bytes_written = shmop_write($shm_id, $my_string, 0);
?>
现在有一些方法,我可以通过它传递值,$shm_id然后在java中读取它.
我确定我正在尝试的是非常简单的,但我以前从未完全使用多线程,所以我不知道从哪里开始.
我正在使用PCNTL创建一个多线程的PHP应用程序.我想要做的是同时运行3个函数,我希望它们的返回值合并为一个数组.所以逻辑上我需要在他们追加结果的所有子节点之间共享一些变量,或者只在一个子节点和父节点之间共享三个变量 - 然后父节点可以稍后合并结果.
问题是 - 我不知道该怎么做.首先想到的是使用共享内存,但我觉得应该有一个更简单的方法.
此外,如果它有任何影响,则分叉进程的函数是公共类方法.所以我的代码看起来如下所示:
<?php
class multithreaded_search {
/* ... */
/* Constructors and such */
/* ... */
public function search( $string = '' ) {
$search_types = array( 'tag', 'substring', 'levenshtein' );
$pids = array();
foreach( $search_types as $type ) {
$pid = pcntl_fork();
$pids[$pid] = $type;
if( $pid == 0 ) { // child process
/* confusion */
$results = call_user_func( 'multithreaded_search::'.$type.'_search', $string );
/* What do we do …我对使用POSIX系统调用的c中的共享内存分段有疑问.我是从客户端和服务器分离和删除段是否正确,或者我只需要从服务器中删除？
考虑我有2个程序
一个用于服务器,一个用于客户端
the steps for the server
1)create memory segment
2)attach
3)detach
4)remove
steps for the client
1)create
2)attach
3)detach
4)remove
这是我的代码:
//server
#include<stdlib.h>
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<sys/shm.h>
#define SHMSZ 100
int main()
{
key_t key;
char c;
int shmid;
char *shm;
key=1025;
//locate
if((shmid=shmget(key,SHMSZ,0666 | IPC_CREAT))<0)
{
perror("shmget");
exit(-1);
}
//attach
if((shm=shmat(shmid,NULL,0))==(char*)-1)
{
perror("shmat");
exit(-1);
}
sprintf(shm,"Hi there");
//shm="Hi There";
while(*shm!='*');
sleep(1);
//detach
shmctl(shmid,IPC_RMID,NULL);
return 0;
}
这是客户端
//client
#include<stdlib.h>
#include<stdio.h>
#include<sys/ipc.h>
#include<sys/types.h>
#include<sys/wait.h>
#include<sys/shm.h>
#define SHMSZ …如果你对动机感兴趣我会在接下来的几句中详细阐述它,如果不是只是跳到Q.
我正在考虑制作快速记录器但是在程序崩溃时没有受到影响的记录器(也就是少数最后一次记录消息没有丢失).所以我的想法是写入共享内存(ringbuffer)并从中读取另一个低prio进程并进行转储.但为了工作,我需要知道如果一个进程退出(正常退出,SEGFAULT)共享内存会发生什么...
所以我的问题是:当其中一个触发器死掉时,共享内存会发生什么(在Linux中,但你也可以在A中获胜)是UB吗？
我不是一位经验丰富的CUDA程序员.我遇到了这样的问题.我正在尝试从全局内存中将大矩阵(10K*10K)的磁贴(32x32)加载到共享内存中,并在发生时对其进行计时.我意识到,如果我将它加载到专用内存(寄存器),它加载比共享内存加载快4-5倍.
__global__ void speedtest( float *vel,int nx) {
int globalx = blockDim.x * blockIdx.x + threadIdx.x+pad;
int globalz = blockDim.y * blockIdx.y + threadIdx.y+pad;
int localx=threadIdx.x;
int localz=threadIdx.y;
float ptest;
__shared__ float stest[tile][tile];
//stest[localz][localx]=vel[globalz*nx+globalx]; //load to shared memory
ptest=vel[globalz*nx+globalx]; //load to private memory
__syncthreads();
}
我逐一评论stest和ptest并用cudaeventrecord计算经过的时间.stest耗时3.2毫秒,ptest耗时0.75毫秒.我究竟做错了什么？时间应该非常相似吗？我错过了什么？
配置:Cuda 7.5,gtx 980,只有32位变量和计算,没有特定目的,我只是在玩它.
我正在按要求发布示例代码
#include<stdio.h>
#include <math.h>
#define tile 32
#include <helper_cuda.h>
void makeittwo(float *array,int nz,int nx)
{
//this just assigns a number into the vector
int n2; …核心转储仅收集进程空间,但不收集为进程间通信创建的共享内存.如何使核心转储也包含运行进程的共享内存？