当前位置：文江博客话题详情

如何在 MATLAB 中的进程之间共享内存？

发布于 2024-07-20 16:42:15 字数 187 浏览 8 评论 0原文

有没有办法在同一台计算机上的 MATLAB 进程之间共享内存？

我正在多核计算机上运行多个 MATLAB 进程（运行 Windows，如果有必要的话）。它们都使用相同的巨大输入数据。如果内存中只保留它的一个副本，那就太好了。

编辑：不幸的是，每个进程都需要访问整个巨大的输入数据，因此无法划分数据并解决问题。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

⊕婉儿 2024-07-27 16:42:15

如果进程只读取数据，但不修改它，那么我相信您可以将输入数据放入一个大文件中，并打开每个进程并从中读取数据那个文件。每个进程都有自己的文件位置指示器，可以移动到文件中的任何位置以读取所需的数据。我测试了两个 MATLAB 进程同时从一个文件读取一百万次左右，一切似乎都工作正常。我只使用了基本的文件 I/O 命令（如下所列）。看来您也可以使用 MEMMAPFILE 来执行此操作，正如福兹先生在他的回答中提到的（以及评论中的 SCFrench），假设您有 MATLAB R2008a 或更高版本。

以下是您可能为此使用的一些文件 I/O 命令：

FOPEN：每个进程都会调用 FOPEN 并返回一个文件标识符，它将在所有后续调用中使用。您可以以二进制或文本模式打开文件：
```
fid = fopen('data.dat','r');   % 二进制模式 
  fid = fopen('data.txt','rt');   % 文本模式 
  
```
FREAD：在二进制模式下，FREAD将从文件中读取数据：
```
A = fread(fid,20,'double');   % 读取20个双精度值 
  
```
FSCANF：在文本模式下，FSCANF将从文件中读取数据并格式化：
```
A = fscanf(fid,'%d',4);   % 读取4个整数值 
  
```
FGETL/FGETS ：在文本模式下，这些将从文件中读取整行。
FTELL：这会告诉您从文件开头算起的当前文件位置指示符（以字节为单位）：
<前><代码>ftell(fid)
答案=
8 % 位置指示符距文件开头 8 个字节
FSEEK：这会将文件位置指示器设置到文件中所需的位置：
```
fseek(fid,0,-1);   % 将位置指示器移动到文件开头 
  
```
FCLOSE：每个进程都必须关闭对文件的访问（很容易忘记这样做）：
```
fclose(fid); 
  
```

该解决方案可能要求输入文件具有易于遍历的结构良好的格式（即只有一个大矩阵）。如果它有很多可变长度字段，那么从文件中的正确位置读取数据可能会变得非常棘手。

如果流程还必须修改数据，这可能会变得更加困难。一般来说，您不希望多个进程同时写入文件/内存位置，或者在另一个进程从同一位置读取时由一个进程写入，因为可能会导致不需要的行为。在这种情况下，您必须限制对该文件的访问，以便一次只有一个进程对其进行操作。其他进程必须等待第一个进程完成。在这种情况下，每个进程必须运行的代码示例版本是：

processDone = false;
while ~processDone,
  if file_is_free(),  % A function to check that other processes are not
                      %   accessing the file
    fid = fopen(fileName,'r+');  % Open the file
    perform_process(fid);        % The computation this process has to do
    fclose(fid);                 % Close the file
    processDone = true;
  end
end

像这样的同步机制 ("锁"）有时会产生很高的开销，从而降低代码的整体并行效率。

If the processes only ever read the data, but do not modify it, then I believe you can place your input data into one large file and have each process open and read from that file. Each process will have it's own file position indicator that it can move anywhere in the file to read the data it needs. I tested having two MATLAB processes reading simultaneously from a file a million or so times each and everything seemed to work fine. I only used basic file I/O commands (listed below). It appears you could also do this using MEMMAPFILE, as Mr Fooz mentioned in his answer (and SCFrench in a comment), assuming you have MATLAB version R2008a or newer.

Here are some of the file I/O commands that you will likely use for this:

FOPEN: Each process will call FOPEN and return a file identifier it will use in all subsequent calls. You can open a file in either binary or text mode:
```
fid = fopen('data.dat','r');   % Binary mode
fid = fopen('data.txt','rt');  % Text mode
```

FREAD: In binary mode, FREAD will read data from the file:

A = fread(fid,20,'double');  % Reads 20 double-precision values

FSCANF: In text mode, FSCANF will read and format data from the file:
```
A = fscanf(fid,'%d',4);  % Reads 4 integer values
```
FGETL/FGETS: In text mode, these will read whole lines from the file.
FTELL: This will tell you the current file position indicator in bytes from the beginning of the file:
```
ftell(fid)
ans =
     8    % The position indicator is 8 bytes from the file beginning
```
FSEEK: This will set the file position indicator to a desired position in the file:
```
fseek(fid,0,-1);  % Moves the position indicator to the file beginning
```
FCLOSE: Each process will have to close its access to the file (it's easy to forget to do this):
```
fclose(fid);
```

This solution will likely require that the input file has a well-structured format that is easy to traverse (i.e. just one large matrix). If it has lots of variable length fields then reading data from the correct position in the file could get very tricky.

If the processes have to also modify the data, this could get even more difficult. In general, you don't want a file/memory location being simultaneously written to by multiple processes, or written to by one process while another is reading from the same location, since unwanted behavior can result. In such a case, you would have to limit access to the file such that only one process at a time is operating on it. Other processes would have to wait until the first is done. A sample version of code that each process would have to run in such a case is:

processDone = false;
while ~processDone,
  if file_is_free(),  % A function to check that other processes are not
                      %   accessing the file
    fid = fopen(fileName,'r+');  % Open the file
    perform_process(fid);        % The computation this process has to do
    fclose(fid);                 % Close the file
    processDone = true;
  end
end

Synchronization mechanisms like these ("locks") can sometimes have a high overhead that reduces the overall parallel efficiency of the code.

回复收藏 0 原文

木森分化 2024-07-27 16:42:15

您可能想查看我的 Matlab 文件交换提交“sharedmatrix”#28572。它允许 Matlab 矩阵存在于共享内存中，前提是您使用某种 Unix 风格。然后可以将共享矩阵附加到 parfor 或 spmd 的主体中，即，

shmkey=12345;
sharedmatrix('clone',shmkey,X);
clear X;
spmd(8)
    X=sharedmatrix('attach',shmkey);
    % do something with X
    sharedmatrix('detach',shmkey,X);
end
sharedmatrix('free',shmkey);

由于 X 存在于 spmd（或 parfor）主体的共享内存中，因此它没有加载时间，也没有通信时间。从 Matlab 的角度来看，它是 spmd（或 parfor）主体中新创建的变量。

干杯，

乔什

http://www.mathworks.com/matlabcentral/fileexchange/28572-sharedmatrix< /a>

You may want to checkout my Matlab file-exchange submission "sharedmatrix" #28572. It allows a Matlab matrix to exist in shared memory, provided you are using some flavor of Unix. One could then attach the shared matrix in a body of a parfor or spmd, ie,

shmkey=12345;
sharedmatrix('clone',shmkey,X);
clear X;
spmd(8)
    X=sharedmatrix('attach',shmkey);
    % do something with X
    sharedmatrix('detach',shmkey,X);
end
sharedmatrix('free',shmkey);

Since X exists in shared memory for the body of the spmd (or parfor) it has no load time and no communication time. From the perspective of Matlab it is a newly created variable in the spmd (or parfor) body.

Cheers,

Josh

http://www.mathworks.com/matlabcentral/fileexchange/28572-sharedmatrix

回复收藏 0 原文

童话里做英雄 2024-07-27 16:42:15

编辑：将数据放入原始文件中并使用memmapfile （感谢 SCFrench）。

==============================================

不，没有真正的这样做的方法。

我最重要的两个解决方案是：购买更多 RAM 或数据页面。

您可以做的最接近的事情是使用 mex 函数来分配共享内存，然后允许连续调用 mex 函数来提取较小的内存片段。您不会希望将共享内存包装为 Matlab 数组（因为 Matlab 的内存模型无法很好地处理它）。

我本来建议查看 memmap，但显然它是有问题的。

有时，您可以先运行一个 Matlab 程序来预处理数据或将数据分割成更小的块。然后每个 Matlab 进程都可以在自己的较小块上运行。

这是关于在 Matlab 中处理大型数据集的教程。

回复收藏 0 原文

安稳善良 2024-07-27 16:42:15

可能不会，至少不会像对待常规 MATLAB 变量那样对待数据。

如果在 Windows 计算机上，您可以创建 COM/ActiveX 包装器来访问共享数据。 MATLAB 允许通过 actxserver< 来使用 COM 对象/code>函数。但是否真的可以通过不同的进程“直接”访问数据是值得怀疑的。 MATLAB 和 COM 之间存在某种编组层，数据会被转换，至少根据在 MATLAB 和 COM 之间交换数据. 如果我绝对必须在 Windows 计算机上的进程之间共享结构化数据并进行快速访问，我可能会用 C++ 编写一些内容来通过 Boost::interprocess 并将对其的访问包装在 in 中- 处理 COM 服务器 (DLL)。我以前做过一次。尽管 Boost::interprocess 让它变得更容易，但它很痛苦。

Java 方法（因为 MATLAB 在 Java 之上运行）会更有前途，但据我所知，没有任何像样的 Java 库可以提供对共享内存的访问。最接近的事情可能是通过 java.nio.MappedByteBuffer，但这确实是低级的。不过，如果您的数据处于相对“方形”的形式（例如，大小均匀的数据的大 2-D 或 3-D 或 4-D 矩阵），那么这可能会起作用。

您可以尝试使用 HDF5 文件，MATLAB 内置了 HDF5 支持并且“相对”快。但从我的经验来看，HDF5 似乎在并发方面表现得不太好。（至少当一个进程正在写入而其他进程是读取器时不是这样。如果有多个读取器而没有写入器，则效果很好。）