性能测试：一种计算 TP90、TP95 和 TP99 等水位线的方法

最新推荐文章于 2024-05-31 08:58:34 发布

nfzhlk

最新推荐文章于 2024-05-31 08:58:34 发布

阅读量1.2k

点赞数

分类专栏：测试技术文章标签：数据结构算法 c语言

原文链接：https://blog.csdn.net/qq_35246620/article/details/101284451

版权

测试技术专栏收录该内容

24 篇文章 3 订阅

订阅专栏

在性能测试中，我们经常会选择 TP90、TP95 或者 TP99 等水位线作为性能指标。在本文中，我们就给出一种计算 TP90、TP95 和 TP99 等水位线的方法。首先，我们先解释一下 TP90、TP95 和 TP99 的含义：

TP90，top percent 90，即 90% 的数据都满足某一条件；
TP95，top percent 95，即 95% 的数据都满足某一条件；
TP99，top percent 99，即 99% 的数据都满足某一条件；

在这里，我们之所以说其“满足某一条件”，是因为在计算的时候，我们既可以向前计算也可以向后计算，例如：

1, 2, 3, ..., 98, 99, 100

如上所示，这是一个从 1 至 100 的数列，如果我们想计算其 TP99 的值，其方法为用数列中数值的总个数乘以 99%，即100 * 99% = 99，显然在这个数列中有两个数值满足这个 99 的概念，分别为：

2，即数列中 99% 的数值都大于等于2
99，即数列中 99% 的数值都小于等于99

因此，TP90、TP95 或者 TP99 等水位线是有两种含义的，具体选择哪一种，我们可以按需求自己选择。
计算方法

如果我们要计算 TP90、TP95 或者 TP99 等水位线的值，其前提就是需要我们将所有的待计算值保存起来。那么我们应该用什么数据结构来存储这一系列的值呢？数组？或者列表？实际上，无论我们选择哪一种数据结构，我们都不能假设其长度无限大，因为内存空间是有限的，而且数据结构也有理论上的最大值，但是我们要存储的值的个数却可能是无限的。因此，我们就需要利用有限长度的数据结构存储更多的数值。在这里，数据结构我们选择数组，以计算耗时的 TP90、TP95 或者 TP99 等水位线为例：

double[] SCALE = new double[2400]
int[] countContainer = new int[2400]

如上所示，我们创建了两个长度相同数组，其中

SCALE数组，用来存储耗时的占位符，表示对应的耗时值；
countContainer数组，用来存储某个耗时值的出现次数，与SCALE数组一一对应

例如，SCALE[1024]的值为 1025，而countContainer[1024]的值为 2050，则表示耗时为 1025 的值出现了 2050 次。

又因为耗时的值可以无限大，而我们却不能穷尽其所有值，更切合实际的情况是：大部分的耗时值都集中在某一个区域。因此，我们只需要列出常见的数值，并利用步长来控制即可，具体方法为：

SCALE数组索引0 ~ 999，存储1 ~ 1000，步长为 1
SCALE数组索引1000 ~ 1899，存储1010 ~ 10000，步长为 10
SCALE数组索引1900 ~ 2399，存储10100 ~ 60000，步长为 100
countContainer数组索引0 ~ 2399，均初始化为 0

其中，存储的最大耗时值为 60000，表示 60000 毫秒，也就是 1 分钟。

当记录耗时t的时候，假设t = 1000，

拿着t到SCALE数组中匹配对应的槽位，计算得知SCALE[999] = 1000，则其对应槽位的索引值为999；
到countContainer数组中， 将countContainer[999]得值累计 1
循环步骤 1 和步骤 2

当我们想要计算 TP99 的值，则停止步骤 3，获取耗时的总记录个数sum，即countContainer数组中所有值的累加和，然后：

计算 TP99 的水位线，假设sum * 99% = waterline99
从countContainer[0]开始，从前往后累加数组的值（或者从countContainer[2399]开始，从后往前累加数组的值）
当countContainer[0] + countContainer[1] + ... + countContainer[target] >= waterline99的时候，记录target索引
拿着target到SCALE数组中匹配对应的槽位，SCALE[target]即为 TP99 的值

至此，TP99 计算完毕。其它，诸如 TP90 或者 TP95，甚至 TP50 等，可类似计算。
代码

public class MonitorWaterLineCalculator {

	// 累计调用次数
    private long count;
    // 占位数组
    private final double[] SCALE = new double[2400];
    // 统计数组
    private long[] countContainer = new long[2400];
    // 水位线
    private double percentXx;

    /**
     * 构造方法
     *
     * @param waterLine 水位线
     */
    public MonitorWaterLineCalculator(double waterLine) {
        if (waterLine < 0.0 || waterLine > 100.0) {
            throw new IllegalArgumentException("waterLine must be less than 100.0 and more than 0.0");
        } else {
            percentXx = (100.0 - waterLine) / 100;
        }

        // 初始化 SCALE 数组，1 ~ 1000 步长为 1
        for (int i = 0; i < 1000; i++) {
            SCALE[i] = i + 1;
        }
        // 初始化 SCALE 数组，1001 ~ 10000 步长为 10
        for (int i = 1000, j = 10; i < 1900; i++, j += 10) {
            SCALE[i] = 1000 + j;
        }
        // 初始化 SCALE 数组，10001 ~ 60000 步长为 100
        for (int i = 1900, j = 100; i < 2400; i++, j += 100) {
            SCALE[i] = 10000 + j;
        }
    }

    /**
     * 计算方法
     *
     * @param value 待计算值
     */
    public synchronized void accumulate(double value) {
    	// 累加次数
        count++;
        // 找到下标
        int index = positionInValueArray(value);
        countContainer[index]++;
    }

    // 容错，确保通过水位线处理后的数值在 [1, MAX] 范围内
    private long adjust(int input, int max) {
        if (input <= 1) {
            return 1;
        } else if (input >= max) {
            return max;
        } else {
            return input;
        }
    }

    public synchronized double getResult() {
        // 为位置进行容错，该值应该属于 [1,total] 范围
        long percentXxPos = adjust((long) (count * percentXx), count);
        double percentXxValue = Double.MAX_VALUE;
        // 开始遍历每一个元素，从后往前算
        int scanned = 0;
        int length = countContainer.length;

        // 计算结果，或者符合水位线的值，为在步长误差范围内的模糊值
        for (int index = length - 1; index >= 0; index--) {
            // 当前没有值，无论如何也不会成为备选
            if (0.0 == countContainer[index]) {
                continue;
            }

            // 当前有值
            scanned += countContainer[index];
			// 水位线
            if (scanned >= percentXxPos) {
                percentXxValue = SCALE[index];
                break;
            }
        }

        return percentXxValue;
    }

    /**
     * 寻找待处理数值在数组中的位置
     *
     * @param val 待处理值
     * @return 数组中的位置
     */
    private int positionInValueArray(double val) {
        int length = SCALE.length;
        // 如果大于最大值或者小于等于最小值
        if (val >= SCALE[length - 1]) {
            return length - 1;
        } else if (val <= SCALE[0]) {
            return 0;
        }
        // 采用二分法计算
        return binarySearch(SCALE, 0, length - 1, val);
    }

    /**
     * 二分查询
     *
     * @param array 待处理数组
     * @param begin 查询数组起始索引
     * @param end   查询数组结束索引
     * @param value 待查询值
     * @return 数组中的位置
     */
    private int binarySearch(double[] array, int begin, int end, double value) {
        int mid = (begin + end) >> 1;
        double midValue = array[mid];
        double halfMidValue = midValue / 2;
        // 判断是否可以命中
        if (value > halfMidValue && value <= midValue) {
            return mid;
        }
        // 没法命中,则根据大小来定
        if (value <= halfMidValue) {
            // 处理边界条件
            if (mid - 1 < 0) {
                return 0;
            }
            return binarySearch(array, begin, mid - 1, value);
        } else {
            return binarySearch(array, mid + 1, end, value);
        }
    }
}