【转载】源码解读腾讯 GT 的性能测试方案

前言

本文将整理腾讯GT各个性能测试项的测试方法，目的是为了帮助移动性能专项测试同学快速过一遍腾讯GT各个性能数据是如何获取的。
另外对腾讯GT还不了解或者不知道它能做什么的同学可以看看这篇文章：
GT-非官方介绍 · TesterHome

一.GT性能测试方案之CPU测试

1.简要流程

初始化cpu的数据
提供了两种方法获取CPU数据 getCpuUsage: 整机的CPU使用水平，主要用于实时刷新GT上的CPU数据。通过读取/proc/stat的数据，将每一个核的cpu使用跟闲置数据提取。使用率永远是增量式计算。计算方法为100*（cpu忙时增量-cpu整体增量），从计算方法来看，可能会导致负数出现。 getProcessCpuUsage：计算进程的CPU使用率，主要通过”/proc/” + pid + “/stat”来计算，在这里回京过一系列计算，拿到进程的CPU时间片
2.代码流程

cpu数据初始化 经过初始化，让CPU整体使用跟进程的CPU占用都为0
`public CpuUtils() {
initCpuData();
}

private void initCpuData() {
pCpu = o_pCpu = 0.0;
aCpu = o_aCpu = 0.0;

}`
通过不同的调用栈，来监控不同的CPU数据
整体CPU使用率：由于getCpuUsage是通过后台线程不断刷新来实现的，因此，o_cpu/o_idle数据不断在实时更新

RandomAccessFile reader = null;
try {
reader = new RandomAccessFile("/proc/stat", "r");
String load;
load = reader.readLine();
String[] toks = load.split(" ");
double c_idle = Double.parseDouble(toks[5]);
double c_cpu = Double.parseDouble(toks[2])
     + Double.parseDouble(toks[3])
     + Double.parseDouble(toks[4])
     + Double.parseDouble(toks[6])
     + Double.parseDouble(toks[8])
     + Double.parseDouble(toks[7]);
if (0 != ((c_cpu + c_idle) - (o_cpu + o_idle))) {
  // double value = (100.00 * ((c_cpu - o_cpu) ) / ((c_cpu +
  // c_idle) - (o_cpu + o_idle)));
  usage = DoubleUtils.div((100.00 * ((c_cpu - o_cpu))),
        ((c_cpu + c_idle) - (o_cpu + o_idle)), 2);
  // Log.d("CPU", "usage: " + usage);
  if (usage < 0) {
     usage = 0;
  }
  else if (usage > 100)
  {
     usage = 100;
  }
  // BigDecimal b = new BigDecimal(Double.toString(value));

  // usage = b.setScale(2,
  // BigDecimal.ROUND_HALF_UP).doubleValue();
  // Log.d("CPU", "usage: " + usage);
}
o_cpu = c_cpu;
o_idle = c_idle;
} catch (IOException e) {
e.printStackTrace();
} finally {
FileUtil.closeRandomAccessFile(reader);
}

进程的CPU使用时间片获取

public String getProcessCpuUsage(int pid) {

   String result = "";
   String[] result1 = null;
   String[] result2 = null;
   if (pid >= 0) {

      result1 = getProcessCpuAction(pid);
      if (null != result1) {
         pCpu = Double.parseDouble(result1[1])
               + Double.parseDouble(result1[2]);
      }
      result2 = getCpuAction();
      if (null != result2) {
         aCpu = 0.0;
         for (int i = 2; i < result2.length; i++) {

            aCpu += Double.parseDouble(result2[i]);
         }
      }
      double usage = 0.0;
      if ((aCpu - o_aCpu) != 0) {
         usage = DoubleUtils.div(((pCpu - o_pCpu) * 100.00),
               (aCpu - o_aCpu), 2);
         if (usage < 0) {
            usage = 0;
         }
         else if (usage > 100)
         {
            usage = 100;
         }

      }
      o_pCpu = pCpu;
      o_aCpu = aCpu;
      result = String.valueOf(usage) + "%";
   }
   p_jif = pCpu;
   return result;
}

二.GT性能测试方案之内存测试

1.简要流程

内存测试主要通过handleMessage来触发，根据msg参数来决定任务执行

内存数据获取：仅仅简单通过dumpsys meminfo来获取内存数据，然后通过解析来得到pss_Native/naticeHeapSize/naticeAllocated/pss_OtherDev/pss_graphics/pss_gl/pss_UnKnown/pss_total数据
dumpHeap：通过am dumpheap 来获取heap文件
GC：直接kill -10 $pid 来完成GC
2.测试方法

内存数据获取

public static MemInfo getMemInfo(String packageName)
{
   MemInfo result = null;
   String resultString = null;
   try {
      resultString = runCMD("dumpsys meminfo " + packageName);
   } catch (Exception e) {
      e.printStackTrace();
      return MemInfo.EMPTY;
   }

   if(Env.API < 14)
   {
      result = parseMemInfoFrom2x(resultString);
   }
   else if (Env.API < 19)
   {
      result = parseMemInfoFrom4x(resultString);
   }
   else
   {
      result = parseMemInfoFrom44(resultString);
   }

   return result;
}

dumpHeap

private void dumpHeap() {
   String pid = String.valueOf(ProcessUtils
         .getProcessPID(AUTManager.pkn.toString()));

   if (!pid.equals("-1")) {
      boolean isSucess = true;
      ProcessBuilder pb = null;

      String sFolder = Env.S_ROOT_DUMP_FOLDER + AUTManager.pkn.toString() + "/";
      File folder = new File(sFolder);
      if (!folder.exists())
      {
         folder.mkdirs();
      }

      String cmd = "am dumpheap " + pid + " "// 命令
            + Env.S_ROOT_DUMP_FOLDER + AUTManager.pkn.toString() + "/"// 输出路径
            + "dump_" + pid + "_" + GTUtils.getSaveDate() + ".hprof"; // 输出文件名
      pb = new ProcessBuilder("su", "-c", cmd);

      Process exec = null;

      pb.redirectErrorStream(true);
      try {
         exec = pb.start();

         InputStream is = exec.getInputStream();
         BufferedReader reader = new BufferedReader(
               new InputStreamReader(is));

         while ((reader.readLine()) != null) {
            isSucess = false;
         }
      } catch (Exception e) {
         e.printStackTrace();
         isSucess = false;
      }
      // 至此命令算是执行成功
      if (isSucess)
      {
         handler.sendEmptyMessage(6);
      }

   } else {
      Log.d("dump error", "pid not found!");
   }
}

GC

private void gc() {
   String pid = String.valueOf(ProcessUtils
         .getProcessPID(AUTManager.pkn.toString()));

   if (!pid.equals("-1")) {
      boolean isSucess = true;
      ProcessBuilder pb = null;

      String cmd = "kill -10 " + pid;
      pb = new ProcessBuilder("su", "-c", cmd);

      Process exec = null;

      pb.redirectErrorStream(true);
      try {
         exec = pb.start();

         InputStream is = exec.getInputStream();
         BufferedReader reader = new BufferedReader(
               new InputStreamReader(is));

         while ((reader.readLine()) != null) {
            isSucess = false;
         }
      } catch (Exception e) {
         e.printStackTrace();
         isSucess = false;
      }
      // 至此命令算是执行成功
      if (isSucess)
      {
         handler.sendEmptyMessage(5);
      }

   } else {
      Log.d("gc error", "pid not found!");
   }
}

三.GT性能测试方案之内存填充

1.简要流程

内存填充，主要是通过调用系统的malloc来分配内存。内存释放，则是通过系统free来释放。

1. 代码流程

内存分配以及释放的函数

const int BASE_SIZE = 1024*1024; // 1M

int fill(int blockNum)
{
    int memSize = blockNum * BASE_SIZE;
    p = (char *)malloc(memSize);
    int i;
    for (i = 0; i < memSize; i++)
    {
        p[i] = 0;
    }
    return 0;
}

int freeMem()
{
    free(p);
    return 0;
}

加载com_tencent_wstt_gt_api_utils_MemFillTool.c，并提供度应对操作接口

public class MemFillTool {

   public MemFillTool() {
   }

   public static MemFillTool instance = null;

   public static MemFillTool getInstance() {
      if (instance == null) {
         System.loadLibrary("mem_fill_tool");
         instance = new MemFillTool();
      }
      return instance;
   }

   // 填充xxxMB内存
   public native int fillMem(int blockNum);

   // 释放刚才填充的内存
   public native int freeMem();
}

四.GT性能测试方案之帧率测试

1.简要流程

FPS数据收集是一个定时任务（4.3后1s一次），通过异步线程中不断获取FPS数据来刷新到前端页面。而广播模式调用，则直接从缓存的field中获取数据即可。
在这里GT获取fps数据，也是通过采用surfaceflinger来获取（执行”service call SurfaceFlinger 1013”），题外话：Runtime.getRuntime()原来执行多条命令时后续只要拿到process的DataOutputStream对象，继续writeBytes就可以保证是在同一个上下文中执行多条命令了。

2.代码流程

判断当前root状态，如果没有root直接返回，避免消耗系统资源

if (! GTFrameUtils.isHasSu())
{
   return;
}

计算一个周期内的帧率数据，由于比较简单（除了在1中surfaceflinger数据存疑外），直接把核心代码发出来

startTime = System.nanoTime();
if (testCount == 0) {
   try {
      lastFrameNum = getFrameNum();
   } catch (IOException e) {
      e.printStackTrace();
   }
}
int currentFrameNum = 0;
try {
   currentFrameNum = getFrameNum();
} catch (IOException e) {
   e.printStackTrace();
}
int FPS = currentFrameNum - lastFrameNum;
if (realCostTime > 0.0F) {
   int fpsResult = (int) (FPS * 1000 / realCostTime);
   defaultClient.setOutPara("FPS", fpsResult);
}
lastFrameNum = currentFrameNum;

testCount += 1;

帧率获取的部分也发一下。另外感谢@codeskyblue 的指点，service call SurfaceFlinger 1013这个命令是获取系统的总的刷新帧率（返回的是16进制）

public static synchronized int getFrameNum() throws IOException {
   String frameNumString = "";
   String getFps40 = "service call SurfaceFlinger 1013";

   if (process == null)
   {
      process = Runtime.getRuntime().exec("su");
      os = new DataOutputStream(process.getOutputStream());
      ir = new BufferedReader(
            new InputStreamReader(process.getInputStream()));
   }

   os.writeBytes(getFps40 + "\n");
   os.flush();

   String str = "";
   int index1 = 0;
   int index2 = 0;
   while ((str = ir.readLine()) != null) {
      if (str.indexOf("(") != -1) {
         index1 = str.indexOf("(");
         index2 = str.indexOf("  ");

         frameNumString = str.substring(index1 + 1, index2);
         break;
      }
   }

   int frameNum;
   if (!frameNumString.equals("")) {
      frameNum = Integer.parseInt(frameNumString, 16);
   } else {
      frameNum = 0;
   }
   return frameNum;
}

五.GT性能测试方案之流畅度测试

1.简要流程

腾讯的流畅度测试比较简单粗暴，测试方式是通过初始化choreographer日志级别，生成Choreographer日志来得到当前操作的丢帧。通过一系列计算后来计算流畅度。

2.测试方法

执行setprop debug.choreographer.skipwarning 1

View.OnClickListener button_write_property = new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            String cmd = "setprop debug.choreographer.skipwarning 1";
            ProcessBuilder execBuilder = new ProcessBuilder("su", "-c", cmd);
            execBuilder.redirectErrorStream(true);
            try {
                execBuilder.start();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    };

执行getprop debug.choreographer.skipwarning判断，为1则可以进行测试

View.OnClickListener button_check_status = new View.OnClickListener() {

        @Override
        public void onClick(View v) {
            String cmd = "getprop debug.choreographer.skipwarning";
            ProcessBuilder execBuilder = new ProcessBuilder("sh", "-c", cmd);
            execBuilder.redirectErrorStream(true);
            try {
                TextView textview = (TextView) findViewById(R.id.textviewInformation);
                Process p = execBuilder.start();
                InputStream is = p.getInputStream();
                InputStreamReader isr = new InputStreamReader(is);
                BufferedReader br = new BufferedReader(isr);
                Boolean flag = false;
                String line;
                while ((line = br.readLine()) != null) {
                    if (line.compareTo("1") == 0) {
                        flag = true;
                        break;
                    }
                }

                if (flag) {
                    textview.setText("OK");
                } else {
                    textview.setText("NOT OK");
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    };

执行adb logcat -v time -s Choreographer:I *:S
过滤获取当前pid丢帧值

protected void onHandleIntent(Intent intent) {
        try {

            String str = intent.getStringExtra("pid");
            int pid = Integer.parseInt(str);

            List args = new ArrayList(Arrays.asList("logcat", "-v", "time", "Choreographer:I", "*:S"));

            dumpLogcatProcess = RuntimeHelper.exec(args);
            reader = new BufferedReader(new InputStreamReader(dumpLogcatProcess.getInputStream()), 8192);

            String line;

            while ((line = reader.readLine()) != null && !killed) {

                // filter "The application may be doing too much work on its main thread."
                if (!line.contains("uch work on its main t")) {
                    continue;
                }
                int pID = LogLine.newLogLine(line, false).getProcessId();
                if (pID != pid){
                    continue;
                }

                line = line.substring(50, line.length() - 71);
                Integer value = Integer.parseInt(line.trim());

                SMServiceHelper.getInstance().dataQueue.offer(value);
            }
        } catch (IOException e) {
            Log.e(TAG, e.toString() + "unexpected exception");
        } finally {
            killProcess();
        }
    }

数据处理得到sm值 腾讯这边的处理方案是：当丢帧<60时，流畅度SM =60-frame； 当丢帧frame>60时，流畅度SM = 60-frame%60。不过这种处理方式是有问题的。在这里要先说下流畅度计算的原理：
VSync机制可以通过其Loop来了解当前App最高绘制能力，固定每隔16.6ms执行一次，这样最高的刷新的帧率就控制在60FPS以内，Choreographer日志可以打印当前丢帧数，因此通过计算，得到当前APP的流畅度。
而计算这样来计算可能会更加准确（个人看法，欢迎讨论）： SM= 60-丢帧frame/每两行同一线程的丢帧时间差（单位：s），如果只关心UI线程，那就只需要统计UI线程即可。

while (true) {
    if (pause) {
        break;
    }
    int x = count.getAndSet(0);
    // 卡顿大于60时，要将之前几次SM计数做修正
    if (x > 60) {
        int n = x / 60;
        int v = x % 60;
        TagTimeEntry tte = OpPerfBridge.getProfilerData(key);
        int len = tte.getRecordSize();
        // 补偿参数
        int p = n;
        //Math.min(len, n);
        /*
        * n > len是刚启动测试的情况，日志中的亡灵作祟，这种情况不做补偿;
        * 并且本次也记为60。本逻辑在两次测试间会清理数据的情况生效。
        */
        if (n > len) {
            globalClient.setOutPara(key, 60);
//          globalClient.setOutPara(SFKey, 0);
        } else {
            for (int i = 0; i < p; i++) {
            TimeEntry te = tte.getRecord(len - 1 - i);
            te.reduce = 0;
            }
        globalClient.setOutPara(key, v);
//      globalClient.setOutPara(SFKey, 60 - v);
        }
    } else {
        int sm = 60 - x;
        globalClient.setOutPara(key, sm);
//      globalClient.setOutPara(SFKey, x);
    }

六.GT性能测试方案之流量测试

1.简要流程

流量测试有三种方案，默认采用方案1

通过读取”/proc/uid_stat/” + uid + “/tcp_snd”获取发送跟接收流量
直接调用android的api：TrafficStats.getUidTxBytes(uid)来获取流量数据（该方法号称是获取到指定 uid 发送流量的总和，但实测情况是只有 tcp 层的流量）
第三种方案居然空在那里，那实际上只有两种方案
2.代码流程

初始化流量

public void initProcessNetValue(String pName) {

   p_t_base = getOutOctets(pName);
   p_r_base = getInOctets(pName);

   p_t_add = 0;
   p_r_add = 0;
}

其中getOutOctets/getInOctets具体对应什么方法，需要看设备是不是支持uid流量数据获取

获取增加的流量

public String getProcessNetValue(String pName) {
   StringBuffer sb = new StringBuffer();

   java.text.DecimalFormat df = new java.text.DecimalFormat("#.##");
   p_t_cur = getOutOctets(pName);
   p_r_cur = getInOctets(pName);
   p_t_add = (p_t_cur - p_t_base) / B2K;
   p_r_add = (p_r_cur - p_r_base) / B2K;

   sb.append("t");
   sb.append(df.format(p_t_add));
   sb.append("KB|r");
   sb.append(df.format(p_r_add));
   sb.append("KB");

   return sb.toString();
}

矫正处理

// modify on 20120616 过滤有的手机进程流量偶尔输出负数的情况
if ((nowT != lastT || nowR != lastR) && nowT >= 0 && nowR >= 0) {
   OpPerfBridge.addHistory(op, value, new long[]{(long) nowT, (long) nowR});
}

return value;

七.GT性能测试方案之电量测试

1.简单流程

关注指标:
电量测试关注的指标有四个: 电流，电压，电量跟温度。
数据获取方式:
通过ReadPowerTimerTask任务去set关注的电量指标，当update方法调用时，才把数据set进去。电量数据调用的系统命令/sys/class/power_supply/battery/uevent
具体流程:
接收”com.tencent.wstt.gt.plugin.battery.startTest”广播后，update各个指标
注册跟设置出参，并设置刷新频率跟初始化屏幕电量
开启定时任务ReadPowerTimerTask，这个任务的作用就是去获取/sys/class/power_supply/battery/uevent下的电量数据并解析，最后设置出参。刷新频率默认是250ms一次
最后stop时，销毁异步定时任务
2.代码流程

整个生命周期如下，当BATTERY_START_TEST行为被捕获时，开始执行电量测试

String action = intent.getAction();
if (action == null) return;
if (action.equals(BATTERY_START_TEST)) {
   int refreshRate = intent.getIntExtra("refreshRate", 250);
   int brightness = intent.getIntExtra("brightness", 100);

   boolean updateI = intent.getBooleanExtra("I", true);
   GTBatteryEngine.getInstance().updateI(updateI);

   boolean updateU = intent.getBooleanExtra("U", false);
   GTBatteryEngine.getInstance().updateU(updateU);

   boolean updateT = intent.getBooleanExtra("T", false);
   GTBatteryEngine.getInstance().updateT(updateT);

   boolean updateP = intent.getBooleanExtra("P", false);
   GTBatteryEngine.getInstance().updateP(updateP);

   GTBatteryEngine.getInstance().doStart(refreshRate, brightness);
} else if (action.equals(BATTERY_END_TEST)) {
   GTBatteryEngine.getInstance().doStop();
}

update操作很简单，只是注册跟set出参

public void updateI(boolean isChecked)
{
   if (isChecked)
   {
      globalClient.registerOutPara(GTBatteryEngine.OPI, "I");
      globalClient.setOutparaMonitor(GTBatteryEngine.OPI, true);
   }
   else
   {
      globalClient.unregisterOutPara(GTBatteryEngine.OPI);
   }
   state_cb_I = isChecked;
   GTPref.getGTPref().edit().putBoolean(GTBatteryEngine.KEY_I, isChecked).commit();

   for (BatteryPluginListener listener : listeners)
   {
      listener.onUpdateI(isChecked);
   }
}

初始化操作略过，这里展示异步任务，处理流程直接看下面的关键代码即可，方法在GTBatteryEngine.java中

timer = new Timer(true);
timer.schedule(new ReadPowerTimerTask(), refreshRate, refreshRate);

@Override
public void run() {

   BufferedReader br = null;
   try {
      FileReader fr = new FileReader(f);
      br = new BufferedReader(fr);
      String line = "";
      while((line = br.readLine()) != null){

         int found = 0;
         if (line.startsWith("POWER_SUPPLY_VOLTAGE_NOW="))
         {
            U = line.substring(line.lastIndexOf("=") + 1);
            // since 2.1.1 从μV转成mV
            long volt = Long.parseLong(U) / 1000;
            globalClient.setOutPara(OPU, volt + "mV");

            OutPara op = globalClient.getOutPara(OPU);
            if (null != op)
            {
               OpPerfBridge.addHistory(op, U, volt);
            }

            found++;
         }
         if (line.startsWith("POWER_SUPPLY_CURRENT_NOW="))
         {
            I = line.substring(line.lastIndexOf("=") + 1);
            // since 2.1.1 从μA转成mA since 2.2.4 华为本身就是mA
            long current = Long.parseLong(I);
            if (isHuawei)
            {
               current = -current;
            }
            else if (isLGg3)
            {
               current = current >> 1; // 经验值估算LG g3的数据除以2后比较接近真实
            }
            else
            {
               current = current / 1000;
            }
            globalClient.setOutPara(OPI, current + "mA");

            OutPara op = globalClient.getOutPara(OPI);
            if (null != op)
            {
               OpPerfBridge.addHistory(op, I, current);
            }

            found++;
         }
         if (line.startsWith("POWER_SUPPLY_CAPACITY="))
         {
            String lastBattery = POW;
            POW =  line.substring(line.lastIndexOf("=") + 1);
            if (! lastBattery.equals(POW)) // 电池百分比变化了
            {
               if (startBattry != -1)
               {
                  lastBatteryChangeTime = (System.currentTimeMillis() - startBattry)/1000 + "s";
                  String tempValue = POW + "% | -1% time:" + lastBatteryChangeTime;
                  globalClient.setOutPara(OPPow, tempValue);
                  GTLog.logI(LOG_TAG, tempValue);
                  // 将电量加入历史记录
                  OutPara op = globalClient.getOutPara(OPPow);
                  if (null != op)
                  {
                     OpPerfBridge.addHistory(op, tempValue, Long.parseLong(POW));
                  }
               }

               startBattry = System.currentTimeMillis();
            }

            globalClient.setOutPara(OPPow, POW + "% | -1% time:" + lastBatteryChangeTime);
            found++;
         }
         if (line.startsWith("POWER_SUPPLY_TEMP="))
         {
            TEMP = line.substring(line.lastIndexOf("=") + 1);
            int iTemp = Integer.parseInt(TEMP);
            iTemp = iTemp/10;
            if (iTemp > -273)
            {
               TEMP = iTemp + "℃";
            }

            globalClient.setOutPara(OPTemp, TEMP);

            OutPara op = globalClient.getOutPara(OPTemp);
            if (null != op && iTemp != INT_TEMP)
            {
               OpPerfBridge.addHistory(op, TEMP, iTemp);
               GTLog.logI(LOG_TAG, TEMP);
               INT_TEMP = iTemp;
            }

            found++;
         }
         if (found >= 4)
         {
            return;
         }

      }
   } catch (Exception e) {
      doStop();
   }
   finally
   {
      FileUtil.closeReader(br);
   }
}

转载自：https://zhuanlan.zhihu.com/p/27697524