gh0s7/mckernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

perf_event_open: Add support for counting REF_CPU_CYCLES

Browse Source 
Using thread's tsc count instead of performance counter

Refs: #1025
Change-Id: I1d7a18f1c52f1d52087002d31818638a6b206014
This commit is contained in:
Ken Sato
2019-09-25 21:14:35 +09:00
committed by Masamichi Takagi
parent bc06d68d84
commit 309145587f
18 changed files with 2360 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

218
kernel/syscall.c
View File

@@ -3767,10 +3767,48 @@ unsigned long perf_event_read_value(struct mc_perf_event *event)
unsigned long rtn_count = 0;
unsigned long pmc_count = 0;
int counter_id = event->counter_id;
struct thread *thread = cpu_local_var(current);
unsigned long cur_user_tsc, cur_system_tsc;
if (event->stopped_user_tsc) {
cur_user_tsc = event->stopped_user_tsc;
}
else {
cur_user_tsc = thread->user_tsc;
}
if (event->stopped_system_tsc) {
cur_system_tsc = event->stopped_system_tsc;
}
else {
cur_system_tsc = thread->system_tsc;
}
/* -- For use_invariant_tsc --
* Add sum of counts in the previous start-stop periods to
* the current count in the start-read period
*/
if(event->pid == 0) {
pmc_count = ihk_mc_perfctr_value(counter_id,
event->attr.sample_freq);
if (event->use_invariant_tsc) {
if (!event->attr.exclude_user) {
pmc_count += cur_user_tsc -
event->base_user_tsc +
event->user_accum_count;
}
if (!event->attr.exclude_kernel) {
/* Add sum of counts in the previous
* start-stop periods to the current count
* in the start-read period
*/
pmc_count += cur_system_tsc -
event->base_system_tsc +
event->system_accum_count;
}
}
else {
pmc_count = ihk_mc_perfctr_read(counter_id) +
event->attr.sample_freq;
}
}
rtn_count += event->count + pmc_count;
@@ -3787,14 +3825,14 @@ perf_event_read_group(struct mc_perf_event *event, unsigned long read_format, ch
struct mc_perf_event *leader = event->group_leader, *sub;
int n = 0, size = 0, ret;
unsigned long count;
unsigned long values[5];
long long values[5];
count = perf_event_read_value(leader);
values[n++] = 1 + leader->nr_siblings;
values[n++] = count;
size = n * sizeof(unsigned long);
size = n * sizeof(long long);
if (copy_to_user(buf, values, size))
return -EFAULT;
@@ -3805,7 +3843,7 @@ perf_event_read_group(struct mc_perf_event *event, unsigned long read_format, ch
n = 0;
values[n++] = perf_event_read_value(sub);
size = n * sizeof(unsigned long);
size = n * sizeof(long long);
if (copy_to_user(buf + ret, values, size)) {
return -EFAULT;
@@ -3854,25 +3892,75 @@ void perf_start(struct mc_perf_event *event)
int counter_id;
unsigned long counter_mask = 0;
struct mc_perf_event *leader = event->group_leader, *sub;
struct thread *thread = cpu_local_var(current);
/* -- For use_invariant_tsc --
* Record sum of counts the previous start-stop periods
* into accum_count,
* because only the count at the last start is recorded
*/
counter_id = leader->counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id)) {
perf_counter_set(leader);
counter_mask |= 1UL << counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id) &&
leader->state == PERF_EVENT_STATE_INACTIVE) {
if (leader->use_invariant_tsc) {
if (leader->stopped_user_tsc) {
leader->user_accum_count +=
leader->stopped_user_tsc -
leader->base_user_tsc;
leader->stopped_user_tsc = 0;
}
leader->base_user_tsc = thread->user_tsc;
if (leader->stopped_system_tsc) {
leader->system_accum_count +=
leader->stopped_system_tsc -
leader->base_system_tsc;
leader->stopped_system_tsc = 0;
}
leader->base_system_tsc = thread->system_tsc;
}
else {
perf_counter_set(leader);
counter_mask |= 1UL << counter_id;
}
leader->state = PERF_EVENT_STATE_ACTIVE;
}
list_for_each_entry(sub, &leader->sibling_list, group_entry) {
counter_id = sub->counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id)) {
perf_counter_set(sub);
counter_mask |= 1UL << counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id) &&
sub->state == PERF_EVENT_STATE_INACTIVE) {
if (sub->use_invariant_tsc) {
if (sub->stopped_user_tsc) {
sub->user_accum_count +=
sub->stopped_user_tsc -
sub->base_user_tsc;
sub->stopped_user_tsc = 0;
}
sub->base_user_tsc = thread->user_tsc;
if (sub->stopped_system_tsc) {
sub->system_accum_count +=
sub->stopped_system_tsc -
sub->base_system_tsc;
sub->stopped_system_tsc = 0;
}
sub->base_system_tsc = thread->system_tsc;
}
else {
perf_counter_set(sub);
counter_mask |= 1UL << counter_id;
}
sub->state = PERF_EVENT_STATE_ACTIVE;
}
}
if (counter_mask) {
ihk_mc_perfctr_start(counter_mask);
cpu_local_var(current)->proc->perf_status = PP_COUNT;
}
thread->proc->perf_status = PP_COUNT;
}
void
@@ -3880,16 +3968,62 @@ perf_reset(struct mc_perf_event *event)
{
int counter_id;
struct mc_perf_event *leader = event->group_leader, *sub;
struct thread *thread = cpu_local_var(current);
counter_id = leader->counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id)) {
ihk_mc_perfctr_reset(counter_id);
/* Let perf_event_read_value return zero when stopped */
if (leader->use_invariant_tsc) {
if (leader->stopped_user_tsc) {
leader->base_user_tsc =
leader->stopped_user_tsc;
}
else {
leader->base_user_tsc = thread->user_tsc;
}
leader->user_accum_count = 0;
if (leader->stopped_system_tsc) {
leader->base_system_tsc =
leader->stopped_system_tsc;
}
else {
leader->base_system_tsc = thread->system_tsc;
}
leader->system_accum_count = 0;
}
else {
ihk_mc_perfctr_reset(counter_id);
}
}
list_for_each_entry(sub, &leader->sibling_list, group_entry) {
counter_id = sub->counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id)) {
ihk_mc_perfctr_reset(counter_id);
/* Let perf_event_read_value return zero when stopped */
if (sub->use_invariant_tsc) {
if (sub->stopped_user_tsc) {
sub->base_user_tsc =
sub->stopped_user_tsc;
}
else {
sub->base_user_tsc = thread->user_tsc;
}
sub->user_accum_count = 0;
if (sub->stopped_system_tsc) {
sub->base_system_tsc =
sub->stopped_system_tsc;
}
else {
sub->base_system_tsc =
thread->system_tsc;
}
sub->system_accum_count = 0;
}
else {
ihk_mc_perfctr_reset(counter_id);
}
}
}
}
@@ -3900,24 +4034,52 @@ perf_stop(struct mc_perf_event *event)
int counter_id;
unsigned long counter_mask = 0;
struct mc_perf_event *leader = event->group_leader, *sub;
struct thread *thread = cpu_local_var(current);
counter_id = leader->counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id)) {
counter_mask |= 1UL << counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id) &&
leader->state == PERF_EVENT_STATE_ACTIVE) {
if (leader->use_invariant_tsc) {
if (leader->stopped_user_tsc == 0) {
leader->stopped_user_tsc = thread->user_tsc;
}
if (leader->stopped_system_tsc == 0) {
leader->stopped_system_tsc = thread->system_tsc;
}
}
else {
counter_mask |= 1UL << counter_id;
}
leader->state = PERF_EVENT_STATE_INACTIVE;
}
list_for_each_entry(sub, &leader->sibling_list, group_entry) {
counter_id = sub->counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id)) {
counter_mask |= 1UL << counter_id;
if (ihk_mc_perf_counter_mask_check(1UL << counter_id) &&
sub->state == PERF_EVENT_STATE_ACTIVE) {
if (sub->use_invariant_tsc) {
if (sub->stopped_user_tsc == 0) {
sub->stopped_user_tsc =
thread->user_tsc;
}
if (sub->stopped_system_tsc == 0) {
sub->stopped_system_tsc =
thread->system_tsc;
}
}
else {
counter_mask |= 1UL << counter_id;
}
sub->state = PERF_EVENT_STATE_INACTIVE;
}
}
if (counter_mask) {
ihk_mc_perfctr_stop(counter_mask, 0);
cpu_local_var(current)->proc->monitoring_event = NULL;
cpu_local_var(current)->proc->perf_status = PP_NONE;
}
cpu_local_var(current)->proc->monitoring_event = NULL;
cpu_local_var(current)->proc->perf_status = PP_NONE;
}
static int
@@ -3964,8 +4126,7 @@ perf_ioctl(struct mckfd *sfd, ihk_mc_user_context_t *ctx)
break;
case PERF_EVENT_IOC_RESET:
// TODO: reset other process
ihk_mc_perfctr_set(counter_id, event->attr.sample_freq * -1);
event->count = 0L;
perf_reset(event);
break;
case PERF_EVENT_IOC_REFRESH:
// TODO: refresh other process
@@ -4131,6 +4292,19 @@ static int mc_perf_event_alloc(struct mc_perf_event **out,
event->child_count_total = 0;
event->parent = NULL;
if (attr->type == PERF_TYPE_HARDWARE &&
attr->config == PERF_COUNT_HW_REF_CPU_CYCLES) {
event->use_invariant_tsc = 1;
/*
* REF_CPU_CYCLES is counted by thread's tsc.
* Always support.
*/
*out = event;
ret = 0;
goto out;
}
switch (attr->type) {
case PERF_TYPE_HARDWARE :
val = ihk_mc_hw_event_map(attr->config);

15
lib/include/mc_perf_event.h
View File

@@ -256,12 +256,20 @@ struct hw_perf_event_extra {
int idx;
};
/**
* enum perf_event_state - the states of an event:
*/
enum perf_event_state {
PERF_EVENT_STATE_INACTIVE = 0,
PERF_EVENT_STATE_ACTIVE = 1,
};
struct mc_perf_event {
struct perf_event_attr attr;
struct hw_perf_event_extra extra_reg;
unsigned long hw_config;
unsigned long hw_config_ext;
enum perf_event_state state;
int cpu_id;
int counter_id; // counter_id
unsigned long count; // counter_value
@@ -275,6 +283,13 @@ struct mc_perf_event {
int nr_siblings;
int pid;
struct list_head group_entry;
int use_invariant_tsc;
long long base_user_tsc;
long long stopped_user_tsc;
long long user_accum_count;
long long base_system_tsc;
long long stopped_system_tsc;
long long system_accum_count;
};
struct perf_event_mmap_page {

40
test/issues/1025/C1025_aarch64.sh Executable file
View File

@@ -0,0 +1,40 @@
#!/bin/sh
. ../../common.sh
PERF_TYPE_HARDWARE=0
PERF_COUNT_HW_REF_CPU_CYCLES=9
ng=0
echo "*** C1025T01 ******************************************"
echo "** Linux's result *************************************"
echo "* REF_CPU_CYCLES event is NOT supported Linux on aarch64"
echo ""
echo "** McKernel's result *************************************"
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: none]"
${MCEXEC} ./perf_test 0 1 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_all_val.txt
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: user]"
${MCEXEC} ./perf_test 1 1 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: kernel]"
${MCEXEC} ./perf_test 2 1 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
mck_all_val=`grep "REF_CPU" ./mck_all_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
if [ "x${mck_all_val}" != "x" ] && [ "x${mck_user_val}" != "x" ] && \
[ "x${mck_kernel_val}" != "x" ] ; then
echo "** C1025T01 PASSED"
else
echo "** C1025T01 FAILED"
fi
echo ""

670
test/issues/1025/C1025_x86_64.sh Executable file
View File

@@ -0,0 +1,670 @@
#!/bin/sh
. ../../common.sh
PERF_TYPE_HARDWARE=0
PERF_COUNT_HW_CPU_CYCLES=0
PERF_COUNT_HW_INSTRUCTIONS=1
PERF_COUNT_HW_REF_CPU_CYCLES=9
ng=0
echo "*** C1025T01 ******************************************"
echo "** Linux's result *************************************"
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: none]"
./perf_test 0 1 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: user]"
./perf_test 1 1 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: kernel]"
./perf_test 2 1 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo ""
echo "** McKernel's result *************************************"
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: none]"
${MCEXEC} ./perf_test 0 1 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: user]"
${MCEXEC} ./perf_test 1 1 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: kernel]"
${MCEXEC} ./perf_test 2 1 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T01 PASSED"
else
echo "** C1025T01 FAILED"
fi
echo ""
ng=0
echo "*** C1025T02 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-A , Leader fd : YES , exclude: none]"
./perf_case_a 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-A , Leader fd : YES , exclude: user]"
./perf_case_a 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-A , Leader fd : YES , exclude: kernel]"
./perf_case_a 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-A , Leader fd : YES , exclude: none]"
${MCEXEC} ./perf_case_a 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-A , Leader fd : YES , exclude: user]"
${MCEXEC} ./perf_case_a 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-A , Leader fd : YES , exclude: kernel]"
${MCEXEC} ./perf_case_a 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T02 PASSED"
else
echo "** C1025T02 FAILED"
fi
echo ""
ng=0
echo "*** C1025T03 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-B , Leader fd : YES , exclude: none]"
./perf_case_b 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-B , Leader fd : YES , exclude: user]"
./perf_case_b 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-B , Leader fd : YES , exclude: kernel]"
./perf_case_b 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-B , Leader fd : YES , exclude: none]"
${MCEXEC} ./perf_case_b 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-B , Leader fd : YES , exclude: user]"
${MCEXEC} ./perf_case_b 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-B , Leader fd : YES , exclude: kernel]"
${MCEXEC} ./perf_case_b 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T03 PASSED"
else
echo "** C1025T03 FAILED"
fi
echo ""
ng=0
echo "*** C1025T04 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-C , Leader fd : YES , exclude: none]"
./perf_case_c 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-C , Leader fd : YES , exclude: user]"
./perf_case_c 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-C , Leader fd : YES , exclude: kernel]"
./perf_case_c 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-C , Leader fd : YES , exclude: none]"
${MCEXEC} ./perf_case_c 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-C , Leader fd : YES , exclude: user]"
${MCEXEC} ./perf_case_c 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-C , Leader fd : YES , exclude: kernel]"
${MCEXEC} ./perf_case_c 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T04 PASSED"
else
echo "** C1025T04 FAILED"
fi
echo ""
ng=0
echo "*** C1025T05 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-D , Leader fd : YES , exclude: none]"
./perf_case_d 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-D , Leader fd : YES , exclude: user]"
./perf_case_d 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-D , Leader fd : YES , exclude: kernel]"
./perf_case_d 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-D , Leader fd : YES , exclude: none]"
${MCEXEC} ./perf_case_d 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-D , Leader fd : YES , exclude: user]"
${MCEXEC} ./perf_case_d 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-D , Leader fd : YES , exclude: kernel]"
${MCEXEC} ./perf_case_d 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | head -n1 | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | head -n1 | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | head -n1 | grep -o [0-9]*`
echo -n "check user val 1st:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val 1st:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | tail -n1 | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | tail -n1 | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | tail -n1 |grep -o [0-9]*`
echo -n "check user val 2nd:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val 2nd:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T05 PASSED"
else
echo "** C1025T05 FAILED"
fi
echo ""
ng=0
echo "*** C1025T06 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-E , Leader fd : YES , exclude: none]"
./perf_case_e 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-E , Leader fd : YES , exclude: user]"
./perf_case_e 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-E , Leader fd : YES , exclude: kernel]"
./perf_case_e 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-E , Leader fd : YES , exclude: none]"
${MCEXEC} ./perf_case_e 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-E , Leader fd : YES , exclude: user]"
${MCEXEC} ./perf_case_e 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-E , Leader fd : YES , exclude: kernel]"
${MCEXEC} ./perf_case_e 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T06 PASSED"
else
echo "** C1025T06 FAILED"
fi
echo ""
ng=0
echo "*** C1025T07 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-F , Leader fd : YES , exclude: none]"
./perf_case_f 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-F , Leader fd : YES , exclude: user]"
./perf_case_f 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-F , Leader fd : YES , exclude: kernel]"
./perf_case_f 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-F , Leader fd : YES , exclude: none]"
${MCEXEC} ./perf_case_f 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES}
echo "[ CASE-F , Leader fd : YES , exclude: user]"
${MCEXEC} ./perf_case_f 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-F , Leader fd : YES , exclude: kernel]"
${MCEXEC} ./perf_case_f 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T07 PASSED"
else
echo "** C1025T07 FAILED"
fi
echo ""
ng=0
echo "*** C1025T08 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-A , Leader fd : NO , exclude: none]"
./perf_case_a 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-A , Leader fd : NO , exclude: user]"
./perf_case_a 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-A , Leader fd : NO , exclude: kernel]"
./perf_case_a 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-A , Leader fd : NO , exclude: none]"
${MCEXEC} ./perf_case_a 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-A , Leader fd : NO , exclude: user]"
${MCEXEC} ./perf_case_a 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-A , Leader fd : NO , exclude: kernel]"
${MCEXEC} ./perf_case_a 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T08 PASSED"
else
echo "** C1025T08 FAILED"
fi
echo ""
ng=0
echo "*** C1025T09 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-B , Leader fd : NO , exclude: none]"
./perf_case_b 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-B , Leader fd : NO , exclude: user]"
./perf_case_b 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-B , Leader fd : NO , exclude: kernel]"
./perf_case_b 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-B , Leader fd : NO , exclude: none]"
${MCEXEC} ./perf_case_b 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-B , Leader fd : NO , exclude: user]"
${MCEXEC} ./perf_case_b 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-B , Leader fd : NO , exclude: kernel]"
${MCEXEC} ./perf_case_b 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T09 PASSED"
else
echo "** C1025T09 FAILED"
fi
echo ""
ng=0
echo "*** C1025T10 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-C , Leader fd : NO , exclude: none]"
./perf_case_c 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-C , Leader fd : NO , exclude: user]"
./perf_case_c 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-C , Leader fd : NO , exclude: kernel]"
./perf_case_c 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-C , Leader fd : NO , exclude: none]"
${MCEXEC} ./perf_case_c 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-C , Leader fd : NO , exclude: user]"
${MCEXEC} ./perf_case_c 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-C , Leader fd : NO , exclude: kernel]"
${MCEXEC} ./perf_case_c 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T10 PASSED"
else
echo "** C1025T10 FAILED"
fi
echo ""
ng=0
echo "*** C1025T11 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-D , Leader fd : NO , exclude: none]"
./perf_case_d 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-D , Leader fd : NO , exclude: user]"
./perf_case_d 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-D , Leader fd : NO , exclude: kernel]"
./perf_case_d 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-D , Leader fd : NO , exclude: none]"
${MCEXEC} ./perf_case_d 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-D , Leader fd : NO , exclude: user]"
${MCEXEC} ./perf_case_d 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-D , Leader fd : NO , exclude: kernel]"
${MCEXEC} ./perf_case_d 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | head -n1 | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | head -n1 | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | head -n1 | grep -o [0-9]*`
echo -n "check user val 1st:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val 1st:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | tail -n1 | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | tail -n1 | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | tail -n1 |grep -o [0-9]*`
echo -n "check user val 2nd:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val 2nd:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T11 PASSED"
else
echo "** C1025T11 FAILED"
fi
echo ""
ng=0
echo "*** C1025T12 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-E , Leader fd : NO , exclude: none]"
./perf_case_e 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-E , Leader fd : NO , exclude: user]"
./perf_case_e 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-E , Leader fd : NO , exclude: kernel]"
./perf_case_e 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-E , Leader fd : NO , exclude: none]"
${MCEXEC} ./perf_case_e 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-E , Leader fd : NO , exclude: user]"
${MCEXEC} ./perf_case_e 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-E , Leader fd : NO , exclude: kernel]"
${MCEXEC} ./perf_case_e 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T12 PASSED"
else
echo "** C1025T12 FAILED"
fi
echo ""
ng=0
echo "*** C1025T13 ******************************************"
echo "** Linux's result *************************************"
echo "[ CASE-F , Leader fd : NO , exclude: none]"
./perf_case_f 0 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-F , Leader fd : NO , exclude: user]"
./perf_case_f 1 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-F , Leader fd : NO , exclude: kernel]"
./perf_case_f 2 2 ${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./lnx_user_val.txt
echo""
echo "** McKernel's result *************************************"
echo "[ CASE-F , Leader fd : NO , exclude: none]"
${MCEXEC} ./perf_case_f 0 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES}
echo "[ CASE-F , Leader fd : NO , exclude: user]"
${MCEXEC} ./perf_case_f 1 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_kernel_val.txt
echo "[ CASE-F , Leader fd : NO , exclude: kernel]"
${MCEXEC} ./perf_case_f 2 2 \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_CPU_CYCLES} \
${PERF_TYPE_HARDWARE} ${PERF_COUNT_HW_REF_CPU_CYCLES} \
| tee ./mck_user_val.txt
lnx_user_val=`grep "REF_CPU" ./lnx_user_val.txt | grep -o [0-9]*`
mck_user_val=`grep "REF_CPU" ./mck_user_val.txt | grep -o [0-9]*`
mck_kernel_val=`grep "REF_CPU" ./mck_kernel_val.txt | grep -o [0-9]*`
echo -n "check user val:"
./check_val.sh ${lnx_user_val} ${mck_user_val} 0.9 1.1
ng+=$?
echo -n "check kernel val:"
./check_val.sh ${mck_user_val} ${mck_kernel_val} 0 0.01
ng+=$?
if [ $ng -eq 0 ]; then
echo "** C1025T13 PASSED"
else
echo "** C1025T13 FAILED"
fi

39
test/issues/1025/Makefile Normal file
View File

@@ -0,0 +1,39 @@
CC = gcc
TARGET=perf_test perf_case_a perf_case_b perf_case_c perf_case_d perf_case_e perf_case_f
CPPFLAGS =
LDFLAGS =
ARCH=$(shell uname -p)
all: $(TARGET)
perf_tool.o: perftool.c perftool.h
perf_test: perf_test.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
perf_case_a: perf_case_a.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
perf_case_b: perf_case_b.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
perf_case_c: perf_case_c.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
perf_case_d: perf_case_d.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
perf_case_e: perf_case_e.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
perf_case_f: perf_case_f.c perftool.o
$(CC) -o $@ $^ $(LDFLAGS)
test: all
@sh ./C1025_$(ARCH).sh
clean:
rm -f $(TARGET) *.o *.txt

77
test/issues/1025/README Normal file
View File

@@ -0,0 +1,77 @@
【Issue#1025 動作確認】
□ 前提
PERF_COUNT_HW_REF_CPU_CYCLESイベントの計測は、aarch64アーキテクチャの
Linuxではサポートされていない。
しかし、本件の機能追加ではMcKernelのthreadが持つuser_tsc, system_tsc を
用いて計測する方式で実装したため、アーキテクチャによらず計測が可能である。
□ テスト内容
1. Issueで報告された再現プログラムでの確認
C1025T01: PERF_COUNT_HW_REF_CPU_CYCLES 指定での計測
除外なし、ユーザモード除外、カーネルモード除外の3パターンを用いて
PERF_COUNT_HW_REF_CPU_CYCLES の計測を行う
それぞれの計測において、PERF_COUNT_HW_REF_CPU_CYCLESの計測値が
アーキテクチャごとの以下の条件を満たした場合にPASSとする
[x86_64]
- ユーザ時間　：Linuxでのユーザ時間計測値の90% ～ 110%
- カーネル時間：McKernelでのユーザ時間計測結果の1% 未満
[aarch64]
LinuxでのPERF_COUNT_HW_REF_CPUの計測が行えないため、
計測値が取得できた場合にPASSとする
2. 計測の基本機能の確認 (x86_64 でのみ実施)
perf_event_openでの基本機能の確認として、計測対象の演算処理と、
Start, Stop, Reset, Readを以下のフローで実施する
CASE-A: 基本計測の確認
Start -> 演算 -> Stop -> Read
CASE-B: Stop機能の確認
Start -> 演算 -> Stop -> 演算 -> Read
CASE-C: Reset機能の確認
Start -> 演算 -> Stop -> Reset -> Read
CASE-D: Read機能の確認
Start -> 演算 -> Read -> 演算 -> Read
CASE-E: Stop後の再Start機能の確認
Start -> 演算 -> Stop -> 演算 -> Start-> 演算 -> Stop -> Read
CASE-F: Start後の再Start機能の確認
Start -> 演算 -> Start -> 演算 -> Stop -> Read
また、本テストでは、perf_event_openで取得したfdをグループ化し、
グループ内のリーダーとなるfdへの操作でグループ全体の操作が可能な
PERF_FORMAT_GROUP の指定を用いる。
その上で、PERF_COUNT_HW_REF_CPU_CYCLES の指定を行ったfdがリーダーの場合と
リーダー以外の場合で検証を行う。
本テストで実行するテストプログラム群(perf_case_X)では、1つ目の計測項目として
指定したものがリーダーとなる。
C1025T02: CASE-A でPERF_FORMAT_GROUPのリーダーの場合
C1025T03: CASE-B でPERF_FORMAT_GROUPのリーダーの場合
C1025T04: CASE-C でPERF_FORMAT_GROUPのリーダーの場合
C1025T05: CASE-D でPERF_FORMAT_GROUPのリーダーの場合
C1025T06: CASE-E でPERF_FORMAT_GROUPのリーダーの場合
C1025T07: CASE-F でPERF_FORMAT_GROUPのリーダーの場合
C1025T08: CASE-A でPERF_FORMAT_GROUPのリーダー以外の場合
C1025T09: CASE-B でPERF_FORMAT_GROUPのリーダー以外の場合
C1025T10: CASE-C でPERF_FORMAT_GROUPのリーダー以外の場合
C1025T11: CASE-D でPERF_FORMAT_GROUPのリーダー以外の場合
C1025T12: CASE-E でPERF_FORMAT_GROUPのリーダー以外の場合
C1025T13: CASE-F でPERF_FORMAT_GROUPのリーダー以外の場合
それぞれの計測において、PERF_COUNT_HW_REF_CPU_CYCLESの計測値が
以下の条件を満たした場合にPASSとする
- ユーザ時間　：Linuxでのユーザ時間計測値の90% ～ 110%
- カーネル時間：McKernelでのユーザ時間計測結果の1% 未満
□ 実行手順
$ make test
McKernelのインストール先や、OSTEST, LTPの配置場所は、
$HOME/.mck_test_config を参照している
.mck_test_config は、McKernelをビルドした際に生成されるmck_test_config.sample ファイルを
$HOMEにコピーし、適宜編集する
□ 実行結果
x86_64_result.log aarch64_result.log 参照
すべての項目で、PASSしていることを確認した

16
test/issues/1025/aarch64_result.log Normal file
View File

@@ -0,0 +1,16 @@
*** C1025T01 ******************************************
** Linux's result *************************************
* REF_CPU_CYCLES event is NOT supported Linux on aarch64
** McKernel's result *************************************
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: none]
fd: 8
REF_CPU_CYCLES : 6641022
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: user]
fd: 8
REF_CPU_CYCLES : 97
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: kernel]
fd: 8
REF_CPU_CYCLES : 6644473
** C1025T01 PASSED

25
test/issues/1025/check_val.sh Executable file
View File

@@ -0,0 +1,25 @@
#!/bin/sh
if [ $# -lt 4 ]; then
echo "usage: $(basename $0) <base_val> <tgt_val> \
<lower_coef> <upper_coef>"
exit 1
fi
base_val=$1
tgt_val=$2
l_coef=$3
u_coef=$4
lower=`echo "scale=1; ${base_val} * ${l_coef}" | bc`
upper=`echo "scale=1; ${base_val} * ${u_coef}" | bc`
if [ "$(echo "${tgt_val} > ${lower}" | bc)" -eq 1 -a \
"$(echo "${tgt_val} < ${upper}" | bc)" -eq 1 ] ||
[ ${base_val} -eq ${tgt_val} ]; then
echo " ${tgt_val} is IN ${lower} - ${upper} [OK]"
exit 0
else
echo " ${tgt_val} is OUT ${lower} - ${upper} [NG]"
exit 1
fi

91
test/issues/1025/perf_case_a.c Normal file
View File

@@ -0,0 +1,91 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
#define IS_GROUP 1
/* perf flow: Start -> calc -> Stop -> Read */
void
usage()
{
printf("Usage: perf_case_a mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM + 1];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int group_fd = -1;
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(group_fd, mode,
types[i], configs[i], IS_GROUP);
if (group_fd == -1) {
group_fd = fds[i];
}
}
/* perf_start */
PERF_BEGIN(group_fd, PERF_IOC_FLAG_GROUP);
/* calc */
calc_task();
/* perf_end and read */
PERF_END(group_fd, PERF_IOC_FLAG_GROUP);
PERF_READ(group_fd, counts, sizeof(counts));
for (i = 0; i < cntr_num; i++) {
close(fds[i]);
}
/* print result */
for (i = 0; i < counts[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i + 1]);
}
}
return 0;
}

96
test/issues/1025/perf_case_b.c Normal file
View File

@@ -0,0 +1,96 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
#define IS_GROUP 1
/* perf flow: Start -> calc -> Stop -> calc -> Read */
void
usage()
{
printf("Usage: perf_case_b mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM + 1];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int group_fd = -1;
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(group_fd, mode,
types[i], configs[i], IS_GROUP);
if (group_fd == -1) {
group_fd = fds[i];
}
}
/* perf_start */
PERF_BEGIN(group_fd, PERF_IOC_FLAG_GROUP);
/* 1st calc */
calc_task();
/* perf end */
PERF_END(group_fd, PERF_IOC_FLAG_GROUP);
/* 2nd calc */
calc_task();
/* perf read */
PERF_READ(group_fd, counts, sizeof(counts));
for (i = 0; i < cntr_num; i++) {
close(fds[i]);
}
/* print result */
for (i = 0; i < counts[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i + 1]);
}
}
return 0;
}

94
test/issues/1025/perf_case_c.c Normal file
View File

@@ -0,0 +1,94 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
#define IS_GROUP 1
/* perf flow: Start -> calc -> Stop -> Reset -> Read */
void
usage()
{
printf("Usage: perf_case_c mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM + 1];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int group_fd = -1;
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(group_fd, mode,
types[i], configs[i], IS_GROUP);
if (group_fd == -1) {
group_fd = fds[i];
}
}
/* perf_start */
PERF_BEGIN(group_fd, PERF_IOC_FLAG_GROUP);
/* calc */
calc_task();
/* perf end and reset */
PERF_END(group_fd, PERF_IOC_FLAG_GROUP);
PERF_RESET(group_fd, PERF_IOC_FLAG_GROUP);
/* perf read */
PERF_READ(group_fd, counts, sizeof(counts));
for (i = 0; i < cntr_num; i++) {
close(fds[i]);
}
/* print result */
for (i = 0; i < counts[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i + 1]);
}
}
return 0;
}

116
test/issues/1025/perf_case_d.c Normal file
View File

@@ -0,0 +1,116 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
#define IS_GROUP 1
/* perf flow: Start -> calc -> Stop -> calc -> Read */
void
usage()
{
printf("Usage: perf_case_b mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM + 1];
long long counts2[PERF_CNTR_NUM + 1];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int group_fd = -1;
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(group_fd, mode,
types[i], configs[i], IS_GROUP);
if (group_fd == -1) {
group_fd = fds[i];
}
}
/* perf_start */
PERF_BEGIN(group_fd, PERF_IOC_FLAG_GROUP);
/* 1st calc */
calc_task();
/* 1st perf read */
PERF_READ(group_fd, counts, sizeof(counts));
/* 2nd calc */
calc_task();
/* 2nd perf read */
PERF_READ(group_fd, counts2, sizeof(counts2));
/* perf end */
PERF_END(group_fd, PERF_IOC_FLAG_GROUP);
for (i = 0; i < cntr_num; i++) {
close(fds[i]);
}
/* print result 1 */
printf("** Result of 1st read\n");
for (i = 0; i < counts[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i + 1]);
}
}
printf("** Result of 2nd read\n");
for (i = 0; i < counts2[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts2[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts2[i + 1]);
}
}
return 0;
}

103
test/issues/1025/perf_case_e.c Normal file
View File

@@ -0,0 +1,103 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
#define IS_GROUP 1
/* perf flow: Start -> calc -> Stop -> Read */
void
usage()
{
printf("Usage: perf_case_a mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM + 1];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int group_fd = -1;
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(group_fd, mode,
types[i], configs[i], IS_GROUP);
if (group_fd == -1) {
group_fd = fds[i];
}
}
/* perf_start */
PERF_BEGIN(group_fd, PERF_IOC_FLAG_GROUP);
/* calc */
calc_task();
/* perf_end */
PERF_END(group_fd, PERF_IOC_FLAG_GROUP);
/* calc (not counted) */
calc_task();
/* perf_restart */
PERF_START(group_fd, PERF_IOC_FLAG_GROUP);
/* calc */
calc_task();
/* perf_end and read */
PERF_END(group_fd, PERF_IOC_FLAG_GROUP);
PERF_READ(group_fd, counts, sizeof(counts));
for (i = 0; i < cntr_num; i++) {
close(fds[i]);
}
/* print result */
for (i = 0; i < counts[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i + 1]);
}
}
return 0;
}

96
test/issues/1025/perf_case_f.c Normal file
View File

@@ -0,0 +1,96 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
#define IS_GROUP 1
/* perf flow: Start -> calc -> Stop -> calc -> Read */
void
usage()
{
printf("Usage: perf_case_f mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM + 1];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int group_fd = -1;
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(group_fd, mode,
types[i], configs[i], IS_GROUP);
if (group_fd == -1) {
group_fd = fds[i];
}
}
/* perf_start */
PERF_BEGIN(group_fd, PERF_IOC_FLAG_GROUP);
/* 1st calc */
calc_task();
/* perf restart */
PERF_START(group_fd, PERF_IOC_FLAG_GROUP);
/* 2nd calc */
calc_task();
/* perf read */
PERF_READ(group_fd, counts, sizeof(counts));
for (i = 0; i < cntr_num; i++) {
close(fds[i]);
}
/* print result */
for (i = 0; i < counts[0]; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i + 1]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i + 1]);
}
}
return 0;
}

82
test/issues/1025/perf_test.c Normal file
View File

@@ -0,0 +1,82 @@
#include <stdio.h>
#include <stdlib.h>
#include <langinfo.h>
#include <locale.h>
#include <sys/mman.h>
#include "perftool.h"
void
usage()
{
printf("Usage: perf_test mode cntr_num [<type> <config>]...\n");
exit(1);
}
int
main(int argc, char **argv)
{
long fds[PERF_CNTR_NUM];
long long counts[PERF_CNTR_NUM];
int types[PERF_CNTR_NUM];
int configs[PERF_CNTR_NUM];
int cntr_num;
int mode;
int i;
if (argc < 3) {
printf("ERROR: Too few arguments.\n");
usage();
}
mode = atoi(argv[1]);
cntr_num = atoi(argv[2]);
/* perse args */
if (argc < cntr_num * 2 + 2) {
printf("ERROR: Too few arguments.\n");
usage();
}
for (i = 0; i < cntr_num; i++) {
types[i] = atoi(argv[i * 2 + 3]);
configs[i] = atoi(argv[i * 2 + 4]);
}
/* perf_event_open */
for (i = 0; i < cntr_num; i++) {
fds[i] = pe_opener(-1, mode, types[i], configs[i], 0);
}
/* perf_start */
for (i = 0; i < cntr_num; i++) {
PERF_BEGIN(fds[i], 0);
}
calc_task();
/* perf_end and read */
for (i = 0; i < cntr_num; i++) {
PERF_END(fds[i], 0);
PERF_READ(fds[i], &counts[i], sizeof(long long));
close(fds[i]);
}
/* print result */
for (i = 0; i < cntr_num; i++) {
if (types[i] == PERF_TYPE_HARDWARE) {
printf("%s: %16ld\n",
hw_event_names[configs[i]], counts[i]);
}
else if (types[i] == PERF_TYPE_HW_CACHE) {
printf("%s_%s_%s: %16ld\n",
id_names[(configs[i] >> 0) & 0xff],
op_id_names[(configs[i] >> 8) & 0xff],
result_names[(configs[i] >> 16) & 0xff],
counts[i]);
}
}
return 0;
}

102
test/issues/1025/perftool.c Normal file
View File

@@ -0,0 +1,102 @@
#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 "perftool.h"
#define WORKSIZE (1024 * 1024 * 32)
#define LOOPSIZE 1000000
#define REP 1000
long
perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
int cpu, int group_fd, unsigned long flags)
{
int ret;
ret = syscall(__NR_perf_event_open, hw_event, pid, cpu,
group_fd, flags);
return ret;
}
long
pe_opener(long group_fd, int mode, int type, unsigned long config, int is_group)
{
struct perf_event_attr pe;
int fd;
long long perf_hw_cache_id;
long long perf_hw_cache_op_id;
long long perf_hw_cache_op_result_id;
memset(&pe, 0, sizeof(struct perf_event_attr));
pe.type = type;
pe.size = sizeof(struct perf_event_attr);
pe.config = config;
pe.disabled = 1;
if (mode & 0x01) {
// EXCLUDE EVENTS THAT HAPPEN IN USER-SPACE
pe.exclude_user = 1;
} else {
// INCLUDE EVENTS THAT HAPPEN IN USER-SPACE
pe.exclude_user = 0;
}
if (mode & 0x02) {
// EXCUDE EVENTS THAT HAPPEN IN KERNEL-SPACE
pe.exclude_kernel = 1;
} else {
// INCUDE EVENTS THAT HAPPEN IN KERNEL-SPACE
pe.exclude_kernel = 0;
}
pe.exclude_hv = 1;
if (is_group) {
pe.read_format = PERF_FORMAT_GROUP;
}
fd = perf_event_open(&pe, 0, -1, group_fd, 0);
return fd;
}
long long
hw_cache_build(long long id, long long op_id, long long op_result_id)
{
return (id) | (op_id << 8) | (op_result_id << 16);
}
void
memory_task()
{
char *work = malloc(WORKSIZE);
char *fromaddr;
char *toaddr;
double r;
int offset;
int i;
for (i = 0; i < LOOPSIZE; i++) {
r = drand48();
offset = (int)(r * (double)WORKSIZE);
fromaddr = work + offset;
r = drand48();
offset = (int)(r * (double)WORKSIZE);
toaddr = work + offset;
*toaddr = *fromaddr;
}
}
void
calc_task()
{
int i, j;
double tmp;
for (i = 0; i < REP; i++) {
for (j = 0; j < REP; j++) {
tmp = drand48() * drand48();
}
}
}

118
test/issues/1025/perftool.h Normal file
View File

@@ -0,0 +1,118 @@
#ifndef __PERFTOOL_H__
#define __PERFTOOL_H__
#include <sys/ioctl.h>
#include <linux/perf_event.h>
#include <asm/unistd.h>
#include <unistd.h>
long perf_event_open(struct perf_event_attr *hw_event, pid_t pid,
int cpu, int group_fd, unsigned long flags);
long perf_instructions(void);
long perf_count_hw_cache_l1d_read_miss(void);
long perf_count_hw_cache_dtlb_read_miss(void);
long pe_opener(long group_fd, int mode, int type,
unsigned long config, int is_group);
long long hw_cache_build(long long id, long long op_id,
long long op_result_id);
void memory_task(void);
void calc_task(void);
#define PERF_CNTR_NUM 4
#define PERF_BEGIN(fd, opt) do { \
if (fd > 0) \
ioctl(fd, PERF_EVENT_IOC_RESET, opt); \
if (fd > 0) \
ioctl(fd, PERF_EVENT_IOC_ENABLE, opt); \
} while (0)
#define PERF_END(fd, opt) do { \
if (fd > 0) \
ioctl(fd, PERF_EVENT_IOC_DISABLE, opt); \
} while (0)
#define PERF_START(fd, opt) do { \
if (fd > 0) \
ioctl(fd, PERF_EVENT_IOC_ENABLE, opt); \
} while (0)
#define PERF_RESET(fd, opt) do { \
if (fd > 0) \
ioctl(fd, PERF_EVENT_IOC_RESET, opt); \
} while (0)
#define PERF_READ(fd, count, size) do { \
if (fd > 0) \
read(fd, count, size); \
} while (0)
char *hw_event_names[] = {
"CPU_CYCLES ",
"INSTRUCTIONS ",
"CACHE_REFERENCES ",
"CACHE_MISSES ",
"BRANCH_INSTRUCTIONS ",
"BRANCH_MISSES ",
"BUS_CYCLES ",
"STALLED_CYCLES_FRONTEND",
"STALLED_CYCLES_BACKEND ",
"REF_CPU_CYCLES ",
};
char *id_names[] = {
"L1D ",
"L1I ",
"LL ",
"DTLB",
"ITLB",
"BPU ",
"NODE",
};
char *op_id_names[] = {
"OP_READ ",
"OP_WRITE ",
"OP_PREFETCH",
};
char *result_names[] = {
"ACCESS",
"MISS ",
};
long long ids[] = {
PERF_COUNT_HW_CACHE_L1D,
PERF_COUNT_HW_CACHE_L1I,
PERF_COUNT_HW_CACHE_LL,
PERF_COUNT_HW_CACHE_DTLB,
PERF_COUNT_HW_CACHE_ITLB,
PERF_COUNT_HW_CACHE_BPU,
PERF_COUNT_HW_CACHE_NODE,
};
long long op_ids[] = {
PERF_COUNT_HW_CACHE_OP_READ,
PERF_COUNT_HW_CACHE_OP_WRITE,
PERF_COUNT_HW_CACHE_OP_PREFETCH,
};
long long result_ids[] = {
PERF_COUNT_HW_CACHE_RESULT_ACCESS,
PERF_COUNT_HW_CACHE_RESULT_MISS,
};
int hw_configs[] = {
PERF_COUNT_HW_CPU_CYCLES,
PERF_COUNT_HW_INSTRUCTIONS,
PERF_COUNT_HW_CACHE_REFERENCES,
PERF_COUNT_HW_CACHE_MISSES,
PERF_COUNT_HW_BRANCH_INSTRUCTIONS,
PERF_COUNT_HW_BRANCH_MISSES,
PERF_COUNT_HW_BUS_CYCLES,
PERF_COUNT_HW_STALLED_CYCLES_FRONTEND,
PERF_COUNT_HW_STALLED_CYCLES_BACKEND,
PERF_COUNT_HW_REF_CPU_CYCLES,
};
#endif

384
test/issues/1025/x86_64_result.log Normal file
View File

@@ -0,0 +1,384 @@
*** C1025T01 ******************************************
** Linux's result *************************************
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: none]
REF_CPU_CYCLES : 48755980
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: user]
REF_CPU_CYCLES : 153686
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: kernel]
REF_CPU_CYCLES : 48527830
** McKernel's result *************************************
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: none]
REF_CPU_CYCLES : 48341332
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: user]
REF_CPU_CYCLES : 32584
[type: HARDWARE, counter: HW_REF_CPU_CYCLES, exclude: kernel]
REF_CPU_CYCLES : 48403544
check user val: 48403544 is IN 43675047.0 - 53380613.0 [OK]
check kernel val: 32584 is IN 0 - 484035.44 [OK]
** C1025T01 PASSED
*** C1025T02 ******************************************
** Linux's result *************************************
[ CASE-A , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 48236994
CPU_CYCLES : 48235903
[ CASE-A , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 164606
CPU_CYCLES : 163696
[ CASE-A , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 48176180
CPU_CYCLES : 48176171
** McKernel's result *************************************
[ CASE-A , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 48159124
CPU_CYCLES : 48158854
[ CASE-A , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 33256
CPU_CYCLES : 34166
[ CASE-A , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 48114404
CPU_CYCLES : 48113129
check user val: 48114404 is IN 43358562.0 - 52993798.0 [OK]
check kernel val: 33256 is IN 0 - 481144.04 [OK]
** C1025T02 PASSED
*** C1025T03 ******************************************
** Linux's result *************************************
[ CASE-B , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 48421568
CPU_CYCLES : 48420573
[ CASE-B , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 150592
CPU_CYCLES : 149560
[ CASE-B , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 48131044
CPU_CYCLES : 48131051
** McKernel's result *************************************
[ CASE-B , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 48218332
CPU_CYCLES : 48217927
[ CASE-B , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 26588
CPU_CYCLES : 27440
[ CASE-B , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 48184988
CPU_CYCLES : 48183719
check user val: 48184988 is IN 43317939.6 - 52944148.4 [OK]
check kernel val: 26588 is IN 0 - 481849.88 [OK]
** C1025T03 PASSED
*** C1025T04 ******************************************
** Linux's result *************************************
[ CASE-C , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 0
CPU_CYCLES : 0
[ CASE-C , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 0
CPU_CYCLES : 0
[ CASE-C , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 0
CPU_CYCLES : 0
** McKernel's result *************************************
[ CASE-C , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 0
CPU_CYCLES : 0
[ CASE-C , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 0
CPU_CYCLES : 0
[ CASE-C , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 0
CPU_CYCLES : 0
check user val: 0 is IN 0 - 0 [OK]
check kernel val: 0 is IN 0 - 0 [OK]
** C1025T04 PASSED
*** C1025T05 ******************************************
** Linux's result *************************************
[ CASE-D , Leader fd : YES , exclude: none]
** Result of 1st read
REF_CPU_CYCLES : 48435452
CPU_CYCLES : 48434766
** Result of 2nd read
REF_CPU_CYCLES : 96713214
CPU_CYCLES : 96712309
[ CASE-D , Leader fd : YES , exclude: user]
** Result of 1st read
REF_CPU_CYCLES : 167726
CPU_CYCLES : 167090
** Result of 2nd read
REF_CPU_CYCLES : 218972
CPU_CYCLES : 217925
[ CASE-D , Leader fd : YES , exclude: kernel]
** Result of 1st read
REF_CPU_CYCLES : 48358310
CPU_CYCLES : 48358416
** Result of 2nd read
REF_CPU_CYCLES : 96665374
CPU_CYCLES : 96665155
** McKernel's result *************************************
[ CASE-D , Leader fd : YES , exclude: none]
** Result of 1st read
REF_CPU_CYCLES : 48349424
CPU_CYCLES : 48350565
** Result of 2nd read
REF_CPU_CYCLES : 96533776
CPU_CYCLES : 96534029
[ CASE-D , Leader fd : YES , exclude: user]
** Result of 1st read
REF_CPU_CYCLES : 120252
CPU_CYCLES : 123202
** Result of 2nd read
REF_CPU_CYCLES : 124820
CPU_CYCLES : 127588
[ CASE-D , Leader fd : YES , exclude: kernel]
** Result of 1st read
REF_CPU_CYCLES : 48220612
CPU_CYCLES : 48218625
** Result of 2nd read
REF_CPU_CYCLES : 96400228
CPU_CYCLES : 96397658
check user val 1st: 48220612 is IN 43522479.0 - 53194141.0 [OK]
check kernel val 1st: 120252 is IN 0 - 482206.12 [OK]
check user val 2nd: 96400228 is IN 86998836.6 - 106331911.4 [OK]
check kernel val 2nd: 124820 is IN 0 - 964002.28 [OK]
** C1025T05 PASSED
*** C1025T06 ******************************************
** Linux's result *************************************
[ CASE-E , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 96772780
CPU_CYCLES : 96770849
[ CASE-E , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 266708
CPU_CYCLES : 264912
[ CASE-E , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 96471518
CPU_CYCLES : 96471732
** McKernel's result *************************************
[ CASE-E , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 96521304
CPU_CYCLES : 96520373
[ CASE-E , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 28396
CPU_CYCLES : 29419
[ CASE-E , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 96486100
CPU_CYCLES : 96484240
check user val: 96486100 is IN 86824366.2 - 106118669.8 [OK]
check kernel val: 28396 is IN 0 - 964861.00 [OK]
** C1025T06 PASSED
*** C1025T07 ******************************************
** Linux's result *************************************
[ CASE-F , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 97312774
CPU_CYCLES : 97311964
[ CASE-F , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 217334
CPU_CYCLES : 216399
[ CASE-F , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 96420454
CPU_CYCLES : 96420276
** McKernel's result *************************************
[ CASE-F , Leader fd : YES , exclude: none]
REF_CPU_CYCLES : 96623504
CPU_CYCLES : 96624703
[ CASE-F , Leader fd : YES , exclude: user]
REF_CPU_CYCLES : 122824
CPU_CYCLES : 129819
[ CASE-F , Leader fd : YES , exclude: kernel]
REF_CPU_CYCLES : 96483264
CPU_CYCLES : 96483351
check user val: 96483264 is IN 86778408.6 - 106062499.4 [OK]
check kernel val: 122824 is IN 0 - 964832.64 [OK]
** C1025T07 PASSED
*** C1025T08 ******************************************
** Linux's result *************************************
[ CASE-A , Leader fd : NO , exclude: none]
CPU_CYCLES : 48327271
REF_CPU_CYCLES : 48326278
[ CASE-A , Leader fd : NO , exclude: user]
CPU_CYCLES : 181571
REF_CPU_CYCLES : 180544
[ CASE-A , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 48163955
REF_CPU_CYCLES : 48163934
** McKernel's result *************************************
[ CASE-A , Leader fd : NO , exclude: none]
CPU_CYCLES : 48155129
REF_CPU_CYCLES : 48155124
[ CASE-A , Leader fd : NO , exclude: user]
CPU_CYCLES : 35583
REF_CPU_CYCLES : 34760
[ CASE-A , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 48127029
REF_CPU_CYCLES : 48128300
check user val: 48128300 is IN 43347540.6 - 52980327.4 [OK]
check kernel val: 34760 is IN 0 - 481283.00 [OK]
** C1025T08 PASSED
*** C1025T09 ******************************************
** Linux's result *************************************
[ CASE-B , Leader fd : NO , exclude: none]
CPU_CYCLES : 48449221
REF_CPU_CYCLES : 48448270
[ CASE-B , Leader fd : NO , exclude: user]
CPU_CYCLES : 155589
REF_CPU_CYCLES : 154544
[ CASE-B , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 48160727
REF_CPU_CYCLES : 48160710
** McKernel's result *************************************
[ CASE-B , Leader fd : NO , exclude: none]
CPU_CYCLES : 48217557
REF_CPU_CYCLES : 48218028
[ CASE-B , Leader fd : NO , exclude: user]
CPU_CYCLES : 31206
REF_CPU_CYCLES : 30500
[ CASE-B , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 48185577
REF_CPU_CYCLES : 48186852
check user val: 48186852 is IN 43344639.0 - 52976781.0 [OK]
check kernel val: 30500 is IN 0 - 481868.52 [OK]
** C1025T09 PASSED
*** C1025T10 ******************************************
** Linux's result *************************************
[ CASE-C , Leader fd : NO , exclude: none]
CPU_CYCLES : 0
REF_CPU_CYCLES : 0
[ CASE-C , Leader fd : NO , exclude: user]
CPU_CYCLES : 0
REF_CPU_CYCLES : 0
[ CASE-C , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 0
REF_CPU_CYCLES : 0
** McKernel's result *************************************
[ CASE-C , Leader fd : NO , exclude: none]
CPU_CYCLES : 0
REF_CPU_CYCLES : 0
[ CASE-C , Leader fd : NO , exclude: user]
CPU_CYCLES : 0
REF_CPU_CYCLES : 0
[ CASE-C , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 0
REF_CPU_CYCLES : 0
check user val: 0 is IN 0 - 0 [OK]
check kernel val: 0 is IN 0 - 0 [OK]
** C1025T10 PASSED
*** C1025T11 ******************************************
** Linux's result *************************************
[ CASE-D , Leader fd : NO , exclude: none]
** Result of 1st read
CPU_CYCLES : 48495513
REF_CPU_CYCLES : 48494706
** Result of 2nd read
CPU_CYCLES : 96769906
REF_CPU_CYCLES : 96768906
[ CASE-D , Leader fd : NO , exclude: user]
** Result of 1st read
CPU_CYCLES : 167295
REF_CPU_CYCLES : 166634
** Result of 2nd read
CPU_CYCLES : 218489
REF_CPU_CYCLES : 217958
[ CASE-D , Leader fd : NO , exclude: kernel]
** Result of 1st read
CPU_CYCLES : 48240264
REF_CPU_CYCLES : 48240270
** Result of 2nd read
CPU_CYCLES : 96429199
REF_CPU_CYCLES : 96429060
** McKernel's result *************************************
[ CASE-D , Leader fd : NO , exclude: none]
** Result of 1st read
CPU_CYCLES : 48432773
REF_CPU_CYCLES : 48433336
** Result of 2nd read
CPU_CYCLES : 96650562
REF_CPU_CYCLES : 96651624
[ CASE-D , Leader fd : NO , exclude: user]
** Result of 1st read
CPU_CYCLES : 134833
REF_CPU_CYCLES : 133472
** Result of 2nd read
CPU_CYCLES : 139726
REF_CPU_CYCLES : 138260
[ CASE-D , Leader fd : NO , exclude: kernel]
** Result of 1st read
CPU_CYCLES : 48218540
REF_CPU_CYCLES : 48220536
** Result of 2nd read
CPU_CYCLES : 96397701
REF_CPU_CYCLES : 96400280
check user val 1st: 48220536 is IN 43416243.0 - 53064297.0 [OK]
check kernel val 1st: 133472 is IN 0 - 482205.36 [OK]
check user val 2nd: 96400280 is IN 86786154.0 - 106071966.0 [OK]
check kernel val 2nd: 138260 is IN 0 - 964002.80 [OK]
** C1025T11 PASSED
*** C1025T12 ******************************************
** Linux's result *************************************
[ CASE-E , Leader fd : NO , exclude: none]
CPU_CYCLES : 97011286
REF_CPU_CYCLES : 97009406
[ CASE-E , Leader fd : NO , exclude: user]
CPU_CYCLES : 218390
REF_CPU_CYCLES : 216502
[ CASE-E , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 96375684
REF_CPU_CYCLES : 96375526
** McKernel's result *************************************
[ CASE-E , Leader fd : NO , exclude: none]
CPU_CYCLES : 96511772
REF_CPU_CYCLES : 96512684
[ CASE-E , Leader fd : NO , exclude: user]
CPU_CYCLES : 28379
REF_CPU_CYCLES : 27540
[ CASE-E , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 96484648
REF_CPU_CYCLES : 96486504
check user val: 96486504 is IN 86737973.4 - 106013078.6 [OK]
check kernel val: 27540 is IN 0 - 964865.04 [OK]
** C1025T12 PASSED
*** C1025T13 ******************************************
** Linux's result *************************************
[ CASE-F , Leader fd : NO , exclude: none]
CPU_CYCLES : 96528511
REF_CPU_CYCLES : 96527652
[ CASE-F , Leader fd : NO , exclude: user]
CPU_CYCLES : 209363
REF_CPU_CYCLES : 208832
[ CASE-F , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 96227150
REF_CPU_CYCLES : 96226858
** McKernel's result *************************************
[ CASE-F , Leader fd : NO , exclude: none]
CPU_CYCLES : 96505364
REF_CPU_CYCLES : 96505988
[ CASE-F , Leader fd : NO , exclude: user]
CPU_CYCLES : 80671
REF_CPU_CYCLES : 75140
[ CASE-F , Leader fd : NO , exclude: kernel]
CPU_CYCLES : 96369863
REF_CPU_CYCLES : 96369692
check user val: 96369692 is IN 86604172.2 - 105849543.8 [OK]
check kernel val: 75140 is IN 0 - 963696.92 [OK]
** C1025T13 PASSED