static void runSingleTask()

in ptest/src/Program.cc [422:543]
107 lines of code
15 McCabe index (conditional complexity)

static void runSingleTask(int taskId)
{
    taskResult result;
    TaskResultVector &resultVec = totalResults[taskId];
    std::string key = get_task_key(taskId);
    std::string fileName = get_task_fileName(taskId);
    std::stringstream ss;
    auto startTime = std::chrono::system_clock::now();

    int64_t taskMinTransferDurationMs = 0x7FFFFFFF;
    int64_t taskMaxTransferDurationMs = -1;
    int64_t taskAvgTrasnferDurationMs = -1;
    int64_t taskTransferSize = 0;
    int64_t taskTransferDurationMs = 0;
    int taskSucessCnt = 0;
    int taskFailCnt   = 0;

    ClientConfiguration conf;
    auto rateLimiter = std::make_shared<DefaultRateLimiter>();
    if (Config::SpeedKBPerSec > 0) {
        rateLimiter->setRate(Config::SpeedKBPerSec);
        conf.sendRateLimiter = rateLimiter;
        conf.recvRateLimiter = rateLimiter;
    }

    OssClient client(Config::Endpoint, Config::AccessKeyId, Config::AccessKeySecret, conf);

    if (Config::LoopTimes == 0)
    {
        Config::Persistent = true;
    }

    ss.str();
    ss << "\n++++ START " << Config::Command << 
        " : taskID=" << taskId << 
        ", LocalFile=" << fileName <<
        ", RemoteKey=" << key <<
        ", StartTime=" << to_datetime_string(startTime) << std::endl;
    log_msg(std::cout, ss.str());

    int runIndex = 1;
    //while ((runIndex <= Config::LoopTimes) || Config::Persistent)
    while (!is_test_done(runIndex, startTime))
    {
        if (Config::Command == "upload") {
            result = upload(client, key, fileName);
        }
        else if (Config::Command == "upload_resumable") {
            result = upload_resumable(client, key, fileName);
        }
        else if (Config::Command == "upload_async") {
            result = upload_async(client, key, fileName);
        }
        else if (Config::Command == "upload_multipart") {
            result = upload_multipart(client, key, fileName);
        }
        else if (Config::Command == "download") {
            result = download(client, key, fileName);
        }
        else if (Config::Command == "download_resumable") {
            result = download_resumable(client, key, fileName);
        }
        else if (Config::Command == "download_async") {
            result = download_async(client, key, fileName);
        } 
        else {
            std::cout << "The Command Type Error " << Config::Command << std::endl;
            Config::PrintHelp();
            break;
        }

        if (result.success) {
            int64_t trasnferDuration = (std::chrono::duration_cast<std::chrono::milliseconds>(result.stopTimePoint - result.startTimePoint)).count();
            taskTransferSize += result.transferSize;
            taskTransferDurationMs += trasnferDuration;
            taskSucessCnt += 1;

            taskMinTransferDurationMs = std::min(trasnferDuration, taskMinTransferDurationMs);
            taskMaxTransferDurationMs = std::max(trasnferDuration, taskMaxTransferDurationMs);
        }
        else {
            taskFailCnt += 1;
        }

        if (Config::DumpDetail || Config::PrintPercentile) {
            result.taskId = taskId;
            result.seqNum = runIndex;
            resultVec.push_back(result);
        }
        runIndex++;
    }

    if (taskSucessCnt > 0) {
        taskAvgTrasnferDurationMs = taskTransferDurationMs / taskSucessCnt;
    }

    double taskTransferRateMBPerS = ((double)taskTransferSize / 1024.0f / 1024.0f) / ((double)taskTransferDurationMs / 1000.0f);

    ss.str("");
    ss << "\n---- STOP  " << Config::Command <<
        " : taskID=" << taskId <<
        ", LocalFile=" << fileName <<
        ", RemoteKey=" << key <<
        ", StopTime=" << to_datetime_string(result.stopTimePoint) << " " <<
        ", runTimes=" << runIndex <<
        ", OK=" << taskSucessCnt << 
        ", NG=" << taskFailCnt << std::setiosflags(std::ios::fixed) << std::setprecision(2) <<
        ", AvgTransferRate="<< taskTransferRateMBPerS << " MB / S" <<
        ", Latency(min,max,avg)=(" << taskMinTransferDurationMs << "," << taskMaxTransferDurationMs << "," << taskAvgTrasnferDurationMs << ") Ms"<< std::endl;
    log_msg(std::cout, ss.str());

    {
    std::unique_lock<std::mutex> lck(updateMtx);
    totalTransferSize += taskTransferSize;
    totalTransferDurationMS += taskTransferDurationMs;
    totalSucessCnt += taskSucessCnt;
    totalFailCnt += taskFailCnt;
    minTransferDurationMS = std::min(minTransferDurationMS, taskMinTransferDurationMs);
    maxTransferDurationMS = std::max(maxTransferDurationMS, taskMaxTransferDurationMs);
    }

}