void main()
{
	int lck1=1, lck2=2, lck3=3;
													Print("\n Checking Wrong Working of Releaseing of Locks. \n\0",1,1,1);

	lck1 = CreateLock("lock1", 5);					Print("\n lck1 Has Been Created in testCase_4. \n\0",1,1,1);
	lck2 = CreateLock("lock2", 5);					Print("\n lck2 Has Been Created in testCase_4. \n\0",1,1,1);

	Acquire(lck1);									Print("\n lck1 Has Been Acquired in testCase_4. \n\0",1,1,1);
	Acquire(lck2);									Print("\n lck2 Has Been Acquired in testCase_4. \n\0",1,1,1);

	Release(lck1);									Print("\n lck1 Has Been Released in testCase_4. \n\0",1,1,1);
	Release(lck2);									Print("\n lck2 Has Been Released in testCase_4. \n\0",1,1,1);

													Print("\n Error Should Print That lck3 Does Not Exist. \n\0",1,1,1);
	Release(lck3);							

	DeleteLock(lck1);								Print("\n lck1 Has Been Deleted in testCase_4. \n\0",1,1,1);
	DeleteLock(lck2);								Print("\n lck2 Has Been Deleted in testCase_4. \n\0",1,1,1);
	
	Exit(0);
}
Exemple #2
0
int main() {
  Write("Test 5 creates lock and cv\n", sizeof("Test 5 creates lock and cv\n"), ConsoleOutput);
  lock = CreateLock("lock", sizeof("lock"));
  cv = CreateCV("cv", sizeof("cv"));

  for (i = 0; i < 50000; i++) {
    Yield();
  }

  Write("Test 5 destroys lock and cv\n", sizeof("Test 5 destroys lock and cv\n"), ConsoleOutput);
  DestroyLock(lock);
  DestroyCV(cv);
}
Exemple #3
0
void t1_t1(){
    
    /*checks destroy and create invalid input is handled properly*/
    indexcheck1= CreateLock("abc", -1);
    indexcheck2=DestroyLock(indexcheck1+100);
    indexcheck3=DestroyLock(-100);
    if (indexcheck1==-1 && indexcheck2==-1 && indexcheck3==-1){
        Write("passed: create/destroyLOCK validates input\n", sizeof("passed: create/destroyLOCK validates input\n"), 1);
    }
    else{
        Write("failed: create/destroyLOCK validates input\n", sizeof("failed: create/destroyLOCK validates input\n"), 1);
    }
}
Exemple #4
0
void main()
{
	count =0;

	a = CreateLock("lock1",5);
	b = CreateCV("cond1",5);

	Fork(thread1);
	Fork(thread2);
	Yield();
	Yield();
	Yield();
}
Exemple #5
0
void main()
 {

	a = CreateLock("lock1",5);
	b = CreateCV("cond1",5);

	count =0;

	for( j=0;j<105;j++)
	{
		Fork(thread1);
	}
}
CTrMirrorBuffer::CTrMirrorBuffer(uint32 uDataSize, uint32 uDataNum)
{
	CreateLock(&m_Lock);

	m_pRBPatchMgr = new CMirrorRBPatchMgr;
	m_pWBPatchMgr = new CMirrorWBPatchMgr;

	m_pDiscardedCmdMgr = new CTrDiscardedCmdMgr;

	CreateTripleBuffer(uDataSize, uDataNum);

	m_pWriteBuffer->SetVersion(1);  //首先就把write的版本设置为1
}
void main()
{

	lock = CreateLock("lock");
	

	AcquireLock("lock");
	
	Print("Client 1 has the lock..",-1,-1,-1);
	ReleaseLock("lock");
	
	Exit(0);
}
void client2()
{ 
 int Lock1,CV1;
 
 Lock1=CreateLock("USERLOCK",8);
 CV1=CreateCondition("USERCV",6);
 

 
  Acquire(Lock1);
  Signal(CV1,Lock1);
  Release(Lock1);
 
}
void lockcvdestroytest()
{
    int lockd,cvd;

    lockd=CreateLock("lockd",5);
    cvd=CreateCondition("cvd",3);

    Print("Please press any number after you run client 2, for successfull deletion of the lock and cv\n");
    Scan("%d");
    DestroyLock(lockd);
    DestroyCondition(cvd);


}
/*client 1 functions show the proper functioning of signal and wait calls*/
void client1()
{

    int Lock1,CV1,CV2;
    Lock1=CreateLock("USERLOCK",8);
    CV1=CreateCondition("USERCV",6);



    Acquire(Lock1);
    Wait(CV1,Lock1);
    Release(Lock1);

}
Exemple #11
0
int main()
{
	int lock;
	int cv;
	
	cv= CreateCV("lock",4);
	lock= CreateLock("cv",2);
	
	AcquireLock(lock);
	WaitCV(lock,cv);
	ReleaseLock(lock);
	
	Exit(0);
}
Exemple #12
0
int main()
{
	Write("\n\n Test Suite 2\n\n (bracketed terms denote the testsuites)\n\n",100,1);
	Write("\n[2] Execing testsuite2_1\n",100,1);
	i = Exec("../test/testsuite2_1",20);
	Write("\n[2] Execing testsuite2_2\n",100,1);
	i = Exec("../test/testsuite2_2",20); 
	visitorCountLock = CreateLock("vclock",6);
	for(i=0;i<MAX;i++)
	{
		Fork(TestFunc);
	}
	Exit(0);
}
Exemple #13
0
int test()
{
	int int2=0;
	for (int2=0;int2<550;int2++)
		{	
			i=CreateLock("locksTesting");
			AcquireLock(i);
			ReleaseLock(i);
			Print("New loop is %d\n",int2,-1,-1);
			if (int2 % 10 == 0) 
				DestroyLock(i);
		}
	Exit(0);		
}
Exemple #14
0
main() {

int w = CreateLock("lock_test");
Acquire(w);
Release(w);

if(w>=0){
	Write(" Testing lock creation...Pass\n" , 50, ConsoleOutput );
 }
else {
	Write(" Testing lock creation...Fail\n" , 50, ConsoleOutput );
}


       }
Exemple #15
0
int
main(){
	lockid = CreateLock("LOCK1", 5);
	initlock = CreateLock("LOCK2", 5);
	condid = CreateCondition("COND1", 5);
	initcond = CreateCondition("COND2", 5);

	Write( "test4\n", 6, ConsoleOutput );
	Acquire(initlock);
	Fork(waiter);
	Wait(initcond, initlock);

	Fork(signaller);
	while(i != 2){
		Wait(initcond, initlock);
	}
	Release(initlock);

	DestroyLock(lockid);
	DestroyLock(initlock);
	DestroyCondition(condid);
	DestroyCondition(initcond);
	Exit(0);
}
Exemple #16
0
void initScreeningOfficers() {
	int i;
	NumActiveScreeningOfficers = 0;
	#define officer ScreeningOfficers[i]
	for (i = 0; i < NUM_SCREENING_OFFICERS; ++i) {
		officer._lock = CreateLock(concatNumToString("officer_lock_", sizeof("officer_lock_"), i), 14);
    	officer._commCV = CreateCV(concatNumToString("officer_commCV_", sizeof("officer_commCV_"), i), 20);
    	officer._state = BUSY; 
    	officer._passCount = 0;
    	officer._currentPassenger = -1;
    	officer._myNum = i;
    	officer._done = false;
	}
	#undef officer
}
Exemple #17
0
int main() {
  lock1 = CreateLock("Lock1", 5, 0);
	lock2 = CreateLock("Lock2", 5, 0);
	deadLock1 = CreateLock("deadLock1", 9, 0);
	deadLock2 = CreateLock("deadLock2", 9, 0);
	lockToBeDestroyed = CreateLock("lockToBeDestroyed", 17, 0);

  theLockThatDoesntExist = lock1+10;
	Write("Testing invalid actions for locks\n", 34, ConsoleOutput);
	Write("Acquiring theLockThatDoesntExist, should give error\n", 52, ConsoleOutput);
	Acquire(theLockThatDoesntExist);
	Write("Releasing theLockThatDoesntExist, should give error\n", 52, ConsoleOutput);
	Release(theLockThatDoesntExist);
	Write("Destroying theLockThatDoesntExist, should give error\n", 53, ConsoleOutput);
	DestroyLock(theLockThatDoesntExist);
	Write("Destroying lockToBeDestroyed, should be successful\n", 51, ConsoleOutput);
	DestroyLock(lockToBeDestroyed);
	/*Write("Reacquiring lockToBeDestroyed, should give error\n", 49, ConsoleOutput);
	Acquire(lockToBeDestroyed);*/
	Fork(t1,0);
  Fork(t2,0);
	/*Write("Testing Locks\n", 14, ConsoleOutput)
	lockNum = CreateLock("nameLock");
	Acquire(lockNum);
	condNum = CreateCondition("someCondition");
	Signal(lockNum, condNum);
	Broadcast(lockNum, condNum);
	Release(lockNum);
	DestroyLock(lockNum);
	Write("Locks complete\n", 15, ConsoleOutput);
	Exec("../test/halt");
	Exec("../test/halt");
	*/
	Write("Finshing lockfiles.c\n", 22, ConsoleOutput);
	Exit(0);
}
Exemple #18
0
int main()
{
    int cv1=0;
    int l1=CreateLock();
    Write("\n Running cvtest5.c\n",22,1);
    Write("\nTESTING: CVTEST5.C TRIES TO ACCESS THE CV NOT CREATED BY IT",60,1);
    Exec("../test/cvtest1",15);
    Yield();
    Yield();
    Yield();
    WaitCondition(cv1,l1);
    SignalCondition(cv1,l1);
    BroadcastCondition(cv1,l1);
    Exit(0);
}
Exemple #19
0
int main()
{
	int lock1;
	unsigned int i=0;
	Write("\n Running locktest1.c\n",22,1);
	for(i=0;i<67000;i++)
	{
		lock1=CreateLock();
			if(lock1==-1)
			{
				break;
			}
	}
	Exit(0);
}
Exemple #20
0
/*
 * this will initialize the locks and condition variables that we created for each queues, manager, ticker clerks, concession clerks, tikcet takers, customers
 * */
void initializeAllLocks(int debugId)
{
	int i,j;
	i=0, j=0; /*char *lockName;*/

	for(i=(cc_number * 2) ; i <= (cc_number * 2) + 1; i++)
	{ /*we start with the customers and create locks and CVs for them*/
		j=0;
		{
			custLock[i][j]=mtCb.custGrp[i].cust[j].name;
			CreateLock(mtCb.custGrp[i].cust[j].name);
			custCondVar[i][j]=mtCb.custGrp[i].cust[j].name;
			CreateCV(mtCb.custGrp[i].cust[j].name);
		}
	}

	{/* locks and CVs for concession clerks */

		ccLock[cc_number]=mtCb.cc[cc_number].name;
		CreateLock(mtCb.cc[cc_number].name);
		ccCondVar[cc_number]=mtCb.cc[cc_number].name;
		CreateCV(mtCb.cc[cc_number].name);
	}
}
Exemple #21
0
void main()
{




	 a = CreateLock("lock1",5);
	 b = CreateCV("cond1",5);

	 Fork(thread1);
	 	Fork(thread2);
	 	Fork(thread3);
	 	Fork(thread4);

}
Exemple #22
0
void main()
{
	count =0;

	a = CreateLock("lock1",5);
		b=a+2;

	Fork(thread1);


	Yield();



}
Exemple #23
0
CMemThreadMgr::CMemThreadMgr()
{
	m_bEndThreads=false;
	m_bHandleJobDone=true;
	m_pThread=NULL;

	CreateSemaphore(&m_smJobQueue,0,INT_MAX);
	CreateSemaphore(&m_smFetchSymbol, 0, INT_MAX);

	CreateLock(&m_slkJobQueue);
	
	m_pThread = new CMemThread(this);

	Ast(! gs_pInst);
	gs_pInst=this;
}
Exemple #24
0
void main()
{
    Print("\nTest2 is for waiting and signaling condition variable.\n", sizeof("\nTest2 is for waiting and signaling condition variable.\n")/sizeof(char), 0, 0);
     l1 = CreateLock("l1", 2);
     c1 = CreateCondition("c1", 2);
     m1 = CreateMV("m1", 2, 3);
    
    AcquireLock(l1);
    Print("client2 of Test2 has acquired lock1.\n", sizeof("client2 of Test2 has acquired lock1.\n")/sizeof(char), 0, 0);
    SetMV(m1, 1, 10);
    SignalCondition(c1, l1);
    Print("client2 of Test2 signals client1.\n", sizeof("client2 of Test2 signals client1.\n")/sizeof(char), 0, 0);
    ReleaseLock(l1);
    Print("client2 of Test2 has released lock1.\n", sizeof("client2 of Test2 has released lock1.\n")/sizeof(char), 0, 0);
    Exit(0);
}
int main(){
	lk1 = CreateLock("lk1", sizeof("lk1"));
	cv1 = CreateCondition("cv1", sizeof("cv1"));
	
	Acquire(lk1);
	
	Write("Test 2:Acquired lk1 \n", sizeof("Test 2:Acquired lk1 \n"), ConsoleOutput);

	Signal(lk1, cv1);
	Write("Test 2:Signalled lk1 \n", sizeof("Test 2:Signalled lk1 \n"), ConsoleOutput);

	Wait(lk1, cv1);
	Write("Test 2:I was signalled lk1 \n", sizeof("Test 2:I was signalled lk1 \n"), ConsoleOutput);

	Release(lk1);
	Write("Test 2:Released lk1 \n", sizeof("Test 2:Released lk1 \n"), ConsoleOutput);
}
Exemple #26
0
int main() {

	int lock1 = CreateLock("Lock1", 5);

	int i;
	for(i = 0; i < 10; i++){
		Acquire(lock1);
		Fork((void*)print1, "Print", 5, 1);
		Release(lock1);

		Acquire(lock1);
		Fork((void*)print2, "Increment", 9, 2);
		Release(lock1);
	}
	DestroyLock(lock1);
	Exit(0);
}
Exemple #27
0
/*
 * Calendar functions entry
 */
EXPORT	ER	dt_main(INT ac, UB* av[])
{
	ER	er;
	T_DSSY	dssy;

	if (ac < 0) {
		/* Stop other tasks from executing SVC */
		Lock(&dtLock);

		/* Unregister subsystem */
		tk_def_ssy(DT_SVC, NULL);

		/* Delete lock */
		DeleteLock(&dtLock);
		return E_OK;
	}

	/* Create lock */
	er = CreateLock(&dtLock, "dtLk");
	if (er < E_OK) {
		goto err_ret0;
	}

	/* Register subsystem */
	dssy.ssyatr	= TA_NULL;
	dssy.ssypri	= DT_PRI;
	dssy.svchdr	= (FP)svcEntry;
	dssy.breakfn	= NULL;
	dssy.startupfn	= NULL;
	dssy.cleanupfn	= NULL;
	dssy.eventfn	= NULL;
	dssy.resblksz	= 0;
	er = tk_def_ssy(DT_SVC, &dssy);
	if (er < E_OK) {
		goto err_ret1;
	}

	return E_OK;

err_ret1:
	DeleteLock(&dtLock);
	
err_ret0:
	return er;
}
void main()
{
	Print("\n tcase6: Checking Working of Wait and Signal. \n",1,1,1);

	CreateLock("lock1");
/*	Print("\n tcase6: lock1 Has Been Created. \n",1,1,1); */

	CreateCV("cv1");
/*	Print("\n tcase6: cv1 Has Been Created. \n",1,1,1); */

	Print("\n tcase6: Going on wait on 'cv1' using 'lock1' that is not acquired. Will not go on wait.\n",1,1,1);
	Wait("cv1","lock1");
	Print("\nERROR - tcase6: Could not go on wait on 'cv1' using 'lock1'.\n",1,1,1);

	Print("\n tcase6: Signalling on 'cv1' using 'lock1' that is not acquired. Will not Signal.\n",1,1,1);
	Signal("cv1","lock1");
	Print("\nERROR - tcase6: Could not Signal on 'cv1' using 'lock1'.\n",1,1,1);


	Acquire("lock1");
/*	Print("\n tcase6: lock 1 Has Been Acquired. \n",1,1,1); */

	Print("\n tcase6: Going on wait on 'cv2' that is not created using 'lock1'. Will not go on wait.\n",1,1,1);
	Wait("cv2","lock1");
	Print("\n ERROR - tcase6: Could not go on wait on 'cv1' using 'lock2'.\n",1,1,1);

	Print("\n tcase6: Signalling on 'cv2' that is not created using 'lock1'. Will not Signal.\n",1,1,1);
	Signal("cv2","lock1");
	Print("\nERROR - tcase6: Could not Signal on 'cv1' using 'lock1'.\n",1,1,1);

	Release("lock1");
/*	Print("\n tcase6: lock 1 Has Been Released. \n",1,1,1); */

/*	DeleteCV("cv1");
	Print("\n tcase6: cv1 Has Been Deleted. \n",1,1,1);

	DeleteLock("lock1");
	Print("\n tcase6: Lock 1 Deleted. \n",1,1,1);

	DeleteLock("lock2");
	Print("\n tcase6: Lock 2 Deleted. \n",1,1,1);
*/

	Exit(0);
}
Exemple #29
0
int main(){
	int maxCV;
	CreateLock(0);
	Write("Making CV's...\n", sizeof("Making CV's...\n"),ConsoleOutput);
	for (maxCV = 0; maxCV < 255; maxCV++){
		CreateCondition(maxCV);
	}
	Fork(test1);
	Fork(test2);
	Yield();

	Write("Destroying CV's...\n", sizeof("Destroying CV's...\n"), ConsoleOutput);
	for (maxCV = 0; maxCV < 255; maxCV++){
		DestroyCondition(maxCV);
	}

	Write("CV's destroyed.\n", sizeof("CV's destroyed.\n"), ConsoleOutput);
}
Exemple #30
0
int main() {
    
    lock1 = CreateLock("0", sizeof("0"));
    lock2 = CreateLock("0", sizeof("0"));
    lock3 = CreateLock("0", sizeof("0"));
    lock4 = CreateLock("0", sizeof("0"));
    lock5 = CreateLock("0", sizeof("0"));
    lock6 = CreateLock("0", sizeof("0"));
    
    Fork(t5_t2);
    Fork(t5_t3);
    Yield();
}