*** BCC – Matrix Size 2048×2048 / Single precision ( float ) data type ***

Strassen HBC
Matrix Size : 2048 x 2048
Matrix Size Threshold: 128 x 128
Matrix Partitions : 2801
ResultSets Reflection: Enabled
Calculating…
Strassen HBC – Pass 1 – Completed: 11.95000 secs
Strassen HBC – Pass 2 – Completed: 11.10700 secs
Strassen HBC – Pass 3 – Completed: 11.10700 secs
Strassen HBC – Pass 4 – Completed: 11.10700 secs
Strassen HBC – Pass 5 – Completed: 11.09200 secs
ALGORITHM_STRASSEN_HBC – Passed

Compiler: Borland C++ v5.5
Library: ScaLib v1.13.02 ( ScaLib stands for Set of Common Algorithms )
OS: Windows 7 Professional
Hardware: Dell Precision M4700 ( CPU Core i7-3840QM / 16GB )

Note to a Moderator: Please delete my previous post. Thanks.

Thanks,
Badri

Its a real pig to work with. Intel do provide a sample set of example library calls, but they don’t provide the wrapper. You have to compile it yourself.

I am currently using MKL and wish I’d found a proper .Net compliant version or atleast a provider who does recognise that .Net does exist.

I’ve wasted so much time trying to get the wrapper compiled for 32 bit then 64 bit. It is not easy.

Intel fail to tell you that you must register MKLROOT as a global variable plus the Bin eg Intel\MKL\10…\em64t\bin should be in your path variable along with Intel\MKL\10…

Fast but painful.

It has its own matrix multiply, but optionally links with ATLAS which uses optimised and hardware specific routines.

Newer Matlab versions:

Have updated the MATLAB BLAS and LAPACK libraries used
Use more recent AMD and Intel MKL
Allow the user to specify an external Intel MKL
Have introduced multithreaded implementations as default for some mathematical functions

i0,j0,k0 should be iterated up to the relevant number of rows and columns as can still be seen in the post, and then either incremented by the relevant XBLOCK variable or equivalently set to the relevant Xmax variable. If anyone is interested I’ll be happy to send the code in an email.

template class Large_Matrix
{
private:
unsigned nr_rows;
unsigned nr_columns;
T * data;
public:
Large_Matrix(unsigned nr_rows_,unsigned nr_columns_) :
nr_rows(nr_rows_),
nr_columns(nr_columns_),
data(new T[nr_rows_*nr_columns_])
{}
~Large_Matrix()
{
delete [] data;
}
T * operator[](unsigned row)
{
return &data[row*nr_columns];
}
const T * operator[](unsigned row) const
{
return &data[row*nr_columns];
}
static bool multiply(Large_Matrix * answer,
const Large_Matrix & lhs,
const Large_Matrix & rhs)
{
if (lhs.nr_columns != rhs.nr_rows)
return false;
if (answer == &lhs)
{
Large_Matrix temp(lhs);
return multiply(answer,temp,rhs);
}
if (answer == &rhs)
{
Large_Matrix temp(rhs);
return multiply(answer,lhs,temp);
}
unsigned nr_elements = lhs.nr_rows * rhs.nr_columns;
if (answer->nr_rows * answer->nr_columns != nr_elements)
{
delete [] answer->data;
answer->data = new T[lhs.nr_rows*rhs.nr_columns];
}
answer->nr_rows = lhs.nr_rows;
answer->nr_columns = rhs.nr_columns;

{
for (unsigned i = 0; i data[i] = 0;
}

unsigned i0,j0,k0,i,j,k,imax,jmax,kmax,jmax1;
const unsigned IBLOCK=100;
const unsigned JBLOCK=128;
const unsigned KBLOCK=40;
for (i0 = 0; i0 lhs.nr_rows)
imax = lhs.nr_rows;
for (k0 = 0; k0 lhs.nr_columns)
kmax = lhs.nr_columns;
for (j0 = 0; j0 rhs.nr_columns)
jmax = rhs.nr_columns;
jmax1 = jmax & ~15;
for (i = i0; i <imax;i++,lrow += lhs.nr_columns,arow += rhs.nr_columns)
{
const T * rrow = rhs[k0];
for (k = k0; k < kmax;k++,rrow += rhs.nr_columns)
{
T v = lrow[k];
for (j = j0; j < jmax1;j+=16)
{
arow[j] += v*rrow[j];
arow[j+1] += v*rrow[j+1];
arow[j+2] += v*rrow[j+2];
arow[j+3] += v*rrow[j+3];
arow[j+4] += v*rrow[j+4];
arow[j+5] += v*rrow[j+5];
arow[j+6] += v*rrow[j+6];
arow[j+7] += v*rrow[j+7];
arow[j+8] += v*rrow[j+8];
arow[j+9] += v*rrow[j+9];
arow[j+10] += v*rrow[j+10];
arow[j+11] += v*rrow[j+11];
arow[j+12] += v*rrow[j+12];
arow[j+13] += v*rrow[j+13];
arow[j+14] += v*rrow[j+14];
arow[j+15] += v*rrow[j+15];
}
for (j = jmax1; j < jmax;j++)
arow[j] += v*rrow[j];
}
}
}
}
}
return true;
}
};

The right values for IBLOCK,JBLOCK,KBLOCK will vary from machine to machine, though there doesn’t seem to be a sharp minimum, and probably depend on the size of the matrices as well. JBLOCK should be a multiple of 16. If you know in advance the size of the matrices you will be using making the values a factor of this size is probably a good idea.

I am trying to reproduce the same results on my own Intel machine. I get a significant speedup with the Intel MKL, but not nearly as good as yours. Can you please tell me which compiler you used (gcc? icc?) and which compiler flags you used?

Thanks.

oliver