diff options
Diffstat (limited to 'tests/sdcard/stopwatch.h')
| -rw-r--r-- | tests/sdcard/stopwatch.h | 155 |
1 files changed, 155 insertions, 0 deletions
diff --git a/tests/sdcard/stopwatch.h b/tests/sdcard/stopwatch.h new file mode 100644 index 00000000..4d1a7949 --- /dev/null +++ b/tests/sdcard/stopwatch.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2009 The Android Open Source Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef ANDROID_NATIVETEST_SYSTEM_EXTRAS_TESTS_SDCARD_STOPWATCH_H_ +#define ANDROID_NATIVETEST_SYSTEM_EXTRAS_TESTS_SDCARD_STOPWATCH_H_ + +#include <stdlib.h> +#include <stdio.h> +#include <time.h> + +namespace android_test { + +// StopWatch class to collect execution statistics. +// +// Once the watch has been created, start and stop can be called to +// capture an event duration. +// +// On completion, use 'sprint' to retrieve the data. +// +// If StopWatch::setPrintRawMode(true) has been called, the raw +// samples also are printed. +// The print method is thread safe to avoid mixing the result of +// watches on different threads. For processes, use different files +// that you concat after the run. +// +// If the time measure is associated with some volume of data, use +// setMbytes, the print method will compute the average throughput +// based on that value. +// +// To capture the time accurately and since the runs are not too long, +// we collect the raw start and stop time in an array that get +// processed once all the measurements have been done. +// +// Typical Usage: +// ============== +// +// StopWatch watch("my name", 20); +// +// for (int i = 0; i < 20; ++i) { +// watch.start(); +// doMyStuff(); +// watch.stop(); +// } +// char buffer[4096]; +// char *str = buffer; +// size_t size = sizeof(buffer); +// watch.sprint(&str, &size); +// + +class StopWatch { + public: + // Time of the snapshot and its nature (start of the interval or end of it). + struct Measurement { + struct timespec mTime; + bool mIsStart; + }; + static const size_t kUseDefaultCapacity = 20; + + // Create a stop watch. Default capacity == 2 * interval_nb + // @param name To be used when the results are displayed. No + // spaces, use _ instead. + // @param capacity Hint about the number of sampless that will be + // measured (1 sample == 1 start + 1 stop). Used + // to size the internal storage, when the capacity + // is reached, it is doubled. + StopWatch(const char *name, size_t capacity = kUseDefaultCapacity); + ~StopWatch(); + + // A StopWatch instance measures time intervals. Use setDataSize + // if some volume of data is processed during these intervals, to + // get the average throughput (in kbytes/s) printed. + void setDataSize(size_t size_in_bytes) { mSizeKbytes = size_in_bytes / 1000; } + + // Starts and stops the timer. The time between the 2 calls is an + // interval whose duration will be reported in sprint. + void start(); + void stop(); + + // Print a summary of the measurement and optionaly the raw data. + // The summary is commented out using a leading '#'. The raw data + // is a pair (time, duration). The 1st sample is always at time + // '0.0'. + // @param str[inout] On entry points to the begining of a buffer + // where to write the data. On exit points pass the last byte + // written. + // @param size[inout] On entry points to the size of the buffer + // pointed by *str. On exit *size is the amount of free space left + // in the buffer. If there was not enough space the data is truncated + // and a warning is printed. + void sprint(char **str, size_t *size); + + // @return true if at least one interval was timed. + bool used() const { return mUsed; } + + // Affects all the timers. Instructs all the timers to print the + // raw data as well as the summary. + static void setPrintRawMode(bool printRaw); + + private: + void checkCapacity(); + double timespecToDouble(const struct timespec& time); + void printAverageMinMax(char **str, size_t *size); + void printThroughput(char **str, size_t *size); + // Allocate mDeltas and fill it in. Search for the min and max. + void processSamples(); + + char *const mName; // Name of the test. + struct timespec mStart; + size_t mNum; // # of intervals == # of start() calls. + struct Measurement *mData; + size_t mDataLen; + size_t mCapacity; + int mSizeKbytes; + + bool mAlreadyPrinted; + bool mPrintRaw; + + double mDuration; + double mMinDuration; + size_t mMinIdx; + double mMaxDuration; + size_t mMaxIdx; + double *mDeltas; + + bool mUsed; +}; + +} // namespace android_test + +#endif // ANDROID_NATIVETEST_SYSTEM_EXTRAS_TESTS_SDCARD_STOPWATCH_H_ |