// Test if values persist accross transactions
int test_general_2(Thread * Self) {
int num_items=10;
int res1;
printf("Testing if values persist across transactions.\n");
TxStart (Self, 0) ;
board_set(Self,num_items,15);
if(!TXCOMMIT(Self)) {
assert(0);
}
TxStart (Self, 0) ;
res1=board_check(Self,num_items,15);
if(!TXCOMMIT(Self)) {
assert(0);
}
assert(res1);
TxStart (Self, 0) ;
board_set(Self,num_items,16);
board_set(Self,num_items,17);
if(!TXCOMMIT(Self)) {
assert(0);
}
TxStart (Self, 0) ;
res1=board_check(Self,num_items,17);
if(!TXCOMMIT(Self)) {
assert(0);
}
assert(res1);
return 0;
}
// Test for WS overflow
int test_overflow_2(Thread * Self) {
int num_items=400;
int i=0;
for(;;) {
TxStart (Self, 0) ;
printf("start\n");
for(i=0;i<num_items;i++) {
TXSTV(dboard[i],i);
}
printf("going to commit\n");
if(TXCOMMIT(Self)) {
printf("commited\n");
break;
}
}
TxStart (Self, 0) ;
for(i=0;i<num_items;i++) {
assert(TXLDV(dboard[i])==i);
}
if(!TXCOMMIT(Self)) {
assert(0);
}
return 0;
}
// Test local undo
int test_general_3(Thread * Self) {
intptr_t LocalVar = 0;
printf("Test local undo.\n");
TxStart (Self, 0) ;
TXSTV(LocalVar,1);
//TxStore(Self,&LocalVar,1);
//printf("LocalVar= %d\n", TXLDV(LocalVar));
//TxStoreLocal(Self, &LocalVar,1);
assert(TXLDV(LocalVar)==1);
if(!TXCOMMIT(Self)) {
assert(0);
}
assert(LocalVar==1);
TxStart (Self, 0) ;
TXSTV(LocalVar,2);
//TxStoreLocal(Self, &LocalVar,2);
assert(TXLDV(LocalVar)==2);
TXSTV(LocalVar,3);
//TxStoreLocal(Self, &LocalVar,3);
assert(TXLDV(LocalVar)==3);
if(!TXCOMMIT(Self)) {
assert(0);
}
assert(LocalVar==3);
return 0;
}
//test TxSterilize with segfault on sub tx
int test_sterilize_3(Thread * Self) {
// pointer to real value
qwe_thr = (int*)malloc(sizeof(int));
*qwe_thr=1;
//pointer to real value
ptr_qwe_thr = (int**)malloc(sizeof(int));
*ptr_qwe_thr=qwe_thr;
qwe_thr=NULL;
int *qwe,** ptr_qwe;
int val;
volatile int count=0;
count=0;
// ------------------------------------
// start main TXN
TxStart (Self, 0) ;
// ------------------------------------
// start main TXN
TxStart (Self, 0) ;
count++;
printf("startin with count = %d\n", count);
ptr_qwe = (int**)TXLDV(ptr_qwe_thr);
if(ptr_qwe==NULL) {
assert(count==2);
TxAbort(Self,0);
TxAbort(Self,0);
return 1;
}
assert(count==1);
//----------------------
pthread_t thr_a;
pthread_create(&thr_a,NULL,test_sterilize_3_collision,(void*)&count);
pthread_join(thr_a,NULL);
//----------------------
qwe = (int*)TxLoad(Self, (intptr_t *)ptr_qwe_thr);
val = (int) TxLoad(Self, (intptr_t *)qwe);
assert(0);
printf("starting commit with count = %d\n", count);
TXCOMMIT(Self);
printf("finished commit with count = %d\n", count);
TXCOMMIT(Self);
return 1;
}
// 1 nested tx
int test_subtx_1(Thread * Self) {
int val0;
int val1;
int val2;
dboard[0]=0;
dboard[1]=0;
dboard[2]=0;
// ------------------------------------
// start main TXN
TxStart (Self, 0) ;
TXSTV(dboard[1],1);
val0 = TXLDV(dboard[0]);
assert(val0==0);
val1 = TXLDV(dboard[1]);
assert(val1==1);
val2 = TXLDV(dboard[2]);
assert(val2==0);
// ------------------------------------
// start sub TXN
TxStart (Self, 0) ;
TXSTV(dboard[2],1);
val0 = TXLDV(dboard[0]);
assert(val0==0);
val1 = TXLDV(dboard[1]);
assert(val1==1);
val2 = TXLDV(dboard[2]);
assert(val2==1);
TXCOMMIT(Self);
// end sub TXN ------------------------
val0 = TXLDV(dboard[0]);
assert(val0==0);
val1 = TXLDV(dboard[1]);
assert(val1==1);
val2 = TXLDV(dboard[2]);
assert(val2==1);
TXCOMMIT(Self);
val0 = dboard[0];
assert(val0==0);
val1 = dboard[1];
assert(val1==1);
val2 = dboard[2];
assert(val2==1);
return 1;
}
// 2 TX nested in 1 tx
int test_subtx_2(Thread * Self) {
int val;
dboard[0]=0;
// ------------------------------------
// start main TXN
TxStart (Self, 0) ;
TXSTV(dboard[0],1);
val = TXLDV(dboard[0]);
assert(val==1);
// start sub TXN
TxStart (Self, 0) ;
TXSTV(dboard[0],1);
val = TXLDV(dboard[0]);
assert(val==1);
TXCOMMIT(Self);
// end sub TXN ------------------------
val = TXLDV(dboard[0]);
assert(val==1);
// ------------------------------------
// start sub TXN
TxStart (Self, 0) ;
val = TXLDV(dboard[0]);
assert(val==1);
TXSTV(dboard[0],2);
val = TXLDV(dboard[0]);
assert(val==2);
TXCOMMIT(Self);
// end sub TXN ------------------------
val = TXLDV(dboard[0]);
assert(val==2);
TXCOMMIT(Self);
val = dboard[0];
assert(val==2);
return 1;
}
//test TxSterilize
int test_sterilize_1(Thread * Self) {
// pointer to real value
qwe_thr = (int*)malloc(sizeof(int));
*qwe_thr=1;
int qwe,* ptr_qwe;
volatile int count=0;
// ------------------------------------
// start main TXN
TxStart (Self, 0) ;
count++;
printf("startin with count = %d\n", count);
ptr_qwe = (int*)TXLDV(qwe_thr);
//----------------------
pthread_t thr_a;
pthread_create(&thr_a,NULL,test_sterilize_1_collision,(void*)&count);
pthread_join(thr_a,NULL);
if(ptr_qwe!=NULL) {
qwe = TXLDA((uintptr_t)ptr_qwe); // it will abort and retry
//assert(0); // if we reach here -> TX is inconsistent
assert(!TxValid(Self));
} else {
assert(count==2);
}
TXCOMMIT(Self);
return 1;
}
void * test_sterilize_2_collision(void * count) {
int ** to_release1 = NULL;
int * to_release2 = NULL;
if(*(int*)count==1) {
printf("provoking colision - started\n");
Thread * Self2;
Self2 = TxNewThread () ;
// ------------------------------------
// start main TXN
TxStart(Self2, 0) ;
to_release1 = (int**)TxLoad(Self2,(intptr_t *)&ptr_qwe_thr);
to_release2 = (int*)TxLoad(Self2,(intptr_t *)ptr_qwe_thr);
TxStore(Self2, (intptr_t *)(&ptr_qwe_thr), (uintptr_t) NULL);
TXCOMMIT(Self2);
TxSterilize(Self2,to_release1,1);
TxSterilize(Self2,to_release2,1);
*to_release2=100;
free(to_release2);
*to_release1=(int*)0xBAD;
free(to_release1);
TxEndThread(Self2);
printf("provoking colision - finished\n");
}
return NULL;
}
int cs8900_xmit(struct sk_buff *skb, struct net_device *dev)
{
volatile u16 status;
spin_lock_irq(&mylock);
netif_stop_queue(dev);
cs8900_write(dev, PP_TxCMD, TxStart(After5));
cs8900_write(dev, PP_TxLength, skb->len);
status = cs8900_read(dev, PP_BusST);
if((status & TxBidErr))
{
spin_unlock_irq(&mylock);
printk("invalid data length!\n");
return 0;
}
if(!(status & Rdy4TxNOW))
{
spin_unlock_irq(&mylock);
printk("tx buffer is not free!\n");
return 0;
}
cs8900_frame_write(dev, skb);
spin_unlock_irq(&mylock);
dev_kfree_skb(skb);
return 0;
}
// OBJSTM with simple tx
int test_objstm_1(Thread * Self) {
int res1, res2, res3;
obj1.a=0;
obj1.b=0;
obj1.c=0;
TxStart (Self, 0) ;
TxOpenReadENC(Self,&dboard[0]);
res1=obj1.a;
res2=obj1.b;
res3=obj1.c;
assert(res1==0 &&res2==0&&res3==0);
TxOpenWriteENC(Self, &obj1,sizeof(obj_t));
obj1.b=1;
obj1.c=2;
if(!TXCOMMIT(Self)) {
assert(0);
}
assert(obj1.a==0 && obj1.b==1 && obj1.c==2);
return 1;
}
// Test tx colision t1:W - t2:R
int test_general_6(Thread * Self) {
int count=0;
dboard[0]=0;
printf("T1 - W(a) T2 - R(a)\n");
for(;;) {
TxStart (Self, 0) ;
count++;
printf("starting tx witch count=%d\n",count);
TXSTV(dboard[0], 1);
//----------------------
pthread_t thr_a;
pthread_create(&thr_a,NULL,test_general_6_collision,(void*)&count);
//----------------------
sched_yield();
usleep(100000);
usleep(100000);
sched_yield();
TXSTV(dboard[0], 2);
if(TXCOMMIT(Self)) {
pthread_join(thr_a,NULL);
break;
}
}
assert(count==1);
return 0;
}
// Test tx colision T1:Ra - T2:Wa - T1:Wa
int test_general_5(Thread * Self) {
int res1;
int count=0;
printf("Provoking Collision - T1-R(a) - T2 - W(a) - T3 - W(a)\n");
for(;;) {
TxStart (Self, 0) ;
count++;
printf("starting tx witch count=%d\n",count);
res1=TXLDV(dboard[0]);
//----------------------
pthread_t thr_a;
pthread_create(&thr_a,NULL,test_general_5_collision,(void*)&count);
pthread_join(thr_a,NULL);
//----------------------
TXSTV(dboard[0],res1+1);
printf("going to commit tx witch count=%d\n",count);
if(TXCOMMIT(Self)) {
assert(count==2);
break;
}
}
assert(dboard[0]==res1+1&&res1==100);
return 0;
}
// Test abort - with retry (local variables)
int test_abort_2(Thread * Self) {
int val;
volatile int count;
intptr_t LocalVar=0;
count=0;
dboard[0]=0;
// start TXN
TxStart (Self, 0) ;
count++;
//TxStoreLocal(Self, &LocalVar,count);
TXSTV(dboard[0],count);
if(count==1) {
printf("aborted with count = %d\n", count);
TxAbort(Self, 1);
} else {
TXCOMMIT(Self);
printf("commited with count = %d\n", count);
}
// end TXN
val = dboard[0];
assert(val==2);
//assert(LocalVar==2);
return 0;
}
// sub tx abort(retry=0) - main tx abort(retry=1)
int test_subtx_6(Thread * Self) {
int val;
volatile int countA=0;
volatile int countB=0;
// ------------------------------------
// start main TXN 2
TxStart (Self, 0) ;
printf("starting main tx 2\n");
countA++;
assert(countA<=2);
assert(countB<=1);
// ------------------------------------
// start sub TXN 2-1
TxStart (Self, 0) ;
printf("starting sub tx 2-1\n");
countB++;
assert((countB==1 && countA==1) || (countB==2 && countA==2));
TXSTV(dboard[0],0);
printf("aborted with countB = %d\n", countB);
TxAbort(Self, 0);
// end sub TXN ------------------------
val = TXLDV(dboard[0]);
assert(val==0);
if(countA==1) {
assert(countB==1);
TxAbort(Self, 1);
} else if(countA==2) {
assert(countB==2);
TxAbort(Self, 0);
} else {
assert(0);
}
val = dboard[0];
assert(val==0);
return 1;
}
// RO transaction
int test_general_4(Thread * Self) {
int num_items=10;
printf("Writing and reading. two different transactions.");
TxStart (Self, 0) ;
board_set(Self,num_items,52);
TXCOMMIT(Self);
TxStart (Self, 1) ;
board_check(Self,num_items,52);
TXCOMMIT(Self);
// TxStart (Self, 1) ;
// board_set(Self,num_items,52);
// TXCOMMIT(Self);
return 0;
}
// Test abort - without retry (global variables)
int test_abort_1(Thread * Self) {
intptr_t num_items=10;
TxStart (Self, 0) ;
board_set(Self,num_items,52);
board_check(Self,num_items,52);
TXCOMMIT(Self);
TxStart (Self, 0) ;
board_set(Self,num_items,53);
board_check(Self,num_items,53);
TxAbort(Self, 0);
TxStart (Self, 0) ;
board_check(Self,num_items,52);
TXCOMMIT(Self);
return 0;
}
// main tx commit
// sub tx abort(retry=1)
int test_subtx_4(Thread * Self) {
int val;
volatile int countA=0;
volatile int countB=0;
dboard[0]=0;
// ------------------------------------
// start main TXN
TxStart (Self, 0) ;
printf("starting main tx\n");
countA++;
assert(countA<=1);
assert(countB==0);
// ------------------------------------
// start sub TXN
TxStart (Self, 0) ;
printf("starting sub tx\n");
countB++;
TXSTV(dboard[0],countB);
if(countB==1) {
printf("aborted with countB = %d\n", countB);
TxAbort(Self, 1);
} else {
TXCOMMIT(Self);
printf("commited with countB = %d\n", countB);
}
// end sub TXN ------------------------
val = TXLDV(dboard[0]);
assert(val==2);
TXCOMMIT(Self);
val = dboard[0];
assert(val==2);
return 1;
}
// Test abort - without retry (local variables)
int test_abort_3(Thread * Self) {
intptr_t LocalVar = 1;
TxStart (Self, 0) ;
//TxStoreLocal(Self, &LocalVar,2);
TxStore(Self,&LocalVar,2);
assert(TXLDV(LocalVar)==2);
TxAbort(Self, 0);
assert(LocalVar==1);
TxStart (Self, 0) ;
//TxStoreLocal(Self, &LocalVar,10);
TxStore(Self,&LocalVar,10);
assert(TXLDV(LocalVar)==10);
//TxStoreLocal(Self, &LocalVar,11);
TxStore(Self,&LocalVar,11);
assert(TXLDV(LocalVar)==11);
TxAbort(Self, 0);
assert(LocalVar==1);
return 0;
}
// Test for RS and WS overflow
int test_overflow_3(Thread * Self) {
int i;
int num_items=800;
int res1=1;
for(;;) {
res1=1;
TxStart (Self, 0) ;
for(i=0;i<num_items;i++) {
TXSTV(dboard[i],100+i);
int val2 = TXLDV(dboard[i]);
if(val2!=(100+i))
res1=0;
}
if(TXCOMMIT(Self)) {
break;
}
}
assert(res1);
for(;;) {
res1=1;
TxStart (Self, 0) ;
for(i=0;i<num_items;i++) {
int val1 = TXLDV(dboard[i]);
if(val1!=(100+i))
res1=0;
}
if(TXCOMMIT(Self)) {
break;
}
}
assert(res1);
return 0;
}
void * test_subtx_8_collision(void * countA) {
if(*(int*)countA==1) {
printf("provoking colision - started\n");
Thread * Self2;
Self2 = TxNewThread () ;
// ------------------------------------
// start main TXN
TxStart (Self2, 0) ;
TxStore(Self2, &(dboard[0]), 100);
TXCOMMIT(Self2);
TxEndThread(Self2);
printf("provoking colision - finished\n");
}
return NULL;
}
// Test for RS overflow
int test_overflow_1(Thread * Self) {
int num_items=400;
int i=0;
for(;;) {
TxStart (Self, 0) ;
for(i=0;i<num_items;i++) {
TXLDV(dboard[i]);
}
if(TXCOMMIT(Self)) {
break;
}
}
return 0;
}
void * test_general_5_collision(void * count) {
if(*(int*)count==1) {
printf("provoking colision - started\n");
Thread * Self2;
Self2 = TxNewThread () ;
// ------------------------------------
// start main TXN
TxStart (Self2, 0) ;
TxStore(Self2, &(dboard[0]), 100);
TXCOMMIT(Self2);
TxEndThread(Self2);
printf("provoking colision - finished\n");
}
printf("Antes do NULL\n");
return NULL;
printf("Depois do NULL\n");
}
void * test_general_6_collision(void * count) {
if(*(int*)count==1) {
printf("provoking colision - started\n");
Thread * Self2;
Self2 = TxNewThread () ;
// ------------------------------------
// start main TXN
TxStart (Self2, 0) ;
int res1 = TxLoad(Self2, &(dboard[0]));
int res2 = TXCOMMIT(Self2);
printf("res=%d\n",res1);
assert(!res2 || res1==0 || res1==2);
TxEndThread(Self2);
printf("provoking colision - finished\n");
}
return NULL;
}
void * test_objstm_3_collision(void * count) {
if(*(int*)count==1) {
printf("provoking colision - started\n");
Thread * Self2;
Self2 = TxNewThread () ;
// ------------------------------------
// start main TXN
TxStart (Self2, 0) ;
TxOpenWriteENC(Self2, &obj1, sizeof(obj_t));
obj1.a=100;
obj1.b=101;
obj1.c=102;
TXCOMMIT(Self2);
TxEndThread(Self2);
printf("provoking colision - finished\n");
}
return NULL;
}
// Test if values persist within the same transaction
int test_general_1(Thread * Self) {
int num_items=10;
int res1,res2;
printf("Testing if values persist within same Transaction\n");
// test 1
TxStart (Self, 0) ;
board_set(Self,num_items,12);
res1=board_check(Self,num_items,12);
board_set(Self,num_items,13);
res2=board_check(Self,num_items,13);
if(!TXCOMMIT(Self)) {
assert(0);
}
assert(res1);
assert(res2);
return 0;
}
static int cirrus_send_start (struct sk_buff *skb,struct net_device *dev)
{
cirrus_t *priv = (cirrus_t *) dev->priv;
u16 status;
mdelay(10);
netif_stop_queue (dev);
cirrus_write (dev,PP_TxCMD,TxStart (After5));
cirrus_write (dev,PP_TxLength,skb->len);
status = cirrus_read (dev,PP_BusST);
if ((status & TxBidErr)) {
printk (KERN_WARNING "%s: Invalid frame size %d!\n",dev->name,skb->len);
priv->stats.tx_errors++;
priv->stats.tx_aborted_errors++;
priv->txlen = 0;
return (1);
}
if (!(status & Rdy4TxNOW)) {
//printk (KERN_WARNING "%s: Transmit buffer not free!\n",dev->name);
priv->stats.tx_errors++;
priv->txlen = 0;
/* FIXME: store skb and send it in interrupt handler */
return (1);
}
cirrus_frame_write (dev,skb);
dev->trans_start = jiffies;
dev_kfree_skb (skb);
priv->txlen = skb->len;
return (0);
}
//objstm with colision
int test_objstm_3(Thread * Self) {
int count=0;
//int res1, res2, res3;
obj1.a=0;
obj1.b=0;
obj1.c=0;
for(;;) {
TxStart (Self, 0) ;
count++;
printf("starting tx witch count=%d\n",count);
TxOpenReadENC(Self, &obj1);
if(count==1) {
assert(obj1.a==0 && obj1.b==0 && obj1.c==0);
} else if(count==2) {
assert(obj1.a==100 && obj1.b==101 && obj1.c==102);
} else {
assert(0);
}
//----------------------
pthread_t thr_a;
pthread_create(&thr_a,NULL,test_objstm_3_collision,(void*)&count);
pthread_join(thr_a,NULL);
//----------------------
assert(obj1.a==100 && obj1.b==101 && obj1.c==102);
printf("going to commit tx witch count=%d\n",count);
if(TXCOMMIT(Self)) {
assert(count==2);
break;
}
}
assert(obj1.a==100 && obj1.b==101 && obj1.c==102);
return 1;
}
// OBJSTM with tx abort
int test_objstm_2(Thread * Self) {
int res1, res2, res3;
obj1.a=0;
obj1.b=0;
obj1.c=0;
TxStart (Self, 0) ;
TxOpenReadENC(Self,&obj1);
res1=obj1.a;
res2=obj1.b;
res3=obj1.c;
assert(res1==0 &&res2==0&&res3==0);
TxOpenWriteENC(Self, &obj1, sizeof(obj_t));
obj1.b=1;
obj1.c=2;
TxAbort(Self, 0);
assert(obj1.a==0 && obj1.b==0 && obj1.c==0);
return 1;
}
// simulate rs not coherent within subtx
int test_subtx_8(Thread * Self) {
int val;
volatile int countA=0;
volatile int countB=0;
dboard[0]=0;
// ------------------------------------
// start main TXN
for(;;) {
TxStart (Self, 0) ;
printf("starting main tx with countA=%d and countB=%d\n", countA, countB);
countA++;
assert(countA<=2);
// ------------------------------------
// start sub TXN
TxStart (Self, 0) ;
printf("starting sub tx with countA=%d and countB=%d\n", countA, countB);
countB++;
assert((countB==1 && countA==1) || (countB==2 && countA==2));
TXLDV(dboard[0]);
TXSTV(dboard[0],1);
//----------------------
pthread_t thr_a;
pthread_create(&thr_a,NULL,test_subtx_8_collision,(void*)&countA);
sched_yield();//ensure the other thread got the chance to colide
sched_yield();//ensure the other thread got the chance to colide
usleep(100000);
sched_yield();//ensure the other thread got the chance to colide
sched_yield();//ensure the other thread got the chance to colide
//----------------------
printf("starting sub tx commit with countA=%d and countB=%d\n", countA, countB);
if(!TXCOMMIT(Self)) {
assert(countB==1);
}
// end sub TXN ------------------------
val = TXLDV(dboard[0]);
//assert(val==1);
printf("starting main tx commit with countA=%d and countB=%d\n", countA, countB);
if(TXCOMMIT(Self)) {
pthread_join(thr_a,NULL);
break;
}
}
//a==1 && b==1 on enc
//a==1 && b==1 on cmt
assert((countB==1 && countA==1) || (countB==2 && countA==2));
val = dboard[0];
assert(val==1||val==100);
return 1;
}