static int lua_likwid_readTemp(lua_State* L)
{
int cpuid = lua_tounsigned(L,-1);
uint32_t data;
if (thermal_read(cpuid, &data)) {
lua_pushstring(L,"Cannot read thermal data");
lua_error(L);
}
lua_pushnumber(L, data);
return 1;
}
int main (int argc, char** argv)
{
int socket_fd = -1;
int optInfo = 0;
int optClock = 0;
int optStethoscope = 0;
int optSockets = 0;
double runtime;
int hasDRAM = 0;
int c;
bstring argString;
bstring eventString = bfromcstr("CLOCK");
int numSockets=1;
int numThreads=0;
int threadsSockets[MAX_NUM_NODES*2];
int threads[MAX_NUM_THREADS];
threadsSockets[0] = 0;
if (argc == 1)
{
HELP_MSG;
exit (EXIT_SUCCESS);
}
while ((c = getopt (argc, argv, "+c:hiM:ps:v")) != -1)
{
switch (c)
{
case 'c':
CHECK_OPTION_STRING;
numSockets = bstr_to_cpuset_physical((uint32_t*) threadsSockets, argString);
bdestroy(argString);
optSockets = 1;
break;
case 'h':
HELP_MSG;
exit (EXIT_SUCCESS);
case 'i':
optInfo = 1;
break;
case 'M': /* Set MSR Access mode */
CHECK_OPTION_STRING;
accessClient_setaccessmode(str2int((char*) argString->data));
bdestroy(argString);
break;
case 'p':
optClock = 1;
break;
case 's':
CHECK_OPTION_STRING;
optStethoscope = str2int((char*) argString->data);
bdestroy(argString);
break;
case 'v':
VERSION_MSG;
exit (EXIT_SUCCESS);
case '?':
if (optopt == 's' || optopt == 'M' || optopt == 'c')
{
HELP_MSG;
}
else if (isprint (optopt))
{
fprintf (stderr, "Unknown option `-%c'.\n", optopt);
}
else
{
fprintf (stderr,
"Unknown option character `\\x%x'.\n",
optopt);
}
exit( EXIT_FAILURE);
default:
HELP_MSG;
exit (EXIT_SUCCESS);
}
}
if (!lock_check())
{
fprintf(stderr,"Access to performance counters is locked.\n");
exit(EXIT_FAILURE);
}
if (optClock && optind == argc)
{
fprintf(stderr,"Commandline option -p requires an executable.\n");
exit(EXIT_FAILURE);
}
if (optSockets && !optStethoscope && optind == argc)
{
fprintf(stderr,"Commandline option -c requires an executable if not used in combination with -s.\n");
exit(EXIT_FAILURE);
}
if (cpuid_init() == EXIT_FAILURE)
{
fprintf(stderr, "CPU not supported\n");
exit(EXIT_FAILURE);
}
if (numSockets > cpuid_topology.numSockets)
{
fprintf(stderr, "System has only %d sockets but %d are given on commandline\n",
cpuid_topology.numSockets, numSockets);
exit(EXIT_FAILURE);
}
numa_init(); /* consider NUMA node as power unit for the moment */
accessClient_init(&socket_fd);
msr_init(socket_fd);
timer_init();
/* check for supported processors */
if ((cpuid_info.model == SANDYBRIDGE_EP) ||
(cpuid_info.model == SANDYBRIDGE) ||
(cpuid_info.model == IVYBRIDGE) ||
(cpuid_info.model == IVYBRIDGE_EP) ||
(cpuid_info.model == HASWELL) ||
(cpuid_info.model == NEHALEM_BLOOMFIELD) ||
(cpuid_info.model == NEHALEM_LYNNFIELD) ||
(cpuid_info.model == NEHALEM_WESTMERE))
{
power_init(numa_info.nodes[0].processors[0]);
}
else
{
fprintf (stderr, "Query Turbo Mode only supported on Intel Nehalem/Westmere/SandyBridge/IvyBridge/Haswell processors!\n");
exit(EXIT_FAILURE);
}
double clock = (double) timer_getCpuClock();
printf(HLINE);
printf("CPU name:\t%s \n",cpuid_info.name);
printf("CPU clock:\t%3.2f GHz \n", (float) clock * 1.E-09);
printf(HLINE);
if (optInfo)
{
if (power_info.turbo.numSteps != 0)
{
printf("Base clock:\t%.2f MHz \n", power_info.baseFrequency );
printf("Minimal clock:\t%.2f MHz \n", power_info.minFrequency );
printf("Turbo Boost Steps:\n");
for (int i=0; i < power_info.turbo.numSteps; i++ )
{
printf("C%d %.2f MHz \n",i+1, power_info.turbo.steps[i] );
}
}
printf(HLINE);
}
if (cpuid_info.model == SANDYBRIDGE_EP)
{
hasDRAM = 1;
}
else if ((cpuid_info.model != SANDYBRIDGE) &&
(cpuid_info.model != SANDYBRIDGE_EP) &&
(cpuid_info.model != IVYBRIDGE) &&
(cpuid_info.model != IVYBRIDGE_EP) &&
(cpuid_info.model != HASWELL))
{
fprintf (stderr, "RAPL not supported on this processor!\n");
exit(EXIT_FAILURE);
}
if (optInfo)
{
printf("Thermal Spec Power: %g Watts \n", power_info.tdp );
printf("Minimum Power: %g Watts \n", power_info.minPower);
printf("Maximum Power: %g Watts \n", power_info.maxPower);
printf("Maximum Time Window: %g micro sec \n", power_info.maxTimeWindow);
printf(HLINE);
exit(EXIT_SUCCESS);
}
if (optClock)
{
affinity_init();
argString = bformat("S%u:0-%u", threadsSockets[0], cpuid_topology.numCoresPerSocket-1);
for (int i=1; i<numSockets; i++)
{
bstring tExpr = bformat("@S%u:0-%u", threadsSockets[i], cpuid_topology.numCoresPerSocket-1);
bconcat(argString, tExpr);
}
numThreads = bstr_to_cpuset(threads, argString);
bdestroy(argString);
perfmon_init(numThreads, threads, stdout);
perfmon_setupEventSet(eventString, NULL);
}
{
PowerData pDataPkg[MAX_NUM_NODES*2];
PowerData pDataDram[MAX_NUM_NODES*2];
printf("Measure on sockets: %d", threadsSockets[0]);
for (int i=1; i<numSockets; i++)
{
printf(", %d", threadsSockets[i]);
}
printf("\n");
if (optStethoscope)
{
if (optClock)
{
perfmon_startCounters();
}
else
{
for (int i=0; i<numSockets; i++)
{
int cpuId = numa_info.nodes[threadsSockets[i]].processors[0];
if (hasDRAM) power_start(pDataDram+i, cpuId, DRAM);
power_start(pDataPkg+i, cpuId, PKG);
}
}
sleep(optStethoscope);
if (optClock)
{
perfmon_stopCounters();
perfmon_printCounterResults();
perfmon_finalize();
}
else
{
for (int i=0; i<numSockets; i++)
{
int cpuId = numa_info.nodes[threadsSockets[i]].processors[0];
power_stop(pDataPkg+i, cpuId, PKG);
if (hasDRAM) power_stop(pDataDram+i, cpuId, DRAM);
}
}
runtime = (double) optStethoscope;
}
else
{
TimerData time;
argv += optind;
bstring exeString = bfromcstr(argv[0]);
for (int i=1; i<(argc-optind); i++)
{
bconchar(exeString, ' ');
bcatcstr(exeString, argv[i]);
}
printf("%s\n",bdata(exeString));
if (optClock)
{
perfmon_startCounters();
}
else
{
for (int i=0; i<numSockets; i++)
{
int cpuId = numa_info.nodes[threadsSockets[i]].processors[0];
if (hasDRAM) power_start(pDataDram+i, cpuId, DRAM);
power_start(pDataPkg+i, cpuId, PKG);
}
timer_start(&time);
}
if (system(bdata(exeString)) == EOF)
{
fprintf(stderr, "Failed to execute %s!\n", bdata(exeString));
exit(EXIT_FAILURE);
}
if (optClock)
{
perfmon_stopCounters();
perfmon_printCounterResults();
perfmon_finalize();
}
else
{
timer_stop(&time);
for (int i=0; i<numSockets; i++)
{
int cpuId = numa_info.nodes[threadsSockets[i]].processors[0];
power_stop(pDataPkg+i, cpuId, PKG);
if (hasDRAM) power_stop(pDataDram+i, cpuId, DRAM);
}
runtime = timer_print(&time);
}
}
if (!optClock)
{
printf("Runtime: %g second \n",runtime);
printf(HLINE);
for (int i=0; i<numSockets; i++)
{
printf("Socket %d\n",threadsSockets[i]);
printf("Domain: PKG \n");
printf("Energy consumed: %g Joules \n", power_printEnergy(pDataPkg+i));
printf("Power consumed: %g Watts \n", power_printEnergy(pDataPkg+i) / runtime );
if (hasDRAM)
{
printf("Domain: DRAM \n");
printf("Energy consumed: %g Joules \n", power_printEnergy(pDataDram+i));
printf("Power consumed: %g Watts \n", power_printEnergy(pDataDram+i) / runtime );
}
printf("\n");
}
}
}
#if 0
if ( cpuid_hasFeature(TM2) )
{
thermal_init(0);
printf("Current core temperatures:\n");
for (uint32_t i = 0; i < cpuid_topology.numCoresPerSocket; i++ )
{
printf("Core %d: %u C\n",
numa_info.nodes[socketId].processors[i],
thermal_read(numa_info.nodes[socketId].processors[i]));
}
}
#endif
msr_finalize();
return EXIT_SUCCESS;
}
void kernel_main(uint32_t r0, uint32_t r1, uint32_t *atags,
uint32_t memory_kernel) {
unsigned int memory_total;
int init_process,idle_process;
struct atag_info_t atag_info;
uint32_t framebuffer_width=800,framebuffer_height=600;
uint32_t temperature;
(void) r0; /* Ignore boot method */
/* Initialize Software Structures */
processes_init();
/* Detect Hardware */
atags_detect(atags,&atag_info);
hardware_type=atag_info.hardware_type;
/* Initialize Hardware */
/* Serial console is most important so do that first */
uart_init();
/* Enable HW random number generator */
bcm2835_rng_init();
/* Enable Interrupts */
enable_interrupts();
/************************/
/* Boot message! */
/************************/
printk("\nBooting VMWos...\n");
/**************************/
/* Device Drivers */
/**************************/
/* Set up ACT LED */
led_init();
/* Set up timer */
timer_init();
/* Set up keyboard */
ps2_keyboard_init();
/* Enable the Framebuffer */
if (atag_info.framebuffer_x!=0) {
framebuffer_width=atag_info.framebuffer_x;
}
if (atag_info.framebuffer_y!=0) {
framebuffer_height=atag_info.framebuffer_y;
}
framebuffer_init(framebuffer_width,framebuffer_height,24);
framebuffer_console_init();
/* Delay to allow time for serial port to settle */
/* So we can actually see the output on the terminal */
delay(0x3f0000);
printk("\nWaiting for serial port to be ready (press any key)\n");
uart_getc();
uart_enable_interrupts();
/* Clear screen */
printk("\n\033[2J\n\n");
/* Print boot message */
printk("\033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m VMW OS\n");
printk(" \033[0;41m \033[42m \033[44m \033[42m \033[44m \033[0m Version 0.%d\n\n",VERSION);
/* Print hardware version */
printk("Hardware version: %x ",r1);
if (r1==0xc42) printk("(Raspberry Pi)");
else printk("(Unknown Hardware)");
printk("\n");
printk("Detected Model ");
switch(hardware_type) {
case RPI_MODEL_A: printk("A"); break;
case RPI_MODEL_APLUS: printk("A+"); break;
case RPI_MODEL_B: printk("B"); break;
case RPI_MODEL_BPLUS: printk("B+"); break;
case RPI_MODEL_B2: printk("B2"); break;
case RPI_COMPUTE_NODE: printk("Compute Node"); break;
default: printk("Unknown %x",hardware_type); break;
}
printk("\n");
/* Check temperature */
temperature=thermal_read();
printk("CPU Temperature: %dC, %dF\n",
temperature/1000,
((temperature*9)/5000)+32);
/* Print ATAGS */
atags_dump(atags);
printk("\n");
/* Get amount of RAM from ATAGs */
memory_total=atag_info.ramsize;
/* Init memory subsystem */
memory_init(memory_total,memory_kernel);
/* Start HW Perf Counters */
arm1176_init_pmu();
#if 0
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
asm("nop");
// printk("Heisenbug!\n");
#endif
/* Setup Memory Hierarchy */
#if 1
memset_benchmark(memory_total);
#else
/* Enable L1 i-cache */
printk("Enabling L1 icache\n");
enable_l1_dcache();
/* Enable branch predictor */
printk("Enabling branch predictor\n");
/* Enable L1 d-cache */
printk("Enabling MMU with 1:1 Virt/Phys page mapping\n");
enable_mmu(0,memory_total);
printk("Enabling L1 dcache\n");
enable_l1_dcache();
#endif
/* Init the file descriptor table */
fd_table_init();
/* Initialize the ramdisk */
ramdisk_init(initrd_image,sizeof(initrd_image));
/* Mount the ramdisk */
mount("/dev/ramdisk","/","romfs",0,NULL);
/* Load the idle thread */
idle_process=load_process("idle",PROCESS_FROM_RAM,
(char *)&idle_task,8,4096);
init_process=load_process("shell",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printa",PROCESS_FROM_DISK,
NULL,0,8192);
load_process("printb",PROCESS_FROM_DISK,
NULL,0,8192);
/* Enter our "init" process*/
printk("\nEntering userspace by starting process %d!\n",
init_process);
process[idle_process].ready=1;
process[init_process].ready=1;
userspace_started=1;
/* run init and restore stack as we won't return */
run_process(init_process,0x8000);
/* we should never get here */
while(1) {
/* Loop Forever */
/* Should probably execute a wfi instruction */
}
}
