小编use*_*156的帖子

在使用Python multiprocessing模块时,我几乎没有基本问题:

class Someparallelworkerclass(object) :

    def __init__(self):
       self.num_workers = 4
       self.work_queue = multiprocessing.JoinableQueue()
       self.result_queue = multiprocessing.JoinableQueue()

    def someparallellazymethod(self):
       p = multiprocessing.Process(target=self.worktobedone).start()

    def worktobedone(self):
      # get data from work_queue
      # put back result in result queue

是否有必要通过work_queue,并result_queue作为args对Process？答案取决于操作系统吗？更基本的问题是:子进程是否从父进程获得复制(COW)地址空间,因此知道类/类方法的定义？如果是的话,它是如何知道的队列是IPC要共享,而且它不应该做的副本work_queue,并result_queue在子进程？我尝试在线搜索,但我发现的大部分文档都很模糊,并没有详细说明底层究竟发生了什么.

我正在编写一个异步日志记录框架,我有多个线程转储数据.我开始玩Boost asio,因为它提供了一些简单的方法来强制执行序列化和排序.由于我是初学者,我开始使用线程安全(使用boost::mutex和boost:condition_variable)圆形bounded_buffer(实际上是矢量)进行设计.

我写了一个简单的小基准来测量性能.基准测试只是记录一百万条消息的单个线程(将其推入缓冲区),我的工作线程只是从队列中获取消息以记录到文件/控制台/记录器列表.(PS互斥和CV的使用是正确的,并且指向消息的指针正在被移动,因此从这个角度看,一切都很好/有效).

当我改变我的实现而不是使用boost::asio::io_service和使用单个线程执行时run(),性能确实得到了提升(实际上它在增加记录的消息数量方面非常好,而不是在我的初始简单模型中降低性能)

以下是我想澄清的几个问题.

1. 为什么性能提升？(我认为boost::asio::io_service内部实现具有处理程序的线程安全队列,这使得它比我自己的初始简单线程安全队列设计更有效).请注意我的设计经过了很好的审核,并且没有任何错误(骨架代码基于经过验证的示例),有人可以更详细地了解如何io_service实现这一点的内部细节.

2. 第二个有趣的观察是,在增加线程时,我的初始实现性能得到了改善,但是以丢失序列化/排序为代价,但是使用boost :: asio降低了性能(非常轻微)(我认为这是因为我的处理程序正在执行非常简单的任务并且上下文切换开销正在降低,我将尝试提出更复杂的任务并在稍后发布我的观察结果).

3. 我真的想知道是否boost::asio只是用于i/o和网络操作,还是我使用它来通过线程池进行并发任务(并行)是一种很好的设计方法.难道io_service只是意味着对象用于I/O对象(如写入文件),但我发现这是一个非常有趣的帮助我解决并发任务(不只是I/O或网络相关)的序列化的方式方法(有时是强制排序使用股线).我是新手,并且非常好奇为什么基本模型没有像我使用boost asio那样执行/扩展.

结果:(我只有1个工作线程)

• 1000任务:两种情况下都是10微秒/任务
• 10000任务:80微秒(有界缓冲),10微秒增强asio
• 100000任务:250微秒(bounde缓冲区),10微秒增强asio

知道boost如何解决io_service处理程序的线程安全队列中的线程安全问题会很有趣(我总是认为在某些实现级别它们也必须使用锁和cv).

据我所知,活动对象设计模式是将一个(私有/专用)线程生命周期与一个对象捆绑在一起并使其在独立数据上工作.从我读到的一些文档中,这种范式的演变是由于两个原因,第一,管理原始线程会很痛苦,第二个争用共享资源的线程使用互斥锁和锁不能很好地扩展.虽然我同意第一个原因,但我并不完全理解第二个原因.使对象处于活动状态只会使对象独立,但是锁定/互斥锁争用等问题仍然存在(因为我们仍然有共享队列/缓冲区),该对象只是将共享责任委派给消息队列.我看到的这种设计模式的唯一优势是我不得不在共享对象上执行长的异步任务(现在我只是将消息传递给共享队列,线程不再需要在互斥锁上长时间阻塞/锁,但他们仍然会阻止并争夺发布消息/任务).除了这种情况,有人可以告诉更多场景,这种设计模式将具有其他优势.

我的第二个问题是(我刚开始挖掘设计模式),活动对象,反应堆和前驱设计模式之间的概念差异是什么.您如何确定哪种设计模式更有效并更符合您的要求.如果某人能够展示某些示例来展示这三种设计模式将如何表现以及哪种模式在不同场景中具有比较优势/劣势,那将是非常好的.

我有点困惑,因为我使用了活动对象(使用共享线程安全缓冲区)和boost :: asio(Proactor)来做类似的异步内容,我想知道是否有任何人对适用性有更多的见解接近问题时的不同模式

我试图更多地了解在执行tf图时看到的某些令人惊讶的结果。我正在使用的图形只是一片森林（一堆树）。这只是一个简单的前向推论图，与训练无关。我正在分享2个实施的摘要

代码段1：

with tf.name_scope("main"):

    def get_tree_output(offset):
        loop_vars = (offset,)
        leaf_indice = tf.while_loop(cond,
                                    body,
                                    loop_vars,
                                    back_prop=False,
                                    parallel_iterations=1,
                                    name="while_loop")
        tree_score = tf.gather(score_tensor, leaf_indice, name="tree-scores")
        output = tf.add(tree_score, output)

    leaf_indices = tf.map_fn(get_tree_output,
                             tree_offsets_tensor,
                             dtype=INT_TYPE,
                             parallel_iterations=n_trees,
                             back_prop=False,
                             name="tree-scores")

    tree_scores = tf.gather(score_tensor, leaf_indices, name="tree-scores")

    output = tf.reduce_sum(tree_scores, name="sum-output")
    output = tf.sigmoid(output, name="sigmoid-output")

代码段2：

with tf.name_scope("main"):
    tree_offsets_tensor = tf.constant(tree_offsets, dtype=INT_TYPE, name="tree_offsets_tensor")
    loop_vars = (tree_offsets_tensor,)
    leaf_indices = tf.while_loop(cond,
                                 body,
                                 loop_vars,
                                 back_prop=False,
                                 parallel_iterations=n_trees,
                                 name="while_loop")

    tree_scores = tf.gather(score_tensor, leaf_indices, name="tree-scores")

    output = tf.reduce_sum(tree_scores, name="sum-output")
    output = tf.sigmoid(output, name="sigmoid-output")

其余代码完全相同：while循环的常量张量，变量，条件和主体。在两种情况下，线程和并行性也相同代码snippet2：需要大约500微秒来进行推理代码片段1：需要大约12毫秒来进行推理 …

我试图转发一些参数来进行对象的原位构造.我不太了解在关联容器中使用emplace背后的基本原理,或者我可能只是以错误的方式使用/思考.如果有人可以共享代码片段以供使用,那将会很棒.

像map这样的关联容器总是存储一个kind对()的对象,而emplace函数表示它会通过转发参数来调用存储的对象的构造函数(对于map的情况总是成对).那么即使函数具有可变参数签名,我们是否仅限于提供两个参数(键,值)？

当我使用增强容器的emplace之前我可以传递如下的参数:emplace(arg1,arg2,arg3,arg4)//其中arg2,arg3,arg4用于构造对象而arg 1是关键.

当用新的gcc-4.6和c ++ 11编译时,这会打破但现在我必须做类似的事情:emplace(arg1,myobj(arg2,arg3,arg4)); //使相同的代码工作;

所以新的安卓不会像升级那样做任何明智的结构吗？我是否限制只为地图提供2个参数,因为对将始终为其构造函数接受两个参数.