JSBool jsj_InitJavaClassReflectionsTable() { if (!java_class_reflections) { java_class_reflections = JSJ_NewHashTable(64, jsj_HashJavaObject, jsj_JavaObjectComparator, NULL, NULL, NULL); if (!java_class_reflections) return JS_FALSE; #ifdef JSJ_THREADSAFE java_class_reflections_monitor = (struct PRMonitor *) PR_NewMonitor(); if (!java_class_reflections_monitor) return JS_FALSE; java_reflect_monitor = (struct PRMonitor *) PR_NewMonitor(); if (!java_reflect_monitor) return JS_FALSE; #endif } return JS_TRUE; }
void RunClients(void) { PRInt32 index; numRequests = _iterations; numClients = _clients; clientMonitor = PR_NewMonitor(); for (index=0; index<_clients; index++) { PRThread *clientThread; clientThread = PR_CreateThread( PR_USER_THREAD, ClientThreadFunc, NULL, PR_PRIORITY_NORMAL, ClientScope, PR_UNJOINABLE_THREAD, THREAD_STACKSIZE); if (!clientThread) { if (debug_mode) printf("\terror creating client thread %d\n", index); } else if (debug_mode) DPRINTF("\tMain created client %d/%d\n", index+1, _clients); } PR_EnterMonitor(clientMonitor); while(numClients) PR_Wait(clientMonitor, PR_INTERVAL_NO_TIMEOUT); PR_ExitMonitor(clientMonitor); }
PR_IMPLEMENT(PRMonitor*) PR_NewNamedMonitor(const char* name) { PRMonitor* mon = PR_NewMonitor(); if (mon) mon->name = name; return mon; }
PKIX_Error * PKIX_PL_MonitorLock_Create( PKIX_PL_MonitorLock **pNewLock, void *plContext) { PKIX_PL_MonitorLock *monitorLock = NULL; PKIX_ENTER(MONITORLOCK, "PKIX_PL_MonitorLock_Create"); PKIX_NULLCHECK_ONE(pNewLock); PKIX_CHECK(PKIX_PL_Object_Alloc (PKIX_MONITORLOCK_TYPE, sizeof (PKIX_PL_MonitorLock), (PKIX_PL_Object **)&monitorLock, plContext), PKIX_ERRORALLOCATINGMONITORLOCK); PKIX_MONITORLOCK_DEBUG("\tCalling PR_NewMonitor)\n"); monitorLock->lock = PR_NewMonitor(); if (monitorLock->lock == NULL) { PKIX_DECREF(monitorLock); PKIX_ERROR(PKIX_OUTOFMEMORY); } *pNewLock = monitorLock; cleanup: PKIX_RETURN(MONITORLOCK); }
static PRUint32 ContentiousMonitor(PRUint32 loops) { PRStatus status; PRThread *thread = NULL; MonitorContentious_t * contention; PRIntervalTime rv, overhead, timein = PR_IntervalNow(); contention = (MonitorContentious_t *) PR_Calloc(1, sizeof(MonitorContentious_t)); contention->loops = loops; contention->overhead = 0; contention->ml = PR_NewMonitor(); contention->interval = contention_interval; thread = PR_CreateThread( PR_USER_THREAD, MonitorContender, contention, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); overhead = PR_IntervalNow() - timein; while (contention->loops > 0) { PR_EnterMonitor(contention->ml); contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ExitMonitor(contention->ml); } timein = PR_IntervalNow(); status = PR_JoinThread(thread); PR_DestroyMonitor(contention->ml); overhead += (PR_IntervalNow() - timein); rv = overhead + contention->overhead; PR_Free(contention); return rv; } /* ContentiousMonitor */
static PRIntervalTime ReentrantMonitor(PRUint32 loops) { PRStatus status; PRThread *thread; PRMonitor *ml = PR_NewMonitor(); if (debug_mode) printf("\nMonitor created for reentrant test\n"); PR_EnterMonitor(ml); PR_EnterMonitor(ml); if (debug_mode) printf("Monitor acquired twice\n"); thread = PR_CreateThread( PR_USER_THREAD, TryEntry, ml, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); PR_Sleep(PR_SecondsToInterval(1)); PR_ExitMonitor(ml); if (debug_mode) printf("Monitor released first time\n"); PR_ExitMonitor(ml); if (debug_mode) printf("Monitor released second time\n"); status = PR_JoinThread(thread); if (debug_mode) printf( "Reentrant thread joined %s\n", (status == PR_SUCCESS) ? "successfully" : "in error"); PR_DestroyMonitor(ml); return 0; } /* ReentrantMonitor */
NS_IMETHODIMP nsPipe::Init(PRBool nonBlockingIn, PRBool nonBlockingOut, PRUint32 segmentSize, PRUint32 segmentCount, nsIMemory *segmentAlloc) { mMonitor = PR_NewMonitor(); if (!mMonitor) return NS_ERROR_OUT_OF_MEMORY; if (segmentSize == 0) segmentSize = DEFAULT_SEGMENT_SIZE; if (segmentCount == 0) segmentCount = DEFAULT_SEGMENT_COUNT; // protect against overflow PRUint32 maxCount = PRUint32(-1) / segmentSize; if (segmentCount > maxCount) segmentCount = maxCount; nsresult rv = mBuffer.Init(segmentSize, segmentSize * segmentCount, segmentAlloc); if (NS_FAILED(rv)) return rv; mInput.SetNonBlocking(nonBlockingIn); mOutput.SetNonBlocking(nonBlockingOut); return NS_OK; }
static int mac_sort_tbl_init(const short scriptcode, unsigned char *mac_sort_tbl) { int i; unsigned char sort_tbl[256]; for (i = 0; i < 256; i++) sort_tbl[i] = (unsigned char) i; /* Get itl2. */ itl2Handle = GetResource('itl2', mac_get_script_sort_id(scriptcode)); if (itl2Handle == NULL) return -1; /* qsort */ PRMonitor* mon = PR_NewMonitor(); PR_EnterMonitor(mon); qsort((void *) sort_tbl, 256, 1, mac_sort_tbl_compare); (void) PR_ExitMonitor(mon); PR_DestroyMonitor(mon); /* Put index to the table so we can map character code to sort oder. */ for (i = 0; i < 256; i++) mac_sort_tbl[sort_tbl[i]] = (unsigned char) i; return 0; }
nsresult aptCoreTrace::Init(const char* sLock) { if (mCanLog) return NS_OK; mLC = new LogClient(); if (!mLC) return NS_ERROR_OUT_OF_MEMORY; const char* logfifo = getenv("JAXERLOG_PIPENAME"); mLC->Init(logfifo, -1, sLock); mLC->OpenPipeForWrite(); #ifdef _WIN32 mPid = GetCurrentProcessId(); #else mPid = getpid(); #endif mLoggerLock = PR_NewMonitor(); mBuf = (char *)PR_Malloc(0x8000); mBufSize = 0x8000; mCanLog = PR_TRUE; nsCOMPtr<nsIPrefBranch> prefBranch(do_GetService(NS_PREFSERVICE_CONTRACTID)); if (prefBranch) UpdatePrefSettings(prefBranch, nsnull); return NS_OK; }
/* ** Stress() ** Flog the hell out of arenas multi-threaded. ** Do NOT pass an individual arena to another thread. ** */ static void Stress( void ) { PRThread *tt; PRIntn i; tMon = PR_NewMonitor(); for ( i = 0 ; i < stressThreads ; i++ ) { PR_EnterMonitor(tMon); tt = PR_CreateThread(PR_USER_THREAD, StressThread, NULL, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_UNJOINABLE_THREAD, 0); threadCount++; PR_ExitMonitor(tMon); } /* Wait for all threads to exit */ PR_EnterMonitor(tMon); while ( threadCount != 0 ) { PR_Wait(tMon, PR_INTERVAL_NO_TIMEOUT); } PR_ExitMonitor(tMon); PR_DestroyMonitor(tMon); return; } /* end Stress() */
PRMonitor* nsAutoMonitor::NewMonitor(const char* name) { PRMonitor* mon = PR_NewMonitor(); #ifdef DEBUG OnSemaphoreCreated(mon, name); #endif return mon; }
nsEventQueueServiceImpl::nsEventQueueServiceImpl() { mEventQMonitor = PR_NewMonitor(); #if defined(PR_LOGGING) && defined(DEBUG_danm) if (!gEventQueueLog) gEventQueueLog = PR_NewLogModule("nseventqueue"); #endif }
static void T1Mon(void) { PRStatus rv; PRThread *t2, *t3; PR_fprintf(err, "\n**********************************\n"); PR_fprintf(err, " MONITORS\n"); PR_fprintf(err, "**********************************\n"); sharedM.o1 = PR_NewMonitor(); sharedM.o2 = PR_NewMonitor(); base = PR_IntervalNow(); PR_EnterMonitor(sharedM.o1); LogNow("T1 waiting 3 seconds on o1", PR_SUCCESS); rv = PR_Wait(sharedM.o1, PR_SecondsToInterval(3)); if (PR_SUCCESS == rv) LogNow("T1 resuming on o1", rv); else LogNow("T1 wait on o1 failed", rv); PR_ExitMonitor(sharedM.o1); LogNow("T1 creating T2", PR_SUCCESS); t2 = PR_CreateThread( PR_USER_THREAD, T2Mon, &sharedM, PR_PRIORITY_NORMAL, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); LogNow("T1 creating T3", PR_SUCCESS); t3 = PR_CreateThread( PR_USER_THREAD, T3Mon, &sharedM, PR_PRIORITY_NORMAL, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_EnterMonitor(sharedM.o2); LogNow("T1 waiting forever on o2", PR_SUCCESS); rv = PR_Wait(sharedM.o2, PR_INTERVAL_NO_TIMEOUT); if (PR_SUCCESS == rv) LogNow("T1 resuming on o2", rv); else LogNow("T1 wait on o2 failed", rv); PR_ExitMonitor(sharedM.o2); (void)PR_JoinThread(t2); (void)PR_JoinThread(t3); PR_DestroyMonitor(sharedM.o1); PR_DestroyMonitor(sharedM.o2); } /* T1Mon */
static void WaitMonitorThread(void *arg) { PRIntervalTime timeout = (PRIntervalTime) arg; PRIntervalTime elapsed; #if defined(XP_UNIX) || defined(WIN32) PRInt32 timeout_msecs = PR_IntervalToMilliseconds(timeout); PRInt32 elapsed_msecs; #endif #if defined(XP_UNIX) struct timeval end_time_tv; #endif #if defined(WIN32) && !defined(WINCE) struct _timeb end_time_tb; #endif PRMonitor *mon; mon = PR_NewMonitor(); if (mon == NULL) { fprintf(stderr, "PR_NewMonitor failed\n"); exit(1); } PR_EnterMonitor(mon); PR_Wait(mon, timeout); PR_ExitMonitor(mon); elapsed = (PRIntervalTime)(PR_IntervalNow() - start_time); if (elapsed + tolerance < timeout || elapsed > timeout + tolerance) { fprintf(stderr, "timeout wrong\n"); exit(1); } #if defined(XP_UNIX) gettimeofday(&end_time_tv, NULL); elapsed_msecs = 1000*(end_time_tv.tv_sec - start_time_tv.tv_sec) + (end_time_tv.tv_usec - start_time_tv.tv_usec)/1000; #endif #if defined(WIN32) #if defined(WINCE) elapsed_msecs = GetTickCount() - start_time_tick; #else _ftime(&end_time_tb); elapsed_msecs = 1000*(end_time_tb.time - start_time_tb.time) + (end_time_tb.millitm - start_time_tb.millitm); #endif #endif #if defined(XP_UNIX) || defined(WIN32) if (elapsed_msecs + tolerance_msecs < timeout_msecs || elapsed_msecs > timeout_msecs + tolerance_msecs) { fprintf(stderr, "timeout wrong\n"); exit(1); } #endif PR_DestroyMonitor(mon); if (debug_mode) { fprintf(stderr, "wait monitor thread (scope %d) done\n", PR_GetThreadScope(PR_GetCurrentThread())); } }
/* ** MONITORS */ static PRIntervalTime MakeMonitor(PRUint32 loops) { PRMonitor *ml = NULL; while (loops-- > 0) { ml = PR_NewMonitor(); PR_DestroyMonitor(ml); ml = NULL; } return 0; } /* MakeMonitor */
static PRIntervalTime NonContentiousMonitor(PRUint32 loops) { PRMonitor *ml = NULL; ml = PR_NewMonitor(); while (loops-- > 0) { PR_EnterMonitor(ml); PR_ExitMonitor(ml); } PR_DestroyMonitor(ml); return 0; } /* NonContentiousMonitor */
static PRIntervalTime NonContentiousMonitor(PRUint32 loops) { PRMonitor *ml = NULL; ml = PR_NewMonitor(); while (loops-- > 0) { PR_EnterMonitor(ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(ml); PR_ExitMonitor(ml); } PR_DestroyMonitor(ml); return 0; } /* NonContentiousMonitor */
int pseudoMain (int argc, char** argv, char *pad) { PRInt32 lastWriteCount = gCounter; PRInt32 lastReadCount = gReads; Arg_t a1 = {500, 250}; Arg_t a2 = {500, 500}; Arg_t a3 = {250, 500}; Arg_t a4 = {750, 250}; Arg_t a5 = {100, 750}; Arg_t a6 = {100, 500}; Arg_t a7 = {100, 750}; gMonitor = PR_NewMonitor (); fireThread ("R1", doReadThread, &a1); fireThread ("R2", doReadThread, &a2); fireThread ("R3", doReadThread, &a3); fireThread ("R4", doReadThread, &a4); fireThread ("W1", doWriteThread, &a5); fireThread ("W2", doWriteThread, &a6); fireThread ("W3", doWriteThread, &a7); fireThread ("R5", doReadThread, &a1); fireThread ("R6", doReadThread, &a2); fireThread ("R7", doReadThread, &a3); fireThread ("R8", doReadThread, &a4); fireThread ("W4", doWriteThread, &a5); fireThread ("W5", doWriteThread, &a6); fireThread ("W6", doWriteThread, &a7); while (1) { PRInt32 writeCount, readCount; PRIntervalTime fiveSecs = PR_SecondsToInterval(5); PR_Sleep (fiveSecs); // get out of the way // print some stats, not threadsafe, informative only writeCount = gCounter; readCount = gReads; printf ("\ntick %d writes (+%d), %d reads (+%d) [max %d, %d, %d]", writeCount, writeCount - lastWriteCount, readCount, readCount - lastReadCount, gMaxReads, gMaxWriteWaits, gMaxReadWaits); lastWriteCount = writeCount; lastReadCount = readCount; gMaxReads = gMaxWriteWaits = gMaxReadWaits = 0; } return 0; }
static void Level_0_Thread(PRThreadScope scope1, PRThreadScope scope2) { PRThread *thr; PRThread *me = PR_GetCurrentThread(); int n; PRInt32 words; PRWord *registers; alive = 0; mon = PR_NewMonitor(); alive = count; for (n=0; n<count; n++) { thr = PR_CreateThreadGCAble(PR_USER_THREAD, Level_1_Thread, (void *)scope2, PR_PRIORITY_NORMAL, scope1, PR_UNJOINABLE_THREAD, 0); if (!thr) { printf("Could not create thread!\n"); alive--; } printf("Level_0_Thread[0x%lx] created %15s thread 0x%lx\n", PR_GetCurrentThread(), (scope1 == PR_GLOBAL_THREAD) ? "PR_GLOBAL_THREAD" : "PR_LOCAL_THREAD", thr); PR_Sleep(0); } PR_SuspendAll(); PR_EnumerateThreads(print_thread, NULL); registers = PR_GetGCRegisters(me, 1, (int *)&words); if (registers) printf("My Registers: R0 = 0x%x R1 = 0x%x R2 = 0x%x R3 = 0x%x\n", registers[0],registers[1],registers[2],registers[3]); printf("My Stack Pointer = 0x%lx\n", PR_GetSP(me)); PR_ResumeAll(); /* Wait for all threads to exit */ PR_EnterMonitor(mon); while (alive) { PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT); } PR_ExitMonitor(mon); PR_DestroyMonitor(mon); }
static PRIntn PR_CALLBACK RealMain(int argc, char **argv) { /* The command line argument: -d is used to determine if the test is being run in debug mode. The regress tool requires only one line output:PASS or FAIL. All of the printfs associated with this test has been handled with a if (debug_mode) test. Usage: test_name [-d] [-c n] */ PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dc:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ debug_mode = 1; break; case 'c': /* loop count */ count = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); if (0 == count) count = DEFAULT_COUNT; #ifdef XP_MAC SetupMacPrintfLog("cvar.log"); debug_mode = 1; #endif mon = PR_NewMonitor(); Measure(CondWaitContextSwitchUU, "cond var wait context switch- user/user"); Measure(CondWaitContextSwitchUK, "cond var wait context switch- user/kernel"); Measure(CondWaitContextSwitchKK, "cond var wait context switch- kernel/kernel"); PR_DestroyMonitor(mon); if (debug_mode) printf("%s\n", (failed) ? "FAILED" : "PASSED"); if(failed) return 1; else return 0; }
FCGXStream::FCGXStream() : mFD(INVALID_SOCKET), mRecvIn(0), mRecvOut(0), mRecvCurBlockType(bt_BeginRequest), mRecvBytesLeftInBlock(0), mSendIn(0), mSendHdrOffset(0), mDocText(nsnull), mDocTextOffset(0), mDocTextHeader(nsnull), mDocTextTail(nsnull), mPostDataAfterEndRequest(PR_FALSE), mLock(PR_NewMonitor()) { }
/** Initialize the monitor subsystem associated with the passed grt. * This routine runs unlocked: it is the job of the caller to * insure that no other threads are running. * * @see gpsee_createRuntime() * * @param cx The current JS context (used for throwing exceptions and gpsee_ds_create()) * @param grt The runtime whose monitor subsystem is to be initialized * @returns JS_TRUE on success, JS_FALSE if we threw */ JSBool gpsee_initializeMonitorSystem(JSContext *cx, gpsee_runtime_t *grt) { #ifdef JS_THREADSAFE grt->monitors.monitor = PR_NewMonitor(); if (!grt->monitors.monitor) return gpsee_throw(cx, GPSEE_GLOBAL_NAMESPACE_NAME ".monitors.initialize: Could not initialize monitor subsystem"); /* Access to monitorList_unlocked is guarded by grt->monitors.monitor henceforth */ grt->monitorList_unlocked = gpsee_ds_create(NULL, GPSEE_DS_UNLOCKED, 5); #else grt->monitors.monitor = gpsee_getNilMonitor(); #endif return JS_TRUE; }
/* * Called once per Java VM, this function initializes the classes, fields, and * methods required for Java reflection. If java_vm is NULL, a new Java VM is * created, using the provided classpath in addition to any default classpath. * The classpath argument is ignored, however, if java_vm_arg is non-NULL. */ JSJavaVM * JSJ_ConnectToJavaVM(SystemJavaVM *java_vm_arg, void* initargs) { SystemJavaVM* java_vm; JSJavaVM *jsjava_vm; JNIEnv *jEnv; JS_ASSERT(JSJ_callbacks); JS_ASSERT(JSJ_callbacks->attach_current_thread); JS_ASSERT(JSJ_callbacks->detach_current_thread); JS_ASSERT(JSJ_callbacks->get_java_vm); jsjava_vm = (JSJavaVM*)malloc(sizeof(JSJavaVM)); if (!jsjava_vm) return NULL; memset(jsjava_vm, 0, sizeof(JSJavaVM)); java_vm = java_vm_arg; /* If a Java VM was passed in, try to attach to it on the current thread. */ if (java_vm) { jEnv = JSJ_callbacks->attach_current_thread(java_vm); if (jEnv == NULL) { jsj_LogError("Failed to attach to Java VM thread\n"); free(jsjava_vm); return NULL; } jsjava_vm->java_vm = java_vm; jsjava_vm->main_thread_env = jEnv; } else { jsjava_vm->init_args = initargs; } #ifdef JSJ_THREADSAFE if (jsjava_vm_list == NULL) { thread_list_monitor = (struct PRMonitor *) PR_NewMonitor(); } #endif /* JSJ_THREADSAFE */ /* Put this VM on the list of all created VMs */ jsjava_vm->next = jsjava_vm_list; jsjava_vm_list = jsjava_vm; return jsjava_vm; }
/** * Create a monitor. Infallible. * * @param grt The GPSEE runtime that owns the monitor * @param monitor_p A pointer to the monitor. This address must stay valid for the lifetime of the runtime. * * @returns The new monitor, or NULL if this was not a JS_THREADSAFE build. */ gpsee_monitor_t gpsee_createMonitor(gpsee_runtime_t *grt) { #ifdef JS_THREADSAFE gpsee_monitor_t monitor; GPSEE_ASSERT(grt->monitors.monitor); PR_EnterMonitor(grt->monitors.monitor); monitor = PR_NewMonitor(); gpsee_ds_put(grt->monitorList_unlocked, monitor, NULL); PR_ExitMonitor(grt->monitors.monitor); return monitor; #else return gpsee_getNilMonitor(); #endif }
static void sajsj_InitLocked() { JRIEnv *env; /* if jsj has already been initialized, we don't do this * standalone jsj setup, and none of the stuff in this * file gets used */ if (!JSJ_Init(&sajsjCallbacks)) return; jsjiTask = JS_Init(8L * 1024L * 1024L); jsmon = PR_NewMonitor(); globalContext = JS_NewContext(jsjiTask, 8192); PR_ASSERT(globalContext); globalObject = NULL; JS_AddRoot(globalContext, &globalObject); globalObject = JS_NewObject(globalContext, &sajsj_global_class, NULL, NULL); if (!globalObject) { PR_ASSERT(globalObject); goto trash_cx; } if (!JS_InitStandardClasses(globalContext, globalObject)) goto trash_cx; if (!JSJ_InitContext(globalContext, globalObject)) goto trash_cx; env = JRI_GetCurrentEnv(); PR_ASSERT(env); return; trash_cx: JS_DestroyContext(globalContext); globalContext = NULL; /* FIXME error codes? */ return; }
static PRUint32 ContentiousMonitor(PRUint32 loops) { PRStatus status; PRThread *thread = NULL; MonitorContentious_t * contention; PRIntervalTime rv, overhead, timein = PR_IntervalNow(); contention = PR_NEWZAP(MonitorContentious_t); contention->loops = loops; contention->overhead = 0; contention->ml = PR_NewMonitor(); contention->interval = contention_interval; thread = PR_CreateThread( PR_USER_THREAD, MonitorContender, contention, PR_PRIORITY_LOW, PR_LOCAL_THREAD, PR_JOINABLE_THREAD, 0); PR_ASSERT(thread != NULL); overhead = PR_IntervalNow() - timein; while (contention->loops-- > 0) { PR_EnterMonitor(contention->ml); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); contention->contentious+= 1; contention->overhead += contention->interval; PR_Sleep(contention->interval); PR_ASSERT_CURRENT_THREAD_IN_MONITOR(contention->ml); PR_ExitMonitor(contention->ml); } timein = PR_IntervalNow(); status = PR_JoinThread(thread); PR_DestroyMonitor(contention->ml); overhead += (PR_IntervalNow() - timein); rv = overhead + contention->overhead; if (verbosity) PR_fprintf( std_err, "Access ratio: %u to %u\n", contention->contentious, contention->contender); PR_Free(contention); return rv; } /* ContentiousMonitor */
void _PR_InitGC(PRWord flags) { static char firstTime = 1; if (!firstTime) return; firstTime = 0; _MD_InitGC(); if (flags == 0) { char *ev = PR_GetEnv("GCLOG"); if (ev && ev[0]) { flags = atoi(ev); } } _pr_gcData.flags = flags; _pr_gcData.lock = PR_NewMonitor(); _pr_collectorTypes = (CollectorType*) PR_CALLOC(256 * sizeof(CollectorType)); PR_RegisterRootFinder(ScanThreads, "scan threads", 0); PR_RegisterRootFinder(_PR_ScanFinalQueue, "scan final queue", 0); }
JSBool jsj_init_js_obj_reflections_table() { #ifdef PRESERVE_JSOBJECT_IDENTITY if(js_obj_reflections != NULL) { return JS_TRUE; } js_obj_reflections = JS_NewHashTable(128, NULL, JS_CompareValues, JS_CompareValues, NULL, NULL); if (!js_obj_reflections) return JS_FALSE; #ifdef JSJ_THREADSAFE js_obj_reflections_monitor = PR_NewMonitor(); if (!js_obj_reflections_monitor) { JS_HashTableDestroy(js_obj_reflections); return JS_FALSE; } #endif /* JSJ_THREADSAFE */ #endif /* PRESERVE_JSOBJECT_IDENTITY */ return JS_TRUE; }
monitor_t monitor_create() { return (monitor_t)PR_NewMonitor(); }
NS_IMETHODIMP nsDNSService::Resolve(const nsACString &hostname, PRUint32 flags, nsIDNSRecord **result) { // grab reference to global host resolver and IDN service. beware // simultaneous shutdown!! nsRefPtr<nsHostResolver> res; nsCOMPtr<nsIIDNService> idn; { nsAutoLock lock(mLock); res = mResolver; idn = mIDN; } NS_ENSURE_TRUE(res, NS_ERROR_OFFLINE); const nsACString *hostPtr = &hostname; nsresult rv; nsCAutoString hostACE; if (idn && !IsASCII(hostname)) { if (NS_SUCCEEDED(idn->ConvertUTF8toACE(hostname, hostACE))) hostPtr = &hostACE; } // // sync resolve: since the host resolver only works asynchronously, we need // to use a mutex and a condvar to wait for the result. however, since the // result may be in the resolvers cache, we might get called back recursively // on the same thread. so, our mutex needs to be re-entrant. inotherwords, // we need to use a monitor! ;-) // PRMonitor *mon = PR_NewMonitor(); if (!mon) return NS_ERROR_OUT_OF_MEMORY; PR_EnterMonitor(mon); nsDNSSyncRequest syncReq(mon); PRUint16 af = GetAFForLookup(*hostPtr); rv = res->ResolveHost(PromiseFlatCString(*hostPtr).get(), flags, af, &syncReq); if (NS_SUCCEEDED(rv)) { // wait for result while (!syncReq.mDone) PR_Wait(mon, PR_INTERVAL_NO_TIMEOUT); if (NS_FAILED(syncReq.mStatus)) rv = syncReq.mStatus; else { NS_ASSERTION(syncReq.mHostRecord, "no host record"); nsDNSRecord *rec = new nsDNSRecord(syncReq.mHostRecord); if (!rec) rv = NS_ERROR_OUT_OF_MEMORY; else NS_ADDREF(*result = rec); } } PR_ExitMonitor(mon); PR_DestroyMonitor(mon); return rv; }