console_output.txt

starting factorization
=== PARDISO is running in In-Core mode, because iparam(60)=0 ===

Percentage of computed non-zeros for LL^T factorization
 33 %  66 %  100 %

=== PARDISO: solving a real structurally symmetric system ===
Matrix checker is turned ON
0-based array is turned ON
PARDISO double precision computation is turned ON
METIS algorithm at reorder step is turned ON
Single-level factorization algorithm is turned ON


Summary: ( starting phase is reordering, ending phase is factorization )
================

Times:
======
Time spent in calculations of symmetric matrix portrait (fulladj): 0.000031 s
Time spent in reordering of the initial matrix (reorder)         : 0.000001 s
Time spent in symbolic factorization (symbfct)                   : 0.000835 s
Time spent in data preparations for factorization (parlist)      : 0.000001 s
Time spent in copying matrix to internal data structure (A to LU): 0.000000 s
Time spent in factorization step (numfct)                        : 0.000164 s
Time spent in allocation of internal data structures (malloc)    : 0.000233 s
Time spent in additional calculations                            : 0.000059 s
Total time spent                                                 : 0.001324 s

Statistics:
===========
Parallel Direct Factorization is running on 6 OpenMP

< Linear system Ax = b >
             number of equations:           3
             number of non-zeros in A:      3
             number of non-zeros in A (%): 33.333333

             number of right-hand sides:    1

< Factors L and U >
             number of columns for each panel: 128
             number of independent subgraphs:  0
< Preprocessing with state of the art partitioning metis>
             number of supernodes:                    3
             size of largest supernode:               1
             number of non-zeros in L:                3
             number of non-zeros in U:                1
             number of non-zeros in L+U:              4
             gflop   for the numerical factorization: 0.000000

             gflop/s for the numerical factorization: 0.000000

saving factorization to file
Segmentation fault (core dumped)

main.cpp

#include <mkl.h>
#include <mkl_spblas.h>
#include <mkl_pardiso.h>
#include <mkl_types.h>
#include <stdio.h>

int main(int argc, char** argv) {
	int k = 3;

	double vals[3] = {1, 1, 1};
	int cols[3] = {0, 1, 2};
	int rows[4] = {0, 1, 2, 3};

	int pt[64];
	int mtype = 1;
	int iparm[64];
	pardisoinit(pt, &mtype, iparm);
	iparm[26] = 1; // validate input sparse matrix
	iparm[34] = 1; // 0-base indexing

	int maxfct = 1;
	int mnum = 1;
	int phase = 12;
	int perm[k];
	int msglvl = 1;
	int err = 0;

	int idum;
	double ddum;

	printf("starting factorization\n");
	pardiso(pt, &maxfct, &mnum, &mtype, &phase, &k, vals, rows, cols, perm, &idum, iparm, &msglvl, &ddum, &ddum, &err);
	if (err) {
	  printf("factorization failed. Code: %d\n", err);
	  exit(1);
	}

	printf("saving factorization to file\n");
	pardiso_handle_store(pt, "", &err);
	if (err) {
	  printf("failed to save the factorization to file. Code; %d\n", err);
	  exit(1);
	}
}

Makefile

CXX = g++-7
MKL = /home/alex_ling/intel/mkl
MKLROOT := $(if $(MKLROOT),$(MKLROOT),$(MKL))

IDIR = -I$(MKLROOT)/include
LIBS = -Wl,--start-group ${MKLROOT}/lib/intel64/libmkl_intel_lp64.a ${MKLROOT}/lib/intel64/libmkl_gnu_thread.a ${MKLROOT}/lib/intel64/libmkl_core.a -Wl,--end-group -lgomp -lpthread -lm -ldl -m64
CXXFLAGS = -Wall -Ofast -std=gnu++14 -fopenmp -march=native

main:
	$(CXX) $(IDIR) $(CXXFLAGS) main.cpp -o main $(LDIR) $(LIBS)
clean:
	rm main