| /** |
| ******************************************************************************** |
| * Copyright (c) 2020-2021 Robert Bosch GmbH. |
| * |
| * This program and the accompanying materials are made |
| * available under the terms of the Eclipse Public License 2.0 |
| * which is available at https://www.eclipse.org/legal/epl-2.0/ |
| * |
| * SPDX-License-Identifier: EPL-2.0 |
| * |
| * Contributors: |
| * Robert Bosch GmbH - initial API and implementation |
| * ******************************************************************************* |
| */ |
| |
| package org.eclipse.app4mc.slg.commons.m2t.generators |
| |
| class InstrumentationGenerator { |
| |
| // Suppress default constructor |
| private new() { |
| throw new IllegalStateException("Utility class"); |
| } |
| |
| static def String getHeaderFileContent() |
| ''' |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <unistd.h> |
| #include <string.h> |
| #include <sys/ioctl.h> |
| #include <linux/perf_event.h> |
| #include <asm/unistd.h> |
| #include <inttypes.h> |
| |
| void instrument_start_measurement(int counter); |
| void instrument_stop_measurement(int counter); |
| int instrument_start(pid_t pid, uint64_t event_list[], int total_events, int counter); |
| void instrument_stop(int fd, int counter); |
| void instrument_read(int fd); |
| ''' |
| |
| static def String getSourceFileContent() |
| ''' |
| #include "instrument.h" |
| #define LOGFILE "codesnippet.log" |
| |
| //average |
| #define ROWLENGTH 80 |
| #define FUNCTIONREPEATS 200 |
| #define MAXCOUNTERS 7 |
| #define MAXDEVIATION 0.01 |
| |
| |
| /* -------------------------------------------------------------------------------------------------------------------------------------- */ |
| /* CONFIGURE EVENTS HERE */ |
| /* -------------------------------------------------------------------------------------------------------------------------------------- */ |
| |
| #define NUM_EVENTS 6 |
| // currently L1 Instruction Cache Access missing |
| // Events: {memory access, L1 Data Cache Access, LD_RETIRED, ST_RETIRED, L2 Data Cache Access, Linefill because of prefetch} |
| uint64_t eventlist[NUM_EVENTS] = {0x0006, 0x0007, 0x0016, 0x00E7, 0x00E8, 0x0003}; |
| |
| |
| int fd = 0; |
| |
| void instrument_start_measurement(int counter){ |
| fd = instrument_start(0, eventlist, NUM_EVENTS, counter); |
| } |
| |
| void instrument_stop_measurement(int counter){ |
| instrument_stop(fd, counter); |
| } |
| |
| static long perf_event_define(pid_t proccess_id, int group_fd, uint64_t pinned, uint32_t event_type, uint64_t event) |
| { |
| struct perf_event_attr hw_event; |
| pid_t pid = proccess_id; // measure the current process/thread |
| int cpu = -1; // measure on any cpu |
| unsigned long flags = 0; |
| int fd_current; |
| |
| memset(&hw_event, 0, sizeof(struct perf_event_attr)); |
| hw_event.type = event_type; |
| hw_event.size = sizeof(struct perf_event_attr); |
| hw_event.config = event; |
| hw_event.disabled = 1; // off by default. specifies whether the counter starts out disabled or enabled. |
| hw_event.exclude_kernel = 1; // excluding events that happen in the kernel-space |
| hw_event.exclude_hv = 1; // excluding events that happen in the hypervisor |
| hw_event.pinned = pinned; // specifies the counter to be on the CPU if at all possible. applies only to hardware counters and only to group leaders. |
| hw_event.exclude_user = 0; // excludes events that happen in user space |
| hw_event.exclude_callchain_kernel = 1; // Do not include kernel callchains. |
| hw_event.exclude_callchain_user = 0; // Do not include user callchains. |
| // hw_event.inherit = 1; // Inherit does not work for some combinations of read_format values, such as PERF_FORMAT_GROUP. |
| //hw_event.exclusive = 1; // not working for counters other than cycle counter |
| //hw_event.exclude_idle = 1; // doesn't work |
| |
| hw_event.read_format = PERF_FORMAT_GROUP; // Allows all counter values in an event group to be read with one read |
| fd_current = syscall(__NR_perf_event_open, &hw_event, pid, cpu, group_fd, flags); |
| if (fd_current == -1) { |
| printf("Error opening leader %llx\n", hw_event.config); |
| exit(EXIT_FAILURE); |
| } |
| |
| return fd_current; |
| } |
| |
| int instrument_start(pid_t pid, uint64_t event_list[], int total_events, int counter){ |
| int i; |
| if(counter==0){ |
| FILE * file_pointer; |
| file_pointer = fopen(LOGFILE, "w+"); |
| fprintf(file_pointer, "CPU cycles\t\t"); |
| for (i = 0; i < total_events; i++){ |
| switch(event_list[i]){ |
| case 0x0001: fprintf(file_pointer, "L1 i refill\t\t"); break; |
| case 0x0002: fprintf(file_pointer, "L1 i tlb refill\t\t"); break; |
| case 0x0003: fprintf(file_pointer, "L1 d refill\t\t"); break; |
| case 0x0004: fprintf(file_pointer, "L1 d access\t\t"); break; |
| case 0x0005: fprintf(file_pointer, "L1 d tlb refill\t\t"); break; |
| case 0x0006: fprintf(file_pointer, "LD_RETIRED\t\t"); break; |
| case 0x0007: fprintf(file_pointer, "ST_RETIRED\t\t"); break; |
| case 0x0013: fprintf(file_pointer, "mem access\t\t"); break; |
| case 0x0014: fprintf(file_pointer, "L1 i access\t\t"); break; |
| case 0x0016: fprintf(file_pointer, "L2 d access\t\t"); break; |
| case 0x0017: fprintf(file_pointer, "L2 d refill\t\t"); break; |
| case 0x00C2: fprintf(file_pointer, "prefetch\t\t"); break; |
| case 0x00E7: fprintf(file_pointer, "_______E8\t\t"); break; |
| case 0x00E8: fprintf(file_pointer, "_______E7\t\t"); break; |
| default: fprintf(file_pointer, "%" PRId64 "\t\t", event_list[i]); break; |
| } |
| } |
| fprintf(file_pointer, "\n"); |
| fclose(file_pointer); |
| } |
| fd = perf_event_define(pid, -1, 1, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); |
| for (i = 0; i < total_events; i++) |
| perf_event_define(pid, fd, 0, PERF_TYPE_RAW, event_list[i]); |
| |
| /* Example usage: |
| |
| perf_event_define(fd, 0, PERF_TYPE_RAW, 0x0008); |
| perf_event_define(fd, 0, PERF_TYPE_RAW, 0x0012); |
| perf_event_define(fd, 0, PERF_TYPE_RAW, 0x0004); |
| perf_event_define(fd, 0, PERF_TYPE_RAW, 0x0003); |
| perf_event_define(fd, 0, PERF_TYPE_RAW, 0x0016); |
| perf_event_define(fd, 0, PERF_TYPE_RAW, 0x0017); |
| |
| int fd = perf_event_define(-1, 1, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); |
| perf_event_define(fd, 0, PERF_TYPE_HARDWARE, PERF_COUNT_HW_INSTRUCTIONS); |
| perf_event_define(fd, 0, PERF_TYPE_HARDWARE, PERF_COUNT_HW_BRANCH_INSTRUCTIONS); |
| perf_event_define(fd , 0, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_REFERENCES); |
| perf_event_define(fd , 0, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CACHE_MISSES); |
| perf_event_define(fd , 0, PERF_TYPE_HW_CACHE, (PERF_COUNT_HW_CACHE_LL) | (PERF_COUNT_HW_CACHE_OP_READ << 8) | (PERF_COUNT_HW_CACHE_RESULT_ACCESS << 16)); |
| perf_event_define(fd , 0, PERF_TYPE_HW_CACHE, (PERF_COUNT_HW_CACHE_LL) | (PERF_COUNT_HW_CACHE_OP_READ << 8) | (PERF_COUNT_HW_CACHE_RESULT_MISS << 16)); |
| |
| */ |
| |
| ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP); |
| ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP); |
| |
| return fd; |
| } |
| |
| struct read_format { |
| uint64_t nr; // The number of events |
| struct { |
| uint64_t value; // The value of the event |
| //uint64_t id; // PERF_FORMAT_ID |
| } values[]; |
| }; |
| |
| void instrument_stop(int fd, int counter){ |
| ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP); |
| char buf[4096]; |
| read(fd, buf, sizeof(buf)); |
| |
| int i; |
| struct read_format* rf = (struct read_format*) buf; |
| |
| FILE * file_pointer; |
| file_pointer = fopen(LOGFILE, "a"); |
| for (i = 0; i < rf->nr; i++){ |
| if(i == (rf->nr - 1)){ |
| fprintf(file_pointer, "%" PRId64, rf->values[i].value); |
| break; |
| } |
| fprintf(file_pointer, "%" PRId64 "\t\t\t", rf->values[i].value); |
| //fprintf(file_pointer, "id: %" PRId64 "\t", rf->values[i].id); |
| } |
| fprintf(file_pointer, "\n"); |
| fclose(file_pointer); |
| close(fd); |
| if(counter == (FUNCTIONREPEATS-1)){ |
| file_pointer = fopen(LOGFILE, "r"); |
| char line[ROWLENGTH]; |
| char * del = "\t\t\t"; |
| char *ptr; |
| uint64_t help[MAXCOUNTERS] = {0}; |
| uint64_t average[MAXCOUNTERS] = {0}; |
| i = 0; |
| if(file_pointer != NULL){ |
| fgets(line, sizeof(line), file_pointer); // first row should be ignored |
| fgets(line, sizeof(line), file_pointer); // second row does not make any sense |
| while(fgets(line, sizeof(line), file_pointer) != NULL){ |
| ptr = strtok(line, del); |
| while(ptr != NULL){ |
| help[i] = strtoul(ptr, NULL, 0); |
| i++; |
| //ptr = (char)ptr; |
| ptr = strtok(NULL, del); |
| } |
| for(i = 0; i < rf->nr; i++){ |
| average[i] = average[i] + help[i]; |
| } |
| i = 0; |
| } |
| for(i = 0; i < rf->nr; i++){ |
| if(average[i] != 0){ |
| average[i] /= FUNCTIONREPEATS; |
| } |
| } |
| } |
| fclose(file_pointer); |
| file_pointer = fopen(LOGFILE, "r"); |
| i = 0; |
| int deviation[MAXCOUNTERS] = {0}; |
| if(file_pointer != NULL){ |
| fgets(line, sizeof(line), file_pointer); // first row should be ignored |
| fgets(line, sizeof(line), file_pointer); // second row does not make any sense |
| while(fgets(line, sizeof(line), file_pointer) != NULL){ |
| ptr = strtok(line, del); |
| while(ptr != NULL){ |
| help[i] = strtoul(ptr, NULL, 0); |
| i++; |
| //ptr = (char)ptr; |
| ptr = strtok(NULL, del); |
| } |
| for(i = 0; i < rf->nr; i++){ |
| if(((average[i]*(1+MAXDEVIATION)) < help[i]) || ((average[i]*(1-MAXDEVIATION)) > help[i])){ |
| deviation[i]++; |
| } |
| } |
| i = 0; |
| } |
| } |
| fclose(file_pointer); |
| file_pointer = fopen(LOGFILE, "a"); |
| fprintf(file_pointer, "\nAVERAGES:\n"); |
| for (i = 0; i < rf->nr; i++){ |
| if(i == (rf->nr - 1)){ |
| fprintf(file_pointer, "%" PRId64, average[i]); |
| break; |
| } |
| fprintf(file_pointer, "%" PRId64 "\t\t\t", average[i]); |
| } |
| fprintf(file_pointer, "\nDEVIATIONS:\n"); |
| for (i = 0; i < rf->nr; i++){ |
| if(i == (rf->nr - 1)){ |
| fprintf(file_pointer, "%d", deviation[i]); |
| break; |
| } |
| fprintf(file_pointer, "%d\t\t\t\t", deviation[i]); |
| } |
| fclose(file_pointer); |
| } |
| |
| } |
| |
| void instrument_read(int fd){ |
| char buf[4096]; |
| read(fd, buf, sizeof(buf)); |
| |
| int i; |
| struct read_format* rf = (struct read_format*) buf; |
| |
| FILE * file_pointer; |
| file_pointer = fopen(LOGFILE, "a"); |
| |
| for (i = 0; i < rf->nr; i++) |
| fprintf(file_pointer, "%" PRId64 "\t", rf->values[i].value); |
| //fprintf(file_pointer, "ID: %" PRId64 "\t", rf->values[i].id); |
| fprintf(file_pointer, "\n"); |
| |
| fclose(file_pointer); |
| ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP); |
| } |
| |
| |
| ''' |
| |
| } |
