0
1
2
3
4
5
6
7
8
9
            #pragma omp parallel for num_threads(THREAD_NUMS) //default schedule
            for (int i = 0; i < M; ++i) {
                for (int j = 0; j < K; ++j) {
                    C[i * K + j] = 0.0f;
                    for (int k = 0; k < N; ++k) {
                        C[i * K + j] += A[i * N + k] * B[k * K + j]; //由于并行的是最外层循环，所以不需要对c数组的写进行枷锁处理，因为同一个地址只有一个线程会访问，线程内又是串行的
                    }
                }
           }

0
1
2
    float *A = (float*)malloc(sizeof(float)*M*N);
    float *B = (float*)malloc(sizeof(float)*N*K);
    float *C = (float*)malloc(sizeof(float)*M*K);

0
1
2
  #pragma omp parallel for num_threads(THREAD_NUMS) //default schedule 
  #pragma omp parallel for num_threads(THREAD_NUMS) schedule(static, AVG_NUM) 
  #pragma omp parallel for num_threads(THREAD_NUMS) schedule(dynamic, 1) 

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//parallel.c
/*
start:开始index, end:结束index, incre:线程的计算跳步步长，functor：并行函数，arg:矩阵地址之类
*/
int parallel_for(int start, int end, int increment, void *(*functor)(void*), void *arg , int num_threads){
    pthread_t *pthread_set = (pthread_t*)malloc(num_threads * sizeof(pthread_t));
    if(!pthread_set){
        printf("threads malloc failed!\n");
        return 0;
    }
    int end_i = end;
    // printf("%p\n", functor);
    struct for_index index_i[num_threads];
    for (int i = 0; i < num_threads; i++) {
        index_i[i].start= i;
        index_i[i].end = end_i;
        index_i[i].increment = increment;
        index_i[i].memory = arg;
        pthread_create(&pthread_set[i], NULL, functor, (void*) &index_i[i]); //开启并行
    }


    for (int i = 0; i < num_threads; i++) {
        pthread_join(pthread_set[i], NULL);
    }
    free(pthread_set);

    return 1;
}

0
1
2
3
4
5
6
7
8
9
10
11
12
//parallel.h
#ifndef PARARREL_H
#define PARARREL_H

struct for_index{
    int start;
    int end;
    int increment;
    void * memory;
};

int parallel_for(int start, int end, int increment, void *(*functor)(void*), void *arg , int num_threads);
#endif

0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//task.c 也就是主函数
void * matrix_multiply_s(void * args) {
    int N = SIZE, K = SIZE, M = SIZE;
    struct for_index * index = (struct for_index *) args;
    double *A = index->memory;
    double *B = A + M * N;
    double *C = B + N * K; //获取堆上的数组指针
    // clock_t start, end;
    // start = clock();
    int increment = index->increment;
    // printf("%d %d %d\n", index->start, index->end, index->increment);
    for (int i = index->start; i < index->end; i+=increment) {
        for (int k = 0; k < N; k++){
            for (int j = 0; j < K; j++){ 
                C[i*K+j] += A[i*N+k] * B[k*K+j];
                // if (i == 0&& k == N-1 && j==K-1) printf("%.8f, %.4f, %.4f\n",C[i*K+j], A[i*N+k], B[k*K+j]);
            }
        }
    }
int main(){
    .......
    double *A = (double *)malloc(sizeof(double) * M * N + sizeof(double) * N * K + sizeof(double) * M * K);
    double *B = A + M * N;
    double *C = B + N * K;
    ......
    parallel_for(0, M, increment, matrix_multiply_s, (void*)A, THREAD_NUMS);
}