3 小試牛刀，編寫性能測試工具

作為一名后端研發人員，必須具備系統性能評估和分析能力，因為只有對系統總體性能了如指掌，才能知道系統什么時候需要擴容，系統哪里有性能瓶頸需要優化。

本章將介紹如何宏觀的評估系統的總體性能，并重點介紹如何編寫性能測試工具對系統性能做一個實測，畢竟理論歸理論，理論上性能指標還是需要靠實際壓測來檢驗。

3.1 系統的總體性能簡述

通常我們使用QPS、平均響應時間、并發數，這三個指標來衡量一個系統的總體性能。

• QPS：表示系統每秒請求數。
• 平均響應時間：表示系統平均單個請求耗時，單位為秒。
• 并發數：表示系統能同時處理的請求數。

系統能支持的最大QPS是由平均響應時間和并發數決定的，即QPS=并發數/平均響應時間。純理論的解說可能不太好理解，我們這邊舉一個例子，比如我們去銀行營業廳辦存款業務，這時有10個柜臺可以辦理存款業務，每個人辦理存款業務平均需要5分鐘，那么這個營業廳每小時可以處理多少的存款業務呢？這里10個柜臺可以辦理業務也就是說“并發數”為10，我們單位時間設定為小時，那么辦理存款業務平均需要5分鐘也就是說“平均響應時間”為13分之1小時，那么這個營業廳每小時可以處理的存款業務數也就是QPS=10/(1/13)，即130。

由上面的公式“QPS=并發數/平均響應時間”，我們可以看出要提高系統的QPS，可以從兩個方面著手，一方面是提高并發數，一方面是降低平均響應時間。

• 提高并發數的方法
  新增更多的服務器，采用多核服務器，單服務器上運行多進程提供服務，進程采用更高效性的IO模型。

• 降低平均響應時間的方法
  響應時間通常由：網絡通訊時間（網絡io時間）+計算處理時間（cpu時間）+磁盤讀寫時間（磁盤io時間）構成的。可以通過使用更大的網絡帶寬，更好的網卡來降低網絡通訊時間，可以使用更強大的cpu或者優化算法來減少計算處理時間，可以使用SSD硬盤來替代普通硬盤來降低單次讀寫磁盤的io時間，可以在業務層和數據庫持久化層之間添加一個緩存層來減少磁盤io次數。

3.2 性能測試工具

我們的性能測試工具是命令行工具，命名為“benchMark”，它用于測試一個系統提供的網絡服務的總體性能，它具備命令參數功能、支持多客戶端并發、支持基于連接的壓測、支持基于特定業務請求的壓測等的功能。

3.2.1 命令參數功能

和所有Linux的命令一樣，我們的工具也支持命令參數，在Linux下有一個getopt_long函數用于支持對命令行參數的解析，通過這個函數我們能輕易是實現對長短參數的解析和獲取。getopt_long函數所在的頭文件和函數原型如下：

#include <getopt.h>

int getopt_long(int argc, char * const argv[], const char *optstring, const struct option *longopts, int *longindex);

作為C/C++入口函數，main的標準函數原型為“int main(int argc, char * argv[])”，命令行參數也正是通過main函數的argc、argv這兩個參數傳遞進來的。

• argc與argv參數

getopt_long函數開頭需要傳入的兩個參數就是main函數的argc和argv參數，argc表示要解析參數的個數，argv是具體要解析的參數列表。

• optstring參數

optstring為選項聲明串，其中一個字符代表一個選項，如果字符后面跟上一個英文冒號表明這個選項必須有一個選項參數，這個選項參數可以和選項在同一個命令行參數中，即“-oarg”，也可以在下一個命令行參數中，即“-o arg”，這個選項參數的值可以從全局變量optarg中獲取到；如果字符后面跟上兩個冒號表明這個選項有一個可選的選項參數，此時可選的選項參數要和選項在同一個命令行參數中，比如我們設置o為有可選的選項參數的選項，這時要設置可選的選項參數，可選的選項參數必須和選項在同一個參數中，即“-oarg”，其中arg為o選項的可選的選項參數，它們之間不能有空格，同樣的這個可選的選項參數可以在全局變量optarg中獲取，沒有設置可選的選項參數時，optarg的值為0。

• longopts參數

optstring中包含的只有短選項，當要支持長選項的時候就需要使用longopts參數了，longopts參數是一個指向struct option數組的指針，在struct option數組中設置了長選項的相關信息。長選項在設置選項參數時和短選項有稍微的不同，短選項為“-oarg”或者“-o arg”，而長選項為“--arg=param”或者“--arg param”，短選項設置可選參數時只能使用“-oarg”的形式，長選項設置可選參數時只能使用“--arg=param”的形式。下面我們看一下struct option中各個字段的含義。

struct option 
{
    const char *name; 
    int         has_arg; 
    int        *flag;
    int         val;
};

name字段：表示長選項的名稱。

has_arg字段：表示長選項參數設置，如果設置成no_argument（或者0）表示長選項沒有參數，如果設置成required_argument（或者1）表示長選項必須有一個參數，如果設置成optional_argument（或者3）表示長選項有一個可選項參數，長選項的可選參數必須使用“--arg=param”來設置。

flag字段：通常為NULL，如果flag為NULL，則當解析到name設置的長選項時getopt_long返回最后一個val字段設置的值，通過這個方式可以使短選項和長選項具備相同的功能；如果flag不為NULL，則當解析到name設置的長選項時getopt_long返回0，flag指向的變量的值將被設置成val設置的值，長選項沒解析到，則flag指向的變量的值不會被改變。

val字段：作為匹配到長選項時getopt_long的返回值（flag為NULL），或者作為設置flag指向的變量的值（flag不為NULL）。

• longindex參數

可以設置為NULL，不為NULL時用于返回匹配的長選項在長選項數組中的索引值。

3.2.2 多客戶端并發

我們使用fork的方式來模擬多客戶端并發的場景，子進程和父進程通過pipe函數創建的匿名管道來進行通信，父進程對測試結果進行匯總統計，在所有子進程結束后在父進程中打印測試的匯總結果。

3.2.3 基于連接還是基于請求

我們的測試工具支持基于連接（創建網絡連接成功后就馬上關閉網絡連接）的并發壓測；也支持基于請求（創建網絡連接成功后還會發起業務請求，并在接收完應答數據后才關閉網絡連接）的并發壓測，可以針對不同的業務設置不同請求數據和應答數據不同的校驗邏輯。

3.2.4 性能工具的局限性

我們的性能工具只能運行在單服務器上，故并發壓測能力受限于單服務器的并發能力，如果是測試外網服務還受限于服務器的外網帶寬，外網帶寬一旦跑滿并發數就難再有所提高。

3.3 數據交互過程

性能測試工具和網絡服務系統的數據交互過程如下圖：

圖3-1 數據交互

3.4 類關系圖

benchMark主要由5個類和1個結構體構成。其中結構體BenchMarkInfo用于保存測試相關的輸入參數；BenchMarkFactory是一個簡單的工廠類，它用于生成具體的壓測類BenchMarkConn（基于連接）和BenchMarkHttp（基于http協議），BenchMarkBase是壓測基類；RobustIo類是對網絡io的封裝，它自帶讀緩沖區。這5個類和1個結構體的關系如下類關系圖：

圖3-2 類關系圖

3.5 http的請求與應答

在BenchMarkHttp類中涉及到了http協議，在BenchMarkHttp中我們壓測的是獲取web站點根目錄接口的性能，發起的是GET請求，url為“/”。http應答解析方面我們使用開源的C語言的http解析api，它沒有其他特別庫的依賴，支持流式的解析，在流式解析過程中采用回調的方式來通知http協議相關的字段信息。在第9章“網絡通信與并發”中我們將自己實現一個簡單的http協議解析類，并對http協議做詳細的講解，加深大家對http協議的理解。

3.5.1 發起http請求

http請求報文由三部分組成，它們分別為：請求行（request_line）、請求頭集合（headers）、請求體（body）；請求行和請求頭都是以“\r\n”為結尾，請求頭集合則以一個 空行（“\r\n”）作為請求頭集合結束的標志，其中body為可選部分，我們http壓測使用的GET請求就沒有body部分。接下來看一下具體的請求數據生成函數。

void BenchMarkHttp::getRequestData(string & data, BenchMarkInfo & info)
{
    //http GET請求
    data = "GET / HTTP/1.1\r\n"           //請求行，表示發起GET請求，url為"/"，使用http 1.1協議
        "User-Agent: benchMark v1.0\r\n"  //User-Agent請求頭，表示當前客戶端代理信息
        "Host: " + info.host +"\r\n"      //Host請求頭，表示請求的服務器域名
        "Accept: */*\r\n"                 //Accept請求頭，表示接受任意格式的應答數據
        "\r\n";                           //一個空行表示請求頭集合的結束
}

3.5.3 解析http應答

我們使用的C語言的http解析api托管在github上，項目鏈接為：https://github.com/nodejs/http-parser 。

主要分為以下幾個步驟來使用開源的http解析api，下面是我們在BenchMarkHttp使用http解析api的相關代碼：

static int http_rsp_complete(http_parser * parser)
{
    //取出之前在解析變量中設置的私有數據，它為bool指針，
    //它指向dealHttpReq函數中的finish變量
    bool * pFinish = (bool *)parser->data;
    //設置finish的值為true，表示已經完成了一個http應答的解析。
    *pFinish = true;
    return 0;
}

bool BenchMarkHttp::dealHttpReq(int sock, BenchMarkInfo & info, int33_t & bytes)
{
    size_t ret = 0;
    string data;
    RobustIo rio;   //封裝的io類變量
    bool finish = false;    //表示應答是否解析完畢，它的指針會被傳遞給http解析變量

    http_parser parser;             //聲明http解析api的解析變量parser
    http_parser_settings settings;  //聲明http解析api的解析設置變量settings
    
    http_parser_init(&parser, HTTP_RESPONSE);   //初始化http解析api的解析變量parser
    http_parser_settings_init(&settings);       //初始化http解析api的解析設置變量settings
    
    settings.on_message_complete = http_rsp_complete; //設置http應答解析完成回調函數
    parser.data = (void *)(&finish);   //在解析變量parser中設置我們的私有數據，在回調函數中會使用

    getRequestData(data, info); //獲取http GET請求的發送數據
    //使用封裝好的網絡io類發送http GET請求
    ret = rio.rioWrite(sock, (void *)data.c_str(), data.size());
    //發送失敗則返回false
    if (ret != data.size())
    {
        return false;
    }
    //統計發送字節數
    bytes += data.size();

    char c;
    int status;
    //初始化io讀緩存區大小
    rio.rioInit(1034);
    //只要還沒解析完應答則一直從網絡中獲取數據，并解析
    while (!finish)
    {
        //從網絡中讀取一個字節，rioRead是自帶緩沖區的
        //故不會頻繁的調用系統read函數，帶來性能影響
        if (rio.rioRead(sock, &c, 1) != 1)
        {
            break;
        }
        //統計接收字節數
        ++bytes; 
        //調用http解析核心api對流式數據進行解析，每次解析從網絡流中獲取的一個字節
        //這個api函數返回解析成功的字節數，如果返回值和傳入的要解析的字節數不一致
        //則表明解析過程中發送錯誤，則返回false
        if (http_parser_execute(&parser, &settings, &c, 1) != 1)
        {
            return false;
        }
    }

    //獲取http應答的狀態碼
    status = parser.status_code;
    if (3 == (status / 100)) //狀態碼為3xx的都表示請求成功，故返回true?
    {
        return true;
    }
    else
    {
        return false;
    }
}

從上面代碼我們可以看到http解析api使用的變量為：parser和settings，它們的類型分別為http_parser和http_parser_settings，在使用它們之前我們需要分別使用http_parser_init和http_parser_settings_init進行初始化，在settings中設置了解析完畢的回調函數http_rsp_complete，在http_rsp_complete函數中我們將dealHttpReq中的finish變量的值設置為true表明http應答已經解析完畢，dealHttpReq就能退出http解析循環。在dealHttpReq函數中我們使用http_parser_execute這個http解析核心api來進行流式解析。

3.6 完整代碼

3.6.1 benchMark.cpp

#include <getopt.h>
#include <stdlib.h>
#include <iostream>
#include "benchMarkBase.h"
#include "benchMarkCommon.h"
#include "benchMarkFactory.h"

using namespace std;

void printVersion()
{
    cout << "benchMark version: 1.0 , auth: rookie" << endl;
}

/*
    輸出benchMark的使用方法
 */
void benchMarkUsage()
{
    cout << "Usage: -h host -p port [option]" << endl;
    cout << endl;
    //常規選項
    cout << "general options:" << endl;
    cout << "   --help          print usage" << endl;
    cout << "   -v,--version    print version info" << endl;
    cout << endl;
    //連接選項
    cout << "connection options:" << endl;
    cout << "   -h,--host       server host to connect to" << endl;
    cout << "   -p,--port       server port" << endl;
    cout << endl;
    //并發選項
    cout << "concurrent options:" << endl;
    cout << "   -c,--clients    number of concurrent clients, default 4, max is 100" << endl;
    cout << endl;
    //交互選項
    cout << "interaction options:" << endl;
    cout << "   -r,--request    request type, support http(2) and connection(1), default conection" << endl;
    cout << "   -t,--times      benchMark test time, unit seconds, default 60 sec" << endl;
    cout << endl;
}

int dealArgv(int argc, char * argv[], BenchMarkInfo & info)
{
    int opt = 0;
    //短選項
    const char shortOpts[] = "?vh:p:c:r:t:";
    //長選項
    const struct option longOpts[] = 
    {
        {"help", no_argument, NULL, '?'},
        {"version", no_argument, NULL, 'v'},
        {"host", required_argument, NULL, 'h'},
        {"port", required_argument, NULL, 'p'},
        {"clients", required_argument, NULL, 'c'},
        {"request", required_argument, NULL, 'r'},
        {"times", required_argument, NULL, 't'},
        {NULL, 0, NULL, 0}  //長選項數組必須以一個空的設置為結束元素
    };

    //一直解析參數直到參數解析完畢
    while ((opt = getopt_long(argc, argv, shortOpts, longOpts, NULL)) != -1)
    {
        switch (opt)
        {
            case 'v':
                printVersion();
                exit(0);
                break;
            case 'h':
                info.host = optarg;
                break;
            case 'p':
                info.port = atoi(optarg);
                break;
            case 'c':
                info.clients = atoi(optarg);
                break;
            case 'r':
                info.requestType = atoi(optarg);
                break;
            case 't':
                info.times = atoi(optarg);
                break;
            case ':':
            case '?':
                benchMarkUsage();
                return -1;
                break;
        }
    }
    
    return 0;
}

void benchMarkInfoInit(BenchMarkInfo & info)
{
    info.host = "";
    info.port = -1;
    info.clients = 4;          //默認并發4個客戶端
    info.requestType = CONN;   //默認是基于連接的壓測
    info.times = 60;           //默認壓測60秒
}

string getRequestTypeStr(int32_t requestType)
{
    if (CONN == requestType)
    {
        return string("CONN");
    }
    else
    {
        return string("HTTP");
    }
}

int checkArgv(BenchMarkInfo & info)
{
    if ("" == info.host)
    {
        cout << "host is empty" << endl;
        return -1;
    }

    if (info.port <= 0)
    {
        cout << "port parameter is invalid" << endl;
        return -1;
    }

    if (info.clients <= 0)
    {
        cout << "number of clients is invalid" << endl;
        return -1;
    }

    if (info.clients > 100)
    {
        cout << "max number of clients is 100" << endl;
        return -1;
    }

    if (info.requestType != CONN && info.requestType != HTTP)
    {
        cout << "requestType only support 1(connection) and 2(http)" << endl;
        return -1;
    }

    if (info.times <= 0)
    {
        cout << "times is invalid" << endl;
        return -1;
    }

    cout << "benchMark running. "<< endl;
    cout << "\thost[" << info.host << "], port[" << info.port 
         << "], clients[" << info.clients << "], time["
         << info.times << "], requestType[" 
         << getRequestTypeStr(info.requestType) << "]" << endl << endl;
    
    return 0;   
}

int main(int argc, char * argv[])
{
    int ret = 0;
    BenchMarkInfo info;
    benchMarkInfoInit(info);    //初始化性能測試信息
    
    ret = dealArgv(argc, argv, info); //解析輸入參數
    if (ret != 0)
    {
        return -1;
    }

    ret = checkArgv(info);  //校驗參數值是否合法
    if (ret != 0)
    {
        benchMarkUsage();
        return -1;
    }

    //使用BenchMark工廠類生成具體的BenchMark類
    BenchMarkBase * pBase = BenchMarkFactory::getBenchMark(info.requestType);
    //運行run進行壓測
    pBase->run(info);
    //釋放空間
    delete pBase;
    
    return 0;
}

3.6.2 BenchMarkBase類

• benchMarkBase.h

//表示頭文件只被編譯一次，相對于使用#ifndef ... #define ... #endif更方便
#pragma once

#include "benchMarkCommon.h"

class BenchMarkBase
{
public:
    void run(BenchMarkInfo & info);
protected:
    virtual void childDeal(int writeFd, BenchMarkInfo & info) = 0;
    void parentDeal(int readFd, BenchMarkInfo & info);
private:
    //nothing.
};

• benchMarkBase.cpp

#include "robustIo.h"
#include "benchMarkBase.h"
#include <errno.h>
#include <string.h>
#include <iostream>

using namespace std;

void BenchMarkBase::parentDeal(int readFd, BenchMarkInfo & info)
{
    RobustIo rio; //封裝的io類變量
    rio.rioInit(1024); //初始化讀緩沖區
    int32_t childReportData[3]; //子進程的報告數據為3個int32_t變量
    int32_t success = 0;
    int32_t failed = 0;
    int32_t bytes = 0;

    while (true)
    {
        //讀取一個子進程的報告
        if (rio.rioRead(readFd, childReportData, 12) != 12)
        {
            break; //讀失敗或者報告全部讀完
        }
        //統計成功次數，成功次數放在第一個int32_t
        success += childReportData[0];
        //統計失敗次數，失敗次數放在第二個int32_t
        failed += childReportData[1];
        //統計上下行流量，上下行流量放在第三個int32_t
        bytes += childReportData[2];
    }

    //輸出壓測報告
    cout << "benchMark report:" << endl;
    if (CONN == info.requestType)
    {
        cout << "\tspeed=" << (success + failed) / info.times << " conn/sec. " 
             << "success=" << success <<", failed=" << failed << endl;
    }
    else
    {
        cout << "\tspeed=" << (success + failed) / info.times << " pages/sec, "
             << (bytes / (info.times * 1024)) << " kbytes/sec. "
             << "success=" << success <<", failed=" << failed << endl;
    }
}

/*
    核心壓測函數
 */
void BenchMarkBase::run(BenchMarkInfo & info)
{
    int fd[2];
    int ret = 0;
    int sockfd = 0;
    pid_t childPid = 0;
    RobustIo rio;

    //先校驗在指定的host和port上是否開放了服務。
    //創建tcp連接失敗說明沒開放服務，直接返回終止壓測
    sockfd = rio.newSocket((char *)info.host.c_str(), info.port);
    if (sockfd < 0)
    {
        cout << "connect " << info.host << ":" << info.port
             << " failed. abort benchMark" << endl;
        return;
    }
    close(sockfd);

    ret = pipe(fd); //創建匿名管道用于父子進程間通信
    if (ret != 0)
    {
        cout << "call pipe() failed! error message = " << strerror(errno) << endl;
        return;
    }

    //調用fork創建指定的子進程數
    for (int32_t i = 0; i < info.clients; ++i)
    {
        childPid = fork();
        if (childPid <= 0) //從子進程中返回，或者父進程調用fork失敗
        {
            break;
        }
    }

    if (0 == childPid) //從子進程中返回
    {
        close(fd[0]); //關閉匿名管道讀端
        childDeal(fd[1], info); //在子進程中進行壓測，并傳入匿名管道寫fd
        return; //壓測完子進程返回，并在返回main函數后結束進程運行
    }

    //在父進程中返回(調用fork失敗，或者調用fork全部成功)
    
    if (childPid < 0) //調用fork失敗的話，打印一下調用失敗原因
    {
        cout << "fork childs failed. error message = " << strerror(errno) << endl;
    }

    //父進程關閉匿名管道的寫端，這里必須關閉寫端，
    //否則在父進程接收子進程的壓測報告數據時，無法讀到文件結束標志，
    //阻塞在read調用,導致父進程無法退出。
    close(fd[1]); 
    //在父進程中接收子進程報告，匯總統計后輸出最后的壓測報告
    parentDeal(fd[0], info);
}

3.6.3 BenchMarkConn類

• benchMarkConn.h

#pragma once

#include "benchMarkBase.h"

class BenchMarkConn : public BenchMarkBase
{
public:
    //nothing.
protected:
    void childDeal(int writeFd, BenchMarkInfo & info);
public:
    //nothing.
};

• benchMarkConn.cpp

#include "robustIo.h"
#include "benchMarkConn.h"
#include <errno.h>
#include <string.h>


void BenchMarkConn::childDeal(int writeFd, BenchMarkInfo & info)
{
    RobustIo rio;
    //子進程壓測報告數據，第一個int32_t是成功次數，
    //第二個int32_t是失敗次數，第三個int32_t是上下行流量統計
    int32_t statData[3];
    int32_t beginTime = time(NULL);
    memset(statData, 0x0, sizeof(statData)); //初始化統計數據為0

    while (time(NULL) <= beginTime + info.times)
    {
        int sock = rio.newSocket((char *)info.host.c_str(), info.port);
        if (sock < 0)
        {
            if (errno != EINTR)
            {
                ++statData[1]; //連接失敗數統計在statData[1]
            }
        }
        else
        {
            ++statData[0]; //連接成功數統計在statData[0]
        }
        close(sock);
    }

    //向匿名管道寫入壓測報告數據
    rio.rioWrite(writeFd, statData, sizeof(statData));
}

3.6.4 BenchMarkHttp類

• benchMarkHttp.h

#pragma once

#include "benchMarkBase.h"

class BenchMarkHttp : public BenchMarkBase
{
public:
    //nothing.
protected:
    bool dealHttpReq(int sock, BenchMarkInfo & info, int32_t & bytes);
    void getRequestData(string & data, BenchMarkInfo & info);
    void childDeal(int writeFd, BenchMarkInfo & info);
private:
    //nothing.
};

• benchMarkHttp.cpp

#include "robustIo.h"
#include "http_parser.h"
#include "benchMarkHttp.h"
#include <iostream>

using namespace std;

void BenchMarkHttp::getRequestData(string & data, BenchMarkInfo & info)
{
    //http GET請求
    data = "GET / HTTP/1.1\r\n"           //請求行，表示發起GET請求，url為"/"，使用http 1.1協議
        "User-Agent: benchMark v1.0\r\n"  //User-Agent請求頭，表示當前客戶端代理信息
        "Host: " + info.host +"\r\n"      //Host請求頭，表示請求的服務器域名
        "Accept: */*\r\n"                 //Accept請求頭，表示接受任意格式的應答數據
        "\r\n";                           //一個空行表示請求頭集合的結束
}

static int http_rsp_complete(http_parser * parser)
{
    //取出之前在解析變量中設置的私有數據，它為bool指針，
    //它指向dealHttpReq函數中的finish變量
    bool * pFinish = (bool *)parser->data;
    //設置finish的值為true，表示已經完成了一個http應答的解析。
    *pFinish = true;
    return 0;
}

bool BenchMarkHttp::dealHttpReq(int sock, BenchMarkInfo & info, int32_t & bytes)
{
    size_t ret = 0;
    string data;
    RobustIo rio;   //封裝的io類變量
    bool finish = false;    //表示應答是否解析完畢，它的指針會被傳遞給http解析變量

    http_parser parser;             //聲明http解析api的解析變量parser
    http_parser_settings settings;  //聲明http解析api的解析設置變量settings
    
    http_parser_init(&parser, HTTP_RESPONSE);   //初始化http解析api的解析變量parser
    http_parser_settings_init(&settings);       //初始化http解析api的解析設置變量settings
    
    settings.on_message_complete = http_rsp_complete; //設置http應答解析完成回調函數
    parser.data = (void *)(&finish);   //在解析變量parser中設置我們的私有數據，在回調函數中會使用

    getRequestData(data, info); //獲取http GET請求的發送數據
    //使用封裝好的網絡io類發送http GET請求
    ret = rio.rioWrite(sock, (void *)data.c_str(), data.size());
    //發送失敗則返回false
    if (ret != data.size())
    {
        return false;
    }
    //統計發送字節數
    bytes += data.size();

    char c;
    int status;
    //初始化io讀緩存區大小
    rio.rioInit(1024);
    //只要還沒解析完應答則一直從網絡中獲取數據，并解析
    while (!finish)
    {
        //從網絡中讀取一個字節，rioRead是自帶緩沖區的
        //故不會頻繁的調用系統read函數，帶來性能影響
        if (rio.rioRead(sock, &c, 1) != 1)
        {
            break;
        }
        //統計接收字節數
        ++bytes; 
        //調用http解析核心api對流式數據進行解析，每次解析從網絡流中獲取的一個字節
        //這個api函數返回解析成功的字節數，如果返回值和傳入的要解析的字節數不一致
        //則表明解析過程中發送錯誤，則返回false
        if (http_parser_execute(&parser, &settings, &c, 1) != 1)
        {
            return false;
        }
    }

    //獲取http應答的狀態碼
    status = parser.status_code;
    if (2 == (status / 100)) //狀態碼為2xx的都表示請求成功，故返回true?
    {
        return true;
    }
    else
    {
        return false;
    }
}

void BenchMarkHttp::childDeal(int writeFd, BenchMarkInfo & info)
{
    int sock = 0;
    RobustIo rio;
    //子進程壓測報告數據，第一個int32_t是成功次數，
    //第二個int32_t是失敗次數，第三個int32_t是上下行流量統計
    int32_t statData[3];
    int32_t beginTime = time(NULL);
    memset(statData, 0x0, sizeof(statData)); //初始化統計數據為0
    

    while (time(NULL) <= beginTime + info.times)
    {
        sock = rio.newSocket((char *)info.host.c_str(), info.port);
        if (sock < 0)
        {
            ++statData[1]; //發起連接失敗統計在statData[1]
        }
        else
        {
            //發起http請求，并統計上下行流量
            if (dealHttpReq(sock, info, statData[2]))
            {
                ++statData[0]; //http請求成功統計在statData[0]
            }
            else
            {
                ++statData[1]; //http請求失敗統計在statData[1]
            }
        }
        close(sock);
    }

    //向匿名管道寫入壓測報告數據
    rio.rioWrite(writeFd, statData, sizeof(statData));
}

3.6.5 BenchMarkFactory類

• benchMarkFactory.h

#pragma once

#include <stdint.h>
#include "benchMarkBase.h"
#include "benchMarkConn.h"
#include "benchMarkHttp.h"
#include "benchMarkCommon.h"

class BenchMarkFactory
{
public:
    static BenchMarkBase * getBenchMark(int32_t requestType);
protected:
    //nothing.
private:
    //nothing.
};

• benchMarkFactory.cpp

#include "benchMarkFactory.h"

BenchMarkBase * BenchMarkFactory::getBenchMark(int32_t requestType)
{
    if (CONN == requestType)
    {
        return new BenchMarkConn;
    }
    else if (HTTP == requestType)
    {
        return new BenchMarkHttp;
    }

    return NULL;
}

3.6.6 BenchMarkInfo結構體

• benchMarkCommon.h

#pragma once        

#include <stdint.h>
#include <string>

using namespace std;

enum RequestType
{
    CONN = 1,       //基于連接
    HTTP = 2        //基于http
};

struct BenchMarkInfo
{
    string host;
    int32_t port;
    int32_t clients;
    int32_t requestType;
    int32_t times;
};

3.7 實測性能工具

3.7.1 編譯

[root@rookie_centos benchMark]# ls
Makefile       benchMark.o        benchMarkBase.o    benchMarkConn.h       benchMarkFactory.h  benchMarkHttp.h  http_parser.h  robustIo.h
benchMark      benchMarkBase.cpp  benchMarkCommon.h  benchMarkConn.o       benchMarkFactory.o  benchMarkHttp.o  http_parser.o  robustIo.o
benchMark.cpp  benchMarkBase.h    benchMarkConn.cpp  benchMarkFactory.cpp  benchMarkHttp.cpp   http_parser.c    robustIo.cpp
[root@rookie_centos benchMark]# 
[root@rookie_centos benchMark]# make
cc  -g -O2 -Wall -Werror -Wshadow    -c http_parser.c -o http_parser.o
g++ -g -O2 -Wall -Werror -Wshadow  -c benchMark.cpp -o benchMark.o
g++ -g -O2 -Wall -Werror -Wshadow  -c benchMarkBase.cpp -o benchMarkBase.o
g++ -g -O2 -Wall -Werror -Wshadow  -c benchMarkConn.cpp -o benchMarkConn.o
g++ -g -O2 -Wall -Werror -Wshadow  -c benchMarkFactory.cpp -o benchMarkFactory.o
g++ -g -O2 -Wall -Werror -Wshadow  -c benchMarkHttp.cpp -o benchMarkHttp.o
g++ -g -O2 -Wall -Werror -Wshadow  -c robustIo.cpp -o robustIo.o
g++ -g -O2 -Wall -Werror -Wshadow   ./http_parser.o ./benchMark.o ./benchMarkBase.o ./benchMarkConn.o ./benchMarkFactory.o ./benchMarkHttp.o ./robustIo.o -o benchMark
Type ./benchMark to execute the program.

3.7.2 運行測試

我們對百度主頁進行壓測

• 基于連接的壓測

[root@rookie_centos benchMark]# ./benchMark -h www.baidu.com -p 30 -c 30 -t 10     
benchMark running. 
    host[www.baidu.com], port[30], clients[30], time[10], requestType[CONN]

benchMark report:
    speed=453 conn/sec. success=4536, failed=0
[root@rookie_centos benchMark]# 

• 基于http的壓測

[root@rookie_centos benchMark]# ./benchMark -h www.baidu.com -p 30 -c 30 -t 10 -r 2
benchMark running. 
    host[www.baidu.com], port[30], clients[30], time[10], requestType[HTTP]

benchMark report:
    speed=104 pages/sec, 11327 kbytes/sec. success=1042, failed=0
[root@rookie_centos benchMark]#

3.8 性能工具擴展

除了對http接口進行壓測外，我們還可以擴展出其他的業務壓測類，只要編寫好相應的壓測類，并放入項目中即可。