a)   Copy sample source code: dgemmx.f and common_func.f from <mkl install directory /examples/blas/source> to your work directory, for example, /Users/yhu5/blas.
b)   Launch the Xcode application, typically found in the Developer > Applications folder.
c)   In Xcode Menu, select File > New > New Project.... , The New Project Assistant window opens. Select Application in the left pane. Select a template, for example, Command Line Tool, and click Next. Name your project, for example, MKL_dgemm_f, and select a type C. Click Next. Specify a directory for your project , For example, /Users/yhu5/blas. Click Create.
 

d)     Xcode creates the named project directory, with an .xcodeproj extension and several new source files like main.c etc.  Remove main.c, etc. file  and add dgemmx.f and common_func.f into ‘Source' project folder.

Each Xcode project has its own Project Editor window that displays project source files, targets, and executables.

2. Setting MKL Options in Xcode IDE

In the Xcode project, select the target and click Build Setting. Under the Build Settings tab, click All. Scroll down until you see IFORT_MKL, Select "Use threaded Intel® Math Kernel Library (or "Use non-thread Intel @ Math Kernal Library.)

3. Build and Run the Project

Select Product > Build. Or Click the  ‘Run' button on project tools bar, the project will build successfully. 
But may run with error message dyld: Library not loaded: libmkl_intel_lp64.dylib

(other compiler errors, like files is not found or Open file failed, please change the path of the files and the code in dgemmx.f, line 49, OPEN(UNIT=1, FILE='/Users/xx/xx/dgemmx.d',STATUS='OLD' so Xcode can find them.)

4) Set Run Environment

Open the Scheme Editor, click the Scheme button in the Project Editor Toolbar and select Edit Scheme, Under the Arguments tab, add DYLD_LIBRARY_PATH as an environment variable.
Set the Value as the full path to the Intel compiler's /lib directory and MKL directory
DYLD_LIBRARY_PATH=/opt/intel/composer_xe_2011_sp1.8.269/compiler/lib:

 /opt/intel/composer_xe_2011_sp1.8.269/mkl/lib

Click Run button again, you will get the result in Output box.

Please refer to Intel Compiler User and Reference Guide =>Building Applications with Xcode* IDE"
or "Configuring the Apple Xcode* Developer Software to Link with Intel MKL" section in MKL user guide for more details. 
And refer to "Linking Your Application with Intel® MKL" section in the Getting Started document to understand which libraries required by your code.

Operating System:

Mac OS*

    double alpha = 1.0; double beta = 0.0;
    pdgemv_("N",&M,&M,&alpha,A,&ONE,&ONE,descA,x,&ONE,&ONE,descx,&ONE,&beta,y,&ONE,& amp;ONE,descy,&ONE);
 
3. Build and Run it
    Build it under linux environment, assume intel 64bit application. 
    ! set environment and build pdgemv.c 
    $source /opt/intel/mkl/10.x.x.0xx/tools/environment/mklvarsem64t.sh
    $source /opt/intel/mpi/3.x.x/bin64/mpivars.sh
    $source /opt/intel/Compiler/11.x/0xx/bin/iccvars.sh intel64
    $mpiicc -w -o pdgemv pdgemv.c -I/opt/intel/mkl/10.x.x.0xx/include -L/opt/intel/mkl/10.x.x.0xx/lib/em64t
     -lmkl_scalapack_lp64 -lmkl_blacs_intelmpi_lp64 -lmkl_intel_lp64 -lmkl_intel_thread -lmkl_core -liomp5 -lpthread

    ! run the application 
    $ mpirun -n 4 ./pdgemv

4. Notes
Intel MKL PBLAS/ScaLAPACK routines are written in FORTRAN interface, so Column-major are used and row-major is not acceptable.  If you gives the matrix to these routines in row-major - even your code is completely right from C (Row-major) point of view,  the result will be almost always wrong.

1. Build a custom library (now unnecessary with Intel MKL 10.3): To interface with Intel MKL from Python we recommend you use the custom library builder in the tools/builder sub-directory of the Intel MKL package. The Intel® MKL User's Guide has documentation on this tool (docs online). Here briefly are the steps I took to do this:
   
   
   1. Set up your environment to use the desired version of Intel MKL:
      source /<MKLpath>/tools/environment/mklvarsem64t.sh
   2. Build the DLL:
      cd /<MKLpath>/tools/builder
make em64t name=~/libmkl4py export=cblas_list


2. Add library paths to LD_LIBRARY_PATH: All the Intel MKL libraries needed must be in directories contained in the LD_LIBRARY_PATH environment variable. The library as built above will depend on the OpenMP* threading runtime library used by Intel MKL (libiomp5.so) so you should make sure that both libraries, libmkl4py.so and libiomp5.so, are in a directory specified in the LD_LIBRARY_PATH environment variable. If you're using Intel MKL 10.3 you need to add the directories for both libmkl_rt.so and libiomp5.so (if you want it to run on multiple cores).


3. Call Intel MKL in your Python script: The following is a simple script (also available here) that loads the shared library just created and calls the matrix function.
   

   from ctypes import *
   
   # Load the share library
   mkl = cdll.LoadLibrary("./libmkl_rt.so")
   # For Intel MKL prior to version 10.3 us the created .so as below
   # mkl = dll.LoadLibrary("./libmkl4py.so")
   cblas_dgemm = mkl.cblas_dgemm
   
   
   def print_mat(mat, m, n):
     for i in xrange(0,m):
       print " ",
       for j in xrange(0,n):
         print mat[i*n+j],
       print 
   
   # Initialize scalar data
   Order = 101  # 101 for row-major, 102 for column major data structures
   TransA = 111 # 111 for no transpose, 112 for transpose, and 113 for conjugate transpose
   TransB = 111
   m = 2
   n = 4
   k = 3
   lda = k
   ldb = n
   ldc = n
   alpha = 1.0
   beta = -1.0
   
   # Create contiguous space for the double precision array
   amat = c_double * 6      
   bmat = c_double * 12
   cmat = c_double * 8
   
   # Initialize the data arrays
   a = amat(1,2,3, 4,5,6)
   b = bmat(0,1,0,1, 1,0,0,1, 1,0,1,0)
   c = cmat(5,1,3,3, 11,4,6,9)
   
   print "\nMatrix A ="
   print_mat(a,2,3) 
   print "\nMatrix B ="
   print_mat(b,3,4)
   print "\nMatrix C ="
   print_mat(c,2,4)
   
   print "\nCompute", alpha, "* A * B + ", beta, "* C"
   
   # Call Intel MKL by casting scalar parameters and passing arrays by reference
   cblas_dgemm( c_int(Order), c_int(TransA), c_int(TransB), \
                c_int(m), c_int(n), c_int(k), c_double(alpha), byref(a), c_int(lda), \
                byref(b), c_int(ldb), c_double(beta), byref(c), c_int(ldc))
   
   print_mat(c,2,4)
   print

4. A few notes:
   • Matrices in the BLAS and LAPACK parts of Intel MKL are stored in one dimensional arrays and integers are used to specify their geometry.
   • I've actually loaded here CBLAS interface to the general matrix multiply function which allows you to choose how the matrix is specified. In my script I've listed the matrix by rows (row-major ordering). If you do not use the cblas interface to the BLAS or if you use LAPACK you should keep in mind that these functions assume the Fortran method of listing matrices by columns (column-major ordering).

We extended the list of examples demonstrate how possible to call different ( not only widespread example like dgemm ) from the Python program:

See the list of 3 different examples attached:
dft.zip  - shows the Python program calls 1D DFTI API
spblas.zip - shows how to call  matrix-matrix multiplication routine for a sparse matrix stored in the block compressed format (BSR)
vsl.zip - shows how to call vdRngGaussian routine ( generates normally distributed random numbers)  from VSL domain.

Notes:
Each zip file contains  *.res and *_list files mean input file and file for custom library building correspondingly

Link: LAPACK examples