how to use parallel potrf

[benyao-shiki]

I am currently using the develop version of OpenBLAS which was built with simpe make , and I'm trying to utilize the parallel version of the POTRF function. However, I am encountering issues with parallel execution.
Here is the core code.

#include "cblas.h"
#include "lapacke.h"
// ...

info = LAPACKE_spotrf(LAPACK_ROW_MAJOR, 'L', n, A, n);

matrix sizes ranging from 36000 x 36000 to 60000 x 60000 and runs on a 256 core tsv110 architecture machine.
I have set OPENBLAS_NUM_THREADS=20, but when I monitor the process with the top command, I observe that only one core is being utilized.

[martin-frbg]

Strange - spotrf should be running multithreaded for any "n" bigger than 128. Did you perhaps build OpenBLAS on a (virtual) machine with only a single cpu core ? (The only other explanation I can think of is that your program loads a different (open)blas library than the one you intended it to use)

[benyao-shiki]

yeah,starnge.I've tested the sgemm's performance for multicore before, It works correctly. But just know I retest the gemm, it runs on single core too. Then I use ps -T -p and the output is indeed 20 threads, maybe there are some wrong with the machine.

[martin-frbg]

I'd try ldd on the program to see if it really uses the libraries you wanted (unless it is statically linked already) - maybe it is finding the single-threaded Reference LAPACK (liblapack.so) now (especially if your system runs a Linux distribution that uses the /etc/alternatives mechanism for switching between implementations)
Guess you could also call openblas_get_num_threads() from your code, or print out the value of "args.nthreads" right before the end of file interface/lapack/potrf.c where it calls the potrf kernel

[benyao-shiki]

The ldd's output is right, with no liblapack. I call openblas_get_num_threads() in my code and the output is also 20.
Here are my entire code,built with gcc test.c -o test -I/OpenBLAS-develop/opt/include -L/OpenBLAS-develop/opt/lib -lopenblas -lm

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>
#include <math.h>
#include "cblas.h"
#include "lapacke.h"

float* generate_random_matrix(int n, int m) {
    float* mat = (float*)malloc(n * m * sizeof(float));
    if (!mat) return NULL;
    for (int i = 0; i < n*m; ++i) {
        mat[i] = 2.0f * ((float)rand()/RAND_MAX) - 1.0f;
    }
    return mat;
}

long long get_time_us() {
    struct timeval tv;
    gettimeofday(&tv, NULL);
    return tv.tv_sec * 1000000LL + tv.tv_usec;
}

double compute_gflops(int m, int n, int k, double time_sec) {
    if (time_sec <= 0) {
        fprintf(stderr, "Error: time_sec must be greater than zero.\n");
        return -1.0; 
    }
    double flops = (1.0 / 3.0) * n * n * n;
    return flops / (time_sec * 1e9);
}

int main() {
    const int sizes[] = {36000, 38000, 40000, 42000, 44000, 46000, 48000, 50000, 52000, 54000, 56000, 60000}; 
    const int num_sizes = sizeof(sizes)/sizeof(sizes[0]);
    
    float alpha = 1.0f;
    float beta = 0.0f;
    srand(time(NULL));

    for (int i = 0; i < num_sizes; ++i) {
        const int scale = sizes[i];
        const int m = scale;
        const int n = scale;
        const int k = scale;
        lapack_int info;
        printf("\nTesting %dx%dx%d matrix...\n", m, k, n);
        
        float *A = generate_random_matrix(m, k);
        // float *B = generate_random_matrix(k, n);
        // float *C_blas = (float*)calloc(m * n, sizeof(float));
        
        // if (!A || !B || !C_blas) {
        //     fprintf(stderr, "Memory allocation failed!\n");
        //     free(A); free(B); free(C_blas);
        //     continue;
        //  }

        int threads_num = openblas_get_num_threads();
        printf("Number of threads: %d\n", threads_num);
        long long start = get_time_us();
        // cblas_sgemm(CblasRowMajor, CblasNoTrans,CblasNoTrans, m, n, k,
        //       alpha, A, k,
        //       B, n,
        //       beta, C_blas, n);
        info = LAPACKE_spotrf( LAPACK_ROW_MAJOR, 'l', n, A,
            n );
        long long blas_time = get_time_us() - start;
        double blas_gflops = compute_gflops(m, n, k, blas_time/1e6);

        printf("BLAS Performance:\n");
        printf("# size\tms\tGFlop/s\n");
        printf("%d\t%8.2f\t%8.2f\n", scale, blas_time/1000.0, blas_gflops);
        
        free(A); 
        // free(B); 
    }
    return 0;
}