标签: interprocess

我想在内存中创建一个映射的二进制文件; 但是我不确定如何创建要映射到系统的文件.我多次阅读文档并意识到有2个映射文件实现,一个在iostream中,另一个在进程间.

你们对如何在共享内存中创建映射文件有任何想法吗？我试图允许多线程程序读取以二进制文件格式写入的大型double数组.iostream中的映射文件和进程间的区别是什么？

我想防止同一个长时间运行的python命令行脚本的多个实例同时运行,我希望新实例能够在新实例自杀之前将数据发送到原始实例.我怎样才能以跨平台的方式做到这一点？

具体来说,我想启用以下行为:

1. " foo.py"从命令行启动,它将保持运行很长时间 - 几天或几周,直到机器重新启动或父进程终止它.
2. 每隔几分钟再次启动相同的脚本,但使用不同的命令行参数
3. 启动时,脚本应查看是否有其他实例正在运行.
4. 如果其他实例正在运行,则实例#2应将其命令行参数发送到实例#1,然后实例#2应退出.
5. 实例#1,如果它从另一个脚本接收命令行参数,则应该启动一个新线程并(使用上面步骤中发送的命令行参数)开始执行实例#2将要执行的工作.

所以我正在寻找两件事:python程序如何知道自己的另一个实例正在运行,然后一个python命令行程序如何与另一个进行通信？

使这更复杂,相同的脚本需要在Windows和Linux上运行,因此理想情况下,该解决方案将仅使用Python标准库而不是任何特定于操作系统的调用.虽然如果我需要一个Windows代码路径和一个*nix代码路径(以及if我的代码中的一个大语句来选择其中一个),那么如果无法实现"相同代码"解决方案就没问题.

我意识到我可能会找到一个基于文件的方法(例如,实例#1监视一个目录进行更改,每个实例在它想要工作时将文件放入该目录)但是我有点担心清理这些文件在非优雅的机器关闭后.理想情况下,我可以使用内存解决方案.但是我再次灵活,如果基于持久文件的方法是唯一的方法,我会对这个选项持开放态度.

更多细节:我正在尝试这样做,因为我们的服务器正在使用监视工具,该工具支持运行python脚本来收集监视数据(例如,数据库查询或Web服务调用的结果),监视工具随后将其编入索引供以后使用.其中一些脚本启动起来非常昂贵,但在启动后运行起来很便宜(例如,建立数据库连接而不是运行查询).所以我们选择让它们在无限循环中运行,直到父进程杀死它们.

这很好用,但是在较大的服务器上,同一个脚本的100个实例可能正在运行,即使它们每个仅每20分钟收集一次数据.这会对RAM,数据库连接限制等造成严重破坏.我们希望将100个进程从1个线程切换到100个线程的进程,每个进程执行以前一个脚本正在执行的工作.

但是,无法更改监视工具调用脚本的方式.我们需要保持调用相同(使用不同的命令行参数启动进程),但是更改脚本以识别另一个是活动的,并让"new"脚本发送其工作指令(从命令行参数)到"旧"剧本.

顺便说一句,这不是我想要在一个脚本基础上做的事情.相反,我想将这种行为打包到一个许多脚本作者可以利用的库中 - 我的目标是使脚本作者能够编写不知道多实例问题的简单的单线程脚本,并处理多线程和单一实例的封面.

我在寻找一个明确的答案(如果确实存在)有多少内存应该通过创建共享内存的静态块时被分配boost::interprocess的managed_shared_memory.即使是官方的例子似乎也会分配任意大块的内存.

考虑以下结构:

// Example: simple struct with two 4-byte fields
struct Point2D {
  int x, y;
};

我最初的反应是必要的大小是8个字节,或者sizeof(Point2D).当我尝试构造一个对象时,这会失败,在运行时给出了seg-fault.

// BAD: 8 bytes is nowhere near enough memory allocated.
managed_shared_memory segment(create_only, "My shared memory", sizeof(Point2D));

什么读/写操作导致seg-faults？堆栈操作？临时分配segment.construct()？分配共享内存时需要多少开销？

通过试错我发现,通过4大小乘可以为上述结构的工作,但是当我开始增加更多的领域,以我的分崩离析struct.所以,这是一个糟糕的黑客.

有些人可能会争辩说,"内存很便宜",在现代电脑,但我不同意这种理念和分配不喜欢比我更需要的,如果我能避免它.我昨天在Boost文档中挖了一遍,找不到任何建议.这是今天要学习新东西的!

可能重复:
我应该在每次交易后关闭套接字(TCPIP)吗？

假设我有一些使用套接字工作的进程间通信.

我的进程是否应该建立连接并保持打开(每个客户端或类似的1个线程)在需要时发送数据; 或者是一种更好的方法来简单地建立连接,发送我想要的数据,关闭它并再次进入我的等待状态？

解决这个问题的方法通常是什么？

我们一直在分析和分析我们的应用程序,以尽可能减少延迟.我们的应用程序由3个独立的Java进程组成,它们都运行在同一台服务器上,它们通过TCP/IP套接字相互传递消息.

我们将第一个组件的处理时间缩短到25μs,但我们发现TCP/IP套接字(在本地主机上)写入下一个组件总是需要大约50μs.我们看到另一个异常行为,因为接受连接的组件可以写得更快(即<50μs).目前,除套接字通信外,所有组件的运行时间均小于100μs.

不是TCP/IP专家,我不知道可以做些什么来加快这个速度.Unix Domain Sockets会更快吗？MemoryMappedFiles？什么其他机制可能是一种更快的方式将数据从一个Java进程传递到另一个Java进程？

更新6/21/2011我们创建了2个基准测试应用程序,一个用Java编写,一个用C++编写,用于更紧密地比较TCP/IP并进行比较.Java应用程序使用NIO(阻塞模式),而C++使用Boost ASIO tcp库.结果或多或少相当,C++应用程序比Java快约4μs(但在其中一项测试中,Java胜过C++).此外,两个版本的每条消息的时间都有很多变化.

我认为我们同意共享内存实现最快的基本结论.(虽然我们也想评估Informatica产品,只要它符合预算.)

我第一次尝试使用命名管道.在此处找到的MS文档中,它指出:

对于每次调用BeginWaitForConnection,必须只调用一次EndWaitForConnection.

所以我想成为一个优秀的小程序员并遵循文档,但是EndWaitForConnection()当我使用它时,它会无限期地挂起.

所以我把我的代码剥离到最低限度,所以看看我是否可以隔离问题而不是骰子.我已经从我写过的课程中提取了以下代码.我已修改它,以便它开始在管道连接上等待,然后立即尝试停止等待该管道连接:

private void WaitForConnectionCallBack(IAsyncResult result)
{

}

public void Start()
{
    var tempPipe = new NamedPipeServerStream("TempPipe",
                                             PipeDirection.In,
                                             254, 
                                             PipeTransmissionMode.Message,
                                             PipeOptions.Asynchronous);

    IAsyncResult result = tempPipe.BeginWaitForConnection(
                                    new AsyncCallback(WaitForConnectionCallBack), this);

    tempPipe.EndWaitForConnection(result);  // <----- Hangs on this line right here
}

1)为什么要坚持下去EndWaitForConnection()？如果我想在收到连接之前关闭我的服务器,我怎么能基本上取消这个BeginWaitForConnection()回调？

2)我们假设我没有上述问题.如果2个客户端尝试很快连接到我的命名管道会发生什么？

我是否为每个人获得了回调调用,或者我是否必须等待接收第一个连接通知EndWaitForConnection()然后 WaitForConnectionCallBack()再次快速呼叫再次开始侦听下一个客户端？

后者对我来说似乎是一种竞争条件,因为我可能不会足够快地设置连接侦听器.

我在放入boost::lockfree::queue<<T, fixed_sized<false>, ..> 共享内存时遇到问题.我需要它,因为我必须能够将超过65535条消息插入队列,并且fixed_sized队列限制为65535.
以下代码正常工作(但capacity<...>选项暗示fixed_sized<true>):

typedef boost::interprocess::allocator<
    MessageT, 
    boost::interprocess::managed_shared_memory::segment_manager>
        ShmemAllocator;
typedef boost::lockfree::queue<
    MessageT,
    boost::lockfree::capacity<65535>,
    boost::lockfree::allocator<ShmemAllocator> >
        Queue;
m_segment = new boost::interprocess::managed_shared_memory(
    boost::interprocess::create_only, segmentName, size);
Queue* m_queue = m_segment->construct<Queue>(
    queueName)(
    m_segment->get_segment_manager());
...
m_queue->bounded_push(message);

以下代码也正常工作(但它不使用共享内存):

boost::lockfree::queue<MessageT> q;
....
q.bounded_push(message);

但是当我尝试将它结合起来时:

typedef boost::interprocess::allocator<
    MessageT, 
    boost::interprocess::managed_shared_memory::segment_manager>
        ShmemAllocator;
typedef boost::lockfree::queue<
    MessageT,
    boost::lockfree::allocator<ShmemAllocator> >
        Queue;
m_segment = new boost::interprocess::managed_shared_memory(
    boost::interprocess::create_only, segmentName, size);
Queue* m_queue = m_segment->construct<Queue>(
    queueName)(
    m_segment->get_segment_manager());
...
m_queue->bounded_push(message);

它无法使用以下日志进行编译:

In file included from src/model/Queue.h:16:

In file included from /home/uppi/lib/include/boost/lockfree/queue.hpp:24: …

假设我的大数据阵列每秒更新1000次以上.
另一个应用程序想要在短时间内访问和读取数组.两个应用程序都在同一台机器上.

我已经尝试使用WCF进行进程间通信,但是每秒数千次序列化和发送整个数组(或大型对象)是不可行的性能.
有没有办法直接访问c#中不同应用程序的对象？

出于好奇,在Linux上实现进程间同步的首选方法是什么？该sem*(2)系统调用的家人似乎有一个非常笨重,过时的接口,同时有三种方式来锁定文件- fcntl(),flock()和lockf().

有什么内部差异(如果有的话)以及你如何证明每种差异的使用？

我通过使用共享内存在多​​个进程之间共享一些数据; 我使用进程间互斥来实现同步.

我的问题如下:是否可以使用无锁数据结构和/或原子操作来实现更快的同步,而无需在两个进程之间使用互斥锁？

如果不是,你知道这是什么主要原因？

它们仅用于同步同一进程的线程.这些概念是否也可以移植到流程中？如果不是,您是否知道跨进程共享/同步数据的更快方法？