我现在有过几次同样的需求，并想就构建解决方案的正确方法获得其他想法。需要的是对多个线程上的多个元素执行一些操作，而无需一次将所有元素都放在内存中，只需要计算中的元素。就像，Iterables.partition是不够的，因为它预先将所有元素都放入内存中。
用代码表达，我想写一个 BulkCalc2，它和 BulkCalc1 做同样的事情，只是并行。下面的示例代码说明了我的最佳尝试。我不满意，因为它又大又丑，但它似乎实现了我的目标，即在工作完成之前保持线程的高度利用，在计算过程中传播任何异常，并且一次在内存中不必有超过numThreads 个 BigThing实例.
我会接受以最简洁的方式满足既定目标的答案，无论是改进 BulkCalc2 的方法还是完全不同的解决方案。
interface BigThing {
int getId();
String getString();
}
class Calc {
// somewhat expensive computation
double calc(BigThing bigThing) {
Random r = new Random(bigThing.getString().hashCode());
double d = 0;
for (int i = 0; i < 100000; i++) {
d += r.nextDouble();
}
return d;
}
}
class BulkCalc1 {
final Calc calc;
public BulkCalc1(Calc calc) {
this.calc = calc;
}
public TreeMap<Integer, …我即将开始一个项目，该项目将获取文本块，将大量数据解析为某种对象，然后可以对其进行序列化、存储和统计/收集数据。这需要尽可能快，因为我需要开始处理 > 10,000,000 个文本块，并且每天将收到 100,000 条。
我在具有 12 个至强核心 + 超线程的系统上运行它。我也可以访问/了解一些关于 CUDA 编程的知识，但对于字符串内容，我认为它不合适。从每个字符串中，我需要解析大量数据，其中一些我知道确切的位置，有些我不知道并且需要使用正则表达式/一些聪明的东西。
所以考虑这样的事情：
object[] parseAll (string [] stringsToParse)
{
parallel foreach
parse( string[n] )
}
object parse(string s)
{
try to use exact positions / substring etc here instead of regex's
}
所以我的问题是：
谢谢你的帮助！对不起，如果这是冗长的。
在一个项目中，我被要求通过 Java 实现共享内存并行化JaMP，它扩展了 Java for OpenMP。我几乎是该领域的初学者，经过 10 分钟的搜索，互联网并没有证明自己很有帮助。
我的主要问题：是JaMP仅 linux 的实现吗？如果没有，开始学习的良好起点是什么？
我使用 MPI 编写了一个小程序来并行化矩阵-矩阵乘法。问题是：在我的电脑上运行程序时，大约需要10秒才能完成，但在集群上大约需要75秒。我想我有一些同步问题，但我无法弄清楚（还）。
这是我的源代码：
/*matrix.c
mpicc -o out matrix.c
mpirun -np 11 out
*/
#include <mpi.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define N 1000
#define DATA_TAG 10
#define B_SENT_TAG 20
#define FINISH_TAG 30
int master(int);
int worker(int, int);
int main(int argc, char **argv) {
int myrank, p;
double s_time, f_time;
MPI_Init(&argc,&argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
MPI_Comm_size(MPI_COMM_WORLD, &p);
if (myrank == 0) {
s_time = MPI_Wtime();
master(p);
f_time = MPI_Wtime();
printf("Complete in %1.2f seconds\n", f_time - s_time);
fflush(stdout);
}
else {
worker(myrank, …我想在不同的线程中训练多个一类 SVM。有人知道 scikit 的 SVM 是否发布了 GIL？我在网上没有找到任何答案。
谢谢
python parallel-processing multithreading machine-learning scikit-learn
在 Windows 7 和 Ubuntu 64 位 11.04 上的 Revolution R 2.12.2 中，我有一个超过 100K 行和 100 多列的数据框，并且我为每个原始列派生了 ~5 列（sqrt、log、log10 等）并将它们添加到同一个数据框中。如果没有使用 foreach 和 %do% 的并行性，这可以正常工作，但速度很慢。当我尝试将它与 foreach 和 %dopar% 并行化时，它不会访问全局环境（以防止竞争条件或类似情况），因此我无法修改数据框，因为“未找到”数据框对象。
我的问题是我怎样才能让它更快？换句话说，如何并行化列或转换？
简化示例：
require(foreach)
require(doSMP)
w <- startWorkers()
registerDoSMP(w)
transform_features <- function()
{
cols<-c(1,2,3,4) # in my real code I select certain columns (not all)
foreach(thiscol=cols, mydata) %dopar% {
name <- names(mydata)[thiscol]
print(paste('transforming variable ', name))
mydata[,paste(name, 'sqrt', sep='_')] <<- sqrt(mydata[,thiscol])
mydata[,paste(name, 'log', sep='_')] <<- log(mydata[,thiscol])
}
}
n<-10 # I …在下面的代码片段中,我希望日志打印数字0 - 4.我知道数字可能不是那个顺序,因为任务将被分解为许多并行操作.
代码段:
from dask import dataframe as dd
import numpy as np
import pandas as pd
df = pd.DataFrame({'A': np.arange(5),
'B': np.arange(5),
'C': np.arange(5)})
ddf = dd.from_pandas(df, npartitions=1)
def aggregate(x):
print('B val received: ' + str(x.B))
return x
ddf.apply(aggregate, axis=1).compute()
但是当运行上面的代码时,我会看到:
B val received: 1
B val received: 1
B val received: 1
B val received: 0
B val received: 0
B val received: 1
B val received: 2
B val received: 3
B val received: 4
而不是0 …
我想并行执行多个数据库查询，并将结果存储在映射中。我正在尝试这样做，但是访问地图时地图没有完全填充。
我做错什么了吗？
public Map<MapKeyEnums, Set<String>> doDBCalls(String phoneNumber, long timestamp) {
Map<MapKeyEnums, Set<String>> instrumentsEdgesMap = new EnumMap<>(MapKeyEnums.class);
CompletableFuture.supplyAsync(() -> dbReadService.getCall(phoneNumber, PhoneNumber.class, "ABC", timestamp)).
thenApply(x -> instrumentsEdgesMap.put(MapKeyEnums.ABC, x));
CompletableFuture.supplyAsync(() -> dbReadService.getCall(phoneNumber, PhoneNumber.class, "XYZ", timestamp)).
thenApply(x -> instrumentsEdgesMap.put(MapKeyEnums.XYZ, x));
CompletableFuture.supplyAsync(() -> dbReadService.getCall(phoneNumber, PhoneNumber.class, "DEF", timestamp)).
thenApply(x -> instrumentsEdgesMap.put(MapKeyEnums.DEF, x));
return instrumentsEdgesMap;
}
任何帮助将不胜感激，在此先感谢。
java parallel-processing multithreading java-8 completable-future
假设我有一个，std::vector<int>并且想知道它是否包含3或将迭代器添加到3。
我不想使用std::set或std::multiset出于任何原因。
我想在std::execution::par_unseq模式下执行此操作。
我看到的两个选项是std::any_of和std::find，但是它们对我来说不太合适。
#include <execution>
#include <functional>
#include <iostream>
#include <vector>
int main()
{
std::vector vec{ 1, 1, 1, 1, 1, 3, 3, 3, 3 };
bool contains{ std::any_of(
std::execution::par_unseq,
vec.begin(), vec.end(),
std::bind(std::equal_to{}, std::placeholders::_1, 3)) };
auto found{ std::find(std::execution::par_unseq, vec.begin(), vec.end(), 3) };
return 0;
}
本std::any_of应该做我想做的，但呼叫是他们做的非常凌乱。范围std::bind_front会有所帮助，但不是很多。
问题std::find在于它必须找到a 的第一次出现3，这限制了它的效率，因为我不在乎3它的发现。
std::any_of按值搜索之外，还有其他选择吗？ …我有一个包含数百万个列表的列表，这些子列表具有一些不同的可能值，可能是10到100。
我想计算这些值的出现次数。
下面的代码可以工作，但是非常慢。我们可以做得更快吗？
count_by_list <- function(lst, var_nm = as.character(substitute(lst)), count_nm = "n"){
unique_lst <- unique(lst)
res <- tibble::tibble(!!var_nm := unique_lst, !!count_nm := NA)
for(i in seq_along(unique_lst)){
res[[count_nm]][[i]] <- sum(lst %in% res[[var_nm]][i])
}
res
}
x <- list(
list(a=1, b=2),
list(a=1, b=2),
list(b=3),
list(b=3, c=4))
count_by_list(x)
#> # A tibble: 3 x 2
#> x n
#> <list> <int>
#> 1 <named list [2]> 2
#> 2 <named list [1]> 1
#> 3 <named list [2]> 1
由reprex软件包（v0.3.0）创建于2019-11-29
我尝试使用库进行哈希处理， …