int main(int argc, char** argv) {
size_t iter = 1;
int q = 1009;
int n = 2000;
std::string file = "";
Argument as[] = {
{ 'q', "-q Q", "Set the field characteristic (-1 for random).", TYPE_INT , &q },
{ 'n', "-n N", "Set the dimension of the matrix.", TYPE_INT , &n },
{ 'i', "-i R", "Set number of repetitions.", TYPE_INT , &iter },
{ 'f', "-f FILE", "Set the input file (empty for random).", TYPE_STR , &file },
END_OF_ARGUMENTS
};
FFLAS::parseArguments(argc,argv,as);
typedef Givaro::Modular<double> Field;
typedef Field::Element Element;
Field F(q);
Element * A;
TTimer chrono;
double time=0.0;
Field::RandIter G(F);
for (size_t i=0;i<iter;++i){
if (!file.empty()){
A = read_field (F, file.c_str(), &n, &n);
} else {
A = FFLAS::fflas_new<Element>(n*n);
for (size_t j=0; j<(size_t) n*n; ++j)
G.random(*(A+j));
}
for (size_t k=0;k<(size_t)n;++k)
while (F.isZero( G.random(*(A+k*(n+1)))));
chrono.clear();
chrono.start();
clapack_dtrtri(CblasRowMajor,CblasUpper, CblasNonUnit,n,A,n);
chrono.stop();
time+=chrono.usertime();
FFLAS::fflas_delete( A);
}
// -----------
// Standard output for benchmark - Alexis Breust 2014/11/14
std::cout << "Time: " << time / double(iter)
<< " Gflops: " << (2.*double(n)/1000.*double(n)/1000.*double(n)/1000.0) / time * double(iter) / 3.;
FFLAS::writeCommandString(std::cout, as) << std::endl;
return 0;
}
//using namespace LinBox;
int main () {
using namespace std;
typedef FLTTYPE Field ;
Field F(17);
typedef Field::Element Element ;
size_t n=768, nmax=5000, prec=512, nbest=0, count=0;
TTimer chrono;
bool bound=false;
Field::RandIter G(F);
Element *A,*B,*C;
A = FFLAS::fflas_new<Element>(nmax*nmax);
B = FFLAS::fflas_new<Element>(nmax*nmax);
C = FFLAS::fflas_new<Element>(nmax*nmax);
for (size_t i=0; i<nmax*nmax;++i)
G.random(A[i]);
for (size_t i=0; i<nmax*nmax;++i)
G.random(B[i]);
for (size_t i=0; i<nmax*nmax;++i)
G.random(C[i]);
std::ofstream outlog;
outlog.open("optim.log", std::ofstream::out | std::ofstream::app);
#ifdef __FFLASFFPACK_HAVE_CXX11
std::time_t result = std::time(NULL);
outlog << std::endl <<
"---------------------------------------------------------------------"
<< std::endl << std::asctime(std::localtime(&result));
#endif
outlog << std::endl
<< "Threshold for finite field Strassen-Winograd matrix multiplication" ;
F.write(outlog << "(using ") << ')' << std::endl;
do {
double basetime, time;
FFLAS::MMHelper<Field, FFLAS::MMHelperAlgo::Winograd> ClassicH(F,0, FFLAS::ParSeqHelper::Sequential());
FFLAS::MMHelper<Field, FFLAS::MMHelperAlgo::Winograd> WinogradH(F,1, FFLAS::ParSeqHelper::Sequential());
int iter=3;
//warm up computation
FFLAS::fgemm(F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans,
n, n, n, F.mOne, A, n, B, n, F.one, C, n, ClassicH);
chrono.start();
for (int i=0;i<iter;i++)
FFLAS::fgemm(F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans, n, n, n, F.mOne, A, n, B, n, F.one, C, n, ClassicH);
chrono.stop();
std::cout << std::endl
<< "fgemm " << n << "x" << n << ": "
<< chrono.realtime()/iter << " s, "
<< GFLOPS << " Gffops"
<< std::endl;
outlog << std::endl
<< "fgemm " << n << "x" << n << ": "
<< chrono.realtime()/iter << " s, "
<< GFLOPS << " Gffops"
<< std::endl;
basetime= chrono.realtime();
//warm up
FFLAS::fgemm(F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans,
n, n, n, F.mOne, A, n, B, n, F.one, C, n, WinogradH);
chrono.clear();
chrono.start();
for (int i=0; i<iter; i++)
FFLAS::fgemm(F, FFLAS::FflasNoTrans, FFLAS::FflasNoTrans,
n, n, n, F.mOne, A, n, B,n, F.one, C, n, WinogradH);
chrono.stop();
std::cout << "1Wino " << n << "x" << n << ": "
<< chrono.realtime()/iter << " s, "
<< GFLOPS << " Gffops"
<< std::endl;
outlog << "1Wino " << n << "x" << n << ": "
<< chrono.realtime()/iter << " s, "
<< GFLOPS << " Gffops"
<< std::endl;
time= chrono.realtime();
if (basetime > time ){
count++;
if (count > 1){
nbest=n;
bound=true;
prec=prec>>1;
n-=prec;
}
}
