Cleanup: use LTTNG_HIDDEN in lttng-ctl filter lib

[lttng-tools.git] / tests / run-report.py

#!/usr/bin/env python

import os, sys
import subprocess
import threading
import Queue
import time
import shlex

from signal import signal, SIGTERM, SIGINT, SIGPIPE, SIG_DFL

SESSIOND_BIN_NAME = "lttng-sessiond"
SESSIOND_BIN_PATH = "src/bin/lttng-sessiond/"
CONSUMERD_BIN_NAME = "lttng-consumerd"
CONSUMERD_BIN_PATH = "src/bin/lttng-consumerd/"
TESTDIR_PATH = ""

PRINT_BRACKET = "\033[1;34m[\033[1;33m+\033[1;34m]\033[00m"
PRINT_RED_BRACKET = "\033[1;31m[+]\033[00m"
PRINT_GREEN_BRACKET = "\033[1;32m[+]\033[00m"
PRINT_ARROW = "\033[1;32m-->\033[00m"

is_root = 1
no_stats = 0
stop_sampling = 1

top_cpu_legend = { 'us': "User CPU time", 'sy': "System CPU time",
        'id': "Idle CPU time", 'ni': "Nice CPU time", 'wa': "iowait",
        'hi': "Hardware IRQ", 'si': "Software Interrupts", 'st': "Steal Time", }

cpu_ret_q = Queue.Queue()
mem_ret_q = Queue.Queue()
test_ret_q = Queue.Queue()

global sdaemon_proc
global worker_proc

def cpu_create_usage_dict(top_line):
    """
    Return a dictionnary from a 'top' cpu line.
    Ex: Cpu(s):  2.1%us,  1.2%sy,  0.0%ni, 96.2%id,  0.4%wa,  0.0%hi,  0.0%si,  0.0%st
    """
    top_dict = {'us': 0, 'sy': 0, 'ni': 0, 'id': 0, 'wa': 0, 'hi': 0, 'si': 0, 'st': 0}

    # Split expression and remove first value which is "Cpu(s)"
    top_line = top_line.replace(",","")
    words = top_line.split()[1:]


    for key in top_dict:
        index = words.index(key)
        # Add the value to the dictionnary
        val = words[index-1]
        top_dict[key] = float(val)

    return top_dict

def cpu_average_usage(top_lines):
    """
    Return a dictionnary of 'top' CPU stats but averaging all values.
    """
    avg_dict = {'us': 0, 'sy': 0, 'ni': 0, 'id': 0, 'wa': 0, 'hi': 0, 'si': 0, 'st': 0}
    # Average count
    count = 0.0

    for line in top_lines:
        tmp_dict = cpu_create_usage_dict(line)
        # Add value to avg dictionnary
        for key in tmp_dict:
            avg_dict[key] += tmp_dict[key]

        count += 1.0

    for key in avg_dict:
        avg_dict[key] = avg_dict[key] / count

    return (count, avg_dict)

def cpu_sample_usage(pid=None):
    """
    Sample CPU usage for num iterations.
    If num is greater than 1, the average will be computed.
    """
    args = ["top", "-b", "-n", "1"]
    if pid:
        args.append("-p")
        args.append(str(pid))

    # Spawn top process
    top = subprocess.Popen(args, stdout = subprocess.PIPE)

    grep = subprocess.Popen(["grep", "Cpu"], stdin = top.stdout,
            stdout = subprocess.PIPE)
    top.stdout.close()

    return grep.communicate()[0].strip("\n")

def mem_sample_usage(pid):
    """
    Sample memory usage using /proc and a pid
    """
    args = ["cat", "/proc/" + str(pid) + "/status"]

    if not os.path.isfile(args[1]):
        return -1

    mem_proc = subprocess.Popen(args, stdout = subprocess.PIPE)

    grep = subprocess.Popen(["grep", "^VmRSS"], stdin = mem_proc.stdout,
            stdout = subprocess.PIPE)
    mem_proc.stdout.close()

    # Return virtual memory size in kilobytes (kB)
    #ret = grep.communicate()[0].split()
    ret = grep.communicate()[0].split()

    if len(ret) > 1:
        ret = ret[1]
    else:
        ret = 0

    return int(ret)

class SamplingWorker(threading.Thread):
    def __init__(self, s_type, worker = None, delay = 0.2, pid = 0):
        threading.Thread.__init__ (self)
        self.s_type = s_type
        self.delay = delay
        self.pid = pid
        self.worker = worker

    def run(self):
        count = 1
        lines = []

        if self.s_type == "cpu":
            while 1:
                if self.worker == None:
                    cpu_line = cpu_sample_usage(self.pid)
                    lines.append(cpu_line)
                    break
                elif self.worker.is_alive():
                    cpu_line = cpu_sample_usage(self.pid)
                    lines.append(cpu_line)
                else:
                    break

                # Delay sec per memory sampling
                time.sleep(self.delay)

            count, stats = cpu_average_usage(lines)
            cpu_ret_q.put((count, stats))
            # grep process has ended here

        elif self.s_type == "mem":
            count = 0
            mem_stat = 0

            while 1:
                if self.worker == None:
                    cpu_line = cpu_sample_usage(self.pid)
                    lines.append(cpu_line)
                    break
                elif self.worker.is_alive():
                    mem_stat += get_mem_usage(self.pid)
                    count += 1
                else:
                    break

                # Delay sec per memory sampling
                time.sleep(self.delay)

            mem_ret_q.put((count, mem_stat))

class TestWorker(threading.Thread):
    def __init__(self, path, name, env):
        threading.Thread.__init__(self)
        self.path = path
        self.name = name
        self.env  = env

    def run(self):
        bin_path_name = os.path.join(self.path, self.name)

        test = subprocess.Popen([bin_path_name], env=self.env, preexec_fn = lambda: signal(SIGPIPE, SIG_DFL))
        test.wait()

        # Send ret value to main thread
        test_ret_q.put(test.returncode)

def get_pid(procname):
    """
    Return pid of process name using 'pidof' command
    """
    pidof = subprocess.Popen(["pidof", procname], stdout = subprocess.PIPE)
    pid = pidof.communicate()[0].split()

    if pid == []:
        return 0

    return int(pid[0])

def spawn_session_daemon():
    """
    Exec the session daemon and return PID
    """
    global sdaemon_proc

    pid = get_pid(SESSIOND_BIN_NAME)
    if pid != 0:
        os.kill(pid, SIGTERM)

    bin_path = os.path.join(TESTDIR_PATH, "..", SESSIOND_BIN_PATH, SESSIOND_BIN_NAME)
    consumer_path = os.path.join(TESTDIR_PATH, "..", CONSUMERD_BIN_PATH, CONSUMERD_BIN_NAME)

    if not os.path.isfile(bin_path):
        print "Error: No session daemon binary found. Compiled?"
        return 0

    try:
        args = shlex.split("libtool execute " + bin_path
                           + " --consumerd32-path=" + consumer_path
                           + " --consumerd64-path=" + consumer_path)

        sdaemon_proc = subprocess.Popen(args, shell = False, stderr = subprocess.PIPE)

    except OSError, e:
        print e
        return 0

    time.sleep(1)

    return get_pid("lt-" + SESSIOND_BIN_NAME)

def start_test(name):
    """
    Spawn test and return exit code
    """
    tw = TestWorker(".", name)
    tw.start()

    return test_ret_q.get(True)

def print_cpu_stats(stats, count):
    """
    Pretty print on one line the CPU stats
    """
    sys.stdout.write(PRINT_ARROW + " Cpu [sampled %d time(s)]:\n   " % (count))
    for stat in stats:
        sys.stdout.write(" %s: %.2f, " % (stat, stats[stat]))
    print ""

def get_cpu_usage(delay=1, pid=0):
    """
    Spawn a worker thread to sample cpu usage.
    """
    sw = SamplingWorker("cpu", delay = delay, pid = pid)
    sw.start()

    return cpu_ret_q.get(True)

def get_mem_usage(pid):
    """
    Get memory usage for PID
    """
    return mem_sample_usage(pid)

def print_test_success(ret, expect):
    """
    Print if test has failed or pass according to the expected value.
    """
    if ret != expect:
        print "\n" + PRINT_RED_BRACKET + \
                " Failed: ret = %d (expected %d)" % (ret, expect)
        return 1
    else:
        print "\n" + PRINT_BRACKET + \
                " Passed: ret = %d (expected %d)" % (ret, expect)
        return 0

def run_test(test):
    """
    Run test 'name' and output report of the test with stats.
    """
    global worker_proc
    global sdaemon_proc
    dem_pid = 0     # Session daemon pid

    print PRINT_BRACKET + " %s" % (test['name'])
    print PRINT_ARROW + " %s" % (test['desc'])
    if no_stats:
        print PRINT_ARROW + " Statistics will NOT be collected"
    else:
        print PRINT_ARROW + " Statistics of the session daemon will be collected"

    if test['kern'] and not is_root:
        print "Needs root for kernel tracing. Skipping"
        return 0

    if not os.path.isfile(test['bin']):
        print "Unable to find test file '%s'. Skipping" % (test['bin'])
        return 0

    # Session daemon is controlled by the test
    if test['daemon'] == "test":
        print PRINT_ARROW + " Session daemon is controlled by the test"
        env = os.environ
        env['TEST_NO_SESSIOND'] = '0'
        tw = TestWorker(".", test['bin'], env)
        tw.start()
        ret = test_ret_q.get(True)
        print_test_success(ret, test['success'])
        return 0
    elif test['daemon'] == False:
        print PRINT_ARROW + " No session daemon needed"
        env = os.environ
        env['TEST_NO_SESSIOND'] = '1'
        tw = TestWorker(".", test['bin'], env)
        tw.start()
        ret = test_ret_q.get(True)
        print_test_success(ret, test['success'])
        return 0
    else:
        print PRINT_ARROW + " Session daemon needed"

    dem_pid = spawn_session_daemon()
    if dem_pid <= 0:
        print "Unable to start %s. Stopping" % (SESSIOND_BIN_NAME)
        print sdaemon_proc.communicate()[1]
        return 0

    print PRINT_BRACKET + " Session daemon spawned (pid: %d)\n" % (dem_pid)

    if not no_stats:
        mem_before = get_mem_usage(dem_pid)
        print PRINT_BRACKET + " Stats *before* test:"
        print PRINT_ARROW + " Mem (kB): %d" % (mem_before)
        cpu_count, cpu_stats = get_cpu_usage(pid = dem_pid)
        print_cpu_stats(cpu_stats, cpu_count)

    # Sessiond was already spawned, do not let the test spawn
    # an additional sessiond
    env = os.environ
    env['TEST_NO_SESSIOND'] = '1'

    tw = TestWorker(".", test['bin'], env)
    tw.start()

    if not no_stats:
        # Start CPU sampling for test
        sw_cpu = SamplingWorker("cpu", worker = tw, pid = dem_pid)
        sw_cpu.start()
        sw_mem = SamplingWorker("mem", worker = tw, pid = dem_pid)
        sw_mem.start()

    ret = test_ret_q.get(True)

    if not no_stats:
        time.sleep(2)
        # Compute memory average
        mem_count, mem_during = mem_ret_q.get(True)
        mem_during = float(mem_during) / float(mem_count)
        cpu_count, cpu_stats = cpu_ret_q.get(True)

        print "\n" + PRINT_BRACKET + " Stats *during* test:"
        print PRINT_ARROW + " Mem (kB): %.0f [sampled %d time(s)]" % (mem_during, mem_count)
        print_cpu_stats(cpu_stats, cpu_count)

        mem_after = get_mem_usage(dem_pid)
        print "\n" + PRINT_BRACKET + " Stats *after* test:"
        print PRINT_ARROW + " Mem (kB): %d" % (mem_after)
        cpu_count, cpu_stats = get_cpu_usage(pid = dem_pid)
        print_cpu_stats(cpu_stats, cpu_count)

        print "\n" + PRINT_BRACKET + " Memory usage differences:"
        print PRINT_ARROW + " Diff during and before (kB): %d" % (mem_during - mem_before)
        print PRINT_ARROW + " Diff during and after (kB): %d" % (mem_during - mem_after)
        print PRINT_ARROW + " Diff before and after (kB): %d" % (mem_after - mem_before)

    # Return value of 0 means that is passed else it failed
    ret = print_test_success(ret, test['success'])

    # Stop session daemon
    if dem_pid > 0:
        print PRINT_BRACKET + " Stopping session daemon (pid: %d)..." % (dem_pid)
        try:
            os.kill(dem_pid, SIGTERM)
            # This call simply does not work... It seems python does not relay the signal
            # to the child processes of sdaemon_proc.
            # sdaemon_proc.terminate()
            if ret != 0:
                print sdaemon_proc.communicate()[1]
            elif sdaemon_proc.returncode == None:
                sdaemon_proc.communicate()
        except OSError, e:
            print e

    # Make sure all thread are released
    if not no_stats:
        tw.join()
        sw_cpu.join()
        sw_mem.join()

    return ret

def main():
    for test in Tests:
        if not test['enabled']:
            continue

        ret = run_test(test)
        if ret != 0:
            # Stop all tests, the last one failed
            return
        print ""

def cleanup(signo, stack):
    """ Cleanup function """
    sys.exit(0)

if __name__ == "__main__":
    if not os.getuid() == 0:
        is_root = 0
        print "NOTICE: Not root. No kernel tracing will be tested\n"

    if os.path.isfile("test_list.py"):
        from test_list import Tests
    else:
        print "No test_list.py found. Stopping"
        cleanup(0, 0)

    TESTDIR_PATH = os.getcwd()

    if len(sys.argv) > 1:
        if sys.argv[1] == "--no-stats":
            no_stats = 1

    try:
        signal(SIGTERM, cleanup)
        signal(SIGINT, cleanup)
        main()
        cleanup(0, 0)
    except KeyboardInterrupt:
        cleanup(0, 0)