Skip to content
Snippets Groups Projects
Select Git revision
  • main default protected
1 result
Blame Permalink
microbenchmark_runner.py 3.90 KiB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114 






import subprocess,sys,os,time
from auditlib import auditctl
from statistics import mean, stdev

NUM_CPUS = 4

""" SYSCALL_MAP = {
    'getpid': '0',
    'mmap2' : '1',
    'write' : '2',
    'read' : '3',
    'close' : '4',
    'openat' : '5',
    'connect' : '6',
    'mprotect' : '7',
    'fstat64' : '8',
    'llseek' : '9',
    'pread64' : '10'
} """

SYSCALL_MAP = {
    'getpid': '0',
    'getppid' : '1',
    'getgid32' : '2',
    'getuid32' : '3',
    'getpgrp' : '4'
}

#Setup performance mode
def setup_perf_mode():
    for i in range(NUM_CPUS):
        with(open('/sys/devices/system/cpu/cpu{}/cpufreq/scaling_governor'.format(str(i)),'w')) as f:
            f.write("performance")
    time.sleep(1)
    for i in range(NUM_CPUS):
        with(open('/sys/devices/system/cpu/cpu{}/cpufreq/scaling_governor'.format(str(i)),'r')) as f:
            print("Current cpu frequency ",f.read())

def read_audit_times_from_file(filename):
    timestamps = []
    with open(filename,'r') as audited_file:
        lines = audited_file.readlines()
        for line in lines:
            if len(line.split()) >= 8:
                timing = int(line.split()[8])/1000.0
                timestamps.append(timing)
    return timestamps[10:] #Discard the first 10 measurements, as they seem to be outliers due to cache effects or other issues starting up

def run_microbenchmark(syscall,iterations,num_threads,output_file_prefix,rt_priority=True):

    print("Test parameters :\n syscall : {} \n iterations : {} \n num_threads : {} \n output_file_prefix : {} \n rt_priority : {}".format(
        syscall, iterations, num_threads, output_file_prefix, rt_priority))


    executable = os.path.join(os.getcwd(),"bin/microbench")
    #setup_perf_mode()

    #setup audit to begin with

    auditctl.clear_syscall_rules()
    auditctl.add_syscall_rule(syscall,executable)
    auditctl.set_buffer_size(10000)
    auditctl.enable_audit()
    auditctl.clear_audit_logs()

    with open(output_file_prefix + '-audited.log','w') as outfile:
        if rt_priority:
            subprocess.run(['chrt','--fifo',"99",executable,iterations,num_threads,SYSCALL_MAP[syscall]],stdout=outfile)
        else:
            subprocess.run([executable,iterations,num_threads,SYSCALL_MAP[syscall]],stdout=outfile)

    print("Sleeping to let the audit records be committed to log")
    time.sleep(5)
    auditctl.save_audit_logs(output_file_prefix + ".audit")
    auditctl.disable_audit()

    with open(output_file_prefix + '-unaudited.log','w') as outfile:
        if rt_priority:
            subprocess.run(['chrt','--fifo',"99",executable,iterations,num_threads,SYSCALL_MAP[syscall]],stdout=outfile)
        else:
            subprocess.run([executable,iterations,num_threads,SYSCALL_MAP[syscall]],stdout=outfile)

    #Here we can run the analysis of the timing data
    audited = read_audit_times_from_file(output_file_prefix + '-audited.log')
    unaudited = read_audit_times_from_file(output_file_prefix + '-unaudited.log')

    audited_mean,audited_stdev = mean(audited),stdev(audited)
    auditless_mean,auditless_stdev = mean(unaudited), stdev(unaudited)

    print("Statistics for run (microseconds) : min , max , mean , stdev")
    print("With audit ",len(audited),min(audited),max(audited),audited_mean,audited_stdev)
    print("Without audit ",len(unaudited),min(unaudited),max(unaudited),auditless_mean,auditless_stdev)
    print("Audit latency ",(audited_mean - auditless_mean))

    return

def main():
    rt_priority = True  #rt_priority is set by default
    syscall = sys.argv[1]
    iterations = sys.argv[2]
    num_threads = sys.argv[3]
    rt_priority = (sys.argv[4] == 'True')
    output_file_prefix = sys.argv[5]

    if syscall == 'all':
        for scall in SYSCALL_MAP.keys():
            run_microbenchmark(scall,iterations,num_threads,scall,rt_priority)

    else:
        run_microbenchmark(syscall,iterations,num_threads,output_file_prefix,rt_priority)

if __name__ == "__main__":
    main()