13dd5f6259bbfa43095f99639af1edeccd36d94b
[charm.git] / src / conv-core / cpuaffinity.c
1
2 /*
3  This scheme relies on using IP address to identify nodes and assigning 
4 cpu affinity.  
5
6  when CMK_NO_SOCKETS, which is typically on cray xt3 and bluegene/L.
7  There is no hostname for the compute nodes.
8  *
9  * last updated 3/20/2010   Gengbin Zheng
10  * new options +pemap +commmap takes complex pattern of a list of cores
11 */
12
13 #define _GNU_SOURCE
14
15 #include "converse.h"
16 #include "sockRoutines.h"
17
18 #define DEBUGP(x)   /* CmiPrintf x;  */
19
20 #if CMK_HAS_SETAFFINITY || defined (_WIN32) || CMK_HAS_BINDPROCESSOR
21
22 #include <stdlib.h>
23 #include <stdio.h>
24 #include <unistd.h>
25
26 #ifdef _WIN32
27 #include <windows.h>
28 #include <winbase.h>
29 #else
30 #define _GNU_SOURCE
31 #include <sched.h>
32 //long sched_setaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
33 //long sched_getaffinity(pid_t pid, unsigned int len, unsigned long *user_mask_ptr);
34 #endif
35
36 #if defined(__APPLE__) 
37 #include <Carbon/Carbon.h> /* Carbon APIs for Multiprocessing */
38 #endif
39
40 #if defined(ARCH_HPUX11) ||  defined(ARCH_HPUX10)
41 #include <sys/mpctl.h>
42 #endif
43
44
45 #define MAX_EXCLUDE      16
46 static int excludecore[MAX_EXCLUDE] = {-1};
47 static int excludecount = 0;
48
49 static int affinity_doneflag = 0;
50
51 static int in_exclude(int core)
52 {
53   int i;
54   for (i=0; i<excludecount; i++) if (core == excludecore[i]) return 1;
55   return 0;
56 }
57
58 static void add_exclude(int core)
59 {
60   if (in_exclude(core)) return;
61   CmiAssert(excludecount < MAX_EXCLUDE);
62   excludecore[excludecount++] = core;
63 }
64
65 #if CMK_HAS_BINDPROCESSOR
66 #include <sys/processor.h>
67 #endif
68
69 #define SET_MASK(cpuid)    \
70   /* set the affinity mask if possible */      \
71   if ((cpuid / 8) > len) {      \
72     printf("Mask size too small to handle requested CPU ID\n");   \
73     return -1;      \
74   } else {    \
75     mask = 1 << cpuid;   /* set the affinity mask exclusively to one CPU */ \
76   }
77
78
79 /* This implementation assumes the default x86 CPU mask size used by Linux */
80 /* For a large SMP machine, this code should be changed to use a variable sized   */
81 /* CPU affinity mask buffer instead, as the present code will fail beyond 32 CPUs */
82 int set_cpu_affinity(unsigned int cpuid) {
83   unsigned long mask = 0xffffffff;
84   unsigned int len = sizeof(mask);
85   int retValue = 0;
86   int pid;
87
88  #ifdef _WIN32
89    HANDLE hProcess;
90  #endif
91  
92 #ifdef _WIN32
93   SET_MASK(cpuid)
94   hProcess = GetCurrentProcess();
95   if (SetProcessAffinityMask(hProcess, mask) == 0) {
96     return -1;
97   }
98 #elif CMK_HAS_BINDPROCESSOR
99   pid = getpid();
100   if (bindprocessor(BINDPROCESS, pid, cpuid) == -1) return -1;
101 #else
102   cpu_set_t cpuset;
103   CPU_ZERO(&cpuset);
104   CPU_SET(cpuid, &cpuset);
105   /*SET_MASK(cpuid)*/
106
107   /* PID 0 refers to the current process */
108   /*if (sched_setaffinity(0, len, &mask) < 0) {*/
109   if (sched_setaffinity(0, sizeof(cpuset), &cpuset) < 0) {
110     perror("sched_setaffinity");
111     return -1;
112   }
113 #endif
114
115   return 0;
116 }
117
118 #if CMK_SMP
119 int set_thread_affinity(int cpuid) {
120   unsigned long mask = 0xffffffff;
121   unsigned int len = sizeof(mask);
122
123 #ifdef _WIN32
124   HANDLE hThread;
125 #endif  
126   
127 #ifdef _WIN32
128   SET_MASK(cpuid)
129   hThread = GetCurrentThread();
130   if (SetThreadAffinityMask(hThread, mask) == 0) {
131     return -1;
132   }
133 #elif  CMK_HAS_PTHREAD_SETAFFINITY
134   int s, j;
135   cpu_set_t cpuset;
136   pthread_t thread;
137
138   thread = pthread_self();
139
140   CPU_ZERO(&cpuset);
141   CPU_SET(cpuid, &cpuset);
142
143   s = pthread_setaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
144   if (s != 0) {
145     perror("pthread_setaffinity");
146     return -1;
147   }
148 #elif CMK_HAS_BINDPROCESSOR
149   if (bindprocessor(BINDTHREAD, thread_self(), cpuid) != 0)
150     return -1;
151 #else
152   return set_cpu_affinity(cpuid);
153 #endif
154
155   return 0;
156 }
157 #endif
158
159 CpvDeclare(int, myCPUAffToCore);
160
161 int CmiSetCPUAffinity(int mycore)
162 {
163   int core = mycore;
164   if (core < 0) {
165     core = CmiNumCores() + core;
166   }
167   if (core < 0) {
168     CmiError("Error: Invalid cpu affinity core number: %d\n", mycore);
169     CmiAbort("CmiSetCPUAffinity failed");
170   }
171
172   CpvAccess(myCPUAffToCore) = core;
173
174   /* set cpu affinity */
175 #if CMK_SMP
176   return set_thread_affinity(core);
177 #else
178   return set_cpu_affinity(core);
179   /* print_cpu_affinity(); */
180 #endif
181 }
182
183 /* This implementation assumes the default x86 CPU mask size used by Linux */
184 /* For a large SMP machine, this code should be changed to use a variable sized   */
185 /* CPU affinity mask buffer instead, as the present code will fail beyond 32 CPUs */
186 int print_cpu_affinity() {
187 #ifdef _WIN32
188   unsigned long pMask, sMask;
189   HANDLE hProcess = GetCurrentProcess();
190   if(GetProcessAffinityMask(hProcess, &pMask, &sMask)){
191         perror("On Windows: GetProcessAffinityMask");
192     return -1;
193   }
194   
195  CmiPrintf("[%d] CPU affinity mask is: 0x%08lx\n", CmiMyPe(), pMask);
196   
197 #elif CMK_HAS_BINDPROCESSOR
198   printf("[%d] CPU affinity mask is unknown for AIX. \n", CmiMyPe());
199 #else
200   /*unsigned long mask;
201   unsigned int len = sizeof(mask);*/
202   cpu_set_t cpuset;
203   char str[256], pe[16];
204   int i;
205   CPU_ZERO(&cpuset);
206  
207   /* PID 0 refers to the current process */
208   /*if (sched_getaffinity(0, len, &mask) < 0) {*/
209   if (sched_getaffinity(0, sizeof(cpuset), &cpuset) < 0) {
210     perror("sched_getaffinity");
211     return -1;
212   }
213
214   sprintf(str, "[%d] CPU affinity mask is: ", CmiMyPe());
215   for (i = 0; i < CPU_SETSIZE; i++)
216         if (CPU_ISSET(i, &cpuset)) {
217             sprintf(pe, " %d ", i);
218             strcat(str, pe);
219         }
220   CmiPrintf("%s\n", str);  
221 #endif
222   return 0;
223 }
224
225 #if CMK_SMP
226 int print_thread_affinity() {
227   unsigned long mask;
228   size_t len = sizeof(mask);
229
230 #if  CMK_HAS_PTHREAD_SETAFFINITY
231   int s, j;
232   cpu_set_t cpuset;
233   pthread_t thread;
234   char str[256], pe[16];
235
236   thread = pthread_self();
237   s = pthread_getaffinity_np(thread, sizeof(cpu_set_t), &cpuset);
238   if (s != 0) {
239     perror("pthread_getaffinity");
240     return -1;
241   }
242
243   sprintf(str, "[%d] %s affinity is: ", CmiMyPe(), CmiMyPe()>=CmiNumPes()?"communication pthread":"pthread");
244   for (j = 0; j < CPU_SETSIZE; j++)
245         if (CPU_ISSET(j, &cpuset)) {
246             sprintf(pe, " %d ", j);
247             strcat(str, pe);
248         }
249   CmiPrintf("%s\n", str);
250 #endif
251   return 0;
252 }
253 #endif
254
255 int CmiPrintCPUAffinity()
256 {
257 #if CMK_SMP
258   return print_thread_affinity();
259 #else
260   return print_cpu_affinity();
261 #endif
262 }
263
264   /* returns which core is running on, only works on Linux */
265 int CmiOnCore(void) {
266   FILE *fp;
267   int core=-1;
268   char str[128];
269   int n;
270
271   fp = fopen("/proc/self/stat", "r");
272   if (fp == NULL) return -1;
273   for (n=0; n<39; n++)  {
274     fscanf(fp, "%s", str);
275   }
276   fclose(fp);
277   core = atoi(str);
278
279   return core;
280 }
281
282
283 static int cpuAffinityHandlerIdx;
284 static int cpuAffinityRecvHandlerIdx;
285
286 typedef struct _hostnameMsg {
287   char core[CmiMsgHeaderSizeBytes];
288   int pe;
289   skt_ip_t ip;
290   int ncores;
291   int rank;
292   int seq;
293 } hostnameMsg;
294
295 typedef struct _rankMsg {
296   char core[CmiMsgHeaderSizeBytes];
297   int *ranks;                  /* PE => core rank mapping */
298   int *nodes;                  /* PE => node number mapping */
299 } rankMsg;
300
301 static rankMsg *rankmsg = NULL;
302 static CmmTable hostTable;
303 static CmiNodeLock affLock = NULL;
304
305 /* called on PE 0 */
306 static void cpuAffinityHandler(void *m)
307 {
308   static int count = 0;
309   static int nodecount = 0;
310   hostnameMsg *rec;
311   hostnameMsg *msg = (hostnameMsg *)m;
312   hostnameMsg *tmpm;
313   int tag, tag1, pe, myrank;
314   int npes = CmiNumPes();
315
316 /*   for debug
317   char str[128];
318   skt_print_ip(str, msg->ip);
319   printf("hostname: %d %s\n", msg->pe, str);
320 */
321   CmiAssert(CmiMyPe()==0 && rankmsg != NULL);
322   tag = *(int*)&msg->ip;
323   pe = msg->pe;
324   if ((rec = (hostnameMsg *)CmmProbe(hostTable, 1, &tag, &tag1)) != NULL) {
325     CmiFree(msg);
326   }
327   else {
328     rec = msg;
329     rec->seq = nodecount;
330     nodecount++;                          /* a new node record */
331     CmmPut(hostTable, 1, &tag, msg);
332   }
333   myrank = rec->rank%rec->ncores;
334   while (in_exclude(myrank)) {             /* skip excluded core */
335     myrank = (myrank+1)%rec->ncores;
336     rec->rank ++;
337   }
338   rankmsg->ranks[pe] = myrank;             /* core rank */
339   rankmsg->nodes[pe] = rec->seq;           /* on which node */
340   rec->rank ++;
341   count ++;
342   if (count == CmiNumPes()) {
343     /* CmiPrintf("Cpuaffinity> %d unique compute nodes detected! \n", CmmEntries(hostTable)); */
344     tag = CmmWildCard;
345     while (tmpm = CmmGet(hostTable, 1, &tag, &tag1)) CmiFree(tmpm);
346     CmmFree(hostTable);
347 #if 1
348     /* bubble sort ranks on each node according to the PE number */
349     {
350     int i,j;
351     for (i=0; i<npes-1; i++)
352       for(j=i+1; j<npes; j++) {
353         if (rankmsg->nodes[i] == rankmsg->nodes[j] && 
354               rankmsg->ranks[i] > rankmsg->ranks[j]) 
355         {
356           int tmp = rankmsg->ranks[i];
357           rankmsg->ranks[i] = rankmsg->ranks[j];
358           rankmsg->ranks[j] = tmp;
359         }
360       }
361     }
362 #endif
363     CmiSyncBroadcastAllAndFree(sizeof(rankMsg)+CmiNumPes()*sizeof(int)*2, (void *)rankmsg);
364   }
365 }
366
367 /* called on each processor */
368 static void cpuAffinityRecvHandler(void *msg)
369 {
370   int myrank, mynode;
371   rankMsg *m = (rankMsg *)msg;
372   m->ranks = (int *)((char*)m + sizeof(rankMsg));
373   m->nodes = (int *)((char*)m + sizeof(rankMsg) + CmiNumPes()*sizeof(int));
374   myrank = m->ranks[CmiMyPe()];
375   mynode = m->nodes[CmiMyPe()];
376
377   /*CmiPrintf("[%d %d] set to core #: %d\n", CmiMyNode(), CmiMyPe(), myrank);*/
378
379   if (-1 != CmiSetCPUAffinity(myrank)) {
380     DEBUGP(("Processor %d is bound to core #%d on node #%d\n", CmiMyPe(), myrank, mynode));
381   }
382   else{
383     CmiPrintf("Processor %d set affinity failed!\n", CmiMyPe());
384     CmiAbort("set cpu affinity abort!\n");
385   }
386   /*CpvAccess(myCPUAffToCore) = myrank;*/
387   CmiFree(m);
388 }
389
390 #if defined(_WIN32) && ! defined(__CYGWIN__)
391   /* strtok is thread safe in VC++ */
392 #define strtok_r(x,y,z) strtok(x,y)
393 #endif
394
395 static int search_pemap(char *pecoremap, int pe)
396 {
397   int *map = (int *)malloc(CmiNumPes()*sizeof(int));
398   char *ptr = NULL;
399   int i, count;
400   char *str;
401
402   char *mapstr = (char*)malloc(strlen(pecoremap)+1);
403   strcpy(mapstr, pecoremap);
404
405   str = strtok_r(mapstr, ",", &ptr);
406   count = 0;
407   while (str)
408   {
409       int hasdash=0, hascolon=0;
410       int start, end, stride=1;
411       for (i=0; i<strlen(str); i++) {
412           if (str[i] == '-' && i!=0) hasdash=1;
413           if (str[i] == ':') hascolon=1;
414       }
415       if (hasdash) {
416           if (hascolon) {
417             if (sscanf(str, "%d-%d:%d", &start, &end, &stride) != 3)
418                  printf("Warning: Check the format of \"%s\".\n", str);
419           }
420           else {
421             if (sscanf(str, "%d-%d", &start, &end) != 2)
422                  printf("Warning: Check the format of \"%s\".\n", str);
423           }
424       }
425       else {
426           sscanf(str, "%d", &start);
427           end = start;
428       }
429       for (i = start; i<=end; i+=stride) {
430         map[count++] = i;
431         if (count == CmiNumPes()) break;
432       }
433       if (count == CmiNumPes()) break;
434       str = strtok_r(NULL, ",", &ptr);
435   }
436   i = map[pe % count];
437
438   free(map);
439   free(mapstr);
440   return i;
441 }
442
443 #if CMK_CRAYXT
444 extern int getXTNodeID(int mype, int numpes);
445 #endif
446
447
448 void CmiInitCPUAffinity(char **argv)
449 {
450   static skt_ip_t myip;
451   int ret, i, exclude;
452   hostnameMsg  *msg;
453   char *pemap = NULL;
454   char *commap = NULL;
455   char *coremap = NULL;
456  
457   int show_affinity_flag;
458   int affinity_flag = CmiGetArgFlagDesc(argv,"+setcpuaffinity",
459                                                 "set cpu affinity");
460
461   while (CmiGetArgIntDesc(argv,"+excludecore", &exclude, "avoid core when setting cpuaffinity")) 
462     if (CmiMyRank() == 0) add_exclude(exclude);
463   
464     /* obsolete */
465   CmiGetArgStringDesc(argv, "+coremap", &coremap, "define core mapping");
466   if (coremap!=NULL && excludecount>0)
467     CmiAbort("Charm++> +excludecore and +coremap can not be used togetehr!");
468
469   CmiGetArgStringDesc(argv, "+pemap", &pemap, "define pe to core mapping");
470   if (pemap!=NULL && (coremap != NULL || excludecount>0))
471     CmiAbort("Charm++> +pemap can not be used with either +excludecore or +coremap.");
472   CmiGetArgStringDesc(argv, "+commap", &commap, "define comm threads to core mapping");
473   show_affinity_flag = CmiGetArgFlagDesc(argv,"+showcpuaffinity",
474                                                 "print cpu affinity");
475
476   cpuAffinityHandlerIdx =
477        CmiRegisterHandler((CmiHandler)cpuAffinityHandler);
478   cpuAffinityRecvHandlerIdx =
479        CmiRegisterHandler((CmiHandler)cpuAffinityRecvHandler);
480
481   CpvInitialize(int, myCPUAffToCore);
482   CpvAccess(myCPUAffToCore) = -1;
483
484   if (CmiMyRank() ==0) {
485      affLock = CmiCreateLock();
486   }
487
488   if (!affinity_flag) {
489     if (show_affinity_flag) CmiPrintCPUAffinity();
490     return;
491   }
492   else if (CmiMyPe() == 0) {
493      CmiPrintf("Charm++> cpu affinity enabled. \n");
494      if (excludecount > 0) {
495        CmiPrintf("Charm++> cpuaffinity excludes core: %d", excludecore[0]);
496        for (i=1; i<excludecount; i++) CmiPrintf(" %d", excludecore[i]);
497        CmiPrintf(".\n");
498      }
499      if (coremap!=NULL)
500        CmiPrintf("Charm++> cpuaffinity core map : %s\n", coremap);
501      if (pemap!=NULL)
502        CmiPrintf("Charm++> cpuaffinity PE-core map : %s\n", pemap);
503   }
504
505   if (CmiMyPe() >= CmiNumPes()) {         /* this is comm thread */
506       /* comm thread either can float around, or pin down to the last rank.
507          however it seems to be reportedly slower if it is floating */
508     CmiNodeAllBarrier();
509     if (commap != NULL) {
510       int mycore = search_pemap(commap, CmiMyPe()-CmiNumPes());
511       printf("Charm++> set comm %d on node %d to core #%d\n", CmiMyPe()-CmiNumPes(), CmiMyNode(), mycore); 
512       if (-1 == CmiSetCPUAffinity(mycore))
513         CmiAbort("set_cpu_affinity abort!");
514       /*CpvAccess(myCPUAffToCore) = mycore;*/
515     }
516     else {
517     /* if (CmiSetCPUAffinity(CmiNumCores()-1) == -1) CmiAbort("set_cpu_affinity abort!"); */
518     }
519     if (coremap == NULL && pemap == NULL) {
520 #if CMK_MACHINE_PROGRESS_DEFINED
521     while (affinity_doneflag < CmiMyNodeSize())  CmiNetworkProgress();
522 #else
523 #if CMK_SMP
524     #error "Machine progress call needs to be implemented for cpu affinity!"
525 #endif
526 #endif
527     }
528     CmiNodeAllBarrier();
529     if (show_affinity_flag) CmiPrintCPUAffinity();
530     return;    /* comm thread return */
531   }
532
533   if (pemap != NULL) {
534     int mycore = search_pemap(pemap, CmiMyPe());
535     printf("Charm++> set PE %d on node %d to core #%d\n", CmiMyPe(), CmiMyNode(), mycore); 
536     if (mycore >= CmiNumCores()) {
537       CmiPrintf("Error> Invalid core number %d, only have %d cores (0-%d) on the node. \n", mycore, CmiNumCores(), CmiNumCores()-1);
538       CmiAbort("Invalid core number");
539     }
540     if (CmiSetCPUAffinity(mycore) == -1) CmiAbort("set_cpu_affinity abort!");
541     /*CpvAccess(myCPUAffToCore) = mycore;*/
542     CmiNodeAllBarrier();
543     CmiNodeAllBarrier();
544     if (show_affinity_flag) CmiPrintCPUAffinity();
545     return;
546   }
547
548   if (coremap!= NULL) {
549     /* each processor finds its mapping */
550     int i, ct=1, myrank;
551     for (i=0; i<strlen(coremap); i++) if (coremap[i]==',' && i<strlen(coremap)-1) ct++;
552 #if CMK_SMP
553     ct = CmiMyRank()%ct;
554 #else
555     ct = CmiMyPe()%ct;
556 #endif
557     i=0;
558     while(ct>0) if (coremap[i++]==',') ct--;
559     myrank = atoi(coremap+i);
560     printf("Charm++> set PE%d on node #%d to core #%d\n", CmiMyPe(), CmiMyNode(), myrank); 
561     if (myrank >= CmiNumCores()) {
562       CmiPrintf("Error> Invalid core number %d, only have %d cores (0-%d) on the node. \n", myrank, CmiNumCores(), CmiNumCores()-1);
563       CmiAbort("Invalid core number");
564     }
565     if (CmiSetCPUAffinity(myrank) == -1) CmiAbort("set_cpu_affinity abort!");
566     /*CpvAccess(myCPUAffToCore) = myrank;*/
567     CmiNodeAllBarrier();
568     CmiNodeAllBarrier();
569     return;
570   }
571
572     /* get my ip address */
573   if (CmiMyRank() == 0)
574   {
575 #if CMK_CRAYXT
576     ret = getXTNodeID(CmiMyPe(), CmiNumPes());
577     memcpy(&myip, &ret, sizeof(int));
578 #elif CMK_HAS_GETHOSTNAME
579     myip = skt_my_ip();        /* not thread safe, so only calls on rank 0 */
580 #else
581     CmiAbort("Can not get unique name for the compute nodes. \n");
582 #endif
583   }
584   CmiNodeAllBarrier();
585
586     /* prepare a msg to send */
587   msg = (hostnameMsg *)CmiAlloc(sizeof(hostnameMsg));
588   CmiSetHandler((char *)msg, cpuAffinityHandlerIdx);
589   msg->pe = CmiMyPe();
590   msg->ip = myip;
591   msg->ncores = CmiNumCores();
592   DEBUGP(("PE %d's node has %d number of cores. \n", CmiMyPe(), msg->ncores));
593   msg->rank = 0;
594   CmiSyncSendAndFree(0, sizeof(hostnameMsg), (void *)msg);
595
596   if (CmiMyPe() == 0) {
597     int i;
598     hostTable = CmmNew();
599     rankmsg = (rankMsg *)CmiAlloc(sizeof(rankMsg)+CmiNumPes()*sizeof(int)*2);
600     CmiSetHandler((char *)rankmsg, cpuAffinityRecvHandlerIdx);
601     rankmsg->ranks = (int *)((char*)rankmsg + sizeof(rankMsg));
602     rankmsg->nodes = (int *)((char*)rankmsg + sizeof(rankMsg) + CmiNumPes()*sizeof(int));
603     for (i=0; i<CmiNumPes(); i++) {
604       rankmsg->ranks[i] = 0;
605       rankmsg->nodes[i] = -1;
606     }
607
608     for (i=0; i<CmiNumPes(); i++) CmiDeliverSpecificMsg(cpuAffinityHandlerIdx);
609   }
610
611     /* receive broadcast from PE 0 */
612   CmiDeliverSpecificMsg(cpuAffinityRecvHandlerIdx);
613   CmiLock(affLock);
614   affinity_doneflag++;
615   CmiUnlock(affLock);
616   CmiNodeAllBarrier();
617
618   if (show_affinity_flag) CmiPrintCPUAffinity();
619 }
620
621 #else           /* not supporting affinity */
622
623
624 int CmiPrintCPUAffinity()
625 {
626   CmiPrintf("Warning: CmiPrintCPUAffinity not supported.\n");
627 }
628
629 void CmiInitCPUAffinity(char **argv)
630 {
631   char *pemap = NULL;
632   char *commap = NULL;
633   char *coremap = NULL;
634   int excludecore = -1;
635   int affinity_flag = CmiGetArgFlagDesc(argv,"+setcpuaffinity",
636                                                 "set cpu affinity");
637   while (CmiGetArgIntDesc(argv,"+excludecore",&excludecore, "avoid core when setting cpuaffinity"));
638   CmiGetArgStringDesc(argv, "+coremap", &coremap, "define core mapping");
639   CmiGetArgStringDesc(argv, "+pemap", &pemap, "define pe to core mapping");
640   CmiGetArgStringDesc(argv, "+commap", &commap, "define comm threads to core mapping");
641   if (affinity_flag && CmiMyPe()==0)
642     CmiPrintf("sched_setaffinity() is not supported, +setcpuaffinity disabled.\n");
643
644   CpvInitialize(myCPUAffToCore);
645   CpvAccess(myCPUAffToCore) = -1;
646 }
647
648 #endif