diff options
Diffstat (limited to 'fbench/src/util/clientstatus.h')
| -rw-r--r-- | fbench/src/util/clientstatus.h | 217 |
1 files changed, 217 insertions, 0 deletions
diff --git a/fbench/src/util/clientstatus.h b/fbench/src/util/clientstatus.h new file mode 100644 index 00000000000..5248f2618c5 --- /dev/null +++ b/fbench/src/util/clientstatus.h @@ -0,0 +1,217 @@ +// Copyright 2016 Yahoo Inc. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. +#pragma once + +#include <map> +#include <vector> + +/** + * This is a helper struct that is used by the @ref Client class to + * aggregate runtime statistics. It is also used to record warnings + * and errors. + **/ +struct ClientStatus +{ + /** + * Indicates wether a fatal error has occurred. + **/ + bool _error; + + /** + * Message explaining the error indicated by _error. + **/ + std::string _errorMsg; + + /** + * The number of requests that has been skipped. + **/ + long _skipCnt; + + /** + * The number of requests that have failed. + **/ + long _failCnt; + + /** + * The number of requests that had response time greater than the + * cycle time. + **/ + long _overtimeCnt; + + /** + * Total response time for all requests. + **/ + double _totalTime; + + /** + * Real time passed. This is used to calculate the actual query + * rate. + **/ + double _realTime; + + /** + * Total number of (successful) requests. Overtime requests are + * counted with, but not failed or skipped ones. + **/ + long _requestCnt; + + /** + * Resolution of timetable. A resolution of 1 means each entry in + * the timetable is 1 millisecond. A resolution of 10 means each + * entry is 1/10th of a millisecond. + **/ + const int _timetableResolution; + + /** + * Table where _timetable[i] is the number of requests with response + * time in milliseconds (i is multiplied with the resolution). + **/ + std::vector<int> _timetable; + + /** + * Number of requests with response time greater than or equal + * _timetableSize divided by _timetableResolution milliseconds. + **/ + long _higherCnt; + + /** + * The minimum response time measured. + **/ + double _minTime; + + /** + * The maximum response time measured. + **/ + double _maxTime; + + /** + * Connection reuse count. Tells us how many requests were made + * without having to open a new connection. If keep-alive is not + * enabled, this will always be 0. + **/ + uint64_t _reuseCnt; + + /** + * The number of zero hit queries + **/ + long _zeroHitQueries; + + /** + * The request status distribution. Key=Status, Value=Count. + **/ + std::map<uint32_t, uint32_t> _requestStatusDistribution; + + ClientStatus(); + ~ClientStatus(); + + /** + * Notify that an error occurred and set an error message describing + * the error. The client should only call this method once right + * before exiting due to a fatal error. + * + * @param errorMsg A string explaining the error. + **/ + void SetError(const char* errorMsg); + + /** + * Notify that a request was skipped. Long requests (measured in + * bytes) will be skipped due to intenal buffer limitations. This + * should happen very rarely. + **/ + void SkippedRequest() { _skipCnt++; } + + /** + * Notify that a request failed. This should be called when the + * client could not establish a connection to the server or a read + * error occurred while fetching the response. + **/ + void RequestFailed() { _failCnt++; } + + /** + * Notify that the cycle time could not be held. This typically + * indicates that either the server response time is longer than the + * cycle time or that your thread/socket libraries are unable to + * handle the number of clients currently running. + **/ + void OverTime() { _overtimeCnt++; } + + /** + * This method is used to register response times measured by the + * client. Response times should only be registered for successful + * requests. + * + * @param ms Response time measured in milliseconds. + **/ + void ResponseTime(double ms); + + /** + * Set real time passed while benchmarking. + * + * @param ms time passed while benchmarking (in milliseconds) + **/ + void SetRealTime(double ms) { _realTime = ms; } + + /** + * Set connection reuse count. + * + * @param cnt connection reuse count + **/ + void SetReuseCount(uint64_t cnt) { _reuseCnt = cnt; } + + /** + * Add request status to request status distribution. + * + * @param status The status to insert + **/ + void AddRequestStatus(uint32_t status); + + /** + * Merge the info held by 'status' into the info held by this + * struct. Note that the error flag and error messages are ignored. If + * you do not want to use data held by a status struct with an error + * you should check the error flag before merging. + * + * @param status The ClientStatus that should be merged into this one. + **/ + void Merge(const ClientStatus & status); + + /** + * @return the minimum response time. + **/ + double GetMin(); + + /** + * @return the maximum response time. + **/ + double GetMax(); + + /** + * @return the average response time. + **/ + double GetAverage(); + + /** + * @return The 50 percent percentile (aka median). + **/ + double GetMedian() { return GetPercentile(50); } + + /** + * This method calculates a response time that separates the 'percent' + * percent fastest requests from the (100 - 'percent') percent slowest + * requests. A single request may be classified by comparing the + * request response time with the percentile returned by this + * method. If the requested percentile lies outside the time table + * measuring interval, -1 is returned. This indicates that the + * requested percentile was greater than _timetableSize (divided by + * resolution) milliseconds. + * + * @return the calculated percentile or -1 if it was outside the time table. + * @param percent percent of requests that should have response time lower + * than the percentile to be calculated by this method. Legal values + * of this parameter is in the range [0,100]. + **/ + double GetPercentile(double percent); + +private: + ClientStatus(const ClientStatus &); + ClientStatus &operator=(const ClientStatus &); +}; |