void __fastcall TForm1::FormCreate(TObject *Sender) { unsigned char loadCPU[20]; sprintf(loadCPU, "%0.0f", getLoadCPU(getNumberOfProcessors())); Label4->SetTextBuf(loadCPU); unsigned char loadRAM[20]; sprintf(loadRAM, "%d", getLoadRAM()); Label5->SetTextBuf(loadRAM); unsigned char numberOfProcessors[20]; sprintf(numberOfProcessors, "%d", getNumberOfProcessors()); Label6->SetTextBuf(numberOfProcessors); saveInPdata(pdata.loadCPU, loadCPU); saveInPdata(pdata.loadRAM, loadRAM); saveInPdata(pdata.numberOfProcessors, numberOfProcessors); if ( 1 == connect() ) { hid.SendData(&pdata); } else { AnsiString s = ""; s += vendorName; s += " "; s += productName; s += " не подключено."; ShowMessage(s); } }
void ossimMpi::initialize(int* argc, char*** argv) { int success=0; success = MPI_Init(argc, argv); if(success == MPI_SUCCESS) { theEnabledFlag = true; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimMpi::initialize\n" << "MPI is initialized and running with " << getNumberOfProcessors() << " processors..." << std::endl; } } else { theEnabledFlag = false; if(traceDebug()) { ossimNotify(ossimNotifyLevel_DEBUG) << "DEBUG ossimMpi::initialize: MPI is not initialized." << std::endl; } } }
// Schedules the thread to run on CPU n of m. m may be less than the // number of physical CPUs, in which case, the thread will be allowed // to run on CPU n, n+m, n+2m etc. void setThreadAffinity (nat n, nat m) { if (RtsFlags.ParFlags.setAffinityTopology != NULL) { nat s = RtsFlags.ParFlags.setAffinityTopologySize; nat c = RtsFlags.ParFlags.setAffinityTopologyCount; char* p = RtsFlags.ParFlags.setAffinityTopology; cpu_set_t* set = (cpu_set_t*)(p + (n % c) * s); sched_setaffinity(0, s, set); } else { nat nproc; cpu_set_t cs; nat i; nproc = getNumberOfProcessors(); CPU_ZERO(&cs); for (i = n; i < nproc; i+=m) { CPU_SET(i, &cs); } sched_setaffinity(0, sizeof(cpu_set_t), &cs); } }
// Schedules the thread to run on CPU n of m. m may be less than the // number of physical CPUs, in which case, the thread will be allowed // to run on CPU n, n+m, n+2m etc. void setThreadAffinity (nat n, nat m) { nat nproc; cpu_set_t cs; nat i; nproc = getNumberOfProcessors(); CPU_ZERO(&cs); for (i = n; i < nproc; i+=m) { CPU_SET(i, &cs); } sched_setaffinity(0, sizeof(cpu_set_t), &cs); }
/* * This (allegedly) OS threads independent layer was initially * abstracted away from code that used Pthreads, so the functions * provided here are mostly just wrappers to the Pthreads API. * */ void initCondition( Condition* pCond ) { pthread_cond_init(pCond, NULL); return; } void closeCondition( Condition* pCond ) { pthread_cond_destroy(pCond); return; } rtsBool broadcastCondition ( Condition* pCond ) { return (pthread_cond_broadcast(pCond) == 0); } rtsBool signalCondition ( Condition* pCond ) { return (pthread_cond_signal(pCond) == 0); } rtsBool waitCondition ( Condition* pCond, Mutex* pMut ) { return (pthread_cond_wait(pCond,pMut) == 0); } void yieldThread(void) { sched_yield(); return; } void shutdownThread(void) { pthread_exit(NULL); } int createOSThread (OSThreadId* pId, OSThreadProc *startProc, void *param) { int result = pthread_create(pId, NULL, (void *(*)(void *))startProc, param); if(!result) pthread_detach(*pId); return result; } OSThreadId osThreadId(void) { return pthread_self(); } rtsBool osThreadIsAlive(OSThreadId id STG_UNUSED) { // no good way to implement this on POSIX, AFAICT. Returning true // is safe. return rtsTrue; } void initMutex(Mutex* pMut) { #if defined(DEBUG) pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_settype(&attr,PTHREAD_MUTEX_ERRORCHECK); pthread_mutex_init(pMut,&attr); #else pthread_mutex_init(pMut,NULL); #endif return; } void closeMutex(Mutex* pMut) { pthread_mutex_destroy(pMut); } void newThreadLocalKey (ThreadLocalKey *key) { int r; if ((r = pthread_key_create(key, NULL)) != 0) { barf("newThreadLocalKey: %s", strerror(r)); } } void * getThreadLocalVar (ThreadLocalKey *key) { return pthread_getspecific(*key); // Note: a return value of NULL can indicate that either the key // is not valid, or the key is valid and the data value has not // yet been set. We need to use the latter case, so we cannot // detect errors here. } void setThreadLocalVar (ThreadLocalKey *key, void *value) { int r; if ((r = pthread_setspecific(*key,value)) != 0) { barf("setThreadLocalVar: %s", strerror(r)); } } void freeThreadLocalKey (ThreadLocalKey *key) { int r; if ((r = pthread_key_delete(*key)) != 0) { barf("freeThreadLocalKey: %s", strerror(r)); } } static void * forkOS_createThreadWrapper ( void * entry ) { Capability *cap; cap = rts_lock(); rts_evalStableIO(&cap, (HsStablePtr) entry, NULL); rts_unlock(cap); return NULL; } int forkOS_createThread ( HsStablePtr entry ) { pthread_t tid; int result = pthread_create(&tid, NULL, forkOS_createThreadWrapper, (void*)entry); if(!result) pthread_detach(tid); return result; } nat getNumberOfProcessors (void) { static nat nproc = 0; if (nproc == 0) { #if defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_ONLN) nproc = sysconf(_SC_NPROCESSORS_ONLN); #elif defined(HAVE_SYSCONF) && defined(_SC_NPROCESSORS_CONF) nproc = sysconf(_SC_NPROCESSORS_CONF); #elif defined(darwin_HOST_OS) || defined(freebsd_HOST_OS) size_t size = sizeof(nat); if(0 != sysctlbyname("hw.ncpu",&nproc,&size,NULL,0)) nproc = 1; #else nproc = 1; #endif } return nproc; } #if defined(HAVE_SCHED_H) && defined(HAVE_SCHED_SETAFFINITY) // Schedules the thread to run on CPU n of m. m may be less than the // number of physical CPUs, in which case, the thread will be allowed // to run on CPU n, n+m, n+2m etc. void setThreadAffinity (nat n, nat m) { nat nproc; cpu_set_t cs; nat i; nproc = getNumberOfProcessors(); CPU_ZERO(&cs); for (i = n; i < nproc; i+=m) { CPU_SET(i, &cs); } sched_setaffinity(0, sizeof(cpu_set_t), &cs); } #elif defined(darwin_HOST_OS) && defined(THREAD_AFFINITY_POLICY) // Schedules the current thread in the affinity set identified by tag n. void setThreadAffinity (nat n, nat m GNUC3_ATTRIBUTE(__unused__)) { thread_affinity_policy_data_t policy; policy.affinity_tag = n; thread_policy_set(mach_thread_self(), THREAD_AFFINITY_POLICY, (thread_policy_t) &policy, THREAD_AFFINITY_POLICY_COUNT); } #elif defined(HAVE_SYS_CPUSET_H) /* FreeBSD 7.1+ */ void setThreadAffinity(nat n, nat m) { nat nproc; cpuset_t cs; nat i; nproc = getNumberOfProcessors(); CPU_ZERO(&cs); for (i = n; i < nproc; i += m) CPU_SET(i, &cs); cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(cpuset_t), &cs); }