华为实验一 MPI 矩阵运算

已于 2024-06-03 17:29:18 修改
阅读量382 收藏 8
点赞数 5
分类专栏： 华为云并行实验记录 文章标签： 华为云
于 2024-05-29 20:07:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63697211/article/details/139298191
版权

一、实验环境

本实验需要在预备实验的配置上继续进行实验。

登录root账户之后，进入之前创建的个人账户：
su - username

执行以下命令，创建 matrix 目录存放该程序的所有文件, 并进入 matrix 目录（四台主机都执行） 
mkdir /home/usersname/matrix
cd /home/usersname/matrix

二、源码程序

  gemm.cpp

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <iostream>
#include "mpi.h"
// #include <cblas.h>

using namespace std;

// void CheckStatus(MPI_Status &status) {
//     if (status.MPI_ERROR != MPI_SUCCESS) {
//         cout << MPI::Get_error_class(status.MPI_ERROR);
//     }
// }

void randMat(int rows, int cols, float*& Mat) {
    Mat = new float[rows * cols];
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            Mat[i * cols + j] = 1.0;
}

void openmp_sgemm(int m, int n, int k, float*& leftMat, float*& rightMat, float*& resultMat) {
    // rightMat is transposed
#pragma omp parallel for
    for (int row = 0; row < m; row++) {
        for (int col = 0; col < k; col++) {
            resultMat[row * k + col] = 0.0;
            for (int i = 0; i < n; i++) {
                resultMat[row * k + col] += leftMat[row * n + i] * rightMat[col * n + i];
            }
        }
    }
    return;
}

void blas_sgemm(int m, int n, int k, float*& leftMat, float*& rightMat, float*& resultMat) {
    // cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, m, k, n, 1.0, leftMat, n, rightMat, n, 0.0, resultMat, k);
}

void mpi_sgemm(int m, int n, int k, float*& leftMat, float*& rightMat,
    float*& resultMat, int rank, int worldsize, bool blas) {
    int rowBlock = sqrt(worldsize);
    if (rowBlock * rowBlock > worldsize)
        rowBlock -= 1;
    int colBlock = rowBlock;
    int rowStride = m / rowBlock;
    int colStride = k / colBlock;
    worldsize = rowBlock * colBlock; // we abandon some processes.
    // so best set process to a square number.
    float* res;
    if (rank == 0) {
        float* buf = new float[k * n];
        // transpose right Mat
        for (int r = 0; r < n; r++) {
            for (int c = 0; c < k; c++) {
                buf[c * n + r] = rightMat[r * k + c];
            }
        }
        for (int r = 0; r < k; r++) {
            for (int c = 0; c < n; c++) {
                rightMat[r * n + c] = buf[r * n + c];
            }
        }
        delete buf;
        MPI_Request sendRequest[2 * worldsize];
        MPI_Status status[2 * worldsize];
        for (int rowB = 0; rowB < rowBlock; rowB++) {
            for (int colB = 0; colB < colBlock; colB++) {
                rowStride = (rowB == rowBlock - 1) ? m - (rowBlock - 1) * (m / rowBlock)
                    : m / rowBlock;
                colStride = (colB == colBlock - 1) ? k - (colBlock - 1) * (k / colBlock)
                    : k / colBlock;
                int sendto = rowB * colBlock + colB;
                if (sendto == 0)
                    continue;
                MPI_Isend(&leftMat[rowB * (m / rowBlock) * n], rowStride * n, MPI_FLOAT,
                    sendto, 0, MPI_COMM_WORLD, &sendRequest[sendto]);
                MPI_Isend(&rightMat[colB * (k / colBlock) * n], colStride * n,
                    MPI_FLOAT, sendto, 1, MPI_COMM_WORLD,
                    &sendRequest[sendto + worldsize]);
            }
        }
        for (int rowB = 0; rowB < rowBlock; rowB++) {
            for (int colB = 0; colB < colBlock; colB++) {
                int recvfrom = rowB * colBlock + colB;
                if (recvfrom == 0)
                    continue;
                MPI_Wait(&sendRequest[recvfrom], &status[recvfrom]);
                MPI_Wait(&sendRequest[recvfrom + worldsize],
                    &status[recvfrom + worldsize]);
            }
        }
        res = new float[(m / rowBlock) * (k / colBlock)];
    }
    else {
        if (rank < worldsize) {
            MPI_Status status[2];
            rowStride = ((rank / colBlock) == rowBlock - 1)
                ? m - (rowBlock - 1) * (m / rowBlock)
                : m / rowBlock;
            colStride = ((rank % colBlock) == colBlock - 1)
                ? k - (colBlock - 1) * (k / colBlock)
                : k / colBlock;
            if (rank != 0) {
                leftMat = new float[rowStride * n];
                rightMat = new float[colStride * n];
            }
            if (rank != 0) {
                MPI_Recv(leftMat, rowStride * n, MPI_FLOAT, 0, 0, MPI_COMM_WORLD,
                    &status[0]);
                MPI_Recv(rightMat, colStride * n, MPI_FLOAT, 0, 1, MPI_COMM_WORLD,
                    &status[1]);
            }
            res = new float[rowStride * colStride];
        }
    }
    MPI_Barrier(MPI_COMM_WORLD);
    if (rank < worldsize) {
        rowStride = ((rank / colBlock) == rowBlock - 1)
            ? m - (rowBlock - 1) * (m / rowBlock)
            : m / rowBlock;
        colStride = ((rank % colBlock) == colBlock - 1)
            ? k - (colBlock - 1) * (k / colBlock)
            : k / colBlock;
        if (!blas)
            openmp_sgemm(rowStride, n, colStride, leftMat, rightMat, res);
        else
            blas_sgemm(rowStride, n, colStride, leftMat, rightMat, res);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    if (rank == 0) {
        MPI_Status status;
        float* buf = new float[(m - (rowBlock - 1) * (m / rowBlock)) *
            (k - (colBlock - 1) * (k / colBlock))];
        float* temp_res;
        for (int rowB = 0; rowB < rowBlock; rowB++) {
            for (int colB = 0; colB < colBlock; colB++) {
                rowStride = (rowB == rowBlock - 1) ? m - (rowBlock - 1) * (m / rowBlock)
                    : m / rowBlock;
                colStride = (colB == colBlock - 1) ? k - (colBlock - 1) * (k / colBlock)
                    : k / colBlock;
                int recvfrom = rowB * colBlock + colB;
                if (recvfrom != 0) {
                    temp_res = buf;
                    MPI_Recv(temp_res, rowStride * colStride, MPI_FLOAT, recvfrom, 0,
                        MPI_COMM_WORLD, &status);
                }
                else {
                    temp_res = res;
                }
                for (int r = 0; r < rowStride; r++)
                    for (int c = 0; c < colStride; c++)
                        resultMat[rowB * (m / rowBlock) * k + colB * (k / colBlock) +
                        r * k + c] = temp_res[r * colStride + c];
            }
        }
    }
    else {
        rowStride = ((rank / colBlock) == rowBlock - 1)
            ? m - (rowBlock - 1) * (m / rowBlock)
            : m / rowBlock;
        colStride = ((rank % colBlock) == colBlock - 1)
            ? k - (colBlock - 1) * (k / colBlock)
            : k / colBlock;
        if (rank < worldsize)
            MPI_Send(res, rowStride * colStride, MPI_FLOAT, 0, 0, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    return;
}

int main(int argc, char* argv[]) {
    if (argc != 5) {
        cout << "Usage: " << argv[0] << " M N K use-blas\n";
        exit(-1);
    }
    int rank;
    int worldSize;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &worldSize);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    int m = atoi(argv[1]);
    int n = atoi(argv[2]);
    int k = atoi(argv[3]);
    int blas = atoi(argv[4]);
    float* leftMat, * rightMat, * resMat;
    struct timeval start, stop;
    if (rank == 0) {
        randMat(m, n, leftMat);
        randMat(n, k, rightMat);
        randMat(m, k, resMat);
    }
    gettimeofday(&start, NULL);
    mpi_sgemm(m, n, k, leftMat, rightMat, resMat, rank, worldSize, blas);
    gettimeofday(&stop, NULL);
    if (rank == 0) {
        cout << "mpi matmul: "
            << (stop.tv_sec - start.tv_sec) * 1000.0 +
            (stop.tv_usec - start.tv_usec) / 1000.0
            << " ms" << endl;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < k; j++)
                if (int(resMat[i * k + j]) != n) {
                    cout << resMat[i * k + j] << "error\n";
                    exit(-1);
                }
            // cout << resMat[i * k + j] << ' ';
            // cout << endl;
        }
    }
    MPI_Finalize();
}

        conv.cpp

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <string.h>
#include <iostream>
#include "mpi.h"
#include <cblas.h>
#include <assert.h>
using namespace std;

void randMat(int rows, int cols, float*& Mat) {
    Mat = new float[rows * cols];
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            Mat[i * cols + j] = 1.0;
}

int get_steps(int kernel, int step, int len) {
    if (kernel > len)
        return 0;
    return (len - kernel) / step + 1;
}

inline void img2col_conv_kernel(int leftAnchorX, int leftAnchorY, int rightAnchorX,
    int rightAnchorY, const int xKernel, const int yKernel, const int xStep,
    const int yStep, float*& img, float*& kernel, float*& conv) {
    int imgRows = rightAnchorX - leftAnchorX,
        imgCols = rightAnchorY - leftAnchorY;
    int convRows = get_steps(xKernel, xStep, imgRows);
    int convCols = get_steps(yKernel, yStep, imgCols);
    float* flattenImg = new float[convRows * convCols * xKernel * yKernel];
    // #pragma omp parallel for
    // for (int i = leftAnchorX; i < rightAnchorX - xKernel; i += xStep) {
    //     for (int r = 0; r < xKernel; r++) {
    //         for (int j = leftAnchorY; j < rightAnchorY - yKernel; j += yStep) {
    //             int pos = (i - leftAnchorX)/xStep * convCols + (j - leftAnchorY) / yStep;
    //             memcpy(&flattenImg[pos * xKernel * yKernel + r * yKernel], &img[(i + r) * imgCols + j], 
    //                    sizeof(float) * yKernel);
    //         }
    //     }
    // }
    // #pragma omp parallel for
    // for (int i = 0; i < convRows * convCols; i++) {
    //     conv[i] = 0.0;
    //     for (int j = 0; j < xKernel * yKernel; j++) {
    //         conv[i] += flattenImg[i*xKernel*yKernel + j] * kernel[j];
    //     }
    // }
    cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, convRows * convCols, 1, xKernel * yKernel, 1.0,
        flattenImg, xKernel * yKernel, kernel, 1, 0.0, conv, 1);
    // cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasTrans, convRows * convCols, 1, xKernel * yKernel, 1.0, 
    //             flattenImg, xKernel * yKernel, kernel, convRows * convCols, 0.0, conv, 1);
    delete flattenImg;
}

inline void naive_conv_kernel(int leftAnchorX, int leftAnchorY, int rightAnchorX,
    int rightAnchorY, const int xKernel, const int yKernel, const int xStep,
    const int yStep, float*& img, float*& kernel, float*& conv) {
    int imgRows = rightAnchorX - leftAnchorX,
        imgCols = rightAnchorY - leftAnchorY;
    int convRows = get_steps(xKernel, xStep, imgRows);
    int convCols = get_steps(yKernel, yStep, imgCols);
#pragma omp parallel for
    for (int i = leftAnchorX; i < rightAnchorX - xKernel; i += xStep) {
        for (int j = leftAnchorY; j < rightAnchorY - yKernel; j += yStep) {
            // to[i / xStride * to_n + j] = 0.0;
            int pos = (i - leftAnchorX) / xStep * convCols + (j - leftAnchorY) / yStep;
            conv[pos] = 0.0;
            for (int r = i; r < i + xKernel; r++)
                for (int c = j; c < j + yKernel; c++) {
                    conv[pos] += img[r * imgCols + c] * kernel[(r - i) * yKernel + (c - j)];
                }
        }
    }
}

void mpi_convolution(int m, int n, int xKernel, int yKernel, int xStep,
    int yStep, float*& img, float*& kernel, float*& conv,
    int rank, int worldsize, bool img2col) {
    const int total_xsteps = get_steps(xKernel, xStep, m);
    const int total_ysteps = get_steps(yKernel, yStep, n);
    const int xsteps_per_proc = total_xsteps / worldsize;
    const int last_xsteps = total_xsteps - xsteps_per_proc * (worldsize - 1);
    int steps;
    if (rank == 0) {
        MPI_Request* sendRequest = new MPI_Request[worldsize];
        MPI_Status* status = new MPI_Status[worldsize];
        for (int i = 1; i < worldsize; i++) {
            steps = (i == worldsize - 1) ? last_xsteps : xsteps_per_proc;
            MPI_Isend(&img[i * xsteps_per_proc * xStep * n],
                (steps * xStep + xKernel - xStep) * n, MPI_FLOAT, i, 0,
                MPI_COMM_WORLD, &sendRequest[i]);
        }
        for (int i = 1; i < worldsize; i++) {
            MPI_Wait(&sendRequest[i], &status[i]);
        }
        delete sendRequest;
        delete status;
    }
    else {
        MPI_Status status;
        steps = (rank == worldsize - 1) ? last_xsteps : xsteps_per_proc;
        img = new float[(steps * xStep + xKernel - xStep) * n];
        MPI_Recv(img, (steps * xStep + xKernel - xStep) * n, MPI_FLOAT, 0, 0,
            MPI_COMM_WORLD, &status);
        conv = new float[steps * total_ysteps];
    }
    MPI_Barrier(MPI_COMM_WORLD);
    steps = (rank == worldsize - 1) ? last_xsteps : xsteps_per_proc;
    if (img2col)
        img2col_conv_kernel(0, 0, steps * xStep + xKernel - xStep, n, xKernel, yKernel,
            xStep, yStep, img, kernel, conv);
    else
        naive_conv_kernel(0, 0, steps * xStep + xKernel - xStep, n, xKernel, yKernel,
            xStep, yStep, img, kernel, conv);
    MPI_Barrier(MPI_COMM_WORLD);
    if (rank == 0) {
        MPI_Status status;
        for (int i = 1; i < worldsize; i++) {
            steps = (i == worldsize - 1) ? last_xsteps : xsteps_per_proc;
            MPI_Recv(&conv[i * xsteps_per_proc * total_ysteps],
                steps * total_ysteps, MPI_FLOAT, i, 0, MPI_COMM_WORLD,
                &status);
        }
    }
    else {
        MPI_Send(conv, steps * total_ysteps, MPI_FLOAT, 0, 0, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    return;
}

int main(int argc, char* argv[]) {
    if (argc != 4) {
        cout << "Usage: " << argv[0] << " M N enabled-img2col";
        exit(-1);
    }
    int rank;
    int worldSize;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &worldSize);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    int m = atoi(argv[1]);
    int n = atoi(argv[2]);
    int img2col = atoi(argv[3]);
    int xKernel = 3, yKernel = 3;
    int xStep = 1, yStep = 1;
    float* Img, * Conv;
    struct timeval start, stop;
    if (rank == 0) {
        randMat(m, n, Img);
        randMat(get_steps(xKernel, xStep, m), get_steps(yKernel, yStep, n), Conv);
    }
    float* Kernel = new float[xKernel * yKernel];
    for (int i = 0; i < xKernel * yKernel; i++)
        Kernel[i] = 1.0;
    gettimeofday(&start, NULL);
    mpi_convolution(m, n, xKernel, yKernel, xStep, yStep, Img, Kernel, Conv, rank, worldSize, img2col);
    gettimeofday(&stop, NULL);
    if (rank == 0) {
        cout << "mpi convolution: " << (stop.tv_sec - start.tv_sec) * 1000.0 + (stop.tv_usec - start.tv_usec) / 1000.0 << " ms" << endl;
        for (int i = 0; i < min(10, m); i++) {
            for (int j = 0; j < min(10, n); j++)
                cout << Conv[i * n + j] << ' ';
            cout << endl;
        }
    }
    delete Img;
    delete Conv;
    MPI_Finalize();
}

        pooling.cpp

#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <iostream>
#include "mpi.h"

using namespace std;

void randMat(int rows, int cols, float*& Mat) {
    Mat = new float[rows * cols];
    for (int i = 0; i < rows; i++)
        for (int j = 0; j < cols; j++)
            Mat[i * cols + j] = 1.0;
}

inline void pooling_kernel(int leftAnchorX, int leftAnchorY, int rightAnchorX,
    int rightAnchorY, int xStride, int yStride,
    int from_m, int from_n, int to_m, int to_n,
    float*& from, float*& to) {
    if ((rightAnchorX - leftAnchorX) % xStride != 0 ||
        (rightAnchorY - leftAnchorY) % yStride != 0)
        exit(-1);
    if (leftAnchorX % xStride != 0 || leftAnchorY % yStride != 0)
        exit(-2);
    for (int i = leftAnchorX; i < rightAnchorX; i += xStride) {
        for (int j = leftAnchorY; j < rightAnchorY; j += yStride) {
            // to[i / xStride * to_n + j] = 0.0;
            float temp = to[i / xStride * to_n + j / yStride];
            for (int r = i; r < i + xStride; r++)
                for (int c = j; c < j + yStride; c++) {
                    temp = max(temp, from[r * from_n + c]);
                }
            to[i / xStride * to_n + j / yStride] = temp;
        }
    }
}

void mpi_pooling(int m, int n, int xstride, int ystride, float*& mat,
    float*& res, int rank, int worldsize) {
    if (m % xstride || n % ystride) {
        cout << "matrix size and stride do not match \n";
        return;
    }
    const int xstrides_per_proc = (m / xstride) / worldsize;
    int strides;
    if (rank == 0) {
        MPI_Request* sendRequest = new MPI_Request[worldsize];
        MPI_Status* status = new MPI_Status[worldsize];
        for (int i = 1; i < worldsize; i++) {
            strides = (i < worldsize - 1)
                ? xstrides_per_proc
                : (m / xstride) - xstrides_per_proc * (worldsize - 1);
            MPI_Isend(&mat[i * xstrides_per_proc * xstride * n],
                strides * xstride * n, MPI_FLOAT, i, 0, MPI_COMM_WORLD,
                &sendRequest[i]);
        }
        for (int i = 1; i < worldsize; i++) {
            MPI_Wait(&sendRequest[i], &status[i]);
        }
        delete[] sendRequest;
        delete[] status;
    }
    else {
        MPI_Status status;
        strides = (rank < worldsize - 1)
            ? xstrides_per_proc
            : (m / xstride) - xstrides_per_proc * (worldsize - 1);
        mat = new float[strides * xstride * n];
        MPI_Recv(mat, strides * xstride * n, MPI_FLOAT, 0, 0, MPI_COMM_WORLD,
            &status);
        res = new float[strides * (n / ystride)];
    }
    MPI_Barrier(MPI_COMM_WORLD);
    strides = (rank < worldsize - 1)
        ? xstrides_per_proc
        : (m / xstride) - xstrides_per_proc * (worldsize - 1);
    // pooling_kernel(rank * xstrides_per_proc * xstride, 0,
    //                (rank * xstrides_per_proc + strides) * xstride, n,
    //                xstride, ystride, m, n, strides, n / ystride, mat, res);
    pooling_kernel(0, 0, strides * xstride, n, xstride, ystride,
        strides * xstride, n, strides, n / ystride, mat, res);
    MPI_Barrier(MPI_COMM_WORLD);
    if (rank == 0) {
        MPI_Status status;
        for (int i = 1; i < worldsize; i++) {
            strides = (i < worldsize - 1)
                ? xstrides_per_proc
                : (m / xstride) - xstrides_per_proc * (worldsize - 1);
            MPI_Recv(&res[i * xstrides_per_proc * (n / ystride)],
                strides * (n / ystride), MPI_FLOAT, i, 0, MPI_COMM_WORLD,
                &status);
        }
    }
    else {
        MPI_Send(res, strides * (n / ystride), MPI_FLOAT, 0, 0, MPI_COMM_WORLD);
    }
    MPI_Barrier(MPI_COMM_WORLD);
    return;
}
int main(int argc, char* argv[]) {
    if (argc != 3) {
        cout << "Usage: " << argv[0] << " M N";
        exit(-1);
    }
    int rank;
    int worldSize;
    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &worldSize);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    int m = atoi(argv[1]);
    int n = atoi(argv[2]);
    int xstride = 4, ystride = 4;
    float* Mat, * resMat;
    struct timeval start, stop;
    if (rank == 0) {
        randMat(m, n, Mat);
        randMat(m / xstride, n / ystride, resMat);
    }
    gettimeofday(&start, NULL);
    mpi_pooling(m, n, xstride, ystride, Mat, resMat, rank, worldSize);
    gettimeofday(&stop, NULL);
    if (rank == 0) {
        cout << "mpi pooling: "
            << (stop.tv_sec - start.tv_sec) * 1000 * 1000L +
            (stop.tv_usec - start.tv_usec)
            << endl;
        // for (int i = 0; i < min(10, m); i++) {
        //     for (int j = 0; j < min(10, n); j++)
        //         cout << Mat[i * k + j] << ' ';
        //     cout << endl;
        // }
    }
    delete[] Mat;
    delete[] resMat;
    MPI_Finalize();
}

        Makefile

CC = mpic++
CCFLAGS = -O2 -fopenmp
LDFLAGS = -lopenblas

all: gemm conv pooling 

gemm: gemm.cpp
	    ${CC} ${CCFLAGS} gemm.cpp -o gemm ${LDFLAGS}

conv: conv.cpp
	    ${CC} ${CCFLAGS} conv.cpp -o conv ${LDFLAGS}

pooling: pooling.cpp
	    ${CC} ${CCFLAGS} pooling.cpp -o pooling ${LDFLAGS}

clean:
	    rm gemm conv pooling

如果遇到Makefile不能写入的问题先退出，再在指令前+sudo试试。

或者在登录个人账户时就将此账户设置为管理员：

usermod -aG wheel zhangsan

三、按照实验指导手册进行编译

执行以下命令，获取包（四台主机都执行）

这个步骤在User目录下执行，不是Matrix。

wget https://github.com/xianyi/OpenBLAS/archive/v0.3.8.tar.gz
执行以下命令，进行编译（四台主机都执行） 
tar -zxvf v0.3.8.tar.gz && cd OpenBLAS-0.3.8
make -j2
sudo make PREFIX=/usr/local/openblas install
sudo chmod -R 777 /usr/local/openblas/
执行以下命令，完成安装（四台主机都执行） 
sudo ln -s /usr/local/openblas/lib/libopenblas.so /usr/lib/libopenblas.so
执行以下命令，配置 OpenBLAS 环境（四台主机都执行） 
vim ~/.bashrc
添加下列内容 
export CPLUS_INCLUDE_PATH=$CPLUS_INCLUDE_PATH:/usr/local/openblas/include
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/openblas/lib
执行以下命令，使环境变量均生效（四台主机都执行） 
source ~/.bashrc
执行以下命令，进行编译（四台主机都执行） 
make

四、主机配置文件

执行以下命令，建立主机配置文件（四台主机都执行） 
vim /home/zhangsan/matrix/hostfile
添加内容如下： 
ecs-hw-0001:2
ecs-hw-0002:2
ecs-hw-0003:2
ecs-hw-0004:2

这里如果完全按照预备实验来做就没有问题，如果预备实验取的节点名字并不是ecs-hw-0001等的话注意修改。

五、运行监测

编写 run.sh 脚本，内容如下： 
app=${1}
if [ ${app} = "gemm" ]; then
mpirun --hostfile hostfile -np ${2} ./gemm 4024 4024 4024 0
fi
if [ ${app} = "conv" ]; then
mpirun --hostfile hostfile -np ${2} ./conv 4096 4096 ${3}
fi
if [ ${app} = "pooling" ]; then
mpirun --hostfile hostfile -np ${2} ./pooling 1024 1024
fi

如果你想测试更多效果，可以修改这个地方的参数。

六、可能出现的问题

  可以执行bash run.sh gemm 1、bash run.sh gemm 2但是执行gemm 3时报错，类似下面，且执行大于2个核心的bash指令时长时间无法运行出结果。

Fatal error in PMPI_Barrier: Unknown error class, error stack:
PMPI_Barrier(289).....................: MPI_Barrier(comm=MPI_COMM_WORLD) failed
PMPI_Barrier(275).....................: 
MPIR_Barrier_impl(175)................: 
MPIR_Barrier_intra_auto(110)..........: 
MPIR_Barrier_intra_smp(43)............: 
MPIR_Barrier_impl(175)................: 
MPIR_Barrier_intra_auto(110)..........: 

解决方法：退出当前账户到root:

exit

检查hosts文件：（四个都检查）

vim /etc/hosts

你也许会发现，除了实验一你所保留的内容之外，又凭空出现了一行，注释掉这一行，只保留预备实验添加的信息：

192.168.0.224  ecs-hw-0001
192.168.0.4  ecs-hw-0002
192.168.0.73 ecs-hw-0003
192.168.0.191 ecs-hw-0004

再次执行不出错。

（每个人做实验遇到的问题都不一样，希望能提供帮助）
 

程序媛媛不圆圆
关注
专栏目录
高性能并行计算华为云实验一：MPI矩阵运算
m0_64198455的博客
06-22 1022
5.1 实验思考1.如何添加 C、C+头文件以及库路径加入环境变量？在Linux系统中，添加C或C++头文件以及库文件到环境变量通常涉及如下步骤：①确定头文件和库文件的位置：首先，需要确定C或C++头文件和库文件存放在哪个目录下。通常这些文件位于/usr/include、/usr/local/include或某个特定安装目录下。
华为机试-----矩阵乘法计算量估算
革命尚未成功的兔子的博客
03-09 342
矩阵乘法计算量估算 #include<iostream> #include<string> #include<stack> using namespace std; int main() { int n,i,r1,c1,r2,c2; string str; stack<int> row; stack<int&...
云计算与大数据技术 第一章
weixin_66185483的博客
01-12 4722
云计算的概念： 云计算（Cloud Computing)是基于互联网的相关服务的增加，使用和交付模式，通常涉及互联网来提供动态易扩展且常为虚拟化的资源，是并行计算（Parallel Computing)，分布式计算（
ToCom：一次训练随意使用，华为提出通用的ViT标记压缩器 | ECCV 2024
weixin_35978903的博客
09-11 55
标记压缩通过减少冗余标记的数量（例如，修剪不重要的标记或合并相似的标记）来加快视觉变换器（ViTs）的训练和推理。然而，当这些方法应用于下游任务时，如果训练和推理阶段的压缩程度不匹配，会导致显著的性能下降，这限制了标记压缩在现成训练模型上的应用。因此提出了标记补偿器（ToCom），以解耦两个阶段之间的压缩程度。该插件通过在预训练模型上额外执行了一个快速参数高效的自蒸馏阶段获得一个小型插件，描述...
九月十月百度，迅雷，华为，阿里巴巴笔试面试六十题(第411~470题)
热门推荐
结构之法 算法之道
09-23 21万+
九月迅雷，华为，阿里巴巴，最新笔试面试三十题题记    本博客自2010年10月11日开通以来，已经帮助了一大批的人找到工作，特别是连续三年在每一年的9、10月份陪伴了至少三届毕业生找工作的旅程，包括校招中的笔试面试，今年也不会例外，希望本博客在3周年之际一如既往的陪伴大家一起成长。    本文所整理的全部笔试面试题要么来源于我群内群友们的分享，要么摘自论坛或博客，所有原题均来自网络，如果大家对以
九月十月百度，迅雷，华为，阿里巴巴，最新校招笔试面试六十题
gdsheng35的专栏
02-01 1973
原文：http://blog.csdn.net/v_july_v/article/details/11921021 题记     本博客自2010年10月11日开通以来，已经帮助了一大批人找到工作，特别是连续三年在每一年的9、10月份陪伴了至少三届毕业生找工作的旅程，包括校招中的笔试面试，今年也不会例外，我会在本博客开通3周年之际一如既往的陪伴大家一起成长。     本文所整理的
九月十月百度 迅雷 华为 阿里巴巴笔试面试六十题 第411 470题
gdfyug的博客
11-05 616
九月十月百度 迅雷 华为 阿里巴巴笔试面试六十题 第411 470题
九月十月百度，迅雷，华为，阿里巴巴，最新校招笔试面试五十题
CSDN高校俱乐部官方博客
10-29 4287
题记     本博客自2010年10月11日开通以来，已经帮助了一大批人找到工作，特别是连续三年在每一年的9、10月份陪伴了至少三届毕业生找工作的旅程，包括校招中的笔试面试，今年也不会例外，我会在本博客开通3周年之际一如既往的陪伴大家一起成长。     本文所整理的全部笔试面试题要么来源于我群内群友们的分享，要么摘自论坛或博客，所有原题均来自网络。虽然本文中整理的绝大部分笔试面试题偏算法（自己
九月十月百度，迅雷，华为，阿里巴巴最新校招笔试面试三十题（10.18）
445822357
10-22 392
九月十月百度，迅雷，华为，阿里巴巴，最新校招笔试面试三十题 题记 本博客自2010年10月11日开通以来，已经帮助了一大批人找到工作，特别是连续三年在每一年的9、10月份陪伴了至少三届毕业生找工作的旅程，包括校招中的笔试面试，今年也不会例外，我会在本博客开通3周年之际一如既往的陪伴大家一起成长。 本文所整理的全部笔试面试题要么来源于我群内群友们的分享，要么摘自...
实验报告- 在华为鲲鹏服务器上的 OpenMP+MPI矩阵LU分解
07-05
【OpenMP+MPI矩阵LU分解】实验报告主要探讨了如何在华为鲲鹏服务器上利用OpenMP和MPI并行计算技术对矩阵进行LU分解，以高效解决线性方程组的问题。矩阵LU分解是线性代数中的一个重要概念，它将线性方程组的求解转化...
华为云分布式缓存服务DCS 8月新特性发布
hwxiaozhi的博客
09-14 421
分布式缓存服务（Distributed Cache Service，简称DCS）是华为云提供的一款兼容Redis的高速内存数据处理引擎，为您提供即开即用、安全可靠、弹性扩容、便捷管理的在线分布式缓存能力，满足用户高并发及数据快速访问的业务诉求。此次为大家带来DCS 8月的特性更新内容，一起来看看吧！
基于STM32设计的智能家庭防盗系统(华为云IOT)(224)
09-11 3040
本项目设计中，采用高性能的STM32F103RCT6作为主控芯片，结合HC-SR501人体红外感应模块与HC-SR04超声波测距模块实现精准的人体探测与距离感应功能。并通过ESP8266-WIFI模块，利用MQTT协议将现场采集的数据实时传输至华为云IOT服务器，实现远程数据查看与分析。
828华为云征文｜部署在线文件管理器 Spacedrive
特立独行的博客
09-15 1826
Spacedrive以其独特的功能和技术架构，为用户提供了一种全新的跨平台文件管理体验。
828华为云征文｜华为Flexus云服务器搭建OnlyOffice私有化在线办公套件
最新发布
繁依Fanyi的博客
09-17 1259
通过华为Flexus云服务器成功搭建OnlyOffice私有化在线办公套件，为企业或个人提供了一个安全、高效的在线办公解决方案。在未来，随着办公需求的不断发展和技术的持续进步，可以进一步探索OnlyOffice与其他办公工具的集成，以及对办公流程的优化，以提升办公效率和用户体验。
华为云ROMA Connect聚焦创新，在Gartner®峰会发布智能集成新视角
hwxiaozhi的博客
09-14 621
特别是RAG和LLM AI工作流模板，快速搭建RAG技术（即检索增强生成），RAG结合了传统语言模型的强大功能和外部知识库的精确度，在华为云应用与数据集成平台ROMA Connect上通过可视化的编排和低代码的点选配置，将原本数周的工作缩短到数天完成，实现企业接入AI技术上时间的缩短和效率的飞跃。将持续在智能集成、全域融合集成、组装式交付和自动化等领域持续创新，打造更智能、更高效、更灵活的集成体验，助力客户消除数字鸿沟，构建业务敏捷性，驱动数字化转型。9月9日，华为云PaaS应用集成域。
828华为云征文 | 华为云FlexusX实例下的Kafka集群部署实践与性能优化
weixin_62782025的博客
09-11 996
华为云FlexusX实例，以创新的柔性算力技术，为Kafka集群部署带来前所未有的性能飞跃。其灵活的CPU与内存配比，结合智能调度与加速技术，让Kafka在高并发场景下依然游刃有余。在828华为云企业上云节期间，FlexusX实例携手海量优惠，助力企业轻松上云，享受数字化转型的加速红利。
828华为云征文 | 使用华为云Flexus云服务器X安装搭建crmeb多门店商城教程
csdndddsd的博客
09-13 983
CRMEB 多门店企业级高并发高性能系统，支持Lunix服务器环境，需要PHP7.1-7.4 版本支持， 可运行于包括Apache和nginx在内的多种WEB服务器和模式，支持Mysql数据库。5.1、公众号可以只使用http域名，则不用配置SSL证书，跳过后续文档中关于https及ssl相关步骤。上述为基本运营配置，实际使用中，如用户量较大造成服务器负载较高，可以优先考虑将数据库更换为独立云数据库，图片等OSS存储，负载均衡等方案。*：泛解析，匹配改域名下所有域名， 直接填写 * 就行。
在华为鲲鹏服务器上的OpenMP MPI SIMD矩阵LU分解实验报告
在本次《高性能计算》实验报告中，我们在华为鲲鹏服务器上进行了OpenMP MPI SIMD矩阵LU分解的课程设计实验。矩阵的LU分解是用于求解线性方程组的方法，通过一系列初等行变换将系数矩阵A分解为单位下三角阵L和上三角...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序媛媛不圆圆

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值