static int lua_likwid_pinProcess(lua_State* L)
{
int cpuID = luaL_checknumber(L,-2);
int silent = luaL_checknumber(L,-1);
luaL_argcheck(L, cpuID >= 0, 1, "CPU ID must be greater or equal 0");
if (affinity_isInitialized == 0)
{
affinity_init();
affinity_isInitialized = 1;
affinity = get_affinityDomains();
}
affinity_pinProcess(cpuID);
if (!silent)
{
#ifdef COLOR
color_on(BRIGHT, COLOR);
#endif
printf("[likwid-pin] Main PID -> core %d - OK", cpuID);
#ifdef COLOR
color_reset();
#endif
printf("\n");
}
return 0;
}
static void
initMemory(size_t size, char* ptr, int domainId)
{
affinity_pinProcess(numa_info.nodes[domainId].processors[0]);
for (size_t i=0; i < size; i += PAGE_ALIGNMENT)
{
ptr[i] = (char) 0xEF;
}
}
void
allocator_allocateVector(
void** ptr,
int alignment,
uint64_t size,
int offset,
DataType type,
bstring domainString)
{
int i;
size_t bytesize = 0;
const AffinityDomain* domain = NULL;
int errorCode;
int elements = 0;
switch ( type )
{
case INT:
bytesize = (size+offset) * sizeof(int);
elements = alignment / sizeof(int);
break;
case SINGLE:
bytesize = (size+offset) * sizeof(float);
elements = alignment / sizeof(float);
break;
case DOUBLE:
bytesize = (size+offset) * sizeof(double);
elements = alignment / sizeof(double);
break;
}
for (i=0;i<domains->numberOfAffinityDomains;i++)
{
if (biseq(domainString, domains->domains[i].tag))
{
domain = domains->domains + i;
}
}
if (!domain)
{
fprintf(stderr, "Error: Cannot use desired domain %s for vector placement, Domain %s does not exist.\n",
bdata(domainString), bdata(domainString));
exit(EXIT_FAILURE);
}
errorCode = posix_memalign(ptr, alignment, bytesize);
if (errorCode)
{
if (errorCode == EINVAL)
{
fprintf(stderr,
"Error: Alignment parameter is not a power of two\n");
exit(EXIT_FAILURE);
}
if (errorCode == ENOMEM)
{
fprintf(stderr,
"Error: Insufficient memory to fulfill the request\n");
exit(EXIT_FAILURE);
}
}
if ((*ptr) == NULL)
{
fprintf(stderr, "Error: posix_memalign failed!\n");
exit(EXIT_FAILURE);
}
allocList[numberOfAllocatedVectors].ptr = *ptr;
allocList[numberOfAllocatedVectors].size = bytesize;
allocList[numberOfAllocatedVectors].offset = offset;
allocList[numberOfAllocatedVectors].type = type;
numberOfAllocatedVectors++;
affinity_pinProcess(domain->processorList[0]);
printf("Allocate: Process running on core %d (Domain %s) - Vector length %llu Offset %d Alignment %llu\n",
affinity_processGetProcessorId(),
bdata(domain->tag),
LLU_CAST bytesize,
offset,
LLU_CAST elements);
switch ( type )
{
case INT:
{
int* sptr = (int*) (*ptr);
sptr += offset;
for ( uint64_t i=0; i < size; i++ )
{
sptr[i] = 1;
}
*ptr = (void*) sptr;
}
break;
case SINGLE:
{
float* sptr = (float*) (*ptr);
sptr += offset;
for ( uint64_t i=0; i < size; i++ )
{
sptr[i] = 1.0;
}
*ptr = (void*) sptr;
}
break;
case DOUBLE:
{
double* dptr = (double*) (*ptr);
dptr += offset;
for ( uint64_t i=0; i < size; i++ )
{
dptr[i] = 1.0;
}
*ptr = (void*) dptr;
}
break;
}
}
