标签: parallel-processing

是否可以创建一个"应用程序组",它可以在一个窗口下运行,但在单独的进程中,如在Chrome浏览器中？我想将一个应用程序分成多个部分,这样一个崩溃或干扰过程就无法取消其他应用程序,但仍然保持外观和感觉尽可能接近原始系统.

我知道Chrome源代码是可用的,但是还有什么东西可以用于Delphi吗？

SUBJ.如何从主类BUT中分别从该类运行线程？

所以有一些细节:我有一个程序必须运行一个进程.该进程(一个cmd)仅在主程序完成并从内存中卸载时运行.并且只有在卸载主程序后才开始工作.

我该怎么加入该计划？

在我基于Debian的机器上使用R的并行软件包玩了一段时间后,我仍然无法找到一种方法来在计算后删除所有僵尸子进程.

我正在寻找一个通用的OS独立解决方案.

下面是一个简单的脚本,说明了2个内核的问题:

library(parallel)
testfun <- function(){TRUE}

cltype <- ifelse(.Platform$OS.type != "windows", "FORK", "PSOCK")
cl <- makeCluster(2, type = cltype)
p <- clusterCall(cl, testfun)
stopCluster(cl)

不幸的是,这个脚本在进程表中留下了两个僵尸进程,只有在R关闭时才会被杀死.

目前我正在使用build in function dist来计算我在R中的距离矩阵.

dist(featureVector,method="manhattan")

这是目前应用程序的瓶颈,因此我们的想法是平衡这项任务(概念上这应该是可能的)

搜索谷歌和这个论坛没有成功.

有人有想法吗？

我正在使用multiprocessor.Pool()模块来加速"令人尴尬的并行"循环.我实际上有一个嵌套循环,并使用multiprocessor.Pool加速内循环.例如,如果没有并行化循环,我的代码将如下所示:

outer_array=[random_array1]
inner_array=[random_array2]
output=[empty_array]    

for i in outer_array:
    for j in inner_array:
        output[j][i]=full_func(j,i)

并行化:

import multiprocessing
from functools import partial

outer_array=[random_array1]
inner_array=[random_array2]
output=[empty_array]    

for i in outer_array:
    partial_func=partial(full_func,arg=i)     
    pool=multiprocessing.Pool() 
    output[:][i]=pool.map(partial_func,inner_array)
    pool.close()

我的主要问题是,如果这是正确的,我应该在循环中包含multiprocessing.Pool(),或者如果我应该在循环外创建池,即:

pool=multiprocessing.Pool() 
for i in outer_array:
     partial_func=partial(full_func,arg=i)     
     output[:][i]=pool.map(partial_func,inner_array)

另外,我不确定我是否应该在上面第二个例子的每个循环结尾处包含"pool.close()"行; 这样做有什么好处？

谢谢!

有一个Task变量,让我们说现在正在运行任务..通过执行以下行.

await _task;

我想知道当我编写这段代码时会发生什么:

await _task;
await _task;

它会执行两次任务吗？或抛出异常,因为它已经运行？

在实现一个用于线程安全的类时,我是否应该在其构造函数的末尾包含一个内存屏障,以确保在访问它们之前已完成任何内部结构的初始化？或者消费者有责任在将实例提供给其他线程之前插入内存屏障吗？

简化问题:

由于初始化和线程安全类的访问之间缺乏内存屏障,下面的代码中是否存在种族危险可能会导致错误行为？或者线程安全类本身是否应该防止这种情况？

ConcurrentQueue<int> queue = null;

Parallel.Invoke(
    () => queue = new ConcurrentQueue<int>(),
    () => queue?.Enqueue(5));

请注意,程序可以接受任何内容,如果第二个委托在第一个委托之前执行,则会发生这种情况.(null条件运算符?.可以防止NullReferenceException这里.)然而,程序抛出一个IndexOutOfRangeException,多次入NullReferenceException队5,陷入无限循环,或者做任何由种族危险引起的其他奇怪事情都是不可接受的关于内部结构.

详细问题:

具体来说,假设我正在为队列实现一个简单的线程安全包装器.(我知道.NET已经提供了ConcurrentQueue<T>;这只是一个例子.)我可以写:

public class ThreadSafeQueue<T>
{
    private readonly Queue<T> _queue;

    public ThreadSafeQueue()
    {
        _queue = new Queue<T>();

        // Thread.MemoryBarrier(); // Is this line required?
    }

    public void Enqueue(T item)
    {
        lock (_queue)
        {
            _queue.Enqueue(item);
        }
    }

    public bool TryDequeue(out T item)
    {
        lock (_queue)
        {
            if (_queue.Count == …

Java 8并行流如何在使用子句中的抛出异常上运行,例如在forEach处理中？例如,以下代码:

final AtomicBoolean throwException = new AtomicBoolean(true);
IntStream.range(0, 1000)
    .parallel()
    .forEach(i -> {
        // Throw only on one of the threads.
        if (throwException.compareAndSet(true, false)) {
            throw new RuntimeException("One of the tasks threw an exception. Index: " + i);
        });

它会立即停止处理元素吗？是否等待已经启动的元素完成？是否等待所有流完成？抛出异常后是否开始处理流元素？

什么时候回来？异常后立即？毕竟/部分元素是由消费者处理的？

在并行流引发异常后,是否继续处理元素？(发现这种情况发生的情况).

这里有一般规则吗？

编辑(15-11-2016)

试图确定并行流是否提前返回,我发现它不是确定的:

@Test
public void testParallelStreamWithException() {
    AtomicInteger overallCount = new AtomicInteger(0);
    AtomicInteger afterExceptionCount = new AtomicInteger(0);
    AtomicBoolean throwException = new AtomicBoolean(true);

    try {
        IntStream.range(0, 1000)
            .parallel()
            .forEach(i -> {
                overallCount.incrementAndGet();
                afterExceptionCount.incrementAndGet();
                try …

如果我使用make -j2它,它构建良好,但利用不足的CPU:

如果我使用make -j4它,它会快速构建,但是对于某些特定模板的文件,它会消耗大量内存,从而减慢整个系统和构建过程,因为交换到HDD:

如何使其根据内存自动限制并行任务数,如下所示:

,以便以最大速率建立项目,但在某些地方放慢速度以避免撞到内存墙？

思路:

• -l如果内存繁忙,请使用并人为调整负载平均值(当系统出现问题时,负载平均值会自然增长).
• 使内存分配系统调用(如sbrk(2)或mmap(2))或页面错误保持进程挂起,直到内存被完成的作业回收,而不是交换其他进程.不幸的是,死锁很容易......

我有这样的PowerShell脚本:

Foreach ($file in $files) {
    [Do something]
    [Do something]
    [Do something]
}

这样,一个文件将在另一个文件之后处理.我想同时处理4个文件.

我知道foreach -parallel循环,但是并行执行[do something]任务.我基本上想要并行运行整个foreach循环.

如何在PowerShell中实现这一目标？