标签: interprocess

这是我第一次在这里发帖提问,我通常会在档案中找到答案,但这次我很难过.

我使用来自使用Windows Driver Kit的供应商的一些代码从操纵杆中获取数据.数据采用具有6个元素的数组形式(它是6个自由度的鼠标).

我已经编写了需要抓取数据的代码,而且它是用C++编写的......它使用标准库很多用向量而不是.似乎使用WDK的标准库是一个很大的痛苦,我花了几天试图上班但失败了.我的下一个想法是使用boost :: interprocess,但由于同样的原因,这很难与WDK一起使用.

我想知道是否有办法在C进程和C++进程之间共享内存.我想使用C程序将数组写入内存并从C++程序中读取.它需要发生得非常快,应该有一种方法可以确保我不会在写入(mutex？)中读取它.

欢迎任何想法或建议.

编辑 我做了一个DLL,现在我只有一个DLL,它有一个getValues()函数,我可以从我的C++项目调用.我不得不使用pimpl成语来隐藏c的东西.谢谢你的帮助!

我需要在进程之间共享一堆字符串(将来可能会有更复杂的对象).我决定使用boost :: interprocess但我无法使用它.我确定这是因为我不理解某些事情.我按照他们的例子,但如果有经验使用该库的人可以查看我的代码并告诉我什么是错的,我将非常感激.问题是它似乎有效,但经过几次迭代后,我在阅读器进程和有时在编写器进程上都会遇到各种异常.这是我的实现的简化版本:

using namespace boost::interprocess;
class SharedMemoryWrapper
{
public:
    SharedMemoryWrapper(const std::string & name, bool server) :
      m_name(name),
      m_server(server)
    {
        if (server)
        {
            named_mutex::remove("named_mutex");
            shared_memory_object::remove(m_name.c_str());
            m_segment = new managed_shared_memory (create_only,name.c_str(),65536);         
            m_stackAllocator = new StringStackAllocator(m_segment->get_segment_manager());
            m_stack = m_segment->construct<StringStack>("MyStack")(*m_stackAllocator);
        }
        else
        {
            m_segment = new managed_shared_memory(open_only ,name.c_str());
            m_stack = m_segment->find<StringStack>("MyStack").first;
        }
        m_mutex = new named_mutex(open_or_create, "named_mutex");
    }

    ~SharedMemoryWrapper()
    {
        if (m_server)
        {
            named_mutex::remove("named_mutex");
            m_segment->destroy<StringStack>("MyStack");
            delete m_stackAllocator;
            shared_memory_object::remove(m_name.c_str());
        }
        delete m_mutex;
        delete m_segment;
    }

    void push(const std::string & in)
    {
        scoped_lock<named_mutex> lock(*m_mutex);
        boost::interprocess::string …

我一直在研究使用Boost.Interprocess来创建磁盘支持的数据结构.Boost文档(http://www.boost.org/doc/libs/1_41_0/doc/html/interprocess.html)上的示例都是为了使用共享内存,即使他们提到也可以使用内存映射文件.我想知道这里是否有人使用过内存映射文件？任何可公开获得的代码示例(例如,内存映射文件支持的映射或集)？

我正在为一个新的硬件设备编写软件,我希望任何一种新的第三方应用程序能够访问它们.

该软件将是一个本机进程(C++),应由第三方游戏和想要支持硬件设备的应用程序进行调查.这些第三方应用程序还应该能够在订阅的基础上从本机进程接收事件.因此,除了原生流程之外,我还将为第三方开发人员提供"连接器"库,以便他们可以选择的所有平台/语言(Java,C++,Python等)嵌入到他们的应用程序中,以便他们可以轻松连接几乎没有任何额外的代码需要由他们写的设备.我想针对所有台式机/笔记本电脑操作系统平台,并且非常了解我想要公开的功能,但理想情况下我不想太过困难(即我希望它能够从客户端和服务器中优雅地扩展观点).

我正在寻求未来的可靠性,性能,可维护性以及未来的跨平台/语言灵活性,以及​​按顺序开发的简易性.

我该怎么用？

CORBA,MessagePack-RPC,Thrift还是完全不同的东西？

(因为它的许可,我省略了ICE)

所以我想知道 - 是否可以将接受的TCP连接(在Windows或Unix上,如OS)从一个进程传递到另一个进程？这里的重点是传递连接 - 而不是代理应用程序的数据.

在我提出这个问题之前,我想明确表示我知道有进程间通信的库和技术.但这是一个关于COM的学习问题.我也知道有关服务器外的服务器,但这不是我想要的.

问题:

我想知道的是,因为我不知道这个,是否有可能,如果是的话,如何共享一个进程中的COM对象(在DLL中定义的对象)生活在一个进程中(已在进程中实例化)跨越另一个过程？即,如何从进程B中的进程A获取指向进程内对象的指针？

提前致谢.

我正在使用boost::interpocess::scoped_locka named_mutex和a timeout; 我在Linux OS中运行.

在我的一次测试中,我遇到了崩溃:从那时起,每当我再次尝试运行应用程序时,它就会卡在我创建锁的位置; 看起来互斥体仍然以某种方式获得(没有可能使用它的进程正在运行).

最重要的是,如果你看下面的代码,我希望在150微秒后,定时scoped_lock返回给我一个错误..但事实并非如此......只是挂在那里.

      #include <boost/interprocess/sync/named_mutex.hpp>
      namespace bi = boost::interprocess;
      bi::named_mutex m_mutex;

 try{
      boost::posix_time::ptime pt( 
          boost::posix_time::microsec_clock::local_time() ) ;

      pt+= boost::posix_time::microseconds( 150 );
      bi::scoped_lock< bi::named_mutex > lock( m_mutex, pt );

      if( !lock.owns() ){
        FATAL( "I didn't acquire the lock." );
           return EXIT_FAILURE;
      }
     ....

我的问题如下:

1. 如何确保boost::interprocess命名的互斥锁被销毁？(那么如何在进程中查看共享的互斥锁以及如何销毁它们)
2. 为什么获取互斥锁不会在150微秒后返回？这下面的代码中有什么问题吗？

非常感谢

AFG

我想用它boost::interprocess::file_lock来确保x进程写入目录的文件在完成之前P1不会被进程读取P2.要做到这一点,我想在编写P1文件boost::interprocess::file_lock时锁定文件,然后在文件完成时将其解锁.然后P2可以跳过(并返回)任何被锁定的文件.

我遇到的问题是它似乎boost::interprocess::file_lock只允许你锁定存在的文件.但是,如果我首先创建文件,然后锁定它,那么就存在竞争条件:

1. P1 创建文件
2. P2 注意到文件并开始阅读
3. P1 锁定文件
4. P1 写一些数据
5. P2读取一些数据,到达终点,最后只得到部分P1输出.

所以我想做的就是创建一个文件,并在创建文件后立即将其锁定.有没有办法使用boost::interprocess::file_lock？

有一个称为flock()进程可用于获取资源的共享("读取")访问或独占("写入")访问的Unix函数.问题是它会使那些请求独占访问的进程匮乏.这样的请求保持排队,直到没有进程持有共享锁; 同时,新的共享锁请求被"授权"在等待独占锁定的进程之前.

显然,请求共享锁的进程越多,编写器就必须等待没有未完成的共享锁的偶然时间窗口.

我寻求的行为是这样的:一旦作家请求了一个独占锁,后来请求共享锁的读者将排在作者后面.我被告知,这种类型的锁的名称是"编写器更喜欢读/写锁".

有几个职位(这个特别),解决了这个问题,但在线程级.我需要的是一个面向Unix/Linux的解决方案,用于以这种方式协调进程.

更新:我需要通过自动删除锁来解决参与进程在保持锁定时崩溃的可能性.

你能用C#调用用C/C++编写的另一个正在运行的进程内的函数吗？

我知道你可以通过注入启动远程线程DLL中做到这一点使用C++,监听相关的键按压,使所需要的功能,其签名和地址已被定义的调用.

C++ to C++教程在这里:http: //www.codeproject.com/Articles/29527/Reverse-Engineering-and-Function-Calling-by-Addres#Applying

如果我没记错的话,我过去也会读到你不能将托管DLL(C#)注入非托管进程(C++).但也许存在另一种方式......

我之所以这样做,是为了对PC游戏进行逆向工程,并用C#编写一些小技巧,这是我熟悉的一种语言.