小编Jér*_*ard的帖子

我是 Numba 新手，我正在尝试使用 Numba （版本 0.54.1）在 Python 中实现旧的 Fortran 代码，但是当我添加时，parallel = True程序实际上变慢了。我的程序非常简单：我更改 L x L 网格中的位置 x 和 y，并对网格中的每个位置执行求和

import numpy as np
import numba as nb

@nb.njit(parallel=True)
def lyapunov_grid(x_grid, y_grid, k, N):
    L = len(x_grid)
    lypnv = np.zeros((L, L))
    for ii in nb.prange(L):
        for jj in range(L):
            x = x_grid[ii]
            y = y_grid[jj]
            beta0 = 0
            sumT11 = 0

            for j in range(N):
                y = (y - k*np.sin(x)) % (2*np.pi)
                x = (x + y) % (2*np.pi) …

我正在尝试使用 OpenMP 并行化以下 C++ 代码：

int np = 1000000;
double kk = 1 / pow(2 * pi, 2);
for (int kes = 1; kes <= 100; kes++) {
  double E1 = 0;
  #pragma omp parallel for reduction(+: E1)
  for (int ies = 0; ies < np; ies++) {
    for (int jes = 0; jes < np; jes++) {
      if (ies != jes) {
        float distanes = sqrt(pow(xp[ies] - xp[jes], 2) + pow(yp[ies] - yp[jes], 2) + pow(zp[ies] - zp[jes], 2)); …

我有这段代码通过将这个 AU 矩阵的每字节 8 个元素打包到 A 中来减少内存消耗，从而使 100k*200k 矩阵占用更少的空间。如您所料，此代码需要永远运行，我还计划将行数增加到 200k。我在一个非常强大的实例（CPU 和 GPU）上运行代码并且可以扩展它，所以任何人都可以帮助并行化此代码，使其更快。

import numpy as np
colm = int(2000000/8)
rows = 1000000
cols = int(colm*8)
AU = np.random.randint(2,size=(rows, cols),dtype=np.int8)
start_time = time.time()

A = np.empty((rows,colm), dtype=np.uint8)
for i in range(A.shape[0]):
    for j in range(A.shape[1]):
        A[i,j] = 0
        for k in range(8):
            if AU[i,(j*8)+k] == 1:
                A[i,j] = A[i,j] | (1<<(7-k))

我想转换这个数组

[array([46, 64, 50, 66]),
 array([53, 61, 59, 59]),
 array([54, 63, 55, 61]),
 array([56, 58, 51, 55])]

进入这个数组

[array([46, 53, 54, 56]),
 array([64, 61, 63, 58]),
 array([50, 59, 55, 51]),
 array([66, 59, 61, 55])]

有没有办法在 numpy 中做到这一点？

我使用以下代码在 c 和 java 中实现并基准测试了以下函数。对于 c，我得到大约 1.688852 秒，而对于 java，只需要 0.355038 秒。即使我删除该sqrt函数，手动内联代码或更改函数签名以接受 6 个double坐标（以避免通过指针访问），c 时间流逝也不会改善太多。

我正在编译 c 程序，例如cc -O2 main.c -lm. 对于java，我使用默认的jvm选项（java 8，openjdk）在intellij idea中运行应用程序。

C：

#include <math.h>\n#include <stdio.h>\n#include <time.h>\n\ntypedef struct point3d\n{\n  double x;\n  double y;\n  double z;\n} point3d_t;\n\ndouble distance(point3d_t *from, point3d_t *to);\n\nint main(int argc, char const *argv[])\n{\n  point3d_t from = {.x = 2.3, .y = 3.45, .z = 4.56};\n  point3d_t to = {.x = 5.678, .y = 3.45, .z = -9.0781};\n\n  double …

我编写了一个简单的测试程序来比较使用 MPI 并行化多个进程的性能，或者使用std::thread. 并行化的工作只是写入一个大数组。我看到的是，多进程 MPI 的性能远远优于多线程。

测试代码为：

#ifdef USE_MPI
#include <mpi.h>
#else
#include <thread>
#endif
#include <iostream>
#include <vector>

void dowork(int i){
    int n = 1000000000;
    std::vector<int> foo(n, -1);
}

int main(int argc, char *argv[]){
    int npar = 1;
#ifdef USE_MPI
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &npar);
#else
    npar = 8;
    if(argc > 1){
        npar = atoi(argv[1]);
    }
#endif
    std::cout << "npar = " << npar << std::endl;

    int i;

#ifdef USE_MPI
    MPI_Comm_rank(MPI_COMM_WORLD, &i);
    dowork(i);
    MPI_Finalize();
#else
    std::vector<std::thread> threads;
    for(i …