void log_rinfo(ninfo_t *e)
{
falist_t *i;
struct tm *t,mt;
char s[MAX_STRING];
int k=0;
time_t tt=time(NULL);
if((i=e->addrs)) {
write_log("address: %s",ftnaddrtoa(&i->addr));
i=i->next;
}
for(*s=0;i;i=i->next) {
if(k)xstrcat(s," ",MAX_STRING);
xstrcat(s,ftnaddrtoa(&i->addr),MAX_STRING);
k++;if(k==2) {
write_log(" aka: %s",s);
k=0;*s=0;
}
}
if(k)write_log(" aka: %s",s);
write_log(" system: %s",e->name);
write_log(" from: %s",e->place);
write_log(" sysop: %s",e->sysop);
write_log(" phone: %s",e->phone);
write_log(" flags: [%d] %s",e->speed,e->flags);
write_log(" mailer: %s",e->mailer);
mt=*localtime(&tt);t=localtime(&e->time);
write_log(" time: %02d:%02d:%02d, %s",t->tm_hour,t->tm_min,t->tm_sec,e->wtime?e->wtime:"unknown");
if(t->tm_mday!=mt.tm_mday||t->tm_mon!=mt.tm_mon||t->tm_year!=mt.tm_year)
write_log(" date: %02d.%02d.%04d",t->tm_mday,t->tm_mon+1,t->tm_year+1900);
if(e->holded&&!e->files&&!e->netmail)write_log(" for us: %d%c on hold",
SIZES(e->holded),SIZEC(e->holded));
else if(e->files||e->netmail)write_log(" for us: %d%c mail; %d%c files",
SIZES(e->netmail),SIZEC(e->netmail),SIZES(e->files),SIZEC(e->files));
}
void show_basic(Btree *bt, int f) {
DISKOFFSET length, blkcount;
BLKSIZE blksize;
fprintf(outfile, "File: %s\n", FDATA(f,filename));
blksize = SIZES(f, block_size);
fprintf(outfile, " Block size: %d, split: %d, merge: %d\n",
blksize,
SIZES(f, split),
SIZES(f, merge));
if (f == NDX)
fprintf(outfile, " Index has %d levels\n",
SIZES(f, levels));
fseek(FDATA(f, file), 0L, SEEK_END);
length = ftell(FDATA(f,file));
blkcount = length/blksize;
fprintf(outfile, " File length %ld (%ld blocks)\n",
length, blkcount);
if (f == NDX)
fprintf(outfile, " Root index block at %ld"
" (block no. %ld)\n",
FDATA(f, root_block),
FDATA(f, root_block)/blksize);
fprintf(outfile,
" First free block at %ld (block no. %ld)\n",
FDATA(f, free_block),
FDATA(f, free_block)/blksize);
}
void show_btree_mapr(Btree *bt, DISKOFFSET iblock)
{
char *pblock;
BlockControl *bc;
unsigned offset;
DISKOFFSET dof;
/* say we've been here */
mapdata[NDX].map[iblock/SIZES(NDX,block_size)] = 'N';
/* get the block */
pblock = bt_getblock4read(bt, NDX, iblock);
if (!pblock)
return;
bc = (BlockControl *)pblock;
/* scan it */
offset = sizeof(BlockControl);
while (offset < bc->bfree) {
offset += GETKEYSIZE(pblock + offset);
dof = *((DISKOFFSET *) (pblock + offset));
offset += sizeof(DISKOFFSET);
if (bc->blockstate == sNode) {
show_btree_mapr(bt, dof);
pblock = bt_getblock4read(bt, NDX, iblock);
if (!pblock)
return;
bc = (BlockControl *)pblock;
}
else
mapdata[DAT].map[dof/SIZES(DAT,block_size)] = 'D';
}
}
void show_btree_map(Btree *bt, FILE *file) {
int i, j;
/* setup maps */
for (i=0; i < 2; i++) {
fseek(FDATA(i, file), 0L, SEEK_END);
mapdata[i].length = ftell(FDATA(i, file));
mapdata[i].blkcount =
mapdata[i].length/SIZES(i, block_size);
mapdata[i].map = malloc(mapdata[i].blkcount);
for (j=0; j < mapdata[i].blkcount; j++)
mapdata[i].map[j] = '.';
mapdata[i].map[0] = 'C';
}
/* walk the tree */
show_btree_mapr(bt, FDATA(NDX, root_block));
/* trace the free blocks */
for (i=0; i < 2; i++) {
DISKOFFSET block;
char *pblock;
BlockControl *bc;
block = FDATA(i, free_block);
while(block) {
pblock = bt_getblock4read(bt, i, block);
if (!pblock)
break;
mapdata[i].map[block/SIZES(i, block_size)] = 'f';
bc = (BlockControl *) pblock;
block = bc -> next;
}
}
/* display the map */
for (i=0; i < 2; i++) {
fprintf(file, "%s Block Map:\n ",
i == 0 ? "Index" : "Data");
for (j=0; j < 10; j++)
fprintf(file, " %d", j);
for (j=0; j < mapdata[i].blkcount; j++) {
if (j % 10 == 0) {
fprintf(file,"\n%4d: ", j);
}
fprintf(file, " %c", mapdata[i].map[j]);
}
fprintf(file, "\n");
free(mapdata[i].map);
}
}
/*
*display contents of data files
*
* mode = 0: just display number of pointers at each level
* mode = 1: display all data
*/
void show_btree(Btree *bt, FILE *f, int mode) {
outfile = f;
if (mode) {
show_basic(bt, NDX);
show_basic(bt, DAT);
}
index_blksize = SIZES(NDX, block_size);
walk_down(bt, NDX, FDATA(NDX, root_block), 0, mode);
}
int main(int argc, char** argv)
{
std::vector<std::chrono::duration<double, std::milli>> duration_vector_1, duration_vector_2;
bool run_ref = false, run_tiramisu = false;
const char* env_ref = std::getenv("RUN_REF");
if (env_ref != NULL && env_ref[0] == '1')
run_ref = true;
const char* env_tiramisu = std::getenv("RUN_TIRAMISU");
if (env_tiramisu != NULL && env_tiramisu[0] == '1')
run_tiramisu = true;
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
double alpha = 2.5;
Halide::Buffer<int> SIZES(1);
SIZES(0) = nrow;
Halide::Buffer<double> b_alpha(1);
b_alpha(0) = alpha;
Halide::Buffer<double> b_X(nrow), b_X_ref(nrow);
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
// ---------------------------------------------------------------------
{
for (int i = 0; i < NB_TESTS; ++i)
{
init_buffer(b_X_ref, (double)1);
auto start = std::chrono::high_resolution_clock::now();
if (run_ref)
scal_ref(nrow, alpha, b_X_ref.data());
auto end = std::chrono::high_resolution_clock::now();
duration_vector_1.push_back(end - start);
}
}
{
for (int i = 0; i < NB_TESTS; ++i)
{
init_buffer(b_X, (double)1);
auto start = std::chrono::high_resolution_clock::now();
if (run_tiramisu)
scal(SIZES.raw_buffer(), b_alpha.raw_buffer(), b_X.raw_buffer());
auto end = std::chrono::high_resolution_clock::now();
duration_vector_2.push_back(end - start);
}
}
print_time("performance_cpu.csv", "scal",
{"Ref", "Tiramisu"},
{median(duration_vector_1), median(duration_vector_2)});
if (CHECK_CORRECTNESS && run_ref && run_tiramisu)
compare_buffers("scal", b_X_ref, b_X);
if (PRINT_OUTPUT)
{
std::cout << "Tiramisu " << std::endl;
print_buffer(b_X);
std::cout << "Reference " << std::endl;
print_buffer(b_X_ref);
}
return 0;
}
void walk_down(Btree *bt, int f, DISKOFFSET block,
int level, int mode) {
char *s, *key;
BlockControl *bc;
unsigned offset, keysize, keycount = 0;
DISKOFFSET *pDof;
prefix(level);
if (f == NDX)
fprintf(outfile,
"Level %d index block %ld at offset %ld.",
level, block/index_blksize, block);
else
fprintf(outfile, "Data block %ld at offset %ld.",
block/SIZES(DAT, block_size), block);
if (mode)
fprintf(outfile, "\n");
s = bt_getblock4read(bt, f, block);
if (!s) {
bt->error_code = 7;
return;
}
bc = (BlockControl *) s;
if (mode) {
prefix(level);
fprintf(outfile,
"blockstate: %s, free data: "
"%d, parent: %ld, next: %ld\n",
BlockStates[bc->blockstate],
bc->bfree,
bc->parent,
bc->next);
}
if (f == NDX) {
offset = sizeof(BlockControl);
while (offset < bc->bfree) {
keysize = GETKEYSIZE(s + offset);
key = s + offset;
pDof = (DISKOFFSET *) (key + keysize);
if (mode) {
prefix(level);
fprintf(outfile,
"Offset %d: key '%s', DISKOFFSET %ld\n",
offset, key, *pDof);
}
offset += keysize + sizeof(DISKOFFSET);
keycount++;
}
if (!mode)
fprintf(outfile, " %u entries\n", keycount);
offset = sizeof(BlockControl);
while (offset < bc->bfree) {
keysize = GETKEYSIZE(s + offset);
walk_down(bt,
bc->blockstate == sLeaf ? DAT : NDX,
*((DISKOFFSET *) (s + offset + keysize)),
level + 1, mode);
/* recursive calls may invalidate our buffer */
s = bt_getblock4read(bt, f, block);
bc = (BlockControl *) s;
offset += keysize + sizeof(DISKOFFSET);
}
}
else { /* f == DAT */
offset = sizeof(BlockControl);
while (offset < bc->bfree) {
keysize = GETRECSIZE(s + offset);
if (mode) {
prefix(level);
fprintf(outfile,
"Offset %d: key '%s', name: %s, addr: %s\n",
offset,
((UR *) (s + offset))->key,
((UR *) (s + offset))->name,
((UR *) (s + offset))->addr);
}
offset += keysize;
keycount++;
}
if (!mode)
fprintf(outfile, " %u entries\n", keycount);
}
}
int main(int, char**)
{
std::vector<std::chrono::duration<double,std::milli>> duration_vector_1;
std::vector<std::chrono::duration<double,std::milli>> duration_vector_2;
#if SYNTHETIC_INPUT
Halide::Buffer<uint8_t> im1(10, 10);
Halide::Buffer<uint8_t> im2(10, 10);
for (int i = 0; i < 10; i++)
for (int j = 0; j < 10; j++)
{
im1(i, j) = (uint8_t) i*i+j*j;
im2(i, j) = (uint8_t) i*i+j*j;
}
#else
Halide::Buffer<uint8_t> im1 = Halide::Tools::load_image("./utils/images/rgb.png");
Halide::Buffer<uint8_t> im2 = Halide::Tools::load_image("./utils/images/rgb.png");
#endif
Halide::Buffer<float> Ix_m(im1.width(), im1.height());
Halide::Buffer<float> Iy_m(im1.width(), im1.height());
Halide::Buffer<float> It_m(im1.width(), im1.height());
Halide::Buffer<int> C1(_NC);
Halide::Buffer<int> C2(_NC);
Halide::Buffer<int> SIZES(2);
Halide::Buffer<int> u(_NC);
Halide::Buffer<int> v(_NC);
Halide::Buffer<float> A(2, 4*w*w);
Halide::Buffer<float> tA(4*w*w, 2);
Halide::Buffer<double> pinvA(4*w*w, 2);
Halide::Buffer<double> det(1);
Halide::Buffer<float> tAA(2, 2);
Halide::Buffer<double> X(2, 2);
SIZES(0) = im1.height();
SIZES(1) = im1.width();
C1(0) = 500; C2(0) = 400;
C1(1) = 800; C2(1) = 900;
C1(2) = 200; C2(2) = 400;
C1(3) = 400; C2(3) = 200;
C1(4) = 400; C2(4) = 500;
C1(5) = 800; C2(5) = 200;
C1(6) = 200; C2(6) = 900;
C1(7) = 900; C2(7) = 200;
det(0) = 0;
init_buffer(Ix_m, (float) 0);
init_buffer(Iy_m, (float) 0);
init_buffer(It_m, (float) 0);
init_buffer(A, (float) 0);
init_buffer(tA, (float) 0);
init_buffer(pinvA, (double) 0);
init_buffer(tAA, (float) 0);
init_buffer(X, (double) 0);
// Warm up
optical_flow_tiramisu(SIZES.raw_buffer(), im1.raw_buffer(), im2.raw_buffer(),
Ix_m.raw_buffer(), Iy_m.raw_buffer(), It_m.raw_buffer(),
C1.raw_buffer(), C2.raw_buffer(), u.raw_buffer(), v.raw_buffer(), A.raw_buffer(), pinvA.raw_buffer(), det.raw_buffer(), tAA.raw_buffer(), tA.raw_buffer(), X.raw_buffer());
// Tiramisu
for (int i=0; i<NB_TESTS; i++)
{
auto start1 = std::chrono::high_resolution_clock::now();
optical_flow_tiramisu(SIZES.raw_buffer(), im1.raw_buffer(), im2.raw_buffer(),
Ix_m.raw_buffer(), Iy_m.raw_buffer(), It_m.raw_buffer(),
C1.raw_buffer(), C2.raw_buffer(), u.raw_buffer(), v.raw_buffer(), A.raw_buffer(), pinvA.raw_buffer(), det.raw_buffer(), tAA.raw_buffer(), tA.raw_buffer(), X.raw_buffer());
auto end1 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double,std::milli> duration1 = end1 - start1;
duration_vector_1.push_back(duration1);
}
std::cout << "Time: " << median(duration_vector_1) << std::endl;
#if SYNTHETIC_INPUT
print_buffer(im1);
print_buffer(im2);
print_buffer(Ix_m);
print_buffer(Iy_m);
print_buffer(It_m);
print_buffer(A);
print_buffer(tA);
print_buffer(tAA);
print_buffer(det);
print_buffer(X);
print_buffer(pinvA);
#endif
std::cout << "Output" << std::endl;
print_buffer(u);
print_buffer(v);
return 0;
}
int emsisession(int mode,ftnaddr_t *calladdr,int speed)
{
int rc,emsi_lo=0,proto;
unsigned long nfiles;
unsigned char *mydat;
char *t,pr[3],s[MAX_STRING];
falist_t *pp=NULL;
qitem_t *q=NULL;
was_req=0;got_req=0;
receive_callback=receivecb;
totaln=0;totalf=0;totalm=0;emsi_lo=0;
if(mode) {
write_log("starting outbound EMSI session");
q=q_find(calladdr);
if(q) {
totalm=q->pkts;
totalf=q_sum(q)+q->reqs;
}
mydat=(unsigned char*)emsi_makedat(calladdr,totalm,totalf,O_PUA,cfgs(CFG_PROTORDER),NULL,1);
rc=emsi_send(mode,mydat);xfree(mydat);
if(rc<0)return S_REDIAL|S_ADDTRY;
rc=emsi_recv(mode,rnode);
if(rc<0)return S_REDIAL|S_ADDTRY;
title("Outbound session %s",ftnaddrtoa(&rnode->addrs->addr));
} else {
rc=emsi_recv(mode,rnode);
if(rc<0) {
write_log("unable to establish EMSI session");
return S_REDIAL|S_ADDTRY;
}
write_log("starting inbound EMSI session");
if((t=getenv("CALLER_ID"))&&strcasecmp(t,"none")&&strlen(t)>3)
title("Inbound session %s (CID %s)",ftnaddrtoa(&rnode->addrs->addr),t);
else title("Inbound session %s",ftnaddrtoa(&rnode->addrs->addr));
}
log_rinfo(rnode);
for(pp=rnode->addrs;pp;pp=pp->next)aso_locknode(&pp->addr,LCK_s);
if(mode) {
if(!has_addr(calladdr,rnode->addrs)) {
write_log("remote isn't %s",ftnaddrtoa(calladdr));
return S_FAILURE;
}
flkill(&fl,0);totalf=0;totalm=0;
for(pp=rnode->addrs;pp;pp=pp->next)makeflist(&fl,&pp->addr,mode);
if(strlen(rnode->pwd))rnode->options|=O_PWD;
if(is_listed(rnode->addrs,cfgs(CFG_NLPATH),cfgi(CFG_NEEDALLLISTED)))rnode->options|=O_LST;
} else {
for(pp=cfgal(CFG_ADDRESS);pp;pp=pp->next)
if(has_addr(&pp->addr,rnode->addrs)) {
write_log("remote also has %s",ftnaddrtoa(&pp->addr));
return S_FAILURE;
}
nfiles=0;rc=0;
for(pp=rnode->addrs;pp;pp=pp->next) {
t=findpwd(&pp->addr);
if(!t||!strcasecmp(rnode->pwd,t)) {
makeflist(&fl,&pp->addr,mode);
if(t)rnode->options|=O_PWD;
} else {
write_log("password not matched for %s",ftnaddrtoa(&pp->addr));
write_log(" (got '%s' instead of '%s')",rnode->pwd,t);
rc=1;
}
}
if(!rc&&!(rnode->options&O_PWD))write_log("remote has been password for us");
if(is_listed(rnode->addrs,cfgs(CFG_NLPATH),cfgi(CFG_NEEDALLLISTED)))rnode->options|=O_LST;
if(rc) {
emsi_lo|=O_BAD;
rnode->options|=O_BAD;
}
if(!cfgs(CFG_FREQTIME)||rc)emsi_lo|=O_NRQ;
if(ccs&&!checktimegaps(ccs))emsi_lo|=O_HRQ;
if(checktimegaps(cfgs(CFG_MAILONLY))||
checktimegaps(cfgs(CFG_ZMH))||rc)emsi_lo|=O_HXT|O_HRQ;
if(cfgi(CFG_SENDONLY))emsi_lo|=O_HAT;
pr[2]=0;pr[1]=0;pr[0]=0;
for(t=cfgs(CFG_PROTORDER);*t;t++) {
#ifdef HYDRA8K16K
if(*t=='4'&&rnode->options&P_HYDRA4) {
*pr='4';emsi_lo|=P_HYDRA4;break;}
if(*t=='8'&&rnode->options&P_HYDRA8) {
*pr='8';emsi_lo|=P_HYDRA8;break;}
if(*t=='6'&&rnode->options&P_HYDRA16) {
*pr='6';emsi_lo|=P_HYDRA16;break;}
#endif/*HYDRA8K16K*/
if(*t=='H'&&rnode->options&P_HYDRA) {
*pr='H';emsi_lo|=P_HYDRA;break;}
if(*t=='J'&&rnode->options&P_JANUS) {
*pr='J';emsi_lo|=P_JANUS;break;}
if(*t=='D'&&rnode->options&P_DIRZAP) {
*pr='D';emsi_lo|=P_DIRZAP;break;}
if(*t=='Z'&&rnode->options&P_ZEDZAP) {
*pr='Z';emsi_lo|=P_ZEDZAP;break;}
if(*t=='1'&&rnode->options&P_ZMODEM) {
*pr='1';emsi_lo|=P_ZMODEM;break;}
}
if(strchr(cfgs(CFG_PROTORDER),'C'))pr[1]='C';
else rnode->opt&=~MO_CHAT;
if(!*pr)emsi_lo|=P_NCP;
mydat=(unsigned char*)emsi_makedat(&rnode->addrs->addr,totalm,totalf,emsi_lo,pr,NULL,!(emsi_lo&O_BAD));
rc=emsi_send(0,mydat);xfree(mydat);
if(rc<0) {
flkill(&fl,0);
return S_REDIAL|S_ADDTRY;
}
}
if(cfgs(CFG_RUNONEMSI)&&*ccs) {
write_log("starting %s %s",ccs,rnode->addrs?ftnaddrtoa(&rnode->addrs->addr):(calladdr?ftnaddrtoa(calladdr):"unknown"));
execnowait(ccs,rnode->addrs?ftnaddrtoa(&rnode->addrs->addr):(calladdr?ftnaddrtoa(calladdr):"unknown"),NULL,NULL);
}
write_log("we have: %d%c mail; %d%c files",SIZES(totalm),SIZEC(totalm),SIZES(totalf),SIZEC(totalf));
rnode->starttime=time(NULL);
if(cfgi(CFG_MAXSESSION))alarm(cci*60);
DEBUG(('S',1,"Maxsession: %d",cci));
proto=(mode?rnode->options:emsi_lo)&P_MASK;
switch(proto) {
case P_NCP:
write_log("no compatible protocols");
flkill(&fl,0);
return S_FAILURE;
case P_ZMODEM:
t="ZModem-1k";break;
case P_ZEDZAP:
t="ZedZap";break;
case P_DIRZAP:
t="DirZap";break;
#ifdef HYDRA8K16K
case P_HYDRA4:
t="Hydra-4k";break;
case P_HYDRA8:
t="Hydra-8k";break;
case P_HYDRA16:
t="Hydra-16k";break;
#endif/*HYDRA8K16K*/
case P_HYDRA:
t="Hydra";break;
case P_JANUS:
t="Janus";break;
default:
t="Unknown";
}
DEBUG(('S',1,"emsopts: %s %x %x %x %x",t,rnode->options&P_MASK,rnode->options,emsi_lo,rnode->opt));
snprintf(s,MAX_STRING-1,"%s%s%s%s%s%s%s%s%s%s",t,
(rnode->options&O_LST)?"/LST":"",
(rnode->options&O_PWD)?"/PWD":"",
(rnode->options&O_HXT)?"/MO":"",
(rnode->options&O_HAT)?"/HAT":"",
(rnode->options&O_HRQ)?"/HRQ":"",
(rnode->options&O_NRQ)?"/NRQ":"",
(rnode->options&O_FNC)?"/FNC":"",
(rnode->options&O_BAD)?"/BAD":"",
(rnode->opt&MO_CHAT)?"/CHT":"");
write_log("options: %s",s);
chatinit(proto);
IFPerl(rc=perl_on_session(s);
if(rc!=S_OK){flkill(&fl,0);return rc;});
static void print_boolean(uint8_t indent, const uint8_t *data, uint32_t size)
{
print_field("%*c%s", indent, ' ', data[0] ? "true" : "false");
}
#define SIZES(args...) ((uint8_t[]) { args, 0xff } )
static struct {
uint8_t value;
uint8_t *sizes;
bool recurse;
const char *str;
void (*print) (uint8_t indent, const uint8_t *data, uint32_t size);
} type_table[] = {
{ 0, SIZES(0), false, "Nil" },
{ 1, SIZES(0, 1, 2, 3, 4), false, "Unsigned Integer", print_uint },
{ 2, SIZES(0, 1, 2, 3, 4), false, "Signed Integer", print_sint },
{ 3, SIZES(1, 2, 4), false, "UUID", print_uuid },
{ 4, SIZES(5, 6, 7), false, "String", print_string },
{ 5, SIZES(0), false, "Boolean", print_boolean },
{ 6, SIZES(5, 6, 7), true, "Sequence" },
{ 7, SIZES(5, 6, 7), true, "Alternative" },
{ 8, SIZES(5, 6, 7), false, "URL", print_string },
{ }
};
static struct {
uint8_t index;
uint8_t bits;
uint8_t size;
int main(int, char **)
{
std::vector<std::chrono::duration<double,std::milli>> duration_vector_1;
std::vector<std::chrono::duration<double,std::milli>> duration_vector_2;
float a = 3, b = 3;
Halide::Buffer<int> SIZES(3, "SIZES");
Halide::Buffer<float> alpha(1, "alpha");
Halide::Buffer<float> beta(1, "beta");
Halide::Buffer<float> A(N, K, "A");
Halide::Buffer<float> B(K, M, "B");
Halide::Buffer<float> C(N, M, "C");
Halide::Buffer<float> C_openblas(N, M, "C_openblas");
SIZES(0) = N; SIZES(1) = M; SIZES(2) = K;
alpha(0) = a; beta(0) = b;
init_buffer(A, (float)1);
init_buffer(B, (float)1);
init_buffer(C, (float)1);
init_buffer(C_openblas, (float)1);
// Calling OpenBLAS
{
long long int lda, ldb, ldc;
long long int rmaxa, cmaxa, rmaxb, cmaxb, rmaxc, cmaxc;
long long int ma, na, mb, nb;
rmaxa = M + 1;
cmaxa = K;
ma = M;
na = K;
rmaxb = K + 1;
cmaxb = N;
mb = K;
nb = N;
rmaxc = M + 1;
cmaxc = N;
lda=cmaxa;
ldb=cmaxb;
ldc=cmaxc;
for (int i = 0; i < NB_TESTS; i++)
{
init_buffer(C_openblas, (float)1);
auto start1 = std::chrono::high_resolution_clock::now();
cblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, M, N, K, a, (float *) A.raw_buffer()->host, lda, (float *) B.raw_buffer()->host, ldb, b, (float *) C_openblas.raw_buffer()->host, ldc);
auto end1 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double,std::milli> duration1 = end1 - start1;
duration_vector_1.push_back(duration1);
}
}
for (int i = 0; i < NB_TESTS; i++)
{
init_buffer(C, (float)1);
auto start2 = std::chrono::high_resolution_clock::now();
//halide_sgemm_notrans(a, A.raw_buffer(), B.raw_buffer(), b, C.raw_buffer(), C.raw_buffer());
//sgemm_halide(alpha.raw_buffer(), beta.raw_buffer(), A.raw_buffer(), B.raw_buffer(), C.raw_buffer());
auto end2 = std::chrono::high_resolution_clock::now();
std::chrono::duration<double,std::milli> duration2 = end2 - start2;
duration_vector_2.push_back(duration2);
}
print_time("performance_CPU.csv", "sgemm",
{"OpenBLAS", "Halide"},
{median(duration_vector_1), median(duration_vector_2)});
// if (CHECK_CORRECTNESS)
// compare_buffers("sgemm", C, C_openblas);
if (PRINT_OUTPUT)
{
std::cout << "Halide sgemm " << std::endl;
print_buffer(C);
std::cout << "OpenBLAS sgemm " << std::endl;
print_buffer(C_openblas);
}
return 0;
}
