标签: parallel-processing

Bundle 支持并行处理--jobs：

--jobs 选项（简称 -j）并行安装 gem。例如，bundle install -j4 将使用 4 个工作线程。我们发现新捆绑安装的速度提高了 40-60%。要始终并行安装，请运行bundle config --global jobs 4或设置BUNDLE_JOBS。

这里使用的是 4 的示例，但为什么不是 2 或 8呢？是否有最佳数量或计算最佳并行进程数的方法？如果时间受到网络活动的限制，我认为它应该很高，例如 64，或者如果受到计算的限制，那么可能是机器上的核心数量。

我正在使用rasterpackage 并尝试切换到，terra但由于某些我不明白的原因，无法重现与和等包并行工作时terra的相同操作。这是一个可重现的示例。rastersnowfallfuture.apply

library(terra)
r <- rast()
r[] <- 1:ncell(r)
m <- rast()
m[] <- c(rep(1,ncell(m)/5),rep(2,ncell(m)/5),rep(3,ncell(m)/5),rep(4,ncell(m)/5),rep(5,ncell(m)/5))
ms <- separate(m,other=NA)
plot(ms)
mymask <- function(ind){
  tipo <- tipo_tav[ind]
  mask <- ms[[ind]]
  
  masked <-
    terra::mask(
      r,
      mask
    )
  
  richard <- function(x){
    k <-0.2
    v <-0.3
    a <-200
    y0 <-2
    y <- k/v*x*(1-((x/a)^v))+y0
    return(y)
  }
  pred <- richard(masked)
  pred <- clamp(pred,lower=0)
  return(pred)
}
#the sequential usage works fine, faster than the `raster` counterpart
system.time(x <- mymask(1))#0.03 …

NOPARALLEL和 和有PARALLEL 1什么区别？如果我像这样创建三个表：

CREATE TABLE t0 (i NUMBER) NOPARALLEL;
CREATE TABLE t1 (i NUMBER) PARALLEL 1;
CREATE TABLE t2 (i NUMBER) PARALLEL 2;

它们在数据字典中显示为

SELECT table_name, degree FROM user_tables WHERE table_name IN ('T0','T1','T2');

TABLE_NAME  DEGREE
T0               1 <==
T1               1 <==
T2               2

该文件，但规定很清楚

NOPARALLEL：为串行执行指定 NOPARALLEL。这是默认设置。

PARALLEL integer : integer 的规范表示并行度，即并行操作中使用的并行线程数。每个并行线程可以使用一个或两个并行执行服务器。

所以，NOPARALLEL肯定是串行的，而PARALLEL 1使用一个线程，可能使用一个或两个并行服务器？？？但是，当数据字典为两者存储相同的值 1 时，Oracle 如何区分它们呢？

顺便说一句，CREATE TABLE sys.tab$?/rdbms/admin/dcore.bsq 中的声明有评论

/* 
 * Legal values for degree, instances: …

解锁std::mutex未锁定的 UB。为什么会这样？为什么它没有任何作用，因为互斥锁尚未锁定，或者已经解锁，那么再次调用解锁有什么危害？

我有超过 10 亿个观测值的大数据，我需要执行一些字符串操作，速度很慢。

我的代码很简单：

DT[, var := some_function(var2)] 

如果我没记错的话，data.table在使用 调用时使用多线程by，并且我正在尝试利用它来并行化此操作。为此，我可以创建一个临时石斑鱼变量，例如

DT[, grouper := .I %/% 100] 

并做

DT[, var := some_function(var2), by = grouper]

我尝试使用小样本数据进行一些基准测试，但令人惊讶的是我没有看到性能改进。所以我的问题是：

1. data.table与 一起使用时是否使用多线程by？
2. 如果是这样，是否存在启用/禁用多线程的条件？
3. 有没有一种方法可以让用户“强制”data.table在这里使用多线程？

仅供参考，当我导入 data.table 时，我发现我的一半核心启用了多线程，所以我猜这里不存在 openMP 问题。

假设我有 6 个测试套件：ABCDEF，我希望 ABC 顺序运行，然后并行运行 DEF。
输出如下：

A
B
C // always in that order
E
D
F // The order doesn't matter

这个想法是能够独立于其余测试来测试 ABC。

我已经尝试过的

创建一个像这样的超级顺序测试类并添加@DoNotDiscover顺序测试。

A
B
C // always in that order
E
D
F // The order doesn't matter

但是，即使 ABC 顺序运行，也会与其他测试并行运行。

我也尝试过

class MasterSuite extends Stepwise(
  Sequential(new A, new B, new C)
)

但对我来说，它按顺序运行所有测试（也许我错过了build.sbt文件中的某些内容）。

我有一个已经可以解决的问题，multiprocessing.Pool但解决方案并不是非常理想。也就是说，我拥有一组相当小的输入，每个输入都映射到一个大数据集。虽然我可以使用imap_unordered返回列表的函数，但这远非高效，因为每个大型数据集都必须作为列表返回。

我的函数可以将它们作为生成器返回以降低延迟，但我无法从子进程返回生成器。

一个虚拟示例：

import time
import multiprocessing


def generate(x):
    for j in range(x, x + 10):
        yield j
        time.sleep(1)

def wrapper(x):
    return list(generate(x))


with multiprocessing.Pool(10) as pool:
    for ready in pool.imap_unordered(wrapper, range(0, 100, 10)):
        for item in set(ready):  # to show that order does not matter:
            print(item)

问题是，虽然整个运行现在只需要顺序运行时间的十分之一，但我仍然需要等待 10 秒才能得到第一个结果，可以通过以下方式立即获得：

def generate(x):
    for j in range(x, x + 10):
        yield j
        time.sleep(1)

for ready in map(generate, range(0, 100, 10):
    for item in set(ready):
        print(item)

它将立即打印第一项，但需要 100 …

我对 的概念很困惑ParallelizationFactor。

我的理解

/sf/answers/4027402571/
过去，一个 KDS 分片只能向一个 Lambda 实例/调用发送数据。从同一 KDS 分片获取数据的多个 Lambda 实例无法同时运行。

https://aws.amazon.com/blogs/compute/new-aws-lambda-scaling-controls-for-kinesis-and-dynamodb-event-sources/
2019 年 11 月，出现了一个新参数ParallelizationFactor（每个分片的并发批次数）出去。

默认因子 1 表现出正常行为。因子 2 允许对 100 个 Kinesis 数据分片进行最多 200 个并发调用。

问题

1. 通过使用ParallelizationFactor，多个 Lambda 实例是否可以同时从同一个 KDS 分片获取不同的数据？
   例如，分片有数据d1、d2、d3 d4和d5，d6我们假设BatchSize= 2 和ParallelizationFactor= 2。Lambda 实例 A 可以消费d1和d2，而 Lambda 实例 B 可以同时消费d3和。d4然后，一旦 Lambda 实例 A 完成第一批，它就会开始处理d5 …

对于某些操作，Parallel可以很好地随 CPU 数量进行扩展，但对于其他操作则不然。

考虑下面的代码，function1获得 10 倍的改进，同时function2获得 3 倍的改进。这是由于内存分配，还是GC？

void function1(int v) {
    for (int i = 0; i < 100000000; i++) {
        var q = Math.Sqrt(v);
    }
}
void function2(int v) {
    Dictionary<int, int> dict = new Dictionary<int, int>();
    for (int i = 0; i < 10000000; i++) {
        dict.Add(i, v);
    }
}
var sw = new System.Diagnostics.Stopwatch();

var iterations = 100;

sw.Restart();
for (int v = 0; v < iterations; v++) function1(v);
sw.Stop(); …

我正在进行基于 GIS 的数据分析，其中计算广域全国预测图（例如天气图等）。因为我的目标区域非常大（整个国家），所以我使用超级计算机（Slurm）和并行化来计算预测图。也就是说，我将预测图分成多个部分，每个部分都在自己的进程中计算（令人尴尬的并行进程），并且在每个进程中，使用多个 CPU 核心来计算该部分（地图部分进一步拆分为更小的部分）对于 CPU 核心）。

我使用 Python 的 joblib-library 来利用我可以使用的多个核心，并且大多数时候一切都运行顺利。但有时，大约有 1.5% 的概率，我会收到以下错误：

Traceback (most recent call last):
  File "main.py", line 557, in <module>
    sub_rasters = Parallel(n_jobs=-1, verbose=0, pre_dispatch='2*n_jobs')(
  File "/root_path/conda/envs/geoconda-2021/lib/python3.8/site-packages/joblib/parallel.py", line 1054, in __call__
    self.retrieve()
  File "/root_path/conda/envs/geoconda-2021/lib/python3.8/site-packages/joblib/parallel.py", line 933, in retrieve
    self._output.extend(job.get(timeout=self.timeout))
  File "/root_path/conda/envs/geoconda-2021/lib/python3.8/site-packages/joblib/_parallel_backends.py", line 542, in wrap_future_result
    return future.result(timeout=timeout)
  File "/root_path/conda/envs/geoconda-2021/lib/python3.8/concurrent/futures/_base.py", line 439, in result
    return self.__get_result()
  File "/root_path/conda/envs/geoconda-2021/lib/python3.8/concurrent/futures/_base.py", line 388, in __get_result
    raise self._exception
joblib.externals.loky.process_executor.TerminatedWorkerError: A worker process managed by the executor was unexpectedly terminated. This …