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;
}
