void ConcurrencyTest1::TestThread(void) { int i; SafetyLock theSafetyLock(theLocker); for (i = 0; i < MAXLOOP; i++) { // Print out 10 sub test markers per thread if (i % (MAXLOOP / 10) == 0) NextSubTest(); CheckLock(0); assert(AcquireLock(i, true)); assert(!lockTestValue); lockTestValue = true; CheckLock(1); assert(AcquireLock(i, false)); CheckLock(2); theLocker->Unlock(); CheckLock(1); assert(lockTestValue); lockTestValue = false; theLocker->Unlock(); CheckLock(0); } }
int main() { lock = CreateLock("lock"); cv2 = CreateCV("cv2"); AcquireLock("lock"); SignalCV("lock","cv2"); Print("Client 3 will now destroy CV...",-1,-1,-1); DestroyCV("cv2"); for (i=0; i<9; i++) Print("\n",-1,-1,-1); ReleaseLock("lock"); AcquireLock("lock"); WaitCV("lock","cv2"); Print("Client 3: This prints as CV has been destroyed...",-1,-1,-1); ReleaseLock("lock"); Exit(0); }
void main() { lck = CreateLock("lock1"); cv = CreateCV("cv1"); Print("\nDistCVTest1_1: Created Lock is %d and CV is %d\n", lck, cv, -1); AcquireLock("lock1"); Print("Client 1: About to go on wait...\n", -1, -1, -1); WaitCV("lock1","cv1"); Print("Client 1: Now out of wait...\n", -1, -1, -1); for (num=0; num<10; num++) Print("\n",-1,-1,-1); Print("Client 1: About to signal Client 2\n", -1, -1, -1); SignalCV("lock1","cv1"); ReleaseLock("lock1"); AcquireLock("lock1"); ReleaseLock("lock1"); Exit(0); }
void otudp_output(OTUDP *x) { // This is called by the Max clock. It's guaranteed not to be called // at notifier level, although if we're in Overdrive this will be called // at interrupt level. Atom arguments[2]; PacketBuffer b; short oldLockout; // BufferSanityCheck(x, 0, 0, 0); while (1) { oldLockout = AcquireLock(x); b = PBFIFODequeue(&(x->pendingBuffers)); ReleaseLock(x,oldLockout); if (b == 0) break; SETLONG(&arguments[0], b->n); SETLONG(&arguments[1], (long) b->buf); outlet_anything(x->o_outlet, ps_FullPacket, 2, arguments); oldLockout = AcquireLock(x); PacketBufferListPush(b, &(x->freeBuffers)); ReleaseLock(x,oldLockout); } // BufferSanityCheck(x, 0, 0, 0); }
int monte_carlo_pi(unsigned int n, int procNumber) { AcquireLock(); printf("CORE %d\n", procNumber); ReleaseLock(); int in = 0, i; int x, y, d; int limit; limit = n*(procNumber + 1)/CORES; if (procNumber == CORES - 1) { //ultimo core, faz o resto limit = n; } for (i = n*procNumber/CORES; i < limit; i++) { //x = ((*randNum % 1000000)/500000.0)-1; x = (((getRandomNumber() % 1000000)/500000)-1)*10; y = (((getRandomNumber() % 1000000)/500000)-1)*10; //y = ((*randNum % 1000000)/500000.0)-1; //x = 1; //y = 2; d = ((x*x) + (y*y)); //AcquireLock(); if (d <= 10) { in+=1; } //ReleaseLock(); } AcquireLock(); printf("IN: %d\n", in); ReleaseLock(); return in; }
int main() { mv = CreateMV("mv1"); mv2 = CreateMV("mv2"); lck = CreateLock("lock1"); lck2 = CreateLock("lock2"); cv = CreateCV("cv1"); for (loop =0; loop<500; loop++) { AcquireLock(lck); SignalCV(lck,cv); AcquireLock(lck2); ret = GetMV(mv2); ReleaseLock(lck2); if (ret != 21)/*This will wait only if the other one isnt finished*/ WaitCV(lck,cv); mvEdit = GetMV(mv); Print("Client 2: Monitor variable was read to be %d..",mvEdit,-1,-1); mvEdit+=7; ret=SetMV(mv,mvEdit); mvEdit = GetMV(lck); Print("Client 2: Monitor variable was set to be %d..",mvEdit,-1,-1); ReleaseLock(lck); Print("Client 2: %d Iterations done..",loop,-1,-1); } AcquireLock(lck2); ret = SetMV(mv2,21); /*this monitor variable is set to 21 here to signify *one of the processes is over and the other will not *wait for it to signal it */ ReleaseLock(lck2); AcquireLock(lck); SignalCV(lck,cv); ReleaseLock(lck); }
int main() { const Lock& lock = AcquireLock(); g = 1; g = 2; g = 3; }
void main() { lck = CreateLock("lock1"); cv = CreateCV("cv1"); Print("Client 2: Created Lock is %d and CV is %d\n", lck, cv, -1); AcquireLock("lock1"); Print("Client 2: About to signal Client 1\n", -1, -1, -1); SignalCV("lock1","cv1"); Print("Client 2: About to go on wait...\n", -1, -1, -1); WaitCV("lock1","cv1"); for (i=0; i<10; i++) Print("\n",-1,-1,-1); Print("Client 2: Now out of wait...\n", -1, -1, -1); ReleaseLock("lock1"); Exit(0); }
static PromiseResult VerifyServices(EvalContext *ctx, Attributes a, Promise *pp) { CfLock thislock; thislock = AcquireLock(ctx, pp->promiser, VUQNAME, CFSTARTTIME, a.transaction, pp, false); if (thislock.lock == NULL) { return PROMISE_RESULT_SKIPPED; } EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser", pp->promiser, DATA_TYPE_STRING, "goal=state,source=promise"); PromiseBanner(pp); PromiseResult result = PROMISE_RESULT_NOOP; if (strcmp(a.service.service_type, "windows") == 0) { result = PromiseResultUpdate(result, VerifyWindowsService(ctx, a, pp)); } else { result = PromiseResultUpdate(result, DoVerifyServices(ctx, a, pp)); } EvalContextVariableRemoveSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser"); YieldCurrentLock(thislock); return result; }
void thread3() { AcquireLock(a); Yield(); Yield(); Exit(0); }
int main() { lock = CreateLock("lock"); lock2 = CreateLock("lock2"); cv1 = CreateCV("cv1"); cv2=CreateCV("cv2"); AcquireLock("lock"); SignalCV("lock","cv1"); Print("Client 2 is going to wait...",-1,-1,-1); WaitCV("lock","cv2"); for (i=0; i<9; i++) Print("\n",-1,-1,-1); Print("Client 2 is now out of wait...",-1,-1,-1); ReleaseLock("lock"); Exit(0); }
void VerifyEnvironmentsPromise(EvalContext *ctx, Promise *pp) { Attributes a = { {0} }; CfLock thislock; Promise *pexp; a = GetEnvironmentsAttributes(ctx, pp); if (EnvironmentsSanityChecks(a, pp)) { thislock = AcquireLock(ctx, "virtual", VUQNAME, CFSTARTTIME, a.transaction, pp, false); if (thislock.lock == NULL) { return; } PromiseBanner(pp); ScopeNewSpecialScalar(ctx, "this", "promiser", pp->promiser, DATA_TYPE_STRING); pexp = ExpandDeRefPromise(ctx, "this", pp); VerifyEnvironments(ctx, a, pp); PromiseDestroy(pexp); } YieldCurrentLock(thislock); }
void ParallelFor(const VectorType& items, const FuncType& func) { using SizeType = decltype(items.size()); SizeType totalCount = items.size(); auto lock = AcquireLock(); SizeType offset = 0; for (int i = 0; i < m_ThreadCount; i++) { SizeType count = totalCount / static_cast<SizeType>(m_ThreadCount); if (static_cast<SizeType>(i) < totalCount % static_cast<SizeType>(m_ThreadCount)) count++; EnqueueUnlocked(lock, [&items, func, offset, count, this]() { for (SizeType j = offset; j < offset + count; j++) { RunTaskFunction([&func, &items, j]() { func(items[j]); }); } }); offset += count; } ASSERT(offset == items.size()); }
void MonitorStartServer(const Policy *policy, const ReportContext *report_context) { char timekey[CF_SMALLBUF]; Averages averages; Promise *pp = NewPromise("monitor_cfengine", "the monitor daemon"); Attributes dummyattr; CfLock thislock; #ifdef __MINGW32__ if (!NO_FORK) { CfOut(cf_verbose, "", "Windows does not support starting processes in the background - starting in foreground"); } #else /* !__MINGW32__ */ if ((!NO_FORK) && (fork() != 0)) { CfOut(cf_inform, "", "cf-monitord: starting\n"); _exit(0); } if (!NO_FORK) { ActAsDaemon(0); } #endif /* !__MINGW32__ */ memset(&dummyattr, 0, sizeof(dummyattr)); dummyattr.transaction.ifelapsed = 0; dummyattr.transaction.expireafter = 0; thislock = AcquireLock(pp->promiser, VUQNAME, CFSTARTTIME, dummyattr, pp, false); if (thislock.lock == NULL) { return; } WritePID("cf-monitord.pid"); MonNetworkSnifferOpen(); while (!IsPendingTermination()) { GetQ(policy, report_context); snprintf(timekey, sizeof(timekey), "%s", GenTimeKey(time(NULL))); averages = EvalAvQ(timekey); LeapDetection(); ArmClasses(averages, timekey); ZeroArrivals(); MonNetworkSnifferSniff(ITER, CF_THIS); ITER++; } }
void CheckProcessMemory() { UINT_PTR i,j,flag,addr; DWORD len; CLIENT_ID id; OBJECT_ATTRIBUTES oa={0}; HANDLE hProc; BYTE buffer[8]; AcquireLock(); id.UniqueThread=0; oa.uLength=sizeof(oa); for (i=0;i<count;i++) { id.UniqueProcess=(proc_record[i]&0xFFF)<<2; addr=proc_record[i]&~0xFFF; flag=0; if (NT_SUCCESS(NtOpenProcess(&hProc,PROCESS_VM_OPERATION|PROCESS_VM_READ,&oa,&id))) { if (NT_SUCCESS(NtReadVirtualMemory(hProc,(PVOID)addr,buffer,8,&len))) if (memcmp(buffer,normal_routine,4)==0) flag=1; NtClose(hProc); } if (flag==0) { for (j=i;j<count;j++) proc_record[j]=proc_record[j+1]; count--; i--; } } ReleaseLock(); }
void ReleaseProcessMemory(HANDLE hProc) { DWORD pid,addr,len; AcquireLock(); if (hProc==NtCurrentProcess()) pid=current_process_id; else { PROCESS_BASIC_INFORMATION info; NtQueryInformationProcess(hProc,ProcessBasicInformation,&info,sizeof(info),&len); pid=info.uUniqueProcessId; } pid>>=2; //NtWaitForSingleObject(thread_man_mutex,0,0); for (UINT_PTR i=0;i<count;i++) { if ((proc_record[i]&0xFFF)==pid) { addr=proc_record[i]&~0xFFF; DWORD size=0x1000; NtFreeVirtualMemory(hProc,(PVOID*)&addr,&size,MEM_RELEASE); count--; for (UINT_PTR j=i;j<count;j++) { proc_record[j]=proc_record[j+1]; } proc_record[count]=0; ReleaseLock(); //NtReleaseMutant(thread_man_mutex,0); return; } } ReleaseLock(); //NtReleaseMutant(thread_man_mutex,0); }
static PromiseResult VerifyServices(EvalContext *ctx, Attributes a, const Promise *pp) { CfLock thislock; thislock = AcquireLock(ctx, pp->promiser, VUQNAME, CFSTARTTIME, a.transaction, pp, false); if (thislock.lock == NULL) { return PROMISE_RESULT_SKIPPED; } PromiseBanner(ctx, pp); PromiseResult result = PROMISE_RESULT_SKIPPED; if (strcmp(a.service.service_type, "windows") == 0) { #ifdef __MINGW32__ result = PromiseResultUpdate(result, VerifyWindowsService(ctx, a, pp)); #else Log(LOG_LEVEL_INFO, "Service type windows not supported on this platform."); #endif } else { result = PromiseResultUpdate(result, DoVerifyServices(ctx, a, pp)); } YieldCurrentLock(thislock); return result; }
/////////////////////////////////////////////////////////////////////////////// // HandleIoctlPowerSet // Input: pMemCard - SD memory card structure // pDevicePowerState - device power state // Output: // Return: // Notes: /////////////////////////////////////////////////////////////////////////////// VOID HandleIoctlPowerSet(PSD_MEMCARD_INFO pMemCard, PCEDEVICE_POWER_STATE pDevicePowerState) { AcquireLock(pMemCard); DEBUGMSG(SDMEM_ZONE_POWER, (TEXT("SDMemory: IOCTL_POWER_SET %d \n"),*pDevicePowerState)); if (*pDevicePowerState < pMemCard->PowerStateForIdle) { // everything above the power state for idle is treated as D0 *pDevicePowerState = D0; pMemCard->CurrentPowerState = D0; // disable low power operation pMemCard->EnableLowPower = FALSE; } else { // everything above the IDLE power state is set to IDLE *pDevicePowerState = pMemCard->PowerStateForIdle; pMemCard->CurrentPowerState = pMemCard->PowerStateForIdle; // enable low power operation pMemCard->EnableLowPower = TRUE; // wake up the idle thread to go into power idle polling SetEvent(pMemCard->hWakeUpIdleThread); } ReleaseLock(pMemCard); }
void t5_t3(){ test=AcquireLock(LockIndex1); Write("3 acquired\n", sizeof("3 acquired\n"), 1); test=ReleaseLock(LockIndex1); Write("3 released\n", sizeof("3 released\n"), 1); Exit(0); }
void VerifyEnvironmentsPromise(Promise *pp) { Attributes a = { {0} }; CfLock thislock; Promise *pexp; a = GetEnvironmentsAttributes(pp); if (EnvironmentsSanityChecks(a, pp)) { thislock = AcquireLock("virtual", VUQNAME, CFSTARTTIME, a, pp, false); if (thislock.lock == NULL) { return; } CF_OCCUR++; PromiseBanner(pp); NewScalar("this", "promiser", pp->promiser, cf_str); pexp = ExpandDeRefPromise("this", pp); VerifyEnvironments(a, pp); DeletePromise(pexp); } YieldCurrentLock(thislock); }
//------------------------------------------------------------------------------ bool BLocker::Lock(void) { status_t result; return (AcquireLock(B_INFINITE_TIMEOUT, &result)); }
static Boolean BufferSanityCheck(OTUDP *x, int *freep, int *pendingp, int *outgoingp) { short oldLockout; int free, pending, outgoing, i; free = 100; // In case we fail to acquire lock // Mutual exclusion to prevent the lists from changing out from under me oldLockout = AcquireLock(x); free = CountPacketList(x->freeBuffers); pending = CountPacketList(x->pendingBuffers.first); outgoing = 0; ReleaseLock(x,oldLockout); if (freep != 0) *freep = free; if (pendingp != 0) *pendingp = pending; if (outgoingp != 0) *outgoingp = outgoing; if (free+pending+outgoing != x->nbufs) { error("otudp: BufferSanityCheck failed! %d free + %d pending + %d outgoing = %d", free, pending, free+pending+outgoing); return false; } else { return true; } }
static void VerifyProcesses(EvalContext *ctx, Attributes a, Promise *pp) { CfLock thislock; char lockname[CF_BUFSIZE]; if (a.restart_class) { snprintf(lockname, CF_BUFSIZE - 1, "proc-%s-%s", pp->promiser, a.restart_class); } else { snprintf(lockname, CF_BUFSIZE - 1, "proc-%s-norestart", pp->promiser); } thislock = AcquireLock(ctx, lockname, VUQNAME, CFSTARTTIME, a.transaction, pp, false); if (thislock.lock == NULL) { return; } EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser", pp->promiser, DATA_TYPE_STRING); PromiseBanner(pp); VerifyProcessOp(ctx, PROCESSTABLE, a, pp); EvalContextVariableRemoveSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser"); YieldCurrentLock(thislock); }
static PromiseResult VerifyServices(EvalContext *ctx, Attributes a, const Promise *pp) { CfLock thislock; thislock = AcquireLock(ctx, pp->promiser, VUQNAME, CFSTARTTIME, a.transaction, pp, false); if (thislock.lock == NULL) { return PROMISE_RESULT_SKIPPED; } EvalContextVariablePutSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser", pp->promiser, CF_DATA_TYPE_STRING, "source=promise"); PromiseBanner(pp); PromiseResult result = PROMISE_RESULT_NOOP; if (strcmp(a.service.service_type, "windows") == 0) { #ifdef __MINGW32__ result = PromiseResultUpdate(result, VerifyWindowsService(ctx, a, pp)); #else Log(LOG_LEVEL_INFO, "Service type windows not supported on this platform."); #endif } else { result = PromiseResultUpdate(result, DoVerifyServices(ctx, a, pp)); } EvalContextVariableRemoveSpecial(ctx, SPECIAL_SCOPE_THIS, "promiser"); YieldCurrentLock(thislock); return result; }
void VerifyProcesses(Attributes a, Promise *pp) { CfLock thislock; char lockname[CF_BUFSIZE]; if (a.restart_class) { snprintf(lockname, CF_BUFSIZE - 1, "proc-%s-%s", pp->promiser, a.restart_class); } else { snprintf(lockname, CF_BUFSIZE - 1, "proc-%s-norestart", pp->promiser); } thislock = AcquireLock(lockname, VUQNAME, CFSTARTTIME, a, pp, false); if (thislock.lock == NULL) { return; } DeleteScalar("this", "promiser"); NewScalar("this", "promiser", pp->promiser, cf_str); PromiseBanner(pp); VerifyProcessOp(PROCESSTABLE, a, pp); DeleteScalar("this", "promiser"); YieldCurrentLock(thislock); }
static PromiseResult VerifyProcesses(EvalContext *ctx, Attributes a, const Promise *pp) { CfLock thislock; char lockname[CF_BUFSIZE]; if (a.restart_class) { snprintf(lockname, CF_BUFSIZE - 1, "proc-%s-%s", pp->promiser, a.restart_class); } else { snprintf(lockname, CF_BUFSIZE - 1, "proc-%s-norestart", pp->promiser); } thislock = AcquireLock(ctx, lockname, VUQNAME, CFSTARTTIME, a.transaction, pp, false); if (thislock.lock == NULL) { return PROMISE_RESULT_SKIPPED; } PromiseBanner(pp); PromiseResult result = VerifyProcessOp(ctx, PROCESSTABLE, a, pp); YieldCurrentLock(thislock); return result; }
CHAR16 * SEnvIGetStr ( IN CHAR16 *Name, IN EFI_LIST_ENTRY *Head ) /*++ Routine Description: Arguments: Name - The variable name Head - The variable list Returns: --*/ { VARIABLE_ID *Var; CHAR16 *Value; AcquireLock (&SEnvLock); // // Walk through linked list to find corresponding Var // Value = NULL; Var = SEnvFindVar (Head, Name); if (Var != NULL) { Value = Var->u.Str; } ReleaseLock (&SEnvLock); return Value; }
//------------------------------------------------------------------------------ status_t BLocker::LockWithTimeout(bigtime_t timeout) { status_t result; AcquireLock(timeout, &result); return result; }
/* * finding total number of customer in particular queue * */ int getTotalCustCount(int debugId, mtQueue *queue) { int count; AcquireLock(queueLock[queue->queueType][queue->queueId]); count=getMv(&queue->numCust); ReleaseLock(queueLock[queue->queueType][queue->queueId]); return count ; }
/* * obtain current state of customer - * We acquire a lock before seeing it * and release lock once we are done * */ int getCustState(int debugId, int custId, int grpId) { int state; AcquireLock(custLock[grpId][custId]); state = getMv(&mtCb.custGrp[grpId].cust[custId].state); ReleaseLock(custLock[grpId][custId]); return state; }