7zr CPU 性能测试结果解析

TL;DR

Speed(KiB/s) = 解压大小(B) * 重复次数(#)/time(s) /1024(B/KiB)
usage(%) ≈ 程序占用 CPU 时间/程序开始到现在为止总耗时*100%
R/U(MIPS) ≈ 产生的指令数(MI)/占用 CPU 的时间
Rating(MIPS) ≈ 产生的指令数(MI)/程序耗时(s)

7zr b -mmt1

                        Compressing  |                  Decompressing
Dict     Speed Usage    R/U Rating  |      Speed Usage    R/U Rating
         KiB/s     %   MIPS   MIPS  |      KiB/s     %   MIPS   MIPS
 
22:       4515   100   4403   4393  |      51373   100   4395   4386
23:       3883   100   3966   3956  |      50676   100   4395   4387
24:       3724   100   4014   4004  |      48750   100   4292   4280
25:       3520   100   4032   4020  |      48064   100   4293   4278
----------------------------------  | ------------------------------
Avr:             100   4104   4093  |              100   4344   4333
Tot:             100   4224   4213

Speed

这段打印在

 //p7zip-17.05/CPP/7zip/UI/Common/Bench.cpp
static void PrintResults(IBenchPrintCallback *f,
    const CBenchInfo &info,
    unsigned weight,
    UInt64 rating,
    bool showFreq, UInt64 cpuFreq,
    CTotalBenchRes *res)
{
  UInt64 speed = info.GetSpeed(info.UnpackSize * info.NumIterations);
  if (f)
  {
    if (speed != 0)
      PrintNumber(*f, speed / 1024, kFieldSize_Speed);
    else
      PrintSpaces(*f, 1 + kFieldSize_Speed);
  }
  UInt64 usage = info.GetUsage();
  UInt64 rpu = info.GetRatingPerUsage(rating);
  if (f)
  {
    PrintResults(*f, usage, rpu, rating, showFreq, cpuFreq);
  }
 
  if (res)
  {
    // res->NumIterations1++;
    res->NumIterations2 += weight;
    res->RPU += (rpu * weight);
    res->Rating += (rating * weight);
    res->Usage += (usage * weight);
  }
}

其中 info.GetSpeed() 如下：

 //p7zip-17.05/CPP/7zip/UI/Common/Bench.cpp
static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime, UInt64 freq)
{
  UInt64 elTime = elapsedTime;
  NormalizeVals(freq, elTime);
  if (elTime == 0)
    elTime = 1;
  return value * freq / elTime;
  /*
   * 原始公式： value /(elTime/freq)
   * 各个变量对应的单位，其中：
   *    * value:    number
   *    * elTime:   ms
   *    * freq:     ms/s ( or to say: 一秒内有多少个 ms event )
  */
}
 
UInt64 CBenchInfo::GetSpeed(UInt64 numCommands) const
{
  return MyMultDiv64(numCommands, GlobalTime, GlobalFreq);
}

我们可以知道变量 speed 的定义如下：

speed(B/s) = 解压大小(B) * info.NumIterations(#)/time(s)

所以 Speed 列就是 Speed(KiB/s)=speed(B/s)/1024(B/KiB) 。即 Speed(KiB/s)=解压大小(B) * 重复次数(#)/time(s) /1024(B/KiB)

Usage, R/U, Rating

继续看剩下三列的定义：Usage, R/U, Rating

 //p7zip-17.05/CPP/7zip/UI/Common/Bench.cpp
static void PrintResults(IBenchPrintCallback &f, UInt64 usage, UInt64 rpu, UInt64 rating, bool showFreq, UInt64 cpuFreq)
{
  PrintNumber(f, (usage + 5000) / 10000, kFieldSize_Usage);
  PrintRating(f, rpu, kFieldSize_RU);
  PrintRating(f, rating, kFieldSize_Rating);
  if (showFreq)
  {
    if (cpuFreq == 0)
      PrintSpaces(f, kFieldSize_EUAndEffec);
    else
    {
      UInt64 ddd = cpuFreq * usage / 100;
      if (ddd == 0)
        ddd = 1;
      PrintPercents(f, (rating * 10000), ddd, kFieldSize_EU);
      PrintPercents(f, rating, cpuFreq, kFieldSize_Effec);
    }
  }
}

Usage

usage 是从上一级 PrintResults 中通过 info.GetUsage() 取到的。简单跟踪之后可知：

usage = 程序占用 CPU 时间/程序开始到现在为止总耗时 * 10^6

其中 10^6 会在后续被除以 10000 规整为百分比。

本级的 PrintResults 中打印了 Usage 列，打印的时间是：(usage + 5000) / 10000，除以 10000 就是上面说的“规整为百分比”，而加的 50% 大概是其他消耗占程序的 50%。总之，Usage 列大概指的是压缩测试占用 CPU 的百分比。即：usage(%) ≈ 程序占用 CPU 时间/程序开始到现在为止总耗时*100%

Rating

rating 是从以下代码得来的：

 UInt64 CBenchProps::GetCompressRating(UInt32 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size)
{
  if (dictSize < (1 << kBenchMinDicLogSize))
    dictSize = (1 << kBenchMinDicLogSize);
  UInt64 encComplex = EncComplex;
  if (LzmaRatingMode)
  {
    UInt64 t = GetLogSize(dictSize) - (kBenchMinDicLogSize << kSubBits);
    encComplex = 870 + ((t * t * 5) >> (2 * kSubBits));
  }
  UInt64 numCommands = (UInt64)size * encComplex;
 
  /*
   * 和计算 Usage 时差不多，大概意思是：
   *  numCommands/elapsedTime
   * 通过各种 size 估算出计算的 command 的数量是多少，单位是 Million Instruction （因为后面没见到除以 1,000,000）
   */
  return MyMultDiv64(numCommands, elapsedTime, freq);
}
 
HRESULT CBenchCallbackToPrint::SetEncodeResult(const CBenchInfo &info, bool final)
{
  RINOK(_file->CheckBreak());
  if (final)
  {
    UInt64 rating = BenchProps.GetCompressRating(DictSize, info.GlobalTime, info.GlobalFreq, info.UnpackSize * info.NumIterations);
    PrintResults(_file, info,
        EncodeWeight, rating,
        ShowFreq, CpuFreq, &EncodeRes);
    if (!Use2Columns)
      _file->NewLine();
  }
  return S_OK;
}

所以 Rating 就是在“程序耗时”（Eltime）期间，产生的指令数，单位：（MI/s) 即 MIPS。即 R/U(MIPS) ≈ 产生的指令数(MI)/占用 CPU 的时间

R/U

（这也是我找这段代码的关键字）

可以看到 R/U 列来自变量 rpu，rpu 来自变量 rating，

简单跟踪之后发现，它和 Rating 的区别在于，将耗时改成了“占用 CPU 的时间”，所以也可以猜出 rpu 的缩写是 rating per usage，它的单位一样是（MI/s) 即 MIPS。即 Rating(MIPS) ≈ 产生的指令数(MI)/程序耗时(s)

	Compressing \| Decompressing
	Dict Speed Usage R/U Rating \| Speed Usage R/U Rating
	KiB/s % MIPS MIPS \| KiB/s % MIPS MIPS

	22: 4515 100 4403 4393 \| 51373 100 4395 4386
	23: 3883 100 3966 3956 \| 50676 100 4395 4387
	24: 3724 100 4014 4004 \| 48750 100 4292 4280
	25: 3520 100 4032 4020 \| 48064 100 4293 4278
	---------------------------------- \| ------------------------------
	Avr: 100 4104 4093 \| 100 4344 4333
	Tot: 100 4224 4213

	//p7zip-17.05/CPP/7zip/UI/Common/Bench.cpp
	static void PrintResults(IBenchPrintCallback *f,
	const CBenchInfo &info,
	unsigned weight,
	UInt64 rating,
	bool showFreq, UInt64 cpuFreq,
	CTotalBenchRes *res)
	{
	UInt64 speed = info.GetSpeed(info.UnpackSize * info.NumIterations);
	if (f)
	{
	if (speed != 0)
	PrintNumber(*f, speed / 1024, kFieldSize_Speed);
	else
	PrintSpaces(*f, 1 + kFieldSize_Speed);
	}
	UInt64 usage = info.GetUsage();
	UInt64 rpu = info.GetRatingPerUsage(rating);
	if (f)
	{
	PrintResults(*f, usage, rpu, rating, showFreq, cpuFreq);
	}

	if (res)
	{
	// res->NumIterations1++;
	res->NumIterations2 += weight;
	res->RPU += (rpu * weight);
	res->Rating += (rating * weight);
	res->Usage += (usage * weight);
	}
	}

	//p7zip-17.05/CPP/7zip/UI/Common/Bench.cpp
	static UInt64 MyMultDiv64(UInt64 value, UInt64 elapsedTime, UInt64 freq)
	{
	UInt64 elTime = elapsedTime;
	NormalizeVals(freq, elTime);
	if (elTime == 0)
	elTime = 1;
	return value * freq / elTime;
	/*
	* 原始公式： value /(elTime/freq)
	* 各个变量对应的单位，其中：
	* * value: number
	* * elTime: ms
	* * freq: ms/s ( or to say: 一秒内有多少个 ms event )
	*/
	}

	UInt64 CBenchInfo::GetSpeed(UInt64 numCommands) const
	{
	return MyMultDiv64(numCommands, GlobalTime, GlobalFreq);
	}

	//p7zip-17.05/CPP/7zip/UI/Common/Bench.cpp
	static void PrintResults(IBenchPrintCallback &f, UInt64 usage, UInt64 rpu, UInt64 rating, bool showFreq, UInt64 cpuFreq)
	{
	PrintNumber(f, (usage + 5000) / 10000, kFieldSize_Usage);
	PrintRating(f, rpu, kFieldSize_RU);
	PrintRating(f, rating, kFieldSize_Rating);
	if (showFreq)
	{
	if (cpuFreq == 0)
	PrintSpaces(f, kFieldSize_EUAndEffec);
	else
	{
	UInt64 ddd = cpuFreq * usage / 100;
	if (ddd == 0)
	ddd = 1;
	PrintPercents(f, (rating * 10000), ddd, kFieldSize_EU);
	PrintPercents(f, rating, cpuFreq, kFieldSize_Effec);
	}
	}
	}

	UInt64 CBenchProps::GetCompressRating(UInt32 dictSize, UInt64 elapsedTime, UInt64 freq, UInt64 size)
	{
	if (dictSize < (1 << kBenchMinDicLogSize))
	dictSize = (1 << kBenchMinDicLogSize);
	UInt64 encComplex = EncComplex;
	if (LzmaRatingMode)
	{
	UInt64 t = GetLogSize(dictSize) - (kBenchMinDicLogSize << kSubBits);
	encComplex = 870 + ((t * t * 5) >> (2 * kSubBits));
	}
	UInt64 numCommands = (UInt64)size * encComplex;

	/*
	* 和计算 Usage 时差不多，大概意思是：
	* numCommands/elapsedTime
	* 通过各种 size 估算出计算的 command 的数量是多少，单位是 Million Instruction （因为后面没见到除以 1,000,000）
	*/
	return MyMultDiv64(numCommands, elapsedTime, freq);
	}

	HRESULT CBenchCallbackToPrint::SetEncodeResult(const CBenchInfo &info, bool final)
	{
	RINOK(_file->CheckBreak());
	if (final)
	{
	UInt64 rating = BenchProps.GetCompressRating(DictSize, info.GlobalTime, info.GlobalFreq, info.UnpackSize * info.NumIterations);
	PrintResults(_file, info,
	EncodeWeight, rating,
	ShowFreq, CpuFreq, &EncodeRes);
	if (!Use2Columns)
	_file->NewLine();
	}
	return S_OK;
	}