int testprog_set_affinity(int start_cpu, int end_cpu)
{
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
int i;
int retval;
int n_cpus = get_nprocs();
int n_cpus_conf = get_nprocs_conf();
if (n_cpus != n_cpus_conf) {
printf("uh, ncpus=%d but ncpus_conf=%d\n", n_cpus, n_cpus_conf);
}
if (start_cpu < 0) start_cpu=0;
if (end_cpu < 0 || end_cpu > n_cpus_conf) {
end_cpu = n_cpus_conf;
}
for (i=start_cpu; i<end_cpu; i++) {
CPU_SET(i,&cpu_set);
}
if ((retval = sched_setaffinity(0, sizeof(cpu_set), &cpu_set)) == 0) {
printf("Set affinity for CPUs %d-%d OK\n", start_cpu, end_cpu-1);
}
return retval;
}
std::string seissol::parallel::maskToString(cpu_set_t const& set) {
std::stringstream st;
for (int cpu = 0; cpu < get_nprocs(); ++cpu) {
if (cpu % 10 == 0 && cpu != 0 && cpu != get_nprocs()-1) {
st << '|';
}
if (CPU_ISSET(cpu, &set)) {
st << cpu % 10;
} else {
st << '-';
}
}
return st.str();
}
static void process_algo() {
int procs_cnt = get_nprocs();
threads = (pthread_t *) malloc(sizeof(pthread_t) * procs_cnt);
int thr_cnt = 0;
int step = (border - 1) / procs_cnt;
if ( (border - 1) % procs_cnt != 0) {
++step;
}
for (int i = 2; i <= border; i += step) {
int start = i;
int end = MIN(border, i + step - 1);
prime_args_t * args = malloc(sizeof *args);
args->start = start;
args->end = end;
int rc = pthread_create(&threads[thr_cnt++], NULL, &calculatePrime, args);
if (rc) {
printf("ERROR. failed to create thread\n");
exit(-1);
}
}
for (int i = 0; i < thr_cnt; ++i) {
int rc = pthread_join(threads[i], NULL);
printf("Thread %d exited\n", i);
}
free(threads);
}
int main(int argc, char *argv[])
{
int cpu_core_num = get_nprocs();
printf("CPU has %d core\n", cpu_core_num);
cpu_set_t mask;
cpu_set_t get;
int myid, i;
for (myid = 0; myid < cpu_core_num; myid++) {
CPU_ZERO(&mask);
CPU_SET(myid, &mask);
if (sched_setaffinity(0, sizeof(mask), &mask) == -1) {
printf("warning: could not set CPU affinity, continuing\n");
}
CPU_ZERO(&get);
if (sched_getaffinity(0, sizeof(get), &get) == -1) {
printf("warning: cound not get cpu affinity\n");
}
for (i = 0; i < cpu_core_num; i++) {
if (CPU_ISSET(i, &get)) {
printf("this process %d is running processor : %d\n",getpid(), i);
}
}
}
return EXIT_SUCCESS;
}
int nativeAvailableProcessors() {
#ifdef __UCLIBC__
return 1;
#else
return get_nprocs();
#endif
}
/*
Multithreading support
*/
int getNumberOfProcessors() {
#if defined(_SC_NPROCESSORS_ONLN)
return sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(__FreeBSD__) || defined(__APPLE__)
unsigned int len, count;
len = sizeof(count);
return sysctlbyname("hw.ncpu", &count, &len, NULL, 0);
#elif defined(_GNU_SOURCE)
return get_nprocs();
#elif defined(_WIN32)
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#else
return 1;
#endif
}
static int get_num_cores(void) {
#ifdef OS_WINDOWS
SYSTEM_INFO sysinfo;
#elif defined(__FreeBSD__) || defined(__APPLE__)
int m[2], count;
size_t len;
#endif
#ifdef linux
return get_nprocs();
#elif defined(OS_WINDOWS)
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined(__FreeBSD__) || defined(__APPLE__)
m[0] = CTL_HW;
m[1] = HW_NCPU;
len = sizeof(int);
sysctl(m, 2, &count, &len, NULL, 0);
return count;
#else
return 2;
#endif
}
int main()
{
uint32_t seq = 0;
unsigned int i=0;
proc_num = get_nprocs();
gap = 100000000 / proc_num;
signal(SIGUSR1,sig_handler);
/*read from stdin*/
for(i=0; i<16; i++)
{
scanf("%2x",&crypto_word[i]);
}
//scanf("%s",BUFF);
//to();
for(i=0; i<proc_num; i++)
{
beginSeq[i] = gap * i;
}
createChildProcess(proc_num);
int waitNum = 0;
while(wait(NULL))
{
waitNum++;
if(waitNum==proc_num)
break;
}
return 0;
}
void
main()
{
printf("get_nprocs_conf %d get_nproc %d\n", get_nprocs_conf(), get_nprocs());
printf("---- N_CONF %d ---N_ONLN %d\n", NPCONF, NPONLN );
return;
}
int thread_binding_cpu(pthread_t _tid, int cpu_seq)
{
int cpu_core_num = get_nprocs();
printf("CPU has %d core\n", cpu_core_num);
cpu_set_t mask;
cpu_set_t get;
_tid = (_tid == 0 ? pthread_self() : _tid);
/* 绑定 */
cpu_seq = (cpu_seq >= (cpu_core_num - 1) ? (cpu_core_num - 1) : cpu_seq);
CPU_ZERO(&mask);
CPU_SET(cpu_seq, &mask);
if (pthread_setaffinity_np(_tid , sizeof(mask), &mask) == -1)
{
printf("warning: could not set CPU affinity, continuing\n");
return 1;
}
/* 查询绑定结果 */
CPU_ZERO(&get);
if (pthread_getaffinity_np(_tid, sizeof(get), &get) == -1)
{
printf("warning: cound not get cpu affinity\n");
return 1;
}
for(int i = 0; i < cpu_core_num; i++)
{
if (CPU_ISSET(i, &get))
{
printf("this thread %d is running processor : %d\n", (int)(_tid), i);
}
}
return 0;
}
long
sysconfupd(int name)
{
long *ptr = sysconftab - MINSYSCONF;
long ret = -1;
switch (name) {
case _SC_NPROCESSORS_ONLN:
ret = ptr[_SC_NPROCESSORS_ONLN] = get_nprocs();
break;
case _SC_NPROCESSORS_CONF:
ret = ptr[_SC_NPROCESSORS_CONF] = get_nprocs_conf();
break;
case _SC_AVPHYS_PAGES:
ret = ptr[_SC_AVPHYS_PAGES] = get_avphys_pages();
break;
case _SC_PHYS_PAGES:
ret = ptr[_SC_PHYS_PAGES] = get_phys_pages();
break;
}
return ret;
}
int main()
{
uint32_t seq = 0;
unsigned int i=0;
proc_num = get_nprocs();
if(proc_num==1)
proc_num += 2;
else if(proc_num==2)
proc_num+=2;
if(proc_num==3 || proc_num == 4)
gap = 123000000 / proc_num;
else
gap = 100000000 / proc_num;
/*read from stdin*/
//scanf("%s",BUFF);
//to();
unsigned int temp;
for(i=0;i<MD5_LEN;i++){
scanf("%2x",&temp);
crypto_word[i] = temp;
}
//if(proc_num == 1){
//
// one_proc();
// exit(0);
// }
signal(SIGUSR1,sig_handler);
for(i=0;i<proc_num;i++){
beginSeq[i] = gap * i;
}
createChildProcess(proc_num);
/*mq_unlink(MSGQUEUE);
struct mq_attr attr;
attr.mq_maxmsg = 10000;
attr.mq_msgsize = MSGSIZE;
msgQueueId = mq_open(MSGQUEUE,O_RDWR|O_CREAT,0664,&attr);
createChildProcess(proc_num);
for(;seq<100000000;seq+=gap){
mq_send(msgQueueId,&seq,4,0);
}*/
int waitNum = 0;
while(wait(NULL)){
waitNum++;
if(waitNum==proc_num)
break;
}
mq_close(msgQueueId);
mq_unlink(MSGQUEUE);
return 0;
}
/**
* ppg_get_num_cpus:
*
* Retrieves the number of CPUs available on the system.
*
* Returns: None.
* Side effects: None.
*/
guint
ppg_get_num_cpus (void)
{
#if __linux__
return get_nprocs();
#else
return 1;
#endif
}
g_val_t
cpu_num_func ( void )
{
g_val_t val;
/* Use _SC_NPROCESSORS_ONLN to get operating cpus */
val.uint16 = get_nprocs();
return val;
}
//returns the number of cores that will be used to run "child-LZMA-encoders"
int getNprocsToUse() {
int coresAvailable = get_nprocs();
if (coresAvailable <1) //just in case it fails
coresAvailable=1;
else if (coresAvailable > DEFAULT_NPROC)
coresAvailable--; //leaves one core unused.
else
coresAvailable=DEFAULT_NPROC;
return coresAvailable;
}
NspJobs *
nsp_jobs_new()
{
NspJobs *jobs = malloc(sizeof(NspJobs));
assert(jobs != NULL);
jobs->pool = g_thread_pool_new ((GFunc)nsp_jobs_main_loop, NULL, get_nprocs()+1, FALSE, NULL );
return jobs;
}
size_t GetNumCPUs()
{
#ifdef LIBHVL_PLATFORM_WIN32
SYSTEM_INFO sysinfo;
GetSystemInfo(&sysinfo);
return sysinfo.dwNumberOfProcessors;
#elif defined LIBHVL_PLATFORM_UNIX
int cpus = get_nprocs();
return cpus > 0 ? cpus : 1;
#endif //HVL_THREADING_
}
cpu_set_t seissol::parallel::getFreeCPUsMask() {
cpu_set_t workerUnion = getWorkerUnionMask();
cpu_set_t set;
CPU_ZERO(&set);
for (int i = 0; i < get_nprocs() ; ++i) {
CPU_SET(i, &set);
}
CPU_XOR(&set, &set, &workerUnion);
return set;
}
int32_t get_CPU_core_num()
{
#if defined(WIN32)
SYSTEM_INFO info;
GetSystemInfo(&info);
return info.dwNumberOfProcessors;
#elif defined(LINUX) || defined(SOLARIS) || defined(AIX)
return get_nprocs(); //GNU fuction
#else
#error unsupported system
#endif
}
void vogl_threading_init()
{
#ifdef WIN32
SYSTEM_INFO g_system_info;
GetSystemInfo(&g_system_info);
g_number_of_processors = math::maximum<uint>(1U, g_system_info.dwNumberOfProcessors);
#elif defined(__GNUC__)
g_number_of_processors = math::maximum<int>(1, get_nprocs());
#else
g_number_of_processors = 1;
#endif
}
uint lzham_get_max_helper_threads()
{
#if defined(__GNUC__)
uint num_procs = get_nprocs();
return num_procs ? (num_procs - 1) : 0;
#else
printf("TODO: lzham_get_max_helper_threads(): Implement system specific func to determine the max # of helper threads\n");
// Just assume a dual-core machine.
return 1;
#endif
}
GLT_func_prefix void glt_init(int argc, char * argv[]) {
int num_threads = get_nprocs();
main_team = (glt_team_t *) malloc(sizeof (glt_team_t));
CHECK(ABT_init(argc, argv),ABT_SUCCESS);
if (getenv("GLT_NUM_THREADS") != NULL) {
num_threads = atoi(getenv("GLT_NUM_THREADS"));
}
int num_pools = num_threads;
if (getenv("GLT_NUM_POOLS") != NULL) {
num_pools = atoi(getenv("GLT_NUM_POOLS"));
}
CHECK(ABT_xstream_self(&main_team->master),ABT_SUCCESS);
main_team->num_xstreams = num_threads;
main_team->num_pools = num_pools;
main_team->max_elem = get_nprocs();
main_team->team = (ABT_xstream *) malloc(sizeof (ABT_xstream) * num_threads);//main_team->max_elem);
main_team->pools = (ABT_pool *) malloc(sizeof (ABT_pool) * num_pools);//main_team->max_elem);
for (int i = 0; i < num_pools; i++) {
CHECK(ABT_pool_create_basic(ABT_POOL_FIFO, ABT_POOL_ACCESS_MPMC, ABT_TRUE,
&main_team->pools[i]),ABT_SUCCESS);
}
CHECK(ABT_xstream_self(&main_team->team[0]),ABT_SUCCESS);
CHECK(ABT_xstream_set_main_sched_basic(main_team->team[0], ABT_SCHED_DEFAULT,
1, &main_team->pools[0]),ABT_SUCCESS);
for (int i = 1; i < num_threads; i++) {
CHECK(ABT_xstream_create_basic(ABT_SCHED_DEFAULT, 1,
&main_team->pools[i % main_team->num_pools],
ABT_SCHED_CONFIG_NULL, &main_team->team[i]),ABT_SUCCESS);
CHECK(ABT_xstream_start(main_team->team[i]),ABT_SUCCESS);
}
}
static void compensate(double load[])
{
static double num = 0.0;
if (num == 0.0) {
num = (double)get_nprocs();
if (num == 0.0)
num = 1.0;
}
for (int i = 0; i < 3; i++)
load[i] /= num;
}
unsigned int embb_core_count_available() {
#ifdef EMBB_PLATFORM_HAS_HEADER_SYSINFO
return get_nprocs();
#elif defined EMBB_PLATFORM_HAS_HEADER_SYSCTL
const size_t kBufferSize = sizeof(unsigned int);
char buf[kBufferSize];
size_t len = kBufferSize;
sysctlbyname("hw.ncpu", buf, &len, NULL, 0);
return *(unsigned int*)&buf;
#else
#error "No implementation for embb_core_count_available()!"
#endif
}
uint32_t
PerfxCpu_GetCount(void)
{
#if defined(__linux__)
return get_nprocs();
#elif defined(__APPLE__)
int count = 0;
size_t size = sizeof(count);
sysctlbyname("hw.ncpu", &count, &size, NULL, 0);
return count;
#else
#error "You're platform is not supported."
#endif
}
void http_server::run()
{
std::vector<std::shared_ptr<std::thread> > threads;
for (std::size_t i = 0; i < get_nprocs(); ++i)
{
std::shared_ptr<std::thread> thread(new std::thread([this](){
io_service_.run();
}));
threads.push_back(thread);
}
for (std::size_t i = 0; i < 2; ++i)
threads[i]->join();
}
/* Get the number of CPUs */
static int get_ncpu() {
int ncpu;
#ifdef _SC_NPROCESSORS_ONLN
ncpu = sysconf(_SC_NPROCESSORS_ONLN);
#elif defined __APPLE__
int mib[2] = {CTL_HW, HW_NCPU};
size_t len = sizeof(ncpu);
sysctl(mib, 2, &ncpu, &len, NULL, 0);
#elif defined _GNU_SOURCE
ncpu = get_nprocs();
#else
ncpu = -1;
#endif
return ncpu;
}
unsigned possibleThreadCount() {
#if defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#elif defined(__APPLE__) || defined(__FreeBSD__)
int count;
size_t size = sizeof(count);
return sysctlbyname("hw.ncpu", &count, &size, NULL, 0) ? 0 : count;
#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
int const count = sysconf(_SC_NPROCESSORS_ONLN);
return (count > 0) ? count : 1;
#elif defined(_GNU_SOURCE)
return get_nprocs();
#else
return 1;
#endif
}
int TestMain () {
#if _WIN32||_WIN64 || __linux__ || __FreeBSD_version >= 701000
#if _WIN32||_WIN64
SYSTEM_INFO si;
GetSystemInfo(&si);
if ( si.dwNumberOfProcessors < 2 )
return Harness::Skipped;
int availableProcs = (int)si.dwNumberOfProcessors / 2;
DWORD_PTR mask = 1;
for ( int i = 1; i < availableProcs; ++i )
mask |= mask << 1;
bool err = !SetProcessAffinityMask( GetCurrentProcess(), mask );
#else /* !WIN */
#if __linux__
int maxProcs = get_nprocs();
typedef cpu_set_t mask_t;
#if __TBB_MAIN_THREAD_AFFINITY_BROKEN
#define setaffinity(mask) sched_setaffinity(0 /*get the mask of the calling thread*/, sizeof(mask_t), &mask)
#else
#define setaffinity(mask) sched_setaffinity(getpid(), sizeof(mask_t), &mask)
#endif
#else /* __FreeBSD__ */
int maxProcs = sysconf(_SC_NPROCESSORS_ONLN);
typedef cpuset_t mask_t;
#if __TBB_MAIN_THREAD_AFFINITY_BROKEN
#define setaffinity(mask) cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1, sizeof(mask_t), &mask)
#else
#define setaffinity(mask) cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_PID, -1, sizeof(mask_t), &mask)
#endif
#endif /* __FreeBSD__ */
if ( maxProcs < 2 )
return Harness::Skipped;
mask_t newMask;
CPU_ZERO(&newMask);
int availableProcs = min(maxProcs, (int)sizeof(mask_t) * CHAR_BIT) / 2;
for ( int i = 0; i < availableProcs; ++i )
CPU_SET( i, &newMask );
int err = setaffinity( newMask );
#endif /* !WIN */
ASSERT( !err, "Setting process affinity failed" );
ASSERT( tbb::task_scheduler_init::default_num_threads() == availableProcs, NULL );
ASSERT( (int)tbb::tbb_thread::hardware_concurrency() == availableProcs, NULL );
return Harness::Done;
#else /* !(WIN || LIN || BSD) */
return Harness::Skipped;
#endif /* !(WIN || LIN || BSD) */
}
unsigned thread::hardware_concurrency()
{
#if defined(PTW32_VERSION) || defined(__hpux)
return pthread_num_processors_np();
#elif defined(__APPLE__) || defined(__FreeBSD__)
int count;
size_t size=sizeof(count);
return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
#elif defined(BOOST_HAS_UNISTD_H) && defined(_SC_NPROCESSORS_ONLN)
int const count=sysconf(_SC_NPROCESSORS_ONLN);
return (count>0)?count:0;
#elif defined(__GLIBC__)
return get_nprocs();
#else
return 0;
#endif
}
