I was trying to use one of your VST random number generator routines,

but when I try to reference them from Visual Studio, I get a lot of useless stuff.

Isnt there a way to jump directly to the routine I want ?

The write up starts on pg 2870, but I CANNOT find the file.

When I do it from Visual Studio I get a lot of useless time-wasting stuff I dont care about.

I would like to actually FIND the written documentation (on my PC)

but there does not seem to be any easy to do that.

The stuff I wanna look at starts on pg 2870 of the docs.

So what is the name of the file , so I can search for it ?

iS THERE AN A- TO Z REFERENCE ?

The libraries are installed, I am looking for the write-ups.

I copied the code from your library reference, vsl routines. in the documentation.

The example they give should run as a standalone program, correct ?

I put the include file along with it, but I get several entry points it cannot find.

so the build fails.

see attached file. This should be the same as your documentation example.

After installing the Intel-Optimized Tensorflow with MKL-DNN, why does it still say that AVX2, FMA, etc, are not supported. Can someone please guide me in detail about this? I am looking to get the best performance.

Hello,

I want to solve a system of sparse matrix equations where my left hand matrix is lower triangular matrix. Now this process is not as expensive as decomposition of the matrix. Here, only a back-substitution step is enough. Now my questions is that if I want to do this in parallel, how can I use PARADISO (specifically cluster interface) to solve this system of equations? Can I use just one of the steps of the solver to perform back-substitution? If yes, how?

This is my first time using PARADISO so kindly hep me with this and apologies if I said anything worng.

Thanks in advance,

Shailesh

Hello MKL fans and sorry for such stupid question >.<

We are some open Source developer who working at the moment on a project called "NumSharp" which shall offers the same APIs from numpy but for .NET languages.

When implementing LAPACK functionalities we saw that there are multiple lapack providers (or LAPACK libs) like NetLib standard LAPACK, MKL, ....and so want to give users the possibility to choose free which licensed provider they want to use.

Sure MKL is one of the most popular. Since anaconda distro using the MKL lib in so many packages like numpy - we was thinking about offering MKL and  different other LAPACK providers (native libs) as .NET package / nuget package.

Licensing is always a sensitive topic and so we were discussing in https://github.com/SciSharp/NumSharp/issues/116.

Now our question

is it allowed to distribute the MKL dlls in package like nuget or is it totally forbitten and everybody has to install by him or herself?

Sorry for this question but we do not want to do sth wrong and so better ask then do.

Wish all a nice day and thanks for your time.

Hi, I`m wondering if I can use MKL FGMRES to solve Ax=B where all the elements in Matrix A and righthand vector are complex

Hello,

I am trying to compile a program that calculates the generalized inverse of a matrix and i am getting the error:

1>VisualFortranTest1.obj : error LNK2019: unresolved external symbol _C referenced in function _MAIN__
1>Unused libraries:
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib\ia32_win\ifconsol.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib\ia32_win\libifportmd.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib\ia32_win\libmmdd.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib\ia32_win\svml_dispmd.lib
1>  C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.14.26428\lib\x86\OLDNAMES.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\mkl\lib\ia32_win\mkl_intel_c_dll.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\mkl\lib\ia32_win\mkl_intel_thread_dll.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\mkl\lib\ia32_win\mkl_core_dll.lib
1>  C:\Program Files (x86)\IntelSWTools\compilers_and_libraries_2018\windows\compiler\lib\ia32_win\libiomp5md.lib
1>  C:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Tools\MSVC\14.14.26428\lib\x86\libcpmt.lib
1>Debug\VisualFortranTest1.exe : fatal error LNK1120: 1 unresolved externals

I followed the steps from here to configure the MKL in my project:

https://software.intel.com/en-us/node/528341

I'm new at programming with Fortran and MKL, is there anything that i am missing?

I'm attaching the full log that i get when i try to execute the program from Visual Studio 2017 and the source code that i am compiling.

Hello,

I am trying to call pardiso through a subroutine in a large program of mine.
The subroutine receives the coefficient array from the main program as a dummy argument Kffv.

This is the subroutine first line, together with an explanation of various arguments (some of them are not important for the issue that I am reporting, as they are not directly used with pardiso):

===========================================================================================

subroutine gauselim(Kffv,bvec,n,nrows,perm,rowIndex,Icol,Kdiag,Idiag,formstffness)

c     INPUT ARGUMENTS: 
c     ----------------                
c      bvec:    RHS vector
c      formstffness: logical variable (see my explanation below
c      Icol:    integer vector with dimension "n": Icol(iv) = the column number to which component "iv" of Kffv corresponds
c      Idiag:   integer vector with dimension "nrows", containing the locations (in Kffv) of the diagonal components of the coefficient array
c      Kdiag:   real vector with dimension nrows, containing the diagonal components of the coefficient array (used for preconditioning)
c      Kffv:    vector containing nonzero values of Kff        
c      n:       dimension of Kffv
c      nrows:   number of rows in system of equations   
c      perm:    integer vector, not used here (only passed for consistency for calling direct solver)
c      rowIndex: integer vector, containing the row information for coefficient array: rowIndex(i) = which component of Kffv corresponds to the 1st nonzero component of row "i", rowIndex(nrow+1) = (component of Kffv which corresponds to the last component of row nrow) - rowIndex(1)
c
c     OUTPUT ARGUMENTS:   
c     -----------------
c      bvec: solution vector      

===================================================================================

I need to call this subroutine for different values of bvec (which are calculated during program execution and are not all known simultaneously, so each time that I call the subroutine I must solve with a single RHS vector bvec. The coefficient array Kffv may or may not change. This is controlled by the logical argument formstffness: if formstffness = .true., then we have a new coefficient array and we need to factorize it before solving.
if formstffness = .false., then we have not changed the coefficient array from the previous factorization (and we do not need to factorize from scratch - we merely need to use the pre-existing factorization to directly solve).

I have the following lines of code in my program (after initializing the various arguments of pardiso):

=================================================================================================

       if(formstffness) then    ! check if coefficient array has changed, at which case we must factorize from scratch:
          ! first, clear memory:
          call pardiso (pt, maxfct, mnum, mtype, -1, nrows, Kffv,rowIndex, icol, perm, nrhs, iparm, msglvl, bvec, xvec, ierror)
           
        ! now, conduct numerical factorization:   
               phase = 12
      
      call pardiso (pt, maxfct, mnum, mtype, phase, nrows, Kffv,  rowIndex, icol, perm, nrhs, iparm, msglvl, bvec, xvec, ierror)
          endif

          ! finally, solve:
           phase = 33
      
      call pardiso (pt, maxfct, mnum, mtype, phase, nrows, Kffv,  rowIndex, icol, perm, nrhs, iparm, msglvl, bvec, xvec, ierror)

============================================================================

This code works fine the first time the routine is called (where formsffness = .true.)
However, the second time that the routine is called (with formsffness = .false.) it does not give a solution, which means that I have somehow lost the factorization.
Do you have any ideas/thoughts on what I may be doing wrong in my routine?
 

Here's the following sparse CSR matrix.

n = 10

ia = {0, 3, 6, 9, 12, 15, 18, 19, 20, 21, 22 };

ja = { 4, 7, 8, 0, 5, 7, 1, 6, 8, 0, 2, 7, 1, 2, 8, 2, 3, 4, 3, 5, 6, 4 };

a = { -1, 1, 1, 1, 1, 5.5, 1, 1, 4, 1, -1, -2, 1, -1, -4, 1, -1, -6, 1, 1, 1, 1 };

perm = {0, 0,0, 0,0,0 ,0,1,1,1}

The exact Schur complement is {-13.5,-6,0,-6,-14,0,1,1,0}.

When calculating the Schur complement, Pardiso is handling a pivoting issue. 

A/ If Pardiso perturbs the pivot elements with 1E-13, then I get {-7.5, 1.72432057769409E-10, 0,0,-8,0,0,1,0

B/ If Pardiso perturbs the pivot elements with 1E-6, then I get {-13.5009434324193, -6.0009554327987, 0,-6,-14.0002128945854,0,1,1.00000000046566,0}

If I include all the zeros in the sparse matrix (full matrix with a sparse matrix representation of 100 coefficients) then I get the exact right answer.

If I am doing the factorization of the upper left corner (7x7) of the matrix and calculating myself the Schur complement

then I get the exact right answer.

What's happening? Is it a bug?

Yvan

There seems to be a discrepancy between the method of initialization of the Philox-4x32-10 random number generator in the following two web-pages when more than a single 32-bit integer is used for initialization:

(1) https://software.intel.com/en-us/mkl-vsnotes-philox4x32-10
Stream Initialization by Function vslNewStreamEx

and the following article:

(2) https://software.intel.com/en-us/articles/new-counter-based-random-numbe...

The case in (1) seems a bit odd to me, since k is meant to be a 64-bit (2x32-bit) key, while the counter c is a128-bit (4x32-bit). Yet, the method described for n>2 is trying to initialize k with more than 64-bits. Perhaps the text is wrong for (1) and that for n>2 the params[3,4,5,6] should instead be setting c?

Has anyone used this BRNG with multiple-word initialization?

Thanks.  P.

Hello,

I am trying to multiply two matrixs.

Matrix A : 1 row & 7180 columns & 1341 elements.

Matrix B : 7180 rows & 10001 columns & 372623 elements.

But segment fault occurs when calling SPMM.
 

The error occurs when calling mkl_sparse_spmm with the two matrixs all in CSR format, while the two matrixs seems (the matrix is big so that I can not confirm the correctness) in correct format by printing it (mkl_sparse_s_export_csr).

However, I can not reproduce it in a simple case.

Any idea what the problem is? Is there any useful information?

Thank you very much in advance.

Zixi

The trace stack is as follows:
[kudu57:09298] *** Process received signal ***
[kudu57:09298] Signal: Segmentation fault (11)
[kudu57:09298] Signal code:  (128)
[kudu57:09298] Failing at address: (nil)
[kudu57:09298] [ 0] /lib/x86_64-linux-gnu/libpthread.so.0(+0x11390)[0x7fe587bbe390]
[kudu57:09298] [ 1] /Program/intel/compilers_and_libraries_2019.1.144/linux/mkl/lib/intel64_lin/libmkl_avx2.so(mkl_sparse_s_csr__g_n_spmm_notr_row_i8_avx2+0x822)[0x7fe5729cefc2]
[kudu57:09298] [ 2] /Program/intel/compilers_and_libraries_2019.1.144/linux/mkl/lib/intel64_lin/libmkl_gnu_thread.so(+0x597153)[0x7fe58c70f153]
[kudu57:09298] [ 3] /Program/intel/compilers_and_libraries_2019.1.144/linux/mkl/lib/intel64_lin/libmkl_gnu_thread.so(+0x598815)[0x7fe58c710815]
[kudu57:09298] [ 4] /Program/intel/compilers_and_libraries_2019.1.144/linux/mkl/lib/intel64_lin/libmkl_gnu_thread.so(mkl_sparse_s_csr__g_n_spmm_i8+0x76b)[0x7fe58c710f9b]
[kudu57:09298] [ 5] /Program/intel/compilers_and_libraries_2019.1.144/linux/mkl/lib/intel64_lin/libmkl_avx2.so(mkl_sparse_s_do_spmm_i8_avx2+0x47b)[0x7fe5728d14fb]
[kudu57:09298] [ 6] ./libsparse[0x40dd8f]
[kudu57:09298] [ 7] ./libsparse[0x40ccf3]
[kudu57:09298] [ 8] /lib/x86_64-linux-gnu/libc.so.6(__libc_start_main+0xf0)[0x7fe586423830]
[kudu57:09298] [ 9] ./libsparse[0x40d209]
[kudu57:09298] *** End of error message ***
Segmentation fault (core dumped)

Compile option:
-std=c++17 -DMKL_ILP64 -m64 -I${MKLROOT}/include -Wall -fopenmp
-L${MKLROOT}/lib/intel64 -Wl,--no-as-needed -lmkl_intel_ilp64 -lmkl_gnu_thread -lmkl_core 
-lgomp -lpthread -lm -ldl -lboost_system -lboost_filesystem -lmpi

Hello, I am using mkl_sparse_convert_csr to perform transpose function by calling with SPARSE_OPERATION_TRANSPOSE option.

However, the values of the result matrix is transposed correctly with the row & col left unchanged.

Here is the code.

#include <bits/stdc++.h>
#include <mkl.h>
#include <omp.h>
using namespace std;

namespace {
// Output MKL sparse matrix in CSR format.
void Print(const sparse_matrix_t &mat) {
  sparse_index_base_t index_base;
  MKL_INT rows, cols;
  MKL_INT *rows_start, *rows_end, *col_idx;
  float *values;
  assert(mkl_sparse_s_export_csr(mat, &index_base, &rows, &cols, &rows_start,
                                 &rows_end, &col_idx,
                                 &values) == SPARSE_STATUS_SUCCESS);
  cout << "IndexBase="<< (index_base == SPARSE_INDEX_BASE_ZERO ? 0 : 1)
       << endl;
  cout << "Rows="<< rows << " Cols="<< cols << endl;
  for (int i = 0; i < rows; ++i) {
    cout << "RowsKey="<< i << ":";
    for (int j = rows_start[i]; j < rows_end[i]; ++j) {
      cout << "("<< col_idx[j] << ","<< values[j] << ")";
    }
    cout << endl;
  }
}

} // namespace

int main() {
  // Auto log flush.
  cout.setf(std::ios::unitbuf);
  mkl_set_num_threads(1);

  const MKL_INT n = 4, m = 5;

  // Create matrix a.
  vector<float> values = {1, 2, 2, 1};
  vector<MKL_INT> rows_start = {0, 0, 2, 3};
  vector<MKL_INT> rows_end = {0, 2, 3, 4};
  vector<MKL_INT> col_idx = {0, 2, 2, 3};

  sparse_matrix_t mat_a;
  assert(mkl_sparse_s_create_csr(&mat_a, SPARSE_INDEX_BASE_ZERO, n, m,
                                 rows_start.data(), rows_end.data(),
                                 col_idx.data(),
                                 values.data()) == SPARSE_STATUS_SUCCESS);
  cout << "Matrix A:"<< endl;
  Print(mat_a);

  sparse_matrix_t mat_b;
  assert(mkl_sparse_convert_csr(mat_a, SPARSE_OPERATION_TRANSPOSE, &mat_b) ==
         SPARSE_STATUS_SUCCESS);
  cout << "Matrix B:"<< endl;
  Print(mat_b);

  mkl_sparse_destroy(mat_b);
  mkl_sparse_destroy(mat_a);
  return 0;
}
 

The result is here:

Matrix A:
IndexBase=0
Rows=4 Cols=5
RowsKey=0:
RowsKey=1:(0,1)(2,2)
RowsKey=2:(2,2)
RowsKey=3:(3,1)
Matrix B:
IndexBase=0
Rows=4 Cols=5
RowsKey=0:(1,1)
RowsKey=1:
RowsKey=2:(1,2)(2,2)
RowsKey=3:(3,1)

As you can see, the rows=4 & cols=5 in the matrix B.

Any idea what the problem is? Is there any useful information?

Thank you very much in advance.

Zixi

Hi

I have binary build Intel C 19.0.1 that is a heavy user of MKL.  

When I do

export MKL_ENABLE_INSTRUCTIONS=AVX512

time goes from  88s to 55s for 1 problem instance.

That is HUGE savnings. 

How come MKL figure that by itself? What is the philosophy?

Also it seems if I instead do

mkl_enable_instructions(MKL_ENABLE_AVX512)

then it has ZERO effect. Why?

Erling

I am using the DGEQRF subroutine to implement an orthogonalization using the QR factorization. Compiling and running the code using gfortan and MKL works well but when I try ifort and MKL I get the following error:

forrtl: error (65): floating invalid

Details:

ifort version: ifort (IFORT) 19.0.1.144 20181018

MKL version: parallel_studio_xe_2019_update1_cluster_edition

The source code can be found at: https://github.com/NLESC-JCER/Fortran_Davidson

The traceback option points me to the following line of the code:

https://github.com/NLESC-JCER/Fortran_Davidson/blob/master/src/davidson....

I am compiling the code using cmake like:

 cmake -H. -Bbuild -DCMAKE_Fortran_COMPILER=ifort -DCMAKE_BUILD_TYPE=Debug

then

 cmake --build build

Finally I run the code like:

./bin/main

I really appreciate any help you can provide.

Best,

Felipe Z. 

I have implemented an orthogonalization method using the DGEQRF subroutine to compute a QR factorization. The compilation and subsequently execution works well using gfortran/MKL but  when I compile and run it with  Ifort/MKL I get the following error:

forrtl: error (65): floating invalid 

I have checked for uninitialized variables or NaN values, and the problem seems to be an arithmetic operation inside DGEQRF.

Issue description:

Ifort version: ifort (IFORT) 19.0.1.144 20181018 

MKL version: parallel_studio_xe_2019_update1_cluster_edition

The source code can be found at: https://github.com/NLESC-JCER/Fortran_Davidson

Line that cause the error: https://github.com/NLESC-JCER/Fortran_Davidson/blob/master/src/davidson....

I compile the code using cmake like: 

 cmake -H. -Bbuild -DCMAKE_Fortran_COMPILER=ifort DCMAKE_BUILD_TYPE=Debug

 cmake --build build

I run the resulting binary like:

./bin/main

Finally, The orthogonalization subroutine is

  subroutine lapack_qr(basis)
    !> Orthoghonalize the basis using the QR factorization.
    !> QR factorization of the M-by-N (M>N) matrx A=Q*R in the form where
    !> Q is square M-by-M matrix and R is an upper triangular M-by-N matrix.
    !> The equality A=Q*R can be re-written also as a product Q1*R1 where Q1
    !> is a rectangular M-by-N submatrix of the matrix Q and R1 is M-by-M
    !> submatrix of the R. Let us note that columns of Q1 are orthonormal
    !> (they are orthogonal to each other and have norms equal to 1).
    !> The equality A=Q1*R1 can be treated as every column of A is a linear
    !> combination of Q1 columns, i.e. they span the same linear space.
    !> In other words, columns of Q1 is the result of ortogonalization of columns A.
    !> DGEQRF does not not compute Q directly, DORGQR must be call subsequently.
    
    !> \param basis
    !> \return orthogonal basis    

    implicit none
    real(dp), dimension(:, :), intent(inout) :: basis
    real(dp), dimension(:), allocatable :: work ! workspace, see lapack documentation
    real(dp), dimension(size(basis, 2)) :: tau ! see DGEQRF documentation
    integer :: info, lwork, m, n

    ! Matrix shape
    m = size(basis, 1)
    n = size(basis, 2)

    ! 1. Call the QR decomposition
    ! 1.1 Query size of the workspace (Check lapack documentation)
    allocate(work(1))
    call DGEQRF(m, n, basis, m, tau, work, -1, info)

    ! 1.2 Allocate memory for the workspace
    lwork = max(1, int(work(1)))
    deallocate(work)
    allocate(work(lwork))

    ! 1.3 Call QR factorization
    call DGEQRF(m, n, basis, m, tau, work, lwork, info)
    deallocate(work)
    
    ! 2. Generates an orthonormal matrix
    ! 2.1 Query size of the workspace (Check lapack documentation)
    allocate(work(1))
    call DORGQR(m, n, min(m, n), basis, m, tau, work, -1, info)

    ! 2.2 Allocate memory fo the workspace
    lwork = max(1, int(work(1)))
    deallocate(work)
    allocate(work(lwork))

    ! 2.3 compute the matrix Q
    call DORGQR(m, n, min(m, n), basis, m, tau, work, lwork, info)
    
    ! release memory
    deallocate(work)
    
  end subroutine lapack_qr

I really appreciate any help you can provide.

Best,

Felipe Z.

Hi there

I struggle a bit to understand (circumvent if possible) the pardiso performance drop measured as "seconds per right hand side" when decreasing the number of right hand sides.

The sparse matrix feed into pardiso has 2,562,698 rows/columns and the factorization yields 168,330,156 non-zero elements (iparm(18)).

After calling pardiso with phase=12, it is called with phase=33. The iparm vector was left with default values. When using 10 r-h-s, the solution was obtained after 2.21 seconds (phase 33 only), when using 750 r-h-s, the solution was obtained after 16.7 seconds (phase 33 only). Thus, in the first case pardiso needed 0.221 seconds per r-h-s, in the second case 0.022 seconds per r-h-s, which is a decrease of almost factor 10.

The timing was obtained on a Intel(R) Xeon(R) CPU E5-2697 v4 @ 2.30GHz with 36 real cores and 256GB ram. The number of MKL cores was 36.

The iparm vector for the 10 r-h-s case was:

1,2,36,0,0,0,0,0,0,0,0,0,0,0,5732781,4282495,8583732,168330156,1014847,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,5732781,5153806,885183,0

for the 750 r-h-s case:

1,2,36,0,0,0,0,0,0,0,0,0,0,0,5732781,4282495,541945253,168330156,1014847,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,-1,0,0,0,5732781,5153806,885183,0

Any suggestion about how I can achieve a time per r-h-s for the 10 r-h-s case similar to that for the 750 r-h-s case are highly appreciated.

Thanks.

I need to work with REALLY LARGE integers.

What would be ideal is something that allows any length of integer.

The basic operations on those, of course. + - / and *

Has anyone developed those ?

I was wondering are individual mkl operation calls parallelized or do the separate mkl calls run in parallel? e.g. I have code similar to this

for (int i=0; i<N; i++)
      mkl_dot_product_call()

Is the mkl_dot_product_call() executed with multiple threads or will multiple threads each execute their own mkl_dot_product_call()?

I have developed Dinrhiw2 machine learning library and neuromarketing software 

using MKL math library. I have M. Sc diploma (TKK.fi).

People in Finland want to murder me and talks about torture.

Police / Government / Companies / Banks don’t work and I need help!

Money keeps disappearing from my bank accounts and difficult to travel.

Thinking problems and CNS remote control and Voice in head. (Murder!)

i have worked in Itella TGM, TKK, Geodetic Institute, Absolutions.

I cannot contact my old friends (Valtteri Laukkanen, Merja Ukkonen, Joni Remes, Jani Engberg, Juha Karhunen, Jyrki Kasvi, Marko Kuisma, Tapani Sarjakoski, Sanna Pöyhönen, Samipekka Ukkonen, Hannu Ukkonen or IIPC people or Samuel Kaski, Marko Lehtovaara, Seppo Halttunen etc). I’m 38 years old, and have nationslutu of Finland.

I cannot remember many names.

World and Europe seems destroyed but buildings keep changing and basic physics bypassed often.

please help

tomas.ukkonen@iki.fi

Tomas Erno Ukkonen

+358-45-6696890