标签: parallel-processing

我正在写一个分布式的Go/Gomoku机器人.

基本上,重点是将树搜索分发到许多计算机上.使用像DFS这样的基本树搜索算法,这将非常简单,因为我可以将搜索空间划分为子树.虽然我宁愿拥有更高效的东西,比如使用alpha-beta修剪的mini-max - 但是根据我的理解,没有任何共享内存它是毫无意义的.所以我有点卡住了.

任何想法我可以使用哪种算法高效且易于分发？更重要的是,我在哪里可以找到一些(伪)代码或者可能实现？

谢谢,

让我们在网站上有2页成像:快速和慢速.慢速页面请求执行1分钟,请求快速5秒.

整个我的开发生涯我认为如果第一次启动请求很慢:他将对DB进行(同步)调用...等待回答...如果在此期间请求快速页面将完成,此请求将被处理系统正在等待DB的响应.

但今天我发现:http: //msdn.microsoft.com/en-us/library/system.web.httpapplication.aspx

HttpApplication类的一个实例用于在其生命周期中处理许多请求.但是,它一次只能处理一个请求.因此,成员变量可用于存储每个请求数据.

这是否意味着我原来的想法是错的？

你能澄清一下他们的意思吗？我很确定这件事是我所期待的......

在仔细阅读了Rx.NET的样本后,我对于Reactive Extensions的概念和实现有多么精彩.它似乎为开发人员提供了一种更易于维护的模式,用于实现.NET 4.0的任务并行库提供的相同类型的多线程并行编码.

Rx.NET会取代TPL吗？应该是？

在TPL(任务 - 并行 - 库)中是否有内置支持用于批处理操作？

我最近玩了一个例程,使用查找表即音译在字符数组上进行字符替换:

for (int i = 0; i < chars.Length; i++)
{
    char replaceChar;

    if (lookup.TryGetValue(chars[i], out replaceChar))
    {
        chars[i] = replaceChar;
    }
}

我可以看到这可能是平凡的并行化,所以跳进了第一次刺,我知道会因为任务太细粒度而表现更差:

Parallel.For(0, chars.Length, i =>
{
    char replaceChar;

    if (lookup.TryGetValue(chars[i], out replaceChar))
    {
        chars[i] = replaceChar;
    }
});

然后我重新编写算法以使用批处理,这样就可以将工作分成不同细粒度的不同线程.这使得线程按预期使用,并且我得到了一些接近线性的加速.

我确信必须内置支持TPL中的批处理.什么是语法,我该如何使用它？

const int CharBatch = 100;
int charLen = chars.Length;

Parallel.For(0, ((charLen / CharBatch) + 1), i =>
{
    int batchUpper = ((i + 1) * CharBatch);

    for (int j = i * …

我正在使用Parallel.ForEach多个线程进行工作,每次迭代都使用一个新的EF5 DbContext,所有这些都包含在TransactionScope中,如下所示:

using (var transaction = new TransactionScope())
{
    int[] supplierIds;

    using (var appContext = new AppContext())
    {
        supplierIds = appContext.Suppliers.Select(s => s.Id).ToArray();
    }

    Parallel.ForEach(
        supplierIds,
        supplierId =>
    {
        using (var appContext = new AppContext())
        {
            Do some work...

            appContext.SaveChanges();                
        }
    });

    transaction.Complete();
}

运行几分钟后,它会抛出一个EntityException"底层提供程序在Open上失败",其中包含以下内部细节:

"此时SQL Server数据库引擎的实例无法获取LOCK资源.当活动用户较少时,请重新运行语句.请数据库管理员检查此实例的锁定和内存配置,或检查长时间运行交易."

有谁知道导致这种情况的原因或如何预防？谢谢.

我刚刚找到了这个提供无锁环的库,它的工作方式比通道快:https://github.com/textnode/gringo(它的工作速度非常快,尤其是GOMAXPROCS> 1)

但有趣的部分是用于管理队列状态的结构:

type Gringo struct {
    padding1 [8]uint64
    lastCommittedIndex uint64
    padding2 [8]uint64
    nextFreeIndex uint64
    padding3 [8]uint64
    readerIndex uint64
    padding4 [8]uint64
    contents [queueSize]Payload
    padding5 [8]uint64
}

如果我删除"paddingX [8] uint64"字段,它的工作速度大约慢20%.它怎么样？

还要感谢有人解释为什么这种无锁算法比通道快得多,甚至缓冲？

有什么区别

extern std::atomic<int> x;
int i = x++;

和

extern std::atomic<int> x;
int i = x.fetch_add(1);

我觉得第二个版本更安全,但我看不出这两个版本之间的测试有什么不同.

如果不进行并行编程,我可以key使用下面的代码在列上合并左侧和右侧数据帧,但由于两者都非常大,因此速度太慢.有没有什么方法可以有效并行化？

我有64个内核,所以实际上我可以使用其中的63个来合并这两个数据帧.

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                      'A': ['A0', 'A1', 'A2', 'A3'],
                     'B': ['B0', 'B1', 'B2', 'B3']})


right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
                      'C': ['C0', 'C1', 'C2', 'C3'],
                      'D': ['D0', 'D1', 'D2', 'D3']})


result = pd.merge(left, right, on='key')

输出将是:

left:
    A   B key
0  A0  B0  K0
1  A1  B1  K1
2  A2  B2  K2
3  A3  B3  K3

right:
    C   D key
0  C0  D0  K0
1  C1  D1  K1
2  C2  D2  K2 …

是否可以获取tf.scan操作的输出并将其直接流式传输到不同的GPU,从而有效地在两个GPU上并行运行两个堆叠的RNN？像这样的东西:

cell1 = tf.nn.rnn_cell.MultiRNNCell(..)
cell2 = tf.nn.rnn_cell.MultiRNNCell(..)

with tf.device("/gpu:0"):
  ys1 = tf.scan(lambda a, x: cell1(x, a[1]), inputs,
          initializer=(tf.zeros([batch_size, state_size]), init_state))

with tf.device("/gpu:1"):
  ys2 = tf.scan(lambda a, x: cell2(x, a[1]), ys1,
          initializer=(tf.zeros([batch_size, state_size]), init_state))

TensorFlow会自动处理该优化,还是会阻止图表流程,直到列表ys1完成为止.

我有一个算法,创建一个图形,其中包含以最短图形路径的形式编码的3位二进制字符串的所有表示,其中路径中的偶数表示0,而奇数表示1:

from itertools import permutations, product
import networkx as nx
import progressbar
import itertools

def groups(sources, template):
    func = permutations
    keys = sources.keys()
    combos = [func(sources[k], template.count(k)) for k in keys]
    for t in product(*combos):
        d = {k: iter(n) for k, n in zip(keys, t)}
        yield [next(d[k]) for k in template]                                      

g = nx.Graph()

added = []   
good = []
index = []
# I create list with 3-bit binary strings
# I do not include one of the pairs …