CPU

收集到的CPU数据，格式如下：

由于这里6个数据为一组来收集latency的数据以及各个分位值的数据，而本质上每一行都是一次完整的测试，因此这里将这个csv文件分为两个文件，第一个是和latency相关的，将6条数据融合为一条，而剩下的数据比如eps等，单独整理为一个文件。

这里分为两步，第一步单独处理每个实例收集到的数据，第二步是汇总所有实例数据。

对于50个实例收到的数据，先通过将6条合并为一条，一共收集到12条数据（线程4*负载3），然后放在一个csv文件里面，再把不需要合并的数据放在另一个csv文件里面。

#写一个方法来处理这个逻辑
import pandas as pd

# 处理第一个文件
def process_file_1(df):
    print(df.columns.tolist())
    # 检查列名是否存在
    required_columns = ["threads", "cpu_max_prime", "percentile", "min_latency", "avg_latency", "max_latency", "percentile_latency"]
    for col in required_columns:
        if col not in df.columns:
            raise KeyError(f"列名 '{col}' 不存在于文件中")
    
    # 提取需要的列
    df = df[required_columns]
    
    # 按照 threads 和 cpu_max_prime 分组
    grouped = df.groupby(["threads", "cpu_max_prime"])
    
    # 定义新的数据结构
    result = []
    
    for name, group in grouped:
        # 确保每组有 6 条数据（对应 6 个百分位）
        if len(group) == 6:
            # 提取百分位数据
            percentiles = group.set_index("percentile")["percentile_latency"].to_dict()
            
            # 计算 min_latency, avg_latency, max_latency 的最大值、最小值和平均值
            min_latency_max = group["min_latency"].max()
            min_latency_min = group["min_latency"].min()
            min_latency_avg = group["min_latency"].mean()
            
            avg_latency_max = group["avg_latency"].max()
            avg_latency_min = group["avg_latency"].min()
            avg_latency_avg = group["avg_latency"].mean()
            
            max_latency_max = group["max_latency"].max()
            max_latency_min = group["max_latency"].min()
            max_latency_avg = group["max_latency"].mean()
            
            # 构建新的一条数据
            new_row = {
                "threads": name[0],
                "cpu_max_prime": name[1],
                "25percentile": percentiles.get(25, None),
                "50percentile": percentiles.get(50, None),
                "75percentile": percentiles.get(75, None),
                "90percentile": percentiles.get(90, None),
                "95percentile": percentiles.get(95, None),
                "99percentile": percentiles.get(99, None),
                "min_latency_max": min_latency_max,
                "min_latency_min": min_latency_min,
                "min_latency_avg": min_latency_avg,
                "avg_latency_max": avg_latency_max,
                "avg_latency_min": avg_latency_min,
                "avg_latency_avg": avg_latency_avg,
                "max_latency_max": max_latency_max,
                "max_latency_min": max_latency_min,
                "max_latency_avg": max_latency_avg,
            }
            result.append(new_row)
    
    # 转换为 DataFrame
    return pd.DataFrame(result)

随后批量处理，将所有的文件汇总到一个csv文件，每一个实例收集到的数据有一个index标记。

 处理node1，node2的数据，也是将6条合并为一条，最后有51*12条数据。

画箱线图：

def plot_boxplots(path, threads, cpu_max_prime, num_boxes=50, ax=None, save_path=None,label=None,y_min=None, y_max=None):
    """
    新增参数:
    - ax: 要绘制的子图坐标轴
    - save_path: 独立保存路径
    """
    df = pd.read_csv(path)
    # 提取指定线程数和 CPU 负载的数据
    data = df[(df['threads'] == threads) & (df['cpu_max_prime'] == cpu_max_prime)]
    data = data.reset_index(drop=True)

    # 检查是否有数据
    if data.empty:
        raise ValueError(f"没有满足条件的数据 (threads={threads}, cpu_max_prime={cpu_max_prime})！")

    # 将相关列转换为 float 类型
    numeric_columns = ['min_latency_min', '25percentile', '50percentile', '75percentile', '90percentile']
    for col in numeric_columns:
        data[col] = pd.to_numeric(data[col], errors='coerce')

    # 收集箱线图所需的数据
    boxplot_data = {
        'min': data['min_latency_min'].values,
        '25%': data['25percentile'].values,
        '50%': data['50percentile'].values,
        '75%': data['75percentile'].values,
        'max': data['90percentile'].values
    }

    # 使用传入的坐标轴或创建新的
    if ax is None:
        fig, ax = plt.subplots(figsize=(15, 8))
    else:
        plt.sca(ax)  # 激活传入的坐标轴

    # 确定 y 轴的范围
    if y_min is None and y_max is None:
        y_min = data[numeric_columns].min().min()
        y_max = data[numeric_columns].max().max()
        ax.set_ylim(y_min * 0.9, y_max * 1.1)
    else:
    # 显式设置用户定义的边界
        ax.set_ylim(y_min, y_max)
    # 绘制指定数量的箱线图
    for i in range(num_boxes):
        min_val = boxplot_data['min'][i]
        q1_val = boxplot_data['25%'][i]
        median_val = boxplot_data['50%'][i]
        q3_val = boxplot_data['75%'][i]
        max_val = boxplot_data['max'][i]

        # 调试打印
        #print(f"Box {i+1}: Min={min_val:.2f}, Q1={q1_val:.2f}, Median={median_val:.2f}, Q3={q3_val:.2f}, Max={max_val:.2f}")
        
        # 绘制箱子（25% 到 75%）
        ax.fill_between(
            x=[i + 0.8, i + 1.2],
            y1=[q1_val, q1_val],
            y2=[q3_val, q3_val],
            color='lightblue', alpha=0.7
        )

        # 绘制中位线
        ax.plot(
            [i + 0.8, i + 1.2],
            [median_val, median_val],
            color='red', linewidth=0.5
        )

        # 绘制下须（min 到 25%）
        ax.plot(
            [i + 1, i + 1],
            [min_val, q1_val],
            color='black', linewidth=1
        )

        # 绘制上须（75% 到 max）
        ax.plot(
            [i + 1, i + 1],
            [q3_val, max_val],
            color='black', linewidth=1
        )


    # 修改所有 plt.plot -> ax.plot
    ax.set_title(f'Latency Distribution (Threads={threads}, CPU={cpu_max_prime}, First {num_boxes} Tests,{label} plot.)')
    ax.set_xlabel('Test Index')
    ax.set_ylabel('Latency (ms)')
    ax.grid(True, linestyle='--', alpha=0.7)
    ax.set_xticks(range(1, num_boxes + 1))

    # 独立保存逻辑
    if save_path:
        plt.savefig(save_path, dpi=300, bbox_inches='tight')
    return ax

这里有两个生成箱线图的函数，一个是做的25%-75%的，一个是5%-95%的。

这里输出的图的纵坐标应该是相同的，从而更方便比较，所以这里的纵坐标也是一个输入变量。

最后得到的图：

这里使用了箱线图，但是具体的图还得改一下。还要加上一些数据说明。

这里的是CPU的图，类似的图有很多张。

这里要证明的是在时间latency的维度上，这里要比较哪个实例最稳定，当证明了虽然性能比较差，共享型实例最稳定/共享型实例的稳定性较物理设备也差不多的时候，可以进一步论述对于不同的实例，哪些负载的稳定性最高。

内存：

内存没有做，但是估计差不多，可以从本地来循环的做，看看数据分布。