标签: parallel-processing

(d:\用户\达西\桌面\ parallel.png)

使用命令时matlabpool open local 4,它会提醒我Undefined函数或变量'matlabpool'.

并行功能有变化吗？

我正在使用R的插入符号包,并且在训练函数(训练)中我使用了allowParallel参数,它可以工作.但是,它使用了所有核心,并且由于培训在我的本地PC上运行,我宁愿为自己留下一个核心,以便能够在训练模型时工作.有没有办法做到这一点？

根据我的收集,似乎不同的模型类型可能使用不同的并行化包.我在windows上工作,所以我猜它不是在使用doMC(我知道如何设置内核的数量......)

前段时间,人们提出了一个有趣的问题:

Can (a == 1 && a == 2 && a == 3) evaluate to true in Java?

我决定证明可以使用Java 8 Stream API(准确地说是并行流).这是我的代码在非常罕见的情况下工作:

class Race {
    private static int a;

    public static void main(String[] args) {
        IntStream.range(0, 100_000).parallel().forEach(i -> {
            a = 1;
            a = 2;
            a = 3;
            testValue();
        });
    }

    private static void testValue() {
        if (a == 1 && a == 2 && a == 3) {
            System.out.println("Success");
        }
    }
}

然后我想,也许是因为潜在的JIT编译器优化？因此,我尝试使用以下VM选项运行代码:

-Djava.compiler=NONE

我禁用了JIT,成功案例数量大幅增加! …

如果我尝试用dask并行化for循环，它的执行速度将比常规版本慢。基本上，我只是按照dask教程中的介绍性示例进行操作，但是由于某种原因，它最终还是失败了。我究竟做错了什么？

In [1]: import numpy as np
   ...: from dask import delayed, compute
   ...: import dask.multiprocessing

In [2]: a10e4 = np.random.rand(10000, 11).astype(np.float16)
   ...: b10e4 = np.random.rand(10000, 11).astype(np.float16)

In [3]: def subtract(a, b):
   ...:     return a - b

In [4]: %%timeit
   ...: results = [subtract(a10e4, b10e4[index]) for index in range(len(b10e4))]
1 loop, best of 3: 10.6 s per loop

In [5]: %%timeit
   ...: values = [delayed(subtract)(a10e4, b10e4[index]) for index in range(len(b10e4)) ]
   ...: resultsDask = compute(*values, get=dask.multiprocessing.get)
1 loop, best of …

我正在看一个开源C++项目,它具有以下代码结构:

while(true) {
  // Do something work

  if(some_condition_becomes_true)
     break;

  __asm volatile ("pause" ::: "memory");
}

最后的陈述是做什么的？我理解这__asm意味着它是一个汇编指令,我发现了一些关于pause指令的帖子,说明该线程有效地暗示核心释放资源并给予其他线程更多资源(在超线程的上下文中).但:::做什么和memory做什么呢？

我正在练习java8并行流部分并编写一个程序,它将从0传递给参数的数字加到该数字.

例如,如果我通过10,它将从1到10的数字相加并返回输出.

以下是该计划

public class ParellelStreamExample {



    public static void main(String[] args) {
        System.out.println("Long Range value - "+ Long.MIN_VALUE + " to "+ Long.MAX_VALUE);
        long startTime = System.nanoTime();
        long sum = sequentailSum(100000000);
        System.out.println(
                "Time in sequential execution " + (System.nanoTime() - startTime) / 1000000 + " msec with sum = " + sum);
        long startTime1 = System.nanoTime();
        long sum1 = parellelSum(100000000);
        System.out.println("Time in parallel execution " + (System.nanoTime() - startTime1) / 1000000
                + " msec with sum = " + …

我需要澄清一些关于Node.js,Promises,CPU和性能的内容.

为了设置上下文,我将讨论多次执行的异步处理(数据库查询)(在循环中),然后在所有异步之后执行其他操作.处理完成.

让我们从代码示例开始:

async function databaseQuery() {
    return await connection.query('SELECT * FROM example;');
}

我想执行n次异步调用(databaseQuery函数),当这些n次执行结束时,执行其他操作.

让我们使用并行Promises来实现这个目标:

const array = [...]; // Assuming this array is full of whatever

const promises = array.map(async (item) => {
    return await databaseQuery();
});

await Promise.all(promise);

// Ok now I'm sure all async calls are done

我尝试在两个环境中实现此代码:

• 本地计算机,Windows 10 x64,Intel i7 6c/12t,16g RAM
• 远程服务器(虚拟化服务器@ OVH),Ubuntu 16.04,1vCore,6g RAM

显然,本地机器上的性能远远优于远程机器(<1秒vs.> 1分钟).

但我需要一些关于为什么的精确度？.我知道物理材料在本地机器上更好.

此外,由于Node.js在单个核心上的单个线程上运行,为什么Windows资源使用10个线程和6个处理器监视Node.js进程？

代码中没有实现"多处理"代码(cluster …

我想链接一个CompletableFuture，以便它在处理过程中呈扇形散开。我的意思是我对列表有一个开放的CompletableFuture，并且我想对列表中的每个项目应用计算。

第一步是调用m_myApi.getResponse（request，executor）发出异步调用。

该异步调用的结果具有getCandidates方法。我想同时解析所有这些候选人。

目前，我的代码按顺序解析它们

public CompletableFuture<List<DOMAIN_OBJECT>> parseAllCandidates(@Nonnull final REQUEST request, @Nonnull final Executor executor)
{
        CompletableFuture<RESPONSE> candidates = m_myApi.getResponse(request, executor);
        return candidates.thenApplyAsync(response -> response.getCandidates()
                                                   .stream()
                                                   .map(MyParser::ParseCandidates)
                                                   .collect(Collectors.toList()));
}

我想要这样的东西：

public CompletableFuture<List<DOMAIN_OBJECT>> parseAllCandidates(@Nonnull final REQUEST request, @Nonnull final Executor executor)
{
        CompletableFuture<RESPONSE> candidates = m_myApi.getResponse(request, executor);
        return candidates.thenApplyAsync(response -> response.getCandidates()
                                                   .stream()
                                                   .PARSE_IN_PARALLEL_USING_EXECUTOR
}

我从VM之一下面输出了.

因此,根据链接,并行流使用默认值ForkJoinPool.commonPool,默认情况下,当您拥有处理器时,默认情况下只有一个线程Runtime.getRuntime().availableProcessors().

如果我这样做Runtime.getRuntime().availableProcessors(),那么它总是返回1,但是看下面的输出,数字应该更多.我在这里缺少什么？

lscpu命令输出是: -

2019-02-05T20:20:33.813+05:30 [APP/PROC/WEB/0] [OUT] Architecture: x86_64
2019-02-05T20:20:33.813+05:30 [APP/PROC/WEB/0] [OUT] CPU op-mode(s): 32-bit, 64-bit
2019-02-05T20:20:33.813+05:30 [APP/PROC/WEB/0] [OUT] Byte Order: Little Endian
2019-02-05T20:20:33.813+05:30 [APP/PROC/WEB/0] [OUT] CPU(s): 4
2019-02-05T20:20:33.813+05:30 [APP/PROC/WEB/0] [OUT] On-line CPU(s) list: 0-3
2019-02-05T20:20:33.814+05:30 [APP/PROC/WEB/0] [OUT] Thread(s) per core: 1
2019-02-05T20:20:33.814+05:30 [APP/PROC/WEB/0] [OUT] Core(s) per socket: 1
2019-02-05T20:20:33.819+05:30 [APP/PROC/WEB/0] [OUT] Socket(s): 4
2019-02-05T20:20:33.819+05:30 [APP/PROC/WEB/0] [OUT] NUMA node(s): 1
2019-02-05T20:20:33.819+05:30 [APP/PROC/WEB/0] [OUT] Vendor ID: GenuineIntel
2019-02-05T20:20:33.819+05:30 [APP/PROC/WEB/0] [OUT] CPU family: …

我必须处理8个处理器.我想按如下方式进行并行调整:

    vector<vector <int> > test;
    test.resize(10000);
    #pragma omp parallel num_threads(8)
    {
        #pragma omp for
        for (int i = 0;i < 10000;i++)test[i].resize(500000);
    }

我注意到程序没有使用100%的处理器能力 - 它只使用了15%.当我更改代码时

    vector<vector <int> > test;
    test.resize(1000000);
    #pragma omp parallel num_threads(8)
    {
        #pragma omp for
        for (int i = 0;i < 1000000;i++)test[i].resize(5000);
    }

该程序使用了大约60%的处理器功率.我不明白这种现象 - 我希望它能在僵硬的情况下使用100%的处理器能力.我在这里错过了什么吗？