int
set_thread_locality(void *threadid, char *loc_type, char *loc_value, int debug, FILE *where) {
int err, value;
tid_t thread_id;
NETPERF_DEBUG_ENTRY(debug,where);
thread_id = *(tid_t *)(threadid);
value = atoi(loc_value);
err = bindprocessor(BINDTHREAD, thread_id, value);
if (debug) {
fprintf(where,
"%s's call to bindprocessor with BINDTHREAD thread %d and value %d returned %d errno %d\n",
__func__,
thread_id,
value,
err,
errno);
fflush(where);
}
NETPERF_DEBUG_EXIT(debug,where);
return(NPE_SUCCESS);
}
/* CPU affinity mask buffer instead, as the present code will fail beyond 32 CPUs */
int set_cpu_affinity(unsigned int cpuid) {
unsigned long mask = 0xffffffff;
unsigned int len = sizeof(mask);
int retValue = 0;
int pid;
#ifdef _WIN32
HANDLE hProcess;
#endif
#ifdef _WIN32
SET_MASK(cpuid)
hProcess = GetCurrentProcess();
if (SetProcessAffinityMask(hProcess, mask) == 0) {
return -1;
}
#elif CMK_HAS_BINDPROCESSOR
pid = getpid();
if (bindprocessor(BINDPROCESS, pid, cpuid) == -1) return -1;
#else
#ifdef CPU_ALLOC
if ( cpuid >= CPU_SETSIZE ) {
cpu_set_t *cpusetp;
size_t size;
int num_cpus;
num_cpus = cpuid + 1;
cpusetp = CPU_ALLOC(num_cpus);
if (cpusetp == NULL) {
perror("set_cpu_affinity CPU_ALLOC");
return -1;
}
size = CPU_ALLOC_SIZE(num_cpus);
CPU_ZERO_S(size, cpusetp);
CPU_SET_S(cpuid, size, cpusetp);
if (sched_setaffinity(0, size, cpusetp) < 0) {
perror("sched_setaffinity dynamically allocated");
CPU_FREE(cpusetp);
return -1;
}
CPU_FREE(cpusetp);
} else
#endif
{
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(cpuid, &cpuset);
/*SET_MASK(cpuid)*/
/* PID 0 refers to the current process */
/*if (sched_setaffinity(0, len, &mask) < 0) {*/
if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
perror("sched_setaffinity");
return -1;
}
}
#endif
return 0;
}
void write_one_affinity(int a) {
if (a >= 0) {
int tid = thread_self();
if (bindprocessor(BINDTHREAD, tid, a) < 0) {
fatal("bindprocessor") ;
}
}
}
int
clear_own_locality(char *loc_type, int debug, FILE *where){
int err;
err = bindprocessor(BINDTHREAD, thread_self(), PROCESSOR_CLASS_ANY);
return(NPE_SUCCESS);
}
void force_one_affinity(int cpu, int a, int verbose, char *name) {
if (a >= 0) {
int tid = thread_self();
int r ;
do {
r = bindprocessor(BINDTHREAD, tid, a) ;
} while (r < 0) ;
}
}
/**
This routine will set affinity for the calling thread that has rank 'rank'.
Ranks start with 0.
If there are multiple instances of QUARK then affinity will be wrong: all ranks 0
will be pinned to core 0.
Also, affinity is not resotred when QUARK_Finalize() is called.
*/
int quark_setaffinity(int rank) {
#ifndef QUARK_AFFINITY_DISABLE
#if (defined QUARK_OS_LINUX)
{
cpu_set_t set;
CPU_ZERO( &set );
CPU_SET( rank, &set );
#if (defined HAVE_OLD_SCHED_SETAFFINITY)
if( sched_setaffinity( 0, &set ) < 0 )
#else /* HAVE_OLD_SCHED_SETAFFINITY */
if( sched_setaffinity( 0, sizeof(set), &set) < 0 )
#endif /* HAVE_OLD_SCHED_SETAFFINITY */
{
return QUARK_ERR_UNEXPECTED;
}
return QUARK_SUCCESS;
}
#elif (defined QUARK_OS_MACOS)
{
thread_affinity_policy_data_t ap;
int ret;
ap.affinity_tag = 1; /* non-null affinity tag */
ret = thread_policy_set( mach_thread_self(),
THREAD_AFFINITY_POLICY,
(integer_t*) &ap,
THREAD_AFFINITY_POLICY_COUNT
);
if(ret != 0)
return QUARK_ERR_UNEXPECTED;
return QUARK_SUCCESS;
}
#elif (defined QUARK_OS_WINDOWS)
{
DWORD mask = 1 << rank;
if( SetThreadAffinityMask(GetCurrentThread(), mask) == 0)
return QUARK_ERR_UNEXPECTED;
return QUARK_SUCCESS;
}
#elif (defined QUARK_OS_AIX)
{
tid_t self_ktid = thread_self ();
bindprocessor(BINDTHREAD, self_ktid, rank);
return QUARK_SUCCESS;
}
#else
return QUARK_ERR_NOT_SUPPORTED;
#endif
#endif /* QUARK_AFFINITY_DISABLE */
return QUARK_ERR_NOT_SUPPORTED;
}
static int ATL_setmyaffinity()
/*
* Attempts to sets the affinity of an already-running thread. The
* aff_set flag is set to true whether we succeed or not (no point in
* trying multiple times).
* RETURNS: 0 on success, non-zero error code on error
*/
{
int bindID;
bindID = omp_get_thread_num();
#ifdef ATL_RANK_IS_PROCESSORID
bindID = bindID % ATL_AFF_NUMID;
#else
bindID = ATL_affinityIDs[bindID%ATL_AFF_NUMID];
#endif
#ifdef ATL_PAFF_PLPA
plpa_cpu_set_t cpuset;
PLPA_CPU_ZERO(&cpuset);
PLPA_CPU_SET(bindID, &cpuset);
if (me->paff_set)
return(0);
me->paff_set = 1;
return(plpa_sched_setaffinity((pid_t)0, sizeof(cpuset), &cpuset));
#elif defined(ATL_PAFF_PBIND)
return(processor_bind(P_LWPID, P_MYID, bindID, NULL));
#elif defined(ATL_PAFF_SCHED)
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(bindID, &cpuset);
if (me->paff_set)
return(0);
me->paff_set = 1;
return(sched_setaffinity(0, sizeof(cpuset), &cpuset));
#elif defined (ATL_PAFF_RUNON)
if (me->paff_set)
return(0);
me->paff_set = 1;
return(pthread_setrunon_np(bindID));
#elif defined(ATL_PAFF_BINDP)
if (me->paff_set)
return(0);
me->paff_set = 1;
return(bindprocessor(BINDTHREAD, thread_self(), bindID));
#elif defined(ATL_PAFF_CPUSET) /* untried FreeBSD code */
cpuset_t mycpuset;
CPU_ZERO(&mycpuset); /* no manpage, so guess works like linux */
CPU_SET(bindID, &mycpuset);
if (me->paff_set)
return(0);
me->paff_set = 1;
return(cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, -1,
sizeof(mycpuset), &mycpuset));
#endif
return(0);
}
bool threadBindToProcessor(threadid_t tid, int pnumber)
{
#if defined(_WIN32)
HANDLE hThread = OpenThread(THREAD_ALL_ACCESS, 0, tid);
if (!hThread)
return false;
bool success = SetThreadAffinityMask(hThread, 1 << pnumber) != 0;
CloseHandle(hThread);
return success;
#elif (defined(__FreeBSD__) && (__FreeBSD_version >= 702106)) \
|| defined(__linux) || defined(linux)
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(pnumber, &cpuset);
return pthread_setaffinity_np(tid, sizeof(cpuset), &cpuset) == 0;
#elif defined(__sun) || defined(sun)
return processor_bind(P_LWPID, MAKE_LWPID_PTHREAD(tid),
pnumber, NULL) == 0;
#elif defined(_AIX)
return bindprocessor(BINDTHREAD, (tid_t)tid, pnumber) == 0;
#elif defined(__hpux) || defined(hpux)
pthread_spu_t answer;
return pthread_processor_bind_np(PTHREAD_BIND_ADVISORY_NP,
&answer, pnumber, tid) == 0;
#elif defined(__APPLE__)
struct thread_affinity_policy tapol;
thread_port_t threadport = pthread_mach_thread_np(tid);
tapol.affinity_tag = pnumber + 1;
return thread_policy_set(threadport, THREAD_AFFINITY_POLICY,
(thread_policy_t)&tapol, THREAD_AFFINITY_POLICY_COUNT) == KERN_SUCCESS;
#else
return false;
#endif
}
void *test7_thread(void *v_param)
{
if(bindprocessor(BINDTHREAD, thread_self(), (cpu_t)v_param) != 0) {
printf("Error binding thread to processor %d, errno = %d.\n",
(int)v_param, errno);
}
while(!done) {
DO_YIELD;
}
return NULL;
}
bool Thread::bindToProcessor(unsigned int proc_number)
{
#if defined(__ANDROID__)
return false;
#elif defined(_WIN32)
return SetThreadAffinityMask(m_thread_handle, 1 << proc_number);
#elif __FreeBSD_version >= 702106 || defined(__linux) || defined(linux)
cpu_set_t cpuset;
CPU_ZERO(&cpuset);
CPU_SET(proc_number, &cpuset);
return pthread_setaffinity_np(m_thread_handle, sizeof(cpuset), &cpuset) == 0;
#elif defined(__sun) || defined(sun)
return processor_bind(P_LWPID, P_MYID, proc_number, NULL) == 0
#elif defined(_AIX)
return bindprocessor(BINDTHREAD, m_kernel_thread_id, proc_number) == 0;
#elif defined(__hpux) || defined(hpux)
pthread_spu_t answer;
return pthread_processor_bind_np(PTHREAD_BIND_ADVISORY_NP,
&answer, proc_number, m_thread_handle) == 0;
#elif defined(__APPLE__)
struct thread_affinity_policy tapol;
thread_port_t threadport = pthread_mach_thread_np(m_thread_handle);
tapol.affinity_tag = proc_number + 1;
return thread_policy_set(threadport, THREAD_AFFINITY_POLICY,
(thread_policy_t)&tapol,
THREAD_AFFINITY_POLICY_COUNT) == KERN_SUCCESS;
#else
return false;
#endif
}
int
main (void)
{
printf("##############################################################\n"
"# K42 Threading Microbenchmarks\n"
"# AIX Run\n"
"##############################################################\n");
if(bindprocessor(BINDPROCESS, getpid(), 0) != 0) {
printf("Bindprocessor failed.\n");
return 8;
}
test1();
test2();
test3();
return 0;
}
/* TODO: seems to be right, but doesn't seem to be working (EINVAL), even after
* aligning the range on 64K... */
static int
hwloc_aix_set_area_membind(hwloc_topology_t topology, const void *addr, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
subrange_t subrange;
rsid_t rsid = { .at_subrange = &subrange };
uint_t aix_policy;
int ret;
fprintf(stderr,"yop\n");
if ((flags & (HWLOC_MEMBIND_MIGRATE|HWLOC_MEMBIND_STRICT))
== (HWLOC_MEMBIND_MIGRATE|HWLOC_MEMBIND_STRICT)) {
errno = ENOSYS;
return -1;
}
subrange.su_offset = (uintptr_t) addr;
subrange.su_length = len;
subrange.su_rstype = R_RSET;
if (hwloc_aix_membind_policy_from_hwloc(&aix_policy, policy))
return -1;
if (hwloc_aix_prepare_membind(topology, &subrange.su_rsid.at_rset, nodeset, flags))
return -1;
subrange.su_policy = aix_policy;
res = ra_attachrset(R_SUBRANGE, rsid, subrange.su_rsid.at_rset, 0);
if (res < 0 && errno == EPERM) {
/* EPERM may mean that one thread has ben bound with bindprocessor().
* Unbind the entire process (we can't unbind individual threads)
* and try again.
* FIXME: actually check that this EPERM can happen
*/
bindprocessor(BINDPROCESS, getpid(), PROCESSOR_CLASS_ANY);
res = ra_attachrset(R_SUBRANGE, rsid, subrange.su_rsid.at_rset, 0);
}
rs_free(subrange.su_rsid.at_rset);
return ret;
}
static int
hwloc_aix_set_sth_cpubind(hwloc_topology_t topology, rstype_t what, rsid_t who, pid_t pid, hwloc_const_bitmap_t hwloc_set, int flags __hwloc_attribute_unused)
{
rsethandle_t rad;
int res;
unsigned cpu;
if (flags & HWLOC_CPUBIND_NOMEMBIND) {
errno = ENOSYS;
return -1;
}
/* The resulting binding is always strict */
if (hwloc_bitmap_isequal(hwloc_set, hwloc_topology_get_complete_cpuset(topology))) {
if (ra_detachrset(what, who, 0))
return -1;
return 0;
}
rad = rs_alloc(RS_EMPTY);
hwloc_bitmap_foreach_begin(cpu, hwloc_set)
rs_op(RS_ADDRESOURCE, rad, NULL, R_PROCS, cpu);
hwloc_bitmap_foreach_end();
res = ra_attachrset(what, who, rad, 0);
if (res < 0 && errno == EPERM) {
/* EPERM may mean that one thread has ben bound with bindprocessor().
* Unbind the entire process (we can't unbind individual threads)
* and try again.
*/
bindprocessor(BINDPROCESS, pid, PROCESSOR_CLASS_ANY);
res = ra_attachrset(what, who, rad, 0);
}
rs_free(rad);
return res;
}
static int
hwloc_aix_set_sth_membind(hwloc_topology_t topology, rstype_t what, rsid_t who, pid_t pid, hwloc_const_bitmap_t nodeset, hwloc_membind_policy_t policy, int flags)
{
rsethandle_t rad;
int res;
if (flags & HWLOC_MEMBIND_NOCPUBIND) {
errno = ENOSYS;
return -1;
}
switch (policy) {
case HWLOC_MEMBIND_DEFAULT:
case HWLOC_MEMBIND_BIND:
break;
default:
errno = ENOSYS;
return -1;
}
if (hwloc_aix_prepare_membind(topology, &rad, nodeset, flags))
return -1;
res = ra_attachrset(what, who, rad, 0);
if (res < 0 && errno == EPERM) {
/* EPERM may mean that one thread has ben bound with bindprocessor().
* Unbind the entire process (we can't unbind individual threads)
* and try again.
*/
bindprocessor(BINDPROCESS, pid, PROCESSOR_CLASS_ANY);
res = ra_attachrset(what, who, rad, 0);
}
rs_free(rad);
return res;
}
static int make_child(server_rec *s, int slot)
{
int pid;
if (slot + 1 > ap_max_daemons_limit) {
ap_max_daemons_limit = slot + 1;
}
if (one_process) {
apr_signal(SIGHUP, just_die);
/* Don't catch AP_SIG_GRACEFUL in ONE_PROCESS mode :) */
apr_signal(SIGINT, just_die);
#ifdef SIGQUIT
apr_signal(SIGQUIT, SIG_DFL);
#endif
apr_signal(SIGTERM, just_die);
child_main(slot);
}
(void) ap_update_child_status_from_indexes(slot, 0, SERVER_STARTING,
(request_rec *) NULL);
#ifdef _OSD_POSIX
/* BS2000 requires a "special" version of fork() before a setuid() call */
if ((pid = os_fork(unixd_config.user_name)) == -1) {
#elif defined(TPF)
if ((pid = os_fork(s, slot)) == -1) {
#else
if ((pid = fork()) == -1) {
#endif
ap_log_error(APLOG_MARK, APLOG_ERR, errno, s, "fork: Unable to fork new process");
/* fork didn't succeed. Fix the scoreboard or else
* it will say SERVER_STARTING forever and ever
*/
(void) ap_update_child_status_from_indexes(slot, 0, SERVER_DEAD,
(request_rec *) NULL);
/* In case system resources are maxxed out, we don't want
Apache running away with the CPU trying to fork over and
over and over again. */
sleep(10);
return -1;
}
if (!pid) {
#ifdef HAVE_BINDPROCESSOR
/* by default AIX binds to a single processor
* this bit unbinds children which will then bind to another cpu
*/
int status = bindprocessor(BINDPROCESS, (int)getpid(),
PROCESSOR_CLASS_ANY);
if (status != OK) {
ap_log_error(APLOG_MARK, APLOG_WARNING, errno,
ap_server_conf, "processor unbind failed %d", status);
}
#endif
RAISE_SIGSTOP(MAKE_CHILD);
AP_MONCONTROL(1);
/* Disable the parent's signal handlers and set up proper handling in
* the child.
*/
apr_signal(SIGHUP, just_die);
apr_signal(SIGTERM, just_die);
/* The child process doesn't do anything for AP_SIG_GRACEFUL.
* Instead, the pod is used for signalling graceful restart.
*/
apr_signal(AP_SIG_GRACEFUL, SIG_IGN);
child_main(slot);
}
ap_scoreboard_image->parent[slot].pid = pid;
return 0;
}
/* start up a bunch of children */
static void startup_children(int number_to_start)
{
int i;
for (i = 0; number_to_start && i < ap_daemons_limit; ++i) {
if (ap_scoreboard_image->servers[i][0].status != SERVER_DEAD) {
continue;
}
if (make_child(ap_server_conf, i) < 0) {
break;
}
--number_to_start;
}
}
/*
* idle_spawn_rate is the number of children that will be spawned on the
* next maintenance cycle if there aren't enough idle servers. It is
* doubled up to MAX_SPAWN_RATE, and reset only when a cycle goes by
* without the need to spawn.
*/
static int idle_spawn_rate = 1;
#ifndef MAX_SPAWN_RATE
#define MAX_SPAWN_RATE (32)
#endif
static int hold_off_on_exponential_spawning;
static void perform_idle_server_maintenance(apr_pool_t *p)
{
int i;
int to_kill;
int idle_count;
worker_score *ws;
int free_length;
int free_slots[MAX_SPAWN_RATE];
int last_non_dead;
int total_non_dead;
/* initialize the free_list */
free_length = 0;
to_kill = -1;
idle_count = 0;
last_non_dead = -1;
total_non_dead = 0;
for (i = 0; i < ap_daemons_limit; ++i) {
int status;
if (i >= ap_max_daemons_limit && free_length == idle_spawn_rate)
break;
ws = &ap_scoreboard_image->servers[i][0];
status = ws->status;
if (status == SERVER_DEAD) {
/* try to keep children numbers as low as possible */
if (free_length < idle_spawn_rate) {
free_slots[free_length] = i;
++free_length;
}
}
else {
/* We consider a starting server as idle because we started it
* at least a cycle ago, and if it still hasn't finished starting
* then we're just going to swamp things worse by forking more.
* So we hopefully won't need to fork more if we count it.
* This depends on the ordering of SERVER_READY and SERVER_STARTING.
*/
if (status <= SERVER_READY) {
++ idle_count;
/* always kill the highest numbered child if we have to...
* no really well thought out reason ... other than observing
* the server behaviour under linux where lower numbered children
* tend to service more hits (and hence are more likely to have
* their data in cpu caches).
*/
to_kill = i;
}
++total_non_dead;
last_non_dead = i;
}
}
ap_max_daemons_limit = last_non_dead + 1;
if (idle_count > ap_daemons_max_free) {
/* kill off one child... we use the pod because that'll cause it to
* shut down gracefully, in case it happened to pick up a request
* while we were counting
*/
ap_mpm_pod_signal(pod);
idle_spawn_rate = 1;
}
else if (idle_count < ap_daemons_min_free) {
/* terminate the free list */
if (free_length == 0) {
/* only report this condition once */
static int reported = 0;
if (!reported) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
"server reached MaxClients setting, consider"
" raising the MaxClients setting");
reported = 1;
}
idle_spawn_rate = 1;
}
else {
if (idle_spawn_rate >= 8) {
ap_log_error(APLOG_MARK, APLOG_INFO, 0, ap_server_conf,
"server seems busy, (you may need "
"to increase StartServers, or Min/MaxSpareServers), "
"spawning %d children, there are %d idle, and "
"%d total children", idle_spawn_rate,
idle_count, total_non_dead);
}
for (i = 0; i < free_length; ++i) {
#ifdef TPF
if (make_child(ap_server_conf, free_slots[i]) == -1) {
if(free_length == 1) {
shutdown_pending = 1;
ap_log_error(APLOG_MARK, APLOG_EMERG, 0, ap_server_conf,
"No active child processes: shutting down");
}
}
#else
make_child(ap_server_conf, free_slots[i]);
#endif /* TPF */
}
/* the next time around we want to spawn twice as many if this
* wasn't good enough, but not if we've just done a graceful
*/
if (hold_off_on_exponential_spawning) {
--hold_off_on_exponential_spawning;
}
else if (idle_spawn_rate < MAX_SPAWN_RATE) {
idle_spawn_rate *= 2;
}
}
}
else {
idle_spawn_rate = 1;
}
}
int
read_hardware_config(SYS_CONF_TYP * scfg, unsigned int tot_cpus, unsigned int pvr) {
int i, j = 0;
int bind_to_cpu , rc, pir;
int node, chip , proc;
char msg[4096];
SYS_CONF_TYP physical_scfg ;
int num_nodes = 0, chips_per_node = 0;
for(i = 0; i < MAX_CPUS ; i++) {
l_p[i] = NO_CPU_DEFINED;
}
#ifndef __HTX_LINUX__
for(i = 0 ; i < tot_cpus ; i++ ) {
bind_to_cpu = i ;
rc = bindprocessor(BINDPROCESS, getpid(), bind_to_cpu);
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with rc = %d, i = %d, errno = %d", rc, i, errno);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
pir = getPir();
l_p[i] = pir ;
rc = bindprocessor(BINDPROCESS, getpid(), PROCESSOR_CLASS_ANY);
if(rc == -1) {
sprintf( msg, "\n%d: bindprocessor failed with %d while unbinding, rc = %d, i = %d ",__LINE__, errno, rc, i);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#else
FILE *fp;
char command[200],fname[256];
int rad, lcpu, nrads, num_procs;
strcpy(fname,htx_d.htx_exer_log_dir);
sprintf(fname,"%s/node_details.%d",fname,getpid());
/*sprintf(command,"/usr/lpp/htx/etc/scripts/get_node_details.sh "
"> %s\n",fname);*/
strcpy(command,getenv("HTXSCRIPTS"));
sprintf(command, "%s/get_node_details.sh > %s\n", command, fname);
if ( (rc = system(command)) == -1 ) {
sprintf(msg, "sytem command to get_node_details failed with %d",rc);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
if ((fp=fopen(fname,"r"))==NULL){
sprintf(msg, "fopen of file %s failed with errno=%d",fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
/* Get total number of chips */
rc = fscanf(fp,"num_nodes=%d\n",&nrads);
if (rc == 0 || rc == EOF) {
sprintf(msg, "fscanf of num_nodes on file %s failed with errno =%d",fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
for (rad = 0; rad < nrads; rad++) {
int cpu_index = 0;
int cur_chip = -1; /* Current chip */
/* Fetch the current chip and the num procs in the chip */
rc = fscanf(fp,"node=%d,cpus_in_node=%d,cpus",&cur_chip,&num_procs);
if (rc == 0 || rc == EOF) {
sprintf(msg, "fscanf: chip =%d,Fetching of cpus in chip error from"
" file %s failed with errno =%d",rad,fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
if ( num_procs > tot_cpus ) {
sprintf(msg, "num_procs %d in this chip cannot be more than max procs %d "
,num_procs,tot_cpus);
hxfmsg(&htx_d,0,HTX_HE_HARD_ERROR, msg);
return(-1);
}
/*
* To find the actual processors (logical cpu Ids that can be
* specified in an rset):
*/
cpu_index = 0 ;
while ( cpu_index < num_procs) {
rc = fscanf(fp,":%d",&lcpu);
if ( rc == 0 || rc == EOF) {
sprintf(msg, "fscanf: cpu fetch for chip=%d caused error from "
" file %s failed with errno =%d",rad,fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
/* Bind to lcpu and get the PIR value for it */
rc = htx_bind_process(BIND_THE_PROCESS, lcpu);
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with %d, binding cpu=%d", errno, lcpu);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
l_p[lcpu] = get_cpu_id(lcpu);
rc = htx_unbind_process();
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with %d, unbinding th=%d, cpu=%d", errno, lcpu);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
DEBUGON("l_p[%d]=%d\n",lcpu, l_p[lcpu]);
cpu_index++;
}
rc = fscanf(fp,"\n");
if (rc == EOF) {
sprintf(msg, "fscanf: expecting new line character at the end of"
" node %d data reading from file %s failed with errno =%d",\
rad,fname,errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#endif
/* Intialize the sysconf data structure */
for(node = 0; node < MAX_NODES; node++) {
for(chip = 0; chip < MAX_CHIPS_PER_NODE; chip ++) {
for(proc = 0; proc < MAX_CPUS_PER_CHIP; proc ++) {
physical_scfg.node[node].chip[chip].lprocs[proc] = -1;
}
physical_scfg.node[node].chip[chip].num_procs = 0;
}
physical_scfg.node[node].num_chips = 0;
}
physical_scfg.num_nodes = 0 ;
i = 0 ;
while(i < MAX_CPUS) {
if(l_p[i] == NO_CPU_DEFINED) {
i++;
continue;
}
if(pvr == PVR_POWER9_NIMBUS){
node = P9_NIMBUS_GET_NODE(l_p[i]);
chip = P9_NIMBUS_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER9_CUMULUS){
node = P9_CUMULUS_GET_NODE(l_p[i]);
chip = P9_CUMULUS_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER8_MURANO || pvr == PVR_POWER8_VENICE || pvr == PVR_POWERP8P_GARRISION) {
node = P8_GET_NODE(l_p[i]);
chip = P8_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER7 || pvr == PVR_POWER7PLUS) {
node = P7_GET_NODE(l_p[i]);
chip = P7_GET_CHIP(l_p[i]);
} else if(pvr == PVR_POWER6) {
node = P6_GET_NODE(l_p[i]);
chip = P6_GET_CHIP(l_p[i]);
} else {
sprintf(msg, "\n We shldnt have been here pvr = %x, PVR mismatch. Exiting !!\n", pvr);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
DEBUGON("Node=%d,Chip%d,proc=%d\n",node,chip,i);
physical_scfg.node[node].chip[chip].lprocs[physical_scfg.node[node].chip[chip].num_procs++] = i ;
i++;
}
for(i = 0; i < MAX_NODES; i ++) {
for( j = 0; j < MAX_CHIPS_PER_NODE; j++) {
if(physical_scfg.node[i].chip[j].num_procs > 0) {
physical_scfg.node[i].num_chips ++;
}
}
if(physical_scfg.node[i].num_chips > 0) {
physical_scfg.num_nodes ++;
}
}
/* Copy the system configuration to scfg */
for(node = 0; node < MAX_NODES; node++) {
if(physical_scfg.node[node].num_chips == 0)
continue;
chips_per_node = 0;
for(chip = 0; chip < MAX_CHIPS_PER_NODE; chip ++) {
if(physical_scfg.node[node].chip[chip].num_procs == 0)
continue;
memcpy(&scfg->node[num_nodes].chip[chips_per_node], &physical_scfg.node[node].chip[chip], sizeof(CHIP));
chips_per_node++;
}
if(chips_per_node != physical_scfg.node[node].num_chips) {
sprintf(msg, "%s: Something Wrong !!! Node = %d, chips_per_node = %d, physical_scfg_chip = %d \n",
__FUNCTION__,node, chips_per_node, physical_scfg.node[node].num_chips) ;
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
scfg->node[num_nodes].num_chips = physical_scfg.node[node].num_chips;
num_nodes++;
}
if(num_nodes != physical_scfg.num_nodes) {
sprintf(msg, "%s: Something Wrong !!! Num_nodes = %d, physical_num_nodes = %d \n",
__FUNCTION__, num_nodes, physical_scfg.num_nodes);
hxfmsg(&htx_d, 0, HTX_HE_HARD_ERROR, msg);
return(-1);
}
scfg->num_nodes = physical_scfg.num_nodes;
return 0 ;
}
int
get_cont_phy_mem(unsigned int num_cpus_mapped, unsigned int memory_mapping[][2], long long size, MEMORY_SET mem[]) {
char *p, *addr, msg[4096];
int i=0, ii, rc, host_cpu , j;
size_t shm_size;
unsigned int cpu, bind_to_cpu;
unsigned int memflg;
#ifndef __HTX_LINUX__ /* AIX Specific */
psize_t psize = 16*M;
struct shmid_ds shm_buf = { 0 };
struct vminfo_psize vminfo_64k = { 0 };
memflg = (IPC_CREAT | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP);
if(SET_PAGESIZE) {
psize = 16*M;
} else {
psize = 4 * K;
}
#else /* Linux Specific */
unsigned long long psize;
memflg = (IPC_CREAT | IPC_EXCL |SHM_R | SHM_W);
if(SET_PAGESIZE) {
memflg |= (SHM_HUGETLB);
psize = 16*M;
} else {
psize = 4 * K;
}
/* shmmax controls the maximum amount of memory to be allocated for shared memory */
rc = system ("echo 268435456 > /proc/sys/kernel/shmmax");
if (rc < 0){
sprintf(msg,"unable to change the /proc/sys/kernel/shmmax variable\n");
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
}
/* The maximum amount of shared memory that can be allocated. */
rc = system ("echo 268435456 > /proc/sys/kernel/shmall");
if (rc < 0) {
sprintf(msg,"unable to change the /proc/sys/kernel/shmall");
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
}
#endif
DEBUGON("\n Need %llx physically contiguous memory \n", size);
shm_size = (size < PG_SZ_16M ? PG_SZ_16M : size);
for(cpu = 0; cpu < num_cpus_mapped; cpu ++) {
if(memory_mapping[cpu][DEST_CPU] != NO_CPU_DEFINED) {
host_cpu = memory_mapping[cpu][HOST_CPU];
bind_to_cpu = memory_mapping[cpu][DEST_CPU];
} else {
continue;
}
#ifdef __HTX_LINUX__
rc = htx_bind_process(BIND_THE_PROCESS, bind_to_cpu);
#else
rc = bindprocessor(BINDPROCESS, getpid(), bind_to_cpu);
#endif
if(rc == -1) {
sprintf(msg, "\n bindprocessor failed with %d, binding th=%d, cpu=%d", errno, cpu,bind_to_cpu);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
mem[host_cpu].shm_id = shmget(IPC_PRIVATE, shm_size, memflg);
if(mem[host_cpu].shm_id == -1) {
memory_set_cleanup();
sprintf(msg,"shmget failed with %d !\n", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
#ifndef __HTX_LINUX__
if(SET_PAGESIZE) {
if ( shm_size > 256*M) {
if ((rc = shmctl(mem[host_cpu].shm_id, SHM_GETLBA, &shm_buf)) == -1) {
memory_set_cleanup();
sprintf(msg,"\n shmctl failed to get minimum alignment requirement - %d", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
shm_buf.shm_pagesize = psize;
if( (rc = shmctl(mem[host_cpu].shm_id, SHM_PAGESIZE, &shm_buf)) == -1) {
memory_set_cleanup();
sprintf(msg,"\n shmctl failed with %d while setting page size.",errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
return(-1);
}
}
#endif
addr = (char *) shmat(mem[host_cpu].shm_id, 0, 0);
if(-1 == (int)addr) {
sprintf(msg,"\n shmat failed with %d",errno);
hxfmsg(&htx_d, -1,HTX_HE_HARD_ERROR, msg);
memory_set_cleanup();
return(-1);
}
/* to be on safer side write touch the remote memory obtained */
char * mem_addr = addr;
for(i=0; i < (shm_size/psize); i++) {
*(unsigned long long *)mem_addr = 0xFFFFffffFFFFffff ;
mem_addr += psize;
}
sprintf(msg, "%s: cpu %d, bound to cpu %d, seg_addr = 0x%llx of size = 0x%llx\n",
__FUNCTION__, host_cpu, bind_to_cpu, (unsigned long long *)addr, shm_size);
hxfmsg(&htx_d, 0, HTX_HE_INFO, msg);
/* Lock the new shared memory, so that its always memory resident */
rc = mlock(addr, shm_size);
if(rc == -1) {
sprintf(msg,"\n mlock failed with %d", errno);
hxfmsg(&htx_d, rc, HTX_HE_HARD_ERROR, msg);
memory_set_cleanup();
return(-1);
}
mem[host_cpu].seg_addr = addr;
mem[host_cpu].memory_set_size = shm_size;
#ifdef __HTX_LINUX__
rc = htx_unbind_process();
#else
rc = bindprocessor(BINDPROCESS, getpid(), PROCESSOR_CLASS_ANY);
#endif
if(rc == -1) {
sprintf(msg, "\n%d: bindprocessor failed with %d while unbinding",__LINE__, errno);
hxfmsg(&htx_d, errno, HTX_HE_HARD_ERROR, msg);
return(-1);
}
} /* Off num_cpus_mapped loop */
return(0);
}
void *DumbTest(void *vp)
{
assert(!bindprocessor(BINDTHREAD, thread_self(), rank));
pthread_exit(vp);
}
PASTIX_INT sopalin_bindthread(PASTIX_INT cpu)
{
#ifdef MARCEL
{
marcel_vpset_t vpset = MARCEL_VPSET_ZERO;
marcel_vpset_vp(&vpset, cpu);
marcel_apply_vpset(&vpset);
}
#else /* Dans les autres cas on se preoccupe de l'archi */
#ifdef WITH_HWLOC
{
hwloc_topology_t topology; /* Topology object */
hwloc_obj_t obj; /* Hwloc object */
hwloc_cpuset_t cpuset; /* HwLoc cpuset */
/* Allocate and initialize topology object. */
hwloc_topology_init(&topology);
/* Perform the topology detection. */
hwloc_topology_load(topology);
/* Get last one. */
obj = hwloc_get_obj_by_type(topology, HWLOC_OBJ_CORE, cpu);
if (!obj)
return 0;
/* Get a copy of its cpuset that we may modify. */
/* Get only one logical processor (in case the core is SMT/hyperthreaded). */
#if !defined(HWLOC_BITMAP_H)
cpuset = hwloc_cpuset_dup(obj->cpuset);
hwloc_cpuset_singlify(cpuset);
#else
cpuset = hwloc_bitmap_dup(obj->cpuset);
hwloc_bitmap_singlify(cpuset);
#endif
/* And try to bind ourself there. */
if (hwloc_set_cpubind(topology, cpuset, HWLOC_CPUBIND_THREAD)) {
char *str = NULL;
#if !defined(HWLOC_BITMAP_H)
hwloc_cpuset_asprintf(&str, obj->cpuset);
#else
hwloc_bitmap_asprintf(&str, obj->cpuset);
#endif
printf("Couldn't bind to cpuset %s\n", str);
free(str);
}
/* Get the number at Proc level */
cpu = obj->children[0]->os_index;
/* Free our cpuset copy */
#if !defined(HWLOC_BITMAP_H)
hwloc_cpuset_free(cpuset);
#else
hwloc_bitmap_free(cpuset);
#endif
/* Destroy topology object. */
hwloc_topology_destroy(topology);
}
#else /* WITH_HWLOC */
#ifdef X_ARCHpower_ibm_aix
{
tid_t self_ktid = thread_self ();
bindprocessor(BINDTHREAD, self_ktid, cpu);
}
#elif (defined X_ARCHalpha_compaq_osf1)
{
bind_to_cpu_id(getpid(), cpu, 0);
}
#elif (defined X_ARCHi686_pc_linux)
#ifndef X_ARCHi686_mac
{
cpu_set_t mask;
CPU_ZERO(&mask);
CPU_SET(cpu, &mask);
#ifdef HAVE_OLD_SCHED_SETAFFINITY
if(sched_setaffinity(0,&mask) < 0)
#else /* HAVE_OLD_SCHED_SETAFFINITY */
if(sched_setaffinity(0,sizeof(mask),&mask) < 0)
#endif /* HAVE_OLD_SCHED_SETAFFINITY */
{
perror("sched_setaffinity");
EXIT(MOD_SOPALIN, INTERNAL_ERR);
}
}
#else /* X_ARCHi686_mac */
{
thread_affinity_policy_data_t ap;
int ret;
ap.affinity_tag = 1; /* non-null affinity tag */
ret = thread_policy_set(
mach_thread_self(),
THREAD_AFFINITY_POLICY,
(integer_t*) &ap,
THREAD_AFFINITY_POLICY_COUNT
);
if(ret != 0)
{
perror("thread_policy_set");
EXIT(MOD_SOPALIN, INTERNAL_ERR);
}
}
#endif /* X_ARCHi686_mac */
#endif /* X_ACHIxxx */
#endif /* WITH_HWLOC */
#endif /* MARCEL */
return cpu;
}
int set_thread_affinity(int cpuid) {
unsigned long mask = 0xffffffff;
unsigned int len = sizeof(mask);
#ifdef _WIN32
HANDLE hThread;
#endif
#ifdef _WIN32
SET_MASK(cpuid)
hThread = GetCurrentThread();
if (SetThreadAffinityMask(hThread, mask) == 0) {
return -1;
}
#elif CMK_HAS_PTHREAD_SETAFFINITY
#ifdef CPU_ALLOC
if ( cpuid >= CPU_SETSIZE ) {
cpu_set_t *cpusetp;
pthread_t thread;
size_t size;
int num_cpus;
num_cpus = cpuid + 1;
cpusetp = CPU_ALLOC(num_cpus);
if (cpusetp == NULL) {
perror("set_thread_affinity CPU_ALLOC");
return -1;
}
size = CPU_ALLOC_SIZE(num_cpus);
thread = pthread_self();
CPU_ZERO_S(size, cpusetp);
CPU_SET_S(cpuid, size, cpusetp);
if (errno = pthread_setaffinity_np(thread, size, cpusetp)) {
perror("pthread_setaffinity dynamically allocated");
CPU_FREE(cpusetp);
return -1;
}
CPU_FREE(cpusetp);
} else
#endif
{
int s, j;
cpu_set_t cpuset;
pthread_t thread;
thread = pthread_self();
CPU_ZERO(&cpuset);
CPU_SET(cpuid, &cpuset);
if (errno = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset)) {
perror("pthread_setaffinity");
return -1;
}
}
#elif CMK_HAS_BINDPROCESSOR
if (bindprocessor(BINDTHREAD, thread_self(), cpuid) != 0)
return -1;
#else
return set_cpu_affinity(cpuid);
#endif
return 0;
}
int ATL_thread_start(ATL_thread_t *thr, int proc, int JOINABLE,
void *(*rout)(void*), void *arg)
/*
* Creates a thread that will run only on processor proc.
* RETURNS: 0 on success, non-zero on error
* NOTE: present implementation dies on error, so 0 is always returned.
*/
{
#ifdef ATL_WINTHREADS
#ifdef ATL_WIN32THREADS
DWORD thrID;
#else
unsigned thrID;
#endif
#ifdef ATL_NOAFFINITY
#ifdef ATL_WIN32THREADS
thr->thrH = CreateThread(NULL, 0, rout, arg, 0, &thrID);
#else
thr->thrH = (HANDLE)_beginthreadex(NULL, 0, rout, arg, 0, &thrID);
#endif
ATL_assert(thr->thrH);
#else
thr->rank = proc;
#ifdef ATL_WIN32THREADS
thr->thrH = CreateThread(NULL, 0, rout, arg, CREATE_SUSPENDED, &thrID);
#else
thr->thrH = (HANDLE)_beginthreadex(NULL, 0, rout, arg,
CREATE_SUSPENDED, &thrID);
#endif
ATL_assert(thr->thrH);
#ifdef ATL_RANK_IS_PROCESSORID
ATL_assert(SetThreadAffinityMask(thr->thrH, (1<<proc)));
#else
ATL_assert(SetThreadAffinityMask(thr->thrH,
(1<<ATL_affinityIDs[proc%ATL_AFF_NUMID])));
#endif
ATL_assert(ResumeThread(thr->thrH) == 1);
#endif
#elif defined(ATL_OMP_THREADS)
fprintf(stderr, "Should not call thread_start when using OpenMP!");
ATL_assert(0);
#elif 0 && defined(ATL_OS_OSX) /* unchecked special OSX code */
/* http://developer.apple.com/library/mac/#releasenotes/Performance/RN-AffinityAPI/_index.html */
pthread_attr_t attr;
#define ATL_OSX_AFF_SETS 2 /* should be probed for */
thread_affinity_policy ap;
ap.affinity_tag = proc % ATL_OSX_AFF_SETS;
ATL_assert(!pthread_attr_init(&attr));
if (JOINABLE)
ATL_assert(!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE));
else
ATL_assert(!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); /* no chk, OK to fail */
ATL_assert(!pthread_create(&thr->thrH, &attr, rout, arg));
ATL_assert(!thread_policy_set(thr->thrH, THREAD_AFFINITY_POLICY,
(integer_t*)&ap,
THREAD_AFFINITY_POLICY_COUNT));
ATL_assert(!pthread_attr_destroy(&attr));
#else
pthread_attr_t attr;
#ifndef ATL_NOAFFINITY
#if defined(ATL_PAFF_SETAFFNP) || defined(ATL_PAFF_SCHED)
cpu_set_t cpuset;
#elif defined(ATL_PAFF_PLPA)
plpa_cpu_set_t cpuset;
#elif defined(ATL_PAFF_CPUSET) /* untried FreeBSD code */
cpuset_t mycpuset;
#endif
#ifdef ATL_RANK_IS_PROCESSORID
const int affID = proc;
#else
const int affID = ATL_affinityIDs[proc%ATL_AFF_NUMID];
#endif
#ifdef ATL_PAFF_SELF
thr->paff_set = 0; /* affinity must be set by created thread */
#endif
#endif
thr->rank = proc;
ATL_assert(!pthread_attr_init(&attr));
if (JOINABLE)
{
#ifdef IBM_PT_ERROR
ATL_assert(!pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_UNDETACHED));
#else
ATL_assert(!pthread_attr_setdetachstate(&attr,
PTHREAD_CREATE_JOINABLE));
#endif
}
else
ATL_assert(!pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED));
pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM); /* no chk, OK to fail */
#ifdef ATL_PAFF_SETAFFNP
CPU_ZERO(&cpuset);
CPU_SET(affID, &cpuset);
ATL_assert(!pthread_attr_setaffinity_np(&attr, sizeof(cpuset), &cpuset));
#elif defined(ATL_PAFF_SETPROCNP)
ATL_assert(!pthread_attr_setprocessor_np(&attr, (pthread_spu_t)affID,
PTHREAD_BIND_FORCED_NP));
#endif
ATL_assert(!pthread_create(&thr->thrH, &attr, rout, arg));
#if defined(ATL_PAFF_PBIND)
ATL_assert(!processor_bind(P_LWPID, thr->thrH, affID, NULL));
thr->paff_set = 0; /* affinity set by spawner */
#elif defined(ATL_PAFF_BINDP)
ATL_assert(!bindprocessor(BINDTHREAD, thr->thrH, bindID));
thr->paff_set = 0; /* affinity set by spawner */
#elif defined(ATL_PAFF_CPUSET) /* untried FreeBSD code */
CPU_ZERO(&mycpuset); /* no manpage, so guess works like linux */
CPU_SET(bindID, &mycpuset);
if (!cpuset_setaffinity(CPU_LEVEL_WHICH, CPU_WHICH_TID, thr->thrH,
sizeof(mycpuset), &mycpuset));
thr->paff_set = 0; /* affinity set by spawner */
#endif
ATL_assert(!pthread_attr_destroy(&attr));
#endif
return(0);
}
void prefetch_irritator(void *arg)
{
int i, rc, no_of_pages, tid , thread_no, tc, oper , number_of_operations;
unsigned long long saved_seed, random_no , starting_address , memory_fetch_size;
pthread_t ptid;
unsigned char *start_addr;
struct thread_context *th = (struct thread_context *)arg;
struct ruleinfo *current_rule = th->current_rule;
int cache_type = current_rule->tgt_cache;
int cache_line_size = system_information.cinfo[cache_type].line_size;
unsigned int loop_count ;
long int offset;
unsigned long long temp_storage = 0x1, temp_pattern = 0x1;
/*
* char *contig_mem[NUM_SEGS*SEG_SIZE/(16*M)]; Physically contiguous
* memory pointer. memory_set_size variable gives total memory
* allocated both are variables of global structure.
*/
thread_no = th->thread_no ;
int pcpu = pcpus_thread_wise[thread_no];
tid = th->bind_to_cpu; /* Bind to the processor */
ptid = th->tid; /* PThread Id for this thread */
prefetch_streams = th->prefetch_streams; /* Number of prefetch streams for this thread. */
if (current_rule->testcase_type != PREFETCH_ONLY) {
/* Set Thread Cancel Type as ASYNCHRONOUS */
pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
}
#ifdef __HTX_LINUX__
/*printf(" Prefetch:calling htx_bind with pcpu=%d for thread_no= %d\n",pcpu,thread_no);*/
if(pcpu == -1){
pcpu = htx_bind_thread(tid, -1);
rc = pcpu;
pcpus_thread_wise[thread_no]=pcpu;
if(pcpu < 0){
pcpus_thread_wise[thread_no]= -1;
}
}
else {
rc = htx_bind_thread(tid,pcpu);
}
#else
rc = bindprocessor(BINDTHREAD, thread_self(), tid);
#endif
DEBUG_LOG("[%d] thread %d, binding to cpu %d \n",__LINE__,thread_no,tid);
if(rc < 0) {
#ifdef __HTX_LINUX__
if( rc == -2) {
tot_thread_count --;
sprintf(msg,"lcpu:%d(pcpu=%d) prefetch has been hot removed, thread will be terminating now tot_thread_count=%d\n",tid,pcpu,tot_thread_count);
hxfmsg(&h_d, errno, HTX_HE_INFO, msg);
pthread_exit(NULL);
}
else {
sprintf(msg, "%d: Bindprocessor for prefetch irritator on lcpu:%d and corresponding pcpu:%d failed with rc=%d\n", __LINE__, tid,pcpu,rc);
hxfmsg(&h_d, errno, HTX_HE_HARD_ERROR, msg);
}
#else
sprintf(msg, "Binding to cpu:%d failed with errno: %d \n",tid,errno);
hxfmsg(&h_d, errno, HTX_HE_SOFT_ERROR, msg);
#endif
} /* End of if */
else {
/*sprintf(msg,"::physical cpu:%d for log cpu:%d\n",pcpu,tid);
hxfmsg(&h_d, rc , HTX_HE_INFO, msg);*/
#ifdef DEBUG
sprintf(msg,"[%d] Bindprocessor success [prefetch thread_bo %d]! cpu_no : %d , pthread id : 0x%x \n",__LINE__,thread_no,tid,ptid);
hxfmsg(&h_d, errno, HTX_HE_INFO, msg);
#endif
}
th->seedval = time(NULL);
srand48_r(th->seedval,&th->buffer);
number_of_operations = current_rule->num_oper;
starting_address = (unsigned long long)(th_array[thread_no].start_of_contiguous_memory);
memory_fetch_size = current_rule->prefetch_memory_size - BYTES_EXC ;
loop_count = memory_fetch_size / cache_line_size;
for (oper = 0; oper < number_of_operations ; oper++) {
/* if SIGTERM was received, exit */
if(exit_flag != 0) {
break;
}
random_no = get_random_number_perf(thread_no);
random_no = (unsigned long long)(random_no<<32) | (random_no);
/*random_no = 0xaabbccdd;
random_no = th_array[thread_no].random_pattern;*/
th_array[thread_no].prev_seed = random_no;
/* Now write DSCR if needed */
if ( system_information.pvr >= POWER8_MURANO ) {
prefetch_randomise_dscr(random_no, th->current_rule->pf_dscr , thread_no);
}
if (th_array[thread_no].prefetch_algorithm == RR_ALL_ENABLED_PREFETCH_ALGORITHMS) {
/* Run all the enabled prefetch variants in round robin method */
/* If prefetch nstride is set in the current prefetch configuration */
if ( (PREFETCH_NSTRIDE & current_rule->pf_conf) == PREFETCH_NSTRIDE ) {
n_stride(starting_address,memory_fetch_size,random_no,&th_array[thread_no].prefetch_scratch_mem[0]);
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
/* If prefetch partial is set in the current prefetch configuration */
if ( (PREFETCH_PARTIAL & current_rule->pf_conf) == PREFETCH_PARTIAL ) {
partial_dcbt(starting_address,memory_fetch_size,random_no,&th_array[thread_no].prefetch_scratch_mem[0]);
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
if ( (PREFETCH_IRRITATOR & current_rule->pf_conf) == PREFETCH_IRRITATOR ) {
rc = do_prefetch( starting_address , memory_fetch_size , random_no, thread_no, loop_count, th_array[thread_no].pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
/*prefetch(starting_address,memory_fetch_size,random_no,&th_array[thread_no].prefetch_scratch_mem[0]);*/
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
if( (PREFETCH_TRANSIENT & current_rule->pf_conf) == PREFETCH_TRANSIENT ) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = transient_dcbt((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern );
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
/* if SIGTERM was received, exit */
if (exit_flag != 0) {
break;
}
if ( (PREFETCH_NA & current_rule->pf_conf) == PREFETCH_NA ) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = prefetch_dcbtna((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern,&temp_storage,&temp_pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x copied data = %x0x, copied pattern = %x0x, thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), temp_storage, temp_pattern, thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
if (exit_flag != 0) {
break;
}
}
else { /* Else Run only the specified algorithm */
/*starting_address = (unsigned long long)(th_array[thread_no].start_of_contiguous_memory);
memory_fetch_size = current_rule->prefetch_memory_size - BYTES_EXC ;*/
if(th_array[thread_no].prefetch_algorithm == PREFETCH_NSTRIDE) {
/*lrand48_r(&th->buffer, &random_no);*/
n_stride(starting_address, memory_fetch_size, random_no, &th_array[thread_no].prefetch_scratch_mem[0]);
}
else if(th_array[thread_no].prefetch_algorithm == PREFETCH_PARTIAL) {
partial_dcbt(starting_address, memory_fetch_size, random_no, &th_array[thread_no].prefetch_scratch_mem[0]);
}
else if(th_array[thread_no].prefetch_algorithm == PREFETCH_TRANSIENT) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = transient_dcbt((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern );
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
else if(th_array[thread_no].prefetch_algorithm == PREFETCH_IRRITATOR) {
rc = do_prefetch( starting_address , memory_fetch_size , random_no, thread_no, loop_count, th_array[thread_no].pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch!! Expected data = 0x%x Actual data = 0x%x thread_index : 0x%x Start of memory = %p, memory size = 0x%x\n"
,__LINE__,th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)starting_address + 128*(loop_count-rc)), thread_no, starting_address, memory_fetch_size);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
else if ( th_array[thread_no].prefetch_algorithm == PREFETCH_NA ) {
/*lrand48_r(&th->buffer, &offset);*/
offset = random_no % (long)16;
start_addr = (unsigned char *)starting_address + offset;
rc = prefetch_dcbtna((unsigned long long)start_addr, loop_count, th_array[thread_no].pattern,&temp_storage, &temp_pattern);
if ( rc != 0 ) {
sprintf(msg,"[%d] Miscompare in Prefetch ( returned %d)!! Expected data = 0x%x Actual data = 0x%x copied data = 0x%x, copied pattern = 0x%x, thread_index : 0x%x Start of memory = %p, offset = %d\n"
,__LINE__, rc, th_array[thread_no].pattern, *(unsigned long long *)((unsigned char *)start_addr + 128*(loop_count-rc)), temp_storage, temp_pattern, thread_no, starting_address, offset);
hxfmsg(&h_d, 0, HTX_HE_MISCOMPARE, msg);
dump_miscompare_data(thread_no, (unsigned char *)starting_address);
return;
}
}
/* if SIGTERM was received, exit */
if(exit_flag != 0) {
break;
}
}
} /* End of for loop */
#ifdef __HTX_LINUX__
/* Restore original/default CPU affinity so that it binds to ANY available processor */
rc = htx_unbind_thread();
#else
rc = bindprocessor(BINDTHREAD, thread_self(), PROCESSOR_CLASS_ANY);
#endif
if(rc == -1) {
sprintf(msg, "%d: Unbinding from cpu:%d failed with errno %d \n",__LINE__, tid, errno);
hxfmsg(&h_d, errno, HTX_HE_SOFT_ERROR, msg);
}
#if defined(__HTX_MAMBO__) || defined(AWAN)
printf("[%d] Thread no: %d, completed passes : %d\n",__LINE__, thread_no, oper);
#endif
}
void initializeThread()
{
srand((unsigned) getpid());
#if defined (_AIX)
bool bindtosinglecpu = false;
// kind of obsolete, do not set
char* env = getenv("JLJBindToSingleCPU");
if (0 != env)
{
int value = atoi(env);
bindtosinglecpu = 1 == value;
}
if (bindtosinglecpu)
{
const int CPUCOUNT = sysconf(_SC_NPROCESSORS_ONLN);
if (1 < CPUCOUNT)
{
const int CPU = rand() % CPUCOUNT;
fprintf(
stdout,
"\n__initbindprocessor() : trying to bind to cpu %d of %d ...",
CPU,
CPUCOUNT);
int result = bindprocessor(BINDPROCESS, getpid(), CPU);
if (0 == result)
{
fprintf(
stdout,
"\n__initbindprocessor() : successfully bound, affinity set to cpu %d.",
CPU + 1);
}
else
{
fprintf(
stdout,
"\n__initbindprocessor() : failed, error = %d.",
result);
}
fflush(stdout);
}
}
env = getenv("AIXTHREAD_SCOPE");
bool SYSTEMSCOPE = false;
if (0 != env)
{
SYSTEMSCOPE = 0 == strcmp("S", env);
}
if (!SYSTEMSCOPE)
{
fprintf(stdout, "If jlj::lang::Thread is used it is strongly recommended to 'export AIXTHREAD_SCOPE=S' \nor application behaviour may be undefined.\n");
}
#elif defined (__sun__)
//********************************************************************
#elif defined (__hpux)
//********************************************************************
#elif defined (_WINDOWS_SOURCE)
//********************************************************************
#endif
}