标签: parallel-processing

SQL和数据库新手的一个问题：

我读过一些关于数据库并发的文章，但同时更新是其中描述最频繁的事情。

但是，我只想从数据库中获取信息。

所以，有以下问题：

是否可以同时从数据库中执行多个 SELECT？这些 SELECT 会干扰吗？情况2可能吗？

通常情况（1）：

• [经过时间：0秒]
• 从表 1 中选择内容 1
• 获取第一个 SELECT 的结果
• [经过时间：1.5秒]
• 从表 1 中选择某些内容 2
• 获取第二个 SELECT 的结果
• [经过时间：3秒]

并发查询案例（2）：

• [经过时间：0秒]
• 从表 1 中选择内容 1
• [经过时间：0.001秒]
• 从表 1 中选择某些内容 2
• 获取第一个 SELECT 的结果
• [经过时间：1.5秒]
• 获取第二个 SELECT 的结果
• [经过时间：1.5001秒]

我有一个非常简单的任务要做，但不知何故我仍然陷入困境。

我有一个大数据文件（“File_initial.dat”），应该由集群上的所有节点读取（使用 MPI），每个节点都会对此大文件的一部分（File_size / number_of_nodes）执行一些操作，最后对每个节点执行一些操作会将其结果写入一个共享的大文件（“File_final.dat”）。文件的元素数量保持不变。

1. 通过谷歌搜索，我了解到，将数据文件写入二进制文件（我在这个文件中只有十进制数字）而不是 *.txt”文件要好得多。因为没有人会读取这个文件，而只会读取计算机。

2. 我尝试自己实现（但使用格式化的输入/输出而不是二进制文件），但我得到了不正确的行为。

到目前为止我的代码如下：

#include <fstream>
#define NNN 30

int main(int argc, char **argv)
{   
    ifstream fin;

    // setting MPI environment

    int rank, nprocs;
    MPI_File file;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &nprocs);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    // reading the initial file

    fin.open("initial.txt");
    for (int i=0;i<NNN;i++)
    {  
        fin  >> res[i];
        cout << res[i] << endl; // to see, what I have in the file
    }  
    fin.close();

    // starting position in the "res" array as a function of "rank" of process …

我正在使用该包parallel进行计算。这是一个玩具示例：

library(parallel)
m = matrix(c(1,1,1,1,0.2,0.2,0.2,0.2), nrow=2)
myFun = function(x) {
  if (any(x<0.5)) {
    write("less than 0.5", stderr())
    return(NA)
  } else {
    write("good", stdout())
    return(mean(x))
  }
}
cl = makeCluster(2, outfile="/tmp/output")
parApply(cl, m, 2, myFun)
stopCluster(cl)

问题是 stdout 和 stderr 都将被重定向到/tmp/output. 该output文件如下所示：

starting worker pid=51083 on localhost:11953 at 11:37:12.966
starting worker pid=51093 on localhost:11953 at 11:37:13.261
good
good
less than 0.5
less than 0.5

有没有办法分别为 stdout 和 stderr 设置两个单独的文件？以及如何忽略“starting worker pid=...”的前两行？

这里有一个关于 MPI 的问题。我需要两个处理器不断修改一个变量，并且我希望两个处理器都能够访问具有最新值的变量。

from mpi4py import MPI
from time import sleep

comm = MPI.COMM_WORLD
rank = comm.rank
assert comm.size == 2

msg = 0
sec = 10
if comm.rank == 0:
    for i in range(sec):
        print msg
        sleep(1)
        msg = comm.bcast(msg,root = 1)
else:
    for i in range(sec*2):
        msg += 1
        sleep(0.5)
        comm.bcast(msg,root = 1)

所以我期望程序打印出类似的内容： 0 2 4 ...

但程序结果打印： 0 1 2 3 4 5 6 7 8 9

我很好奇 mpi4py 中是否有一种机制可以使变量msg由两个处理器共享？也就是说，每当处理器 1 修改msg时，新值立即可供处理器 0 …

我有大量数据文件，描述了大量气象站的天气。这些文件每小时一次，并且包含在按日期分隔的文件中。

例如：

20100101.csv
20100102.csv
20100103.csv
.
.
20140228.csv

我需要按站点聚合数据，然后将其写入磁盘。也就是说，对于每个天气文件，我需要提取i站的数据，然后将其写入磁盘。

输出：

station_001.csv
station_002.csv
.
.
station_999.csv

foreach为了加快速度，我决定使用和包并行读取日常文件doMC，并且在按站并行聚合后还将站文件写入磁盘。

更具体地说，我曾经foreach读取文件并使用它们组合它们.combine="rbind"（我有足够的内存来在内存中生成一个巨大的数据集）。之后，我有另一个foreach循环，我按站对数据进行子集化，然后写入磁盘。我发现通过并行读/写，我体验到了非常好的速度提升。

我的问题是：并行读/写是个好主意吗？我确保不同的线程不会读取相同的数据文件或写入相同的站文件，但经过一番谷歌搜索后，似乎并行化 i/o 任务可能不是一个好主意？（例如，我发现对并行输入/输出说不，并且R-bloggers 上的一篇文章显示了并行读取）

我正在使用GNU Parallel在文件的每一行上同时执行命令。尽管它不会对结果造成任何问题，但 GNU 并行会发出许多以下类型的警告，使输出变得混乱：

parallel: Warning: A full record was not matched in a block. Increasing to --blocksize 1363150

我认为这只是意味着我选择使用的块大小在输入边界处不太匹配，因此并行正在增加块大小，所以它确实如此。正如我所说，我不认为这会对输出结果造成任何问题，这只是我需要一遍又一遍地重复看到的警告，甚至一次。有什么办法可以专门抑制这些警告吗？我真的不想完全重定向 stderr 并错过任何重要消息。

我有一个工作流程，我想按以下方式运行它：

Job1 -> Job2 -> Job3  
     -> Job4 -> Job5

作业流程将从Job1 开始。Job1 成功完成后，Job1 将启动 Job2 和 Job4。
Job2 和 Job4 将并行运行。
Job2成功完成后，Job2将启动Job3。
Job4成功完成后，Job4将启动Job5。

以下是 job1.xml 和 Job1 的作业启动器类的代码片段：

作业1.xml

<bean id="uiJobListener"
    class="com.joblaunch.UIJobListener">
    <property name="vmInfoImportUIBatchLauncher" ref="vmInfoImportUIBatchLauncher" />
    <property name="jobRepository" ref="jobRepository" />
</bean>

<bean id="uiBatchLauncher"
    class="com.joblaunch.UIBatchLauncher">
    <property name="simpleJobLauncher" ref="simpleJobLauncher" />
    <property name="jobLocator" ref="jobRegistry" />
    <property name="jobTwo" value="Job2" />
    <property name="jobFour" value="Job4" />
</bean>

<batch:job id="Job1" restartable="true">
    <batch:step id="stp01">
        <batch:tasklet ref="stp01Operator" />
        <batch:next on="COMPLETED" to="stp02" />
    </batch:step>

    <batch:step id="stp02">
        <batch:tasklet ref="stp02Result" />
    </batch:step> …

我从 MPI 开始。我想尝试一个经典的“Hello，world”程序，它也会打印每个进程的编号以及其他一些信息。我的程序可以工作，但我对mpiexec 的实际工作原理有点困惑。问题是，当我指定进程数时，有时它们不会启动。例如，我使用这个命令：

mpiexec -np 4 ./hello

但只有 2 或 3 个进程被启动，而不是 4 个。启动的进程数量发生变化，所以我真的很困惑。问题出在我的电脑上（我只有双核）还是正常现象？

你好ç：

#include <stdio.h>
#include <mpi.h>

int main(){
    MPI_Init(NULL, NULL);

    // Number of processes
    int world_size;
    MPI_Comm_size( MPI_COMM_WORLD, &world_size );

    // Number of current process
    int process_id;
    MPI_Comm_rank( MPI_COMM_WORLD, &process_id );

    // Processor name
    char processor_name[ MPI_MAX_PROCESSOR_NAME ];
    int name_len;
    MPI_Get_processor_name( processor_name, &name_len );

    printf("Hello! - sent from process %d running on processor %s.\n\
        Number of processes is %d.\n\
        Length of proc name is …

霍夫曼编码涉及的步骤是相当连续的。所以，我想知道如何在支持并行实现的任何平台（如 GPU、多核处理器等）上实现霍夫曼编码时引入并行性？

我的代码使用 CUDA，但运行速度仍然很慢。因此，我将其更改为使用 python 中的多处理（pool.map）并行运行。但我有CUDA ERROR: initialization error

这是函数：

def step_M(self, iter_training):
    gpe, e_tuple_list = iter_training
    g = gpe[0]
    p = gpe[1]
    em_iters = gpe[2]

    e_tuple_list = sorted(e_tuple_list, key=lambda tup: tup[0])
    data = self.X[e_tuple_list[0][0]:e_tuple_list[0][1]]
    cluster_indices = np.array(range(e_tuple_list[0][0], e_tuple_list[0][1], 1), dtype=np.int32)
    for i in range(1, len(e_tuple_list)):
        d = e_tuple_list[i]
        cluster_indices = np.concatenate((cluster_indices, np.array(range(d[0], d[1], 1), dtype=np.int32)))
        data = np.concatenate((data, self.X[d[0]:d[1]]))

    g.train_on_subset(self.X, cluster_indices, max_em_iters=em_iters)
    return g, cluster_indices, data

这里的代码调用：

pool = Pool()
iter_bic_list = pool.map(self.step_M, iter_training.items())

iter_training 相同：

这是错误 你能帮我解决一下吗？谢谢。