google performace 测试用python实现

便于在windows上进行google performance测试，提前发现问题。

# coding=utf-8
# author = ao.deng

import subprocess
import time
import re

import sys

ONE_KB = 1024
ONE_GB = 1048576
FIVE_TWELVE_MB = 524288
PASS = "PASS"
FAIL = "FAIL"
REDUCE = "REDUCE"
OPTIMAL = "OPTIMAL"
SCREEN_TYPE_VGA = "VGA"
SCREEN_TYPE_WVGA = "WVGA"
SCREEN_TYPE_QHD = "QHD"
SCREEN_TYPE_HD = "HD"

MAX_PERSISTENT_MEMORY = 90 * ONE_KB

MIN_FREE_MEMORY_FOR_ONE_GB_VGA = 600 * ONE_KB
MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_VGA = 135 * ONE_KB
MAX_LAUNCHER_MEMORY_VGA = 40 * ONE_KB
MAX_SYSTEM_UI_MEMORY_VGA = 50 * ONE_KB
MAX_SYSTEM_SERVER_MEMORY_VGA = 65 * ONE_KB
MAX_USED_KERNEL_MEMORY_VGA = 70 * ONE_KB

MIN_FREE_MEMORY_FOR_ONE_GB_WVGA = 530 * ONE_KB
MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_WVGA = 125 * ONE_KB
MAX_LAUNCHER_MEMORY_WVGA = 45 * ONE_KB
MAX_SYSTEM_UI_MEMORY_WVGA = 60 * ONE_KB
MAX_SYSTEM_SERVER_MEMORY_WVGA = 75 * ONE_KB
MAX_USED_KERNEL_MEMORY_WVGA = 80 * ONE_KB

MIN_FREE_MEMORY_FOR_ONE_GB_QHD = 510 * ONE_KB
MAX_LAUNCHER_MEMORY_QHD = 50 * ONE_KB
MAX_SYSTEM_UI_MEMORY_QHD = 65 * ONE_KB
MAX_SYSTEM_SERVER_MEMORY_QHD = 80 * ONE_KB
MAX_USED_KERNEL_MEMORY_QHD = 85 * ONE_KB

MIN_FREE_MEMORY_FOR_ONE_GB_HD = 430 * ONE_KB
MAX_LAUNCHER_MEMORY_HD = 55 * ONE_KB
MAX_SYSTEM_UI_MEMORY_HD = 75 * ONE_KB
MAX_SYSTEM_SERVER_MEMORY_HD = 90 * ONE_KB
MAX_USED_KERNEL_MEMORY_HD = 95 * ONE_KB

MAX_MEMORY_CARVEOUT_MT6580M_ONE_GB = 61 * ONE_KB
MAX_MEMORY_CARVEOUT_MT6580M_FIVE_TWELVE_MB = 45 * ONE_KB

MAX_MEMORY_CARVEOUT_MT6737M_ONE_GB = 107 * ONE_KB
MAX_MEMORY_CARVEOUT_MT6737M_FIVE_TWELVE_MB = 89 * ONE_KB

MAX_MEMORY_CARVEOUT_MT6739_ENG_ONE_GB = 129 * ONE_KB
MAX_MEMORY_CARVEOUT_MT6739_ENG_FIVE_TWELVE_MB = 95 * ONE_KB

MAX_MEMORY_CARVEOUT_MSM8909_ONE_GB = 120 * ONE_KB
MAX_MEMORY_CARVEOUT_MSM8909_FIVE_TWELVE_MB = 120 * ONE_KB

MAX_MEMORY_CARVEOUT_MSM8917_ONE_GB = 135 * ONE_KB
MAX_MEMORY_CARVEOUT_MSM8917_FIVE_TWELVE_MB = 120 * ONE_KB

SECTION_SEPARATOR = "----------------------------------------------------------------------"
WAIT_FOR_DEVICE_TIME = 2
wait_time = 300

outputFileName = ''


# 执行命令
def getCmdEexcuteResult(cmd):
    ps = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True)
    data = ps.stdout.readlines()
    return data


def writeFile(filename, data):
    with open(filename, "a+", encoding="utf-8") as f:
        f.write(data + "\n")
        f.close()


def printString(str):
    print(str)
    writeFile(outputFileName, str)


def get_device_serial():
    device_serial_array = getCmdEexcuteResult("adb devices")[1:-1]
    #print(device_serial_array)

    device_count = len(device_serial_array)

    if device_count < 1:
        print("No device found")
        sys.exit(1)
    elif device_count == 1:
        device_serial = bytes.decode(device_serial_array[0]).split("\t")[0]
        return device_serial
    elif device_count > 1:
        print("Too much device")
        sys.exit(1)


def wait_for_device():
    print("Waiting for device to come online ...",end="")
    time.sleep(WAIT_FOR_DEVICE_TIME)
    cmd = "adb wait-for-device"
    getCmdEexcuteResult(cmd)
    boot_completed = getCmdEexcuteResult("adb shell getprop sys.boot_completed")
    # print(boot_completed)
    if boot_completed != [] and boot_completed != [b'\r\n']:
        boot_completed_flag = int((bytes.decode(boot_completed[0])).strip('\r\n'))
    else:
        boot_completed_flag = 0

    while boot_completed_flag != 1:
        print(".", end="", flush=True)
        time.sleep(WAIT_FOR_DEVICE_TIME)
        boot_completed = getCmdEexcuteResult("adb shell getprop sys.boot_completed")
        if boot_completed != [] and boot_completed != [b'\r\n']:
            boot_completed_flag = int((bytes.decode(boot_completed[0])).strip('\r\n'))
        else:
            boot_completed_flag = 0

    time.sleep(WAIT_FOR_DEVICE_TIME)
    print("")


def formatData(dataKB):
    intDataKB = 0
    if dataKB.find(",") > -1:
        dataKB_array = dataKB.split(",")
        dataKB_len = len(dataKB_array)
        for i in range(dataKB_len):
            intDataKB += int(dataKB_array[i]) * (1000 ** (dataKB_len - i - 1))
    else:
        intDataKB = int(dataKB)
    return intDataKB


def formatCompareData(currentData, standardData):
    deviationData = currentData - standardData
    return "    {} - {}(Standard)={}".format(currentData, standardData, deviationData)


# Tests if the device has required memory metrics.
#
# Arguments:
#    Device RAM size
#    Free memory on device
#    Used kernel memory
#    System server Pss
#    System UI Pss
#    Launcher Pss
def test_pss_metrics(total_ram_size, free_memory, kernel_memory, system_server_memory, system_ui_memory,
                     launcher_memory, memory_carveout):
    screen_size = bytes.decode(getCmdEexcuteResult('''adb shell "wm size|cut -d ':' -f 2"''')[0]).strip("\r\n").split(
        "x")
    width = int(screen_size[0])
    height = int(screen_size[1])

    if height <= width:
        short_side = height
        long_side = width
    else:
        short_side = width
        long_side = height

    free_memory_test_result = "N/A"
    launcher_memory_test_result = "N/A"
    kernel_memory_test_result = "N/A"
    system_server_memory_test_result = "N/A"
    system_ui_memory_test_result = "N/A"
    device_screen_type = "N/A"
    if short_side <= 480 and long_side <= 640:  # vga
        device_screen_type = SCREEN_TYPE_VGA
        if total_ram_size == ONE_GB:
            if free_memory >= MIN_FREE_MEMORY_FOR_ONE_GB_VGA:
                free_memory_test_result = PASS + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_VGA)
            else:
                free_memory_test_result = FAIL + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_VGA)
        elif total_ram_size == FIVE_TWELVE_MB:
            if free_memory >= MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_VGA:
                free_memory_test_result = PASS + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_VGA)
            else:
                free_memory_test_result = FAIL + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_VGA)

        if launcher_memory <= MAX_LAUNCHER_MEMORY_VGA:
            launcher_memory_test_result = PASS + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_VGA)
        else:
            launcher_memory_test_result = FAIL + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_VGA)

        if kernel_memory <= MAX_USED_KERNEL_MEMORY_VGA:
            kernel_memory_test_result = OPTIMAL + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_VGA)
        else:
            kernel_memory_test_result = REDUCE + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_VGA)

        if system_server_memory <= MAX_SYSTEM_SERVER_MEMORY_VGA:
            system_server_memory_test_result = OPTIMAL + formatCompareData(system_server_memory,
                                                                           MAX_SYSTEM_SERVER_MEMORY_VGA)
        else:
            system_server_memory_test_result = REDUCE + formatCompareData(system_server_memory,
                                                                          MAX_SYSTEM_SERVER_MEMORY_VGA)

        if system_ui_memory <= MAX_SYSTEM_UI_MEMORY_VGA:
            system_ui_memory_test_result = OPTIMAL + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_VGA)
        else:
            system_ui_memory_test_result = REDUCE + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_VGA)
    elif short_side <= 480 and long_side <= 854:  # wvga
        device_screen_type = SCREEN_TYPE_WVGA
        if total_ram_size == ONE_GB:
            if free_memory >= MIN_FREE_MEMORY_FOR_ONE_GB_WVGA:
                free_memory_test_result = PASS + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_WVGA)
            else:
                free_memory_test_result = FAIL + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_WVGA)
        elif total_ram_size == FIVE_TWELVE_MB:
            if free_memory >= MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_WVGA:
                free_memory_test_result = PASS + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_WVGA)
            else:
                free_memory_test_result = FAIL + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_FIVE_TWELVE_MB_WVGA)

        if launcher_memory <= MAX_LAUNCHER_MEMORY_WVGA:
            launcher_memory_test_result = OPTIMAL + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_WVGA)
        else:
            launcher_memory_test_result = REDUCE + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_WVGA)

        if kernel_memory <= MAX_USED_KERNEL_MEMORY_WVGA:
            kernel_memory_test_result = OPTIMAL + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_WVGA)
        else:
            kernel_memory_test_result = REDUCE + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_WVGA)

        if system_server_memory <= MAX_SYSTEM_SERVER_MEMORY_WVGA:
            system_server_memory_test_result = OPTIMAL + formatCompareData(system_server_memory,
                                                                           MAX_SYSTEM_SERVER_MEMORY_WVGA)
        else:
            system_server_memory_test_result = REDUCE + formatCompareData(system_server_memory,
                                                                          MAX_SYSTEM_SERVER_MEMORY_WVGA)

        if system_ui_memory <= MAX_SYSTEM_UI_MEMORY_WVGA:
            system_ui_memory_test_result = OPTIMAL + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_WVGA)
        else:
            system_ui_memory_test_result = REDUCE + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_WVGA)
    elif short_side <= 540 and long_side <= 960:  # qhd
        device_screen_type = SCREEN_TYPE_QHD
        if total_ram_size == ONE_GB:
            if free_memory >= MIN_FREE_MEMORY_FOR_ONE_GB_QHD:
                free_memory_test_result = PASS + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_QHD)
            else:
                free_memory_test_result = FAIL + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_QHD)

        if launcher_memory <= MAX_LAUNCHER_MEMORY_QHD:
            launcher_memory_test_result = PASS + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_QHD)
        else:
            launcher_memory_test_result = FAIL + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_QHD)

        if kernel_memory <= MAX_USED_KERNEL_MEMORY_QHD:
            kernel_memory_test_result = OPTIMAL + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_QHD)
        else:
            kernel_memory_test_result = REDUCE + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_QHD)

        if system_server_memory <= MAX_SYSTEM_SERVER_MEMORY_QHD:
            system_server_memory_test_result = OPTIMAL + formatCompareData(system_server_memory,
                                                                           MAX_SYSTEM_SERVER_MEMORY_QHD)
        else:
            system_server_memory_test_result = REDUCE + formatCompareData(system_server_memory,
                                                                          MAX_SYSTEM_SERVER_MEMORY_QHD)

        if system_ui_memory <= MAX_SYSTEM_UI_MEMORY_QHD:
            system_ui_memory_test_result = OPTIMAL + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_QHD)
        else:
            system_ui_memory_test_result = REDUCE + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_QHD)
    else:  # "hd"
        device_screen_type = SCREEN_TYPE_HD
        if total_ram_size == ONE_GB:
            if free_memory >= MIN_FREE_MEMORY_FOR_ONE_GB_HD:
                free_memory_test_result = PASS + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_HD)
            else:
                free_memory_test_result = FAIL + formatCompareData(free_memory, MIN_FREE_MEMORY_FOR_ONE_GB_HD)

        if launcher_memory <= MAX_LAUNCHER_MEMORY_HD:
            launcher_memory_test_result = PASS + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_HD)
        else:
            launcher_memory_test_result = FAIL + formatCompareData(launcher_memory, MAX_LAUNCHER_MEMORY_HD)

        if kernel_memory <= MAX_USED_KERNEL_MEMORY_HD:
            kernel_memory_test_result = OPTIMAL + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_HD)
        else:
            kernel_memory_test_result = REDUCE + formatCompareData(kernel_memory, MAX_USED_KERNEL_MEMORY_HD)

        if system_server_memory <= MAX_SYSTEM_SERVER_MEMORY_HD:
            system_server_memory_test_result = OPTIMAL + formatCompareData(system_server_memory,
                                                                           MAX_SYSTEM_SERVER_MEMORY_HD)
        else:
            system_server_memory_test_result = REDUCE + formatCompareData(system_server_memory,
                                                                          MAX_SYSTEM_SERVER_MEMORY_HD)

        if system_ui_memory <= MAX_SYSTEM_UI_MEMORY_HD:
            system_ui_memory_test_result = OPTIMAL + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_HD)
        else:
            system_ui_memory_test_result = REDUCE + formatCompareData(system_ui_memory, MAX_SYSTEM_UI_MEMORY_HD)
    chipset_info = bytes.decode(getCmdEexcuteResult('adb shell "cat /proc/cpuinfo |grep -m 1 -i hardware"')[0]).strip(
        "\r\n")
    # print(chipset_info)
    memory_carveout_test_result = "N/A"

    if "MT6580M" in chipset_info:
        if total_ram_size == ONE_GB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MT6580M_ONE_GB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MT6580M_ONE_GB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MT6580M_ONE_GB)
        elif total_ram_size == FIVE_TWELVE_MB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MT6580M_FIVE_TWELVE_MB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MT6580M_FIVE_TWELVE_MB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MT6580M_FIVE_TWELVE_MB)
    elif "MT6737M" in chipset_info:
        if total_ram_size == ONE_GB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MT6737M_ONE_GB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MT6737M_ONE_GB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MT6737M_ONE_GB)
        elif total_ram_size == FIVE_TWELVE_MB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MT6737M_FIVE_TWELVE_MB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MT6737M_FIVE_TWELVE_MB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MT6737M_FIVE_TWELVE_MB)
    elif "MT6739-ENG" in chipset_info:
        if total_ram_size == ONE_GB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MT6739_ENG_ONE_GB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MT6739_ENG_ONE_GB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MT6739_ENG_ONE_GB)
        elif total_ram_size == FIVE_TWELVE_MB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MT6739_ENG_FIVE_TWELVE_MB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MT6739_ENG_FIVE_TWELVE_MB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MT6739_ENG_FIVE_TWELVE_MB)
    elif "MSM8909" in chipset_info:
        if total_ram_size == ONE_GB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MSM8909_ONE_GB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MSM8909_ONE_GB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MSM8909_ONE_GB)
        elif total_ram_size == FIVE_TWELVE_MB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MSM8909_FIVE_TWELVE_MB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MSM8909_FIVE_TWELVE_MB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MSM8909_FIVE_TWELVE_MB)
    elif "MSM8917" in chipset_info:
        if total_ram_size == ONE_GB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MSM8917_ONE_GB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MSM8917_ONE_GB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MSM8917_ONE_GB)
        elif total_ram_size == FIVE_TWELVE_MB:
            if memory_carveout <= MAX_MEMORY_CARVEOUT_MSM8917_FIVE_TWELVE_MB:
                memory_carveout_test_result = OPTIMAL + formatCompareData(memory_carveout,
                                                                          MAX_MEMORY_CARVEOUT_MSM8917_FIVE_TWELVE_MB)
            else:
                memory_carveout_test_result = REDUCE + formatCompareData(memory_carveout,
                                                                         MAX_MEMORY_CARVEOUT_MSM8917_FIVE_TWELVE_MB)

    max_cpu_freq = bytes.decode(
        getCmdEexcuteResult("adb shell cat sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq")[0]).strip("\r\n")
    return '''Chipset Info: %s
Max CPU frequency: %s\n
Build approval metrics (Tested in GTS)
Device screen type: %s
Free memory test: %s
Launcher memory test: %s\n
Metrics impacting free memory and persistent memory
Kernel memory test: %s
System server memory test: %s
System UI memory test: %s
Memory carveout test: %s ''' % (chipset_info, max_cpu_freq, device_screen_type, free_memory_test_result,
                                launcher_memory_test_result, kernel_memory_test_result,
                                system_server_memory_test_result,
                                system_ui_memory_test_result, memory_carveout_test_result)


def get_post_boot_metrics(meminfo_text_strip, device_serial):
    cached_process_array = re.findall("Cached(.*?)Total PSS by category", meminfo_text_strip)
    # print(cached_process_array)
    cached_process_pid_array = re.findall("\(pid (.*?)\)", cached_process_array[0])
    # print(cached_process_pid_array)

    mem_available_kB = getCmdEexcuteResult('''adb shell "cat /proc/meminfo| grep 'MemAvailable:'"''')
    # print(mem_available_kB)
    mem_available = re.findall(".*?(\d+).*?", bytes.decode(mem_available_kB[0]))[0]
    # print(mem_available)
    cache_proc_dirty = int(mem_available)
    for pid in cached_process_pid_array:
        process_cache_info = bytes.decode(
            getCmdEexcuteResult('''adb shell "dumpsys meminfo %s |grep 'TOTAL'||echo ''"''' % pid)[0])

        # print(process_cache_info)
        process_cache_info_array = re.findall(".*?(\d+).*?", process_cache_info)
        # print(process_cache_info_array)
        if len(process_cache_info_array) < 3:
            printString("Error parsing dumpsys meminfo %s. Exiting ..." % pid)
            sys.exit(1)
        cache_proc_dirty += int(process_cache_info_array[1]) + int(process_cache_info_array[2])

    android_build_fingerprint = getCmdEexcuteResult('adb shell getprop "ro.build.fingerprint"')

    printString("Device serial: %s" % device_serial)
    printString("Build fingerprint: %s" % bytes.decode(android_build_fingerprint[0]).strip("\r\n"))
    printString("MemAvailable: %s KB" % mem_available)
    printString("MemAvailable + Dirty Cache: %s KB" % cache_proc_dirty)

    launcher_memory = \
        re.findall(".*?((\d,?){1,}).*?", re.findall("Total PSS by process:(.*?)launcher", meminfo_text_strip)[0])[-1][0]
    launcher_memory = formatData(launcher_memory)
    printString("Launcher Memory: %s KB" % launcher_memory)

    ion_cma = getCmdEexcuteResult('''adb shell "cat /proc/vmallocinfo | grep 'ion_cma'|| echo 0"''')
    print("ion_cma_memory %s" % ion_cma)
    ion_cma_memory = 0
    kernel_memory_base = \
        re.findall(".*?((\d,?){1,}).*?", re.findall("Total PSS by process:(.*?)Used RAM:", meminfo_text_strip)[0])[-1][
            0]
    kernel_memory = formatData(kernel_memory_base) - int(ion_cma_memory)
    printString("Kernel Memory: %s KB" % kernel_memory)

    system_server_memory = \
        re.findall(".*?((\d,?){1,}).*?", re.findall("Total PSS by process:(.*?)system \(", meminfo_text_strip)[0])[-1][
            0]
    system_server_memory = formatData(system_server_memory)
    printString("System server memory: %s KB" % system_server_memory)

    system_ui_memory = re.findall(".*?((\d,?){1,}).*?",
                                  re.findall("Total PSS by process:(.*?)com.android.systemui", meminfo_text_strip)[0])[
        -1][0]
    system_ui_memory = formatData(system_ui_memory)
    printString("System UI Memory: %s KB" % system_ui_memory)

    total_ram = re.findall("Total RAM:.*?(\d.*?)K", meminfo_text_strip)[0]
    total_ram = formatData(total_ram)
    printString("Total RAM: %s" % total_ram)

    if total_ram >= FIVE_TWELVE_MB and total_ram <= ONE_GB:
        memory_carveout = ONE_GB - total_ram
        pss_metrics_test_results = test_pss_metrics(ONE_GB, cache_proc_dirty, kernel_memory, system_server_memory,
                                                    system_ui_memory, launcher_memory, memory_carveout)
    elif total_ram > 0 and total_ram < FIVE_TWELVE_MB:
        memory_carveout = FIVE_TWELVE_MB - total_ram
        pss_metrics_test_results = test_pss_metrics(FIVE_TWELVE_MB, cache_proc_dirty, kernel_memory,
                                                    system_server_memory,
                                                    system_ui_memory, launcher_memory, memory_carveout)
    else:
        pss_metrics_test_results = "Pss metrics test: N/A"
        memory_carveout = 0

    if memory_carveout > 0:
        printString("Memory Carveout: %s KB" % memory_carveout)


    if re.search("Persistent Service",meminfo_text_strip) is None:
        persistent_processes_array = re.findall("Persistent(.*?)Foreground", meminfo_text_strip)[0]
    else:
        persistent_processes_array = re.findall("Persistent(.*?)Persistent Service", meminfo_text_strip)[0]
    #print(persistent_processes_array)
    persistent_processes_array = re.findall("(\d.*?)\(pid .*?\)", persistent_processes_array)
    persistent_memory_array = re.findall(".*?((\d,?){1,}).*?", "".join(persistent_processes_array))
    #print(persistent_memory_array)
    persistent_memory = 0
    for persistent_memory_item in persistent_memory_array:
        persistent_memory += formatData(persistent_memory_item[0])
    # print(persistent_memory_array)
    printString("Total persistent Memory: %s KB" % persistent_memory)
    if persistent_memory < MAX_PERSISTENT_MEMORY:
        persistent_memory_test_result = PASS + formatCompareData(persistent_memory, MAX_PERSISTENT_MEMORY)
    else:
        persistent_memory_test_result = FAIL + formatCompareData(persistent_memory, MAX_PERSISTENT_MEMORY)

    #print(persistent_processes_array)
    for i in range(len(persistent_processes_array)):
        if i == 0:
            printString("")
            printString("--------------------")
            printString("Persistent processes")
            printString("--------------------")
        printString(persistent_processes_array[i])

    printString("")
    printString(SECTION_SEPARATOR)
    printString("%s" % pss_metrics_test_results)
    printString("Persistent memory test: %s" % persistent_memory_test_result)
    printString(SECTION_SEPARATOR)


def main():
    device_serial = get_device_serial()
    global outputFileName
    outputFileName = "post_boot_metrics-%s-%s.txt" % (device_serial, int(time.time()))
    printString("Rebooting device")
    cmd = "adb reboot"
    getCmdEexcuteResult(cmd)

    wait_for_device()
    cmd ="adb wait-for-device"
    getCmdEexcuteResult(cmd)
    cmd = "adb shell wm dismiss-keyguard"
    getCmdEexcuteResult(cmd)
    cmd = "adb shell svc power stayon true"
    getCmdEexcuteResult(cmd)

    printString("Sleeping for %s seconds before taking measurement" % wait_time)

    time.sleep(wait_time)

    meminfo_text_bytes = getCmdEexcuteResult("adb shell dumpsys -t 30 meminfo")
    meminfo_text = ''
    meminfo_text_strip = ''
    for item in meminfo_text_bytes:
        meminfo_text += (bytes.decode(item))
        meminfo_text_strip += (bytes.decode(item)).strip("\r\n")


    get_post_boot_metrics(meminfo_text_strip, device_serial)

    # printString("------------------------------- DEBUG INFO START ------------------------------- ")
    # printString(meminfo_text)
    # printString("------------------------------- DEBUG INFO END ------------------------------- ")

if __name__ == "__main__":
    main()
    subprocess.call("pause", shell=True)