pax_global_header00006660000000000000000000000064144226256730014525gustar00rootroot0000000000000052 comment=8dcce8f68512fca460b171bccc3a5afce0048779 HdrHistogram_c-0.11.8/000077500000000000000000000000001442262567300145115ustar00rootroot00000000000000HdrHistogram_c-0.11.8/.github/000077500000000000000000000000001442262567300160515ustar00rootroot00000000000000HdrHistogram_c-0.11.8/.github/workflows/000077500000000000000000000000001442262567300201065ustar00rootroot00000000000000HdrHistogram_c-0.11.8/.github/workflows/ci.yml000066400000000000000000000047301442262567300212300ustar00rootroot00000000000000name: CI on: [push, pull_request] jobs: build: runs-on: ${{ matrix.runner }} strategy: matrix: os: [linux, windows, macos] build_type: [Debug, RelWithDebInfo] arch: [x86, x64] cmake: [minimal, latest] hdr_log_required: [ON, DISABLED] exclude: - os: linux arch: x86 - os: windows cmake: minimal - os: windows hdr_log_required: DISABLED - os: macos arch: x86 - os: macos cmake: minimal - os: macos hdr_log_required: DISABLED include: - cmake: minimal cmake_url_part: v3.12/cmake-3.12.4 - cmake: latest cmake_url_part: v3.17/cmake-3.17.3 - os: linux runner: ubuntu-latest - os: windows runner: windows-latest - os: windows arch: x86 cmake_args: -A Win32 -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake - os: windows arch: x64 cmake_args: -A x64 -DCMAKE_TOOLCHAIN_FILE=C:/vcpkg/scripts/buildsystems/vcpkg.cmake - os: macos runner: macos-latest env: VCPKG_DEFAULT_TRIPLET: ${{ matrix.arch }}-${{ matrix.os }} VCPKG_TARGET_ARCHITECTURE: ${{ matrix.arch }} VCPKG_LIBRARY_LINKAGE: static steps: - name: Checkout uses: actions/checkout@v1 with: submodules: recursive - name: Install dependencies (linux) if: matrix.os == 'linux' run: | sudo apt-get install -y zlib1g-dev wget --no-check-certificate https://cmake.org/files/${{ matrix.cmake_url_part }}-Linux-x86_64.tar.gz -O /tmp/cmake.tar.gz sudo tar xf /tmp/cmake.tar.gz -C /usr/local --strip-components 1 - name: Install dependencies (windows) if: matrix.os == 'windows' run: vcpkg install zlib - name: CMake version run: | cmake --version ctest --version cpack --version - name: Configure run: cmake -E make_directory _build && cmake -E chdir _build cmake .. -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DHDR_LOG_REQUIRED=${{ matrix.hdr_log_required }} ${{ matrix.cmake_args }} - name: Build run: cmake --build _build --config ${{ matrix.build_type }} - name: Test run: cmake -E chdir _build ctest --build-config ${{ matrix.build_type }} --output-in-failure HdrHistogram_c-0.11.8/.gitignore000066400000000000000000000016141442262567300165030ustar00rootroot00000000000000target .idea out gh-pages HdrHistogram.iml .classpath .project .settings release.properties install_manifest.txt /bin alltests format_example *.a *.iml .sconsign.dblite *.o *.os .DS_Store build CMakeCache.txt CMakeFiles/ CPackConfig.cmake CPackSourceConfig.cmake CTestTestfile.cmake Makefile Testing/ cmake_install.cmake examples/CMakeFiles/ examples/CTestTestfile.cmake examples/Makefile examples/cmake_install.cmake examples/hdr_decoder examples/hiccup src/CMakeFiles/ src/CTestTestfile.cmake src/Makefile src/cmake_install.cmake src/libhdr_histogram.so src/libhdr_histogram.so.* test/CMakeFiles/ test/CTestTestfile.cmake test/Makefile test/cmake_install.cmake test/hdr_atomic_test test/hdr_dbl_histogram_test test/hdr_histogram_atomic_concurrency_test test/hdr_histogram_atomic_test test/hdr_histogram_log_test test/hdr_histogram_test test/perftest .gdb_history debug cmake-build-debug /build-afl .vscode HdrHistogram_c-0.11.8/.gitmodules000066400000000000000000000001771442262567300166730ustar00rootroot00000000000000[submodule "test/vendor/google/benchmark"] path = test/vendor/google/benchmark url = https://github.com/google/benchmark.git HdrHistogram_c-0.11.8/CMakeLists.txt000066400000000000000000000072601442262567300172560ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.12) if(POLICY CMP0135) cmake_policy(SET CMP0135 NEW) set(CMAKE_POLICY_DEFAULT_CMP0135 NEW) endif() file(STRINGS "include/hdr/hdr_histogram_version.h" HDR_VERSION_HEADER) string(REGEX MATCH ".*#define HDR_HISTOGRAM_VERSION \"(.*)\".*" HDR_BLACK_HOLE ${HDR_VERSION_HEADER}) project(hdr_histogram VERSION ${CMAKE_MATCH_1} LANGUAGES C DESCRIPTION "C port of the HdrHistogram" HOMEPAGE_URL "http://hdrhistogram.github.io/HdrHistogram/") set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake") include(GNUInstallDirs) include(CMakePackageConfigHelpers) # Follow all steps below in order to calculate new ABI version when updating the library # NOTE: THIS IS UNRELATED to the actual project version # # 1. If the library source code has changed at all since the last update, then increment revision # 2. If any interfaces have been added, removed, or changed since the last update, increment current and set revision to 0. # 3. If any interfaces have been added since the last public release, then increment age. # 4. If any interfaces have been removed since the last public release, then set age to 0. set(HDR_SOVERSION_CURRENT 6) set(HDR_SOVERSION_AGE 1) set(HDR_SOVERSION_REVISION 3) set(HDR_VERSION ${HDR_SOVERSION_CURRENT}.${HDR_SOVERSION_AGE}.${HDR_SOVERSION_REVISION}) set(HDR_SOVERSION ${HDR_SOVERSION_CURRENT}) option(HDR_LOG_REQUIRED "HDR Logging component required" ON) set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED ON) set(CMAKE_C_EXTENSIONS OFF) set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) if(UNIX) add_compile_options( -Wall -Wno-unknown-pragmas -Wextra -Wshadow -Winit-self -Wpedantic $<$:-Wmissing-prototypes>) add_definitions(-D_GNU_SOURCE) endif() find_package(ZLIB) find_package(Threads REQUIRED) if (HDR_LOG_REQUIRED STREQUAL "DISABLED") set(HDR_LOG_ENABLED "FALSE") else() set(HDR_LOG_ENABLED ${ZLIB_FOUND}) if (${HDR_LOG_REQUIRED} AND NOT HDR_LOG_ENABLED) message(SEND_ERROR "HDR_LOG_REQUIRED=ON and unable to find zlib library") endif() endif() add_subdirectory(include) add_subdirectory(src) option(HDR_HISTOGRAM_BUILD_PROGRAMS "Build tests and examples" ON) if(HDR_HISTOGRAM_BUILD_PROGRAMS) include(CTest) if(BUILD_TESTING) add_subdirectory(test) endif() add_subdirectory(examples) endif() write_basic_package_version_file( ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake VERSION ${PROJECT_VERSION} COMPATIBILITY AnyNewerVersion) configure_file( config.cmake.in ${PROJECT_NAME}-config.cmake @ONLY) if(HDR_HISTOGRAM_INSTALL_SHARED OR HDR_HISTOGRAM_INSTALL_STATIC) install( EXPORT ${PROJECT_NAME}-targets DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME} NAMESPACE ${PROJECT_NAME}::) endif() install( FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config-version.cmake DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}) set(CPACK_GENERATOR "TGZ") include(CPack) include(JoinPaths) join_paths(includedir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") join_paths(libdir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_LIBDIR}") if(${ZLIB_FOUND}) set(PC_REQUIRES_PRIVATE_ZLIB "zlib") else() set(PC_REQUIRES_PRIVATE_ZLIB "") endif() configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_NAME}.pc.in ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc @ONLY ) install( FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig ) HdrHistogram_c-0.11.8/COPYING.txt000066400000000000000000000156101442262567300163650ustar00rootroot00000000000000Creative Commons Legal Code CC0 1.0 Universal CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED HEREUNDER. Statement of Purpose The laws of most jurisdictions throughout the world automatically confer exclusive Copyright and Related Rights (defined below) upon the creator and subsequent owner(s) (each and all, an "owner") of an original work of authorship and/or a database (each, a "Work"). Certain owners wish to permanently relinquish those rights to a Work for the purpose of contributing to a commons of creative, cultural and scientific works ("Commons") that the public can reliably and without fear of later claims of infringement build upon, modify, incorporate in other works, reuse and redistribute as freely as possible in any form whatsoever and for any purposes, including without limitation commercial purposes. These owners may contribute to the Commons to promote the ideal of a free culture and the further production of creative, cultural and scientific works, or to gain reputation or greater distribution for their Work in part through the use and efforts of others. For these and/or other purposes and motivations, and without any expectation of additional consideration or compensation, the person associating CC0 with a Work (the "Affirmer"), to the extent that he or she is an owner of Copyright and Related Rights in the Work, voluntarily elects to apply CC0 to the Work and publicly distribute the Work under its terms, with knowledge of his or her Copyright and Related Rights in the Work and the meaning and intended legal effect of CC0 on those rights. 1. Copyright and Related Rights. A Work made available under CC0 may be protected by copyright and related or neighboring rights ("Copyright and Related Rights"). Copyright and Related Rights include, but are not limited to, the following: i. the right to reproduce, adapt, distribute, perform, display, communicate, and translate a Work; ii. moral rights retained by the original author(s) and/or performer(s); iii. publicity and privacy rights pertaining to a person's image or likeness depicted in a Work; iv. rights protecting against unfair competition in regards to a Work, subject to the limitations in paragraph 4(a), below; v. rights protecting the extraction, dissemination, use and reuse of data in a Work; vi. database rights (such as those arising under Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, and under any national implementation thereof, including any amended or successor version of such directive); and vii. other similar, equivalent or corresponding rights throughout the world based on applicable law or treaty, and any national implementations thereof. 2. Waiver. To the greatest extent permitted by, but not in contravention of, applicable law, Affirmer hereby overtly, fully, permanently, irrevocably and unconditionally waives, abandons, and surrenders all of Affirmer's Copyright and Related Rights and associated claims and causes of action, whether now known or unknown (including existing as well as future claims and causes of action), in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each member of the public at large and to the detriment of Affirmer's heirs and successors, fully intending that such Waiver shall not be subject to revocation, rescission, cancellation, termination, or any other legal or equitable action to disrupt the quiet enjoyment of the Work by the public as contemplated by Affirmer's express Statement of Purpose. 3. Public License Fallback. Should any part of the Waiver for any reason be judged legally invalid or ineffective under applicable law, then the Waiver shall be preserved to the maximum extent permitted taking into account Affirmer's express Statement of Purpose. In addition, to the extent the Waiver is so judged Affirmer hereby grants to each affected person a royalty-free, non transferable, non sublicensable, non exclusive, irrevocable and unconditional license to exercise Affirmer's Copyright and Related Rights in the Work (i) in all territories worldwide, (ii) for the maximum duration provided by applicable law or treaty (including future time extensions), (iii) in any current or future medium and for any number of copies, and (iv) for any purpose whatsoever, including without limitation commercial, advertising or promotional purposes (the "License"). The License shall be deemed effective as of the date CC0 was applied by Affirmer to the Work. Should any part of the License for any reason be judged legally invalid or ineffective under applicable law, such partial invalidity or ineffectiveness shall not invalidate the remainder of the License, and in such case Affirmer hereby affirms that he or she will not (i) exercise any of his or her remaining Copyright and Related Rights in the Work or (ii) assert any associated claims and causes of action with respect to the Work, in either case contrary to Affirmer's express Statement of Purpose. 4. Limitations and Disclaimers. a. No trademark or patent rights held by Affirmer are waived, abandoned, surrendered, licensed or otherwise affected by this document. b. Affirmer offers the Work as-is and makes no representations or warranties of any kind concerning the Work, express, implied, statutory or otherwise, including without limitation warranties of title, merchantability, fitness for a particular purpose, non infringement, or the absence of latent or other defects, accuracy, or the present or absence of errors, whether or not discoverable, all to the greatest extent permissible under applicable law. c. Affirmer disclaims responsibility for clearing rights of other persons that may apply to the Work or any use thereof, including without limitation any person's Copyright and Related Rights in the Work. Further, Affirmer disclaims responsibility for obtaining any necessary consents, permissions or other rights required for any use of the Work. d. Affirmer understands and acknowledges that Creative Commons is not a party to this document and has no duty or obligation with respect to this CC0 or use of the Work. HdrHistogram_c-0.11.8/LICENSE.txt000066400000000000000000000042401442262567300163340ustar00rootroot00000000000000The code in this repository code was Written by Gil Tene, Michael Barker, Matt Warren, and Philip Orwig, and released to the public domain, as explained at http://creativecommons.org/publicdomain/zero/1.0/ For users of this code who wish to consume it under the "BSD" license rather than under the public domain or CC0 contribution text mentioned above, the code found under this directory is *also* provided under the following license (commonly referred to as the BSD 2-Clause License). This license does not detract from the above stated release of the code into the public domain, and simply represents an additional license granted by the Author. ----------------------------------------------------------------------------- ** Beginning of "BSD 2-Clause License" text. ** Copyright (c) 2012, 2013, 2014 Gil Tene Copyright (c) 2014 Michael Barker Copyright (c) 2014 Matt Warren Copyright (c) 2015 Philip Orwig All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. 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 HOLDER 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. HdrHistogram_c-0.11.8/README.md000066400000000000000000000041151442262567300157710ustar00rootroot00000000000000HdrHistogram_c: 'C' port of High Dynamic Range (HDR) Histogram HdrHistogram ---------------------------------------------- [![Gitter chat](https://badges.gitter.im/HdrHistogram/HdrHistogram.png)](https://gitter.im/HdrHistogram/HdrHistogram) This port contains a subset of the functionality supported by the Java implementation. The current supported features are: * Standard histogram with 64 bit counts (32/16 bit counts not supported) * All iterator types (all values, recorded, percentiles, linear, logarithmic) * Histogram serialisation (encoding version 1.2, decoding 1.0-1.2) * Reader/writer phaser and interval recorder Features not supported, but planned * Auto-resizing of histograms Features unlikely to be implemented * Double histograms * Atomic/Concurrent histograms * 16/32 bit histograms # Simple Tutorial ## Recording values ```C #include struct hdr_histogram* histogram; // Initialise the histogram hdr_init( 1, // Minimum value INT64_C(3600000000), // Maximum value 3, // Number of significant figures &histogram) // Pointer to initialise // Record value hdr_record_value( histogram, // Histogram to record to value) // Value to record // Record value n times hdr_record_values( histogram, // Histogram to record to value, // Value to record 10) // Record value 10 times // Record value with correction for co-ordinated omission. hdr_record_corrected_value( histogram, // Histogram to record to value, // Value to record 1000) // Record with expected interval of 1000. // Print out the values of the histogram hdr_percentiles_print( histogram, stdout, // File to write to 5, // Granularity of printed values 1.0, // Multiplier for results CLASSIC); // Format CLASSIC/CSV supported. ``` ## More examples For more detailed examples of recording and logging results look at the [hdr_decoder](examples/hdr_decoder.c) and [hiccup](examples/hiccup.c) examples. You can run hiccup and decoder and pipe the results of one into the other. ``` $ ./examples/hiccup | ./examples/hdr_decoder ``` HdrHistogram_c-0.11.8/cmake/000077500000000000000000000000001442262567300155715ustar00rootroot00000000000000HdrHistogram_c-0.11.8/cmake/JoinPaths.cmake000066400000000000000000000014611442262567300204740ustar00rootroot00000000000000# This module provides function for joining paths # known from most languages # # SPDX-License-Identifier: (MIT OR CC0-1.0) # Copyright 2020 Jan Tojnar # https://github.com/jtojnar/cmake-snips # # Modelled after Python’s os.path.join # https://docs.python.org/3.7/library/os.path.html#os.path.join # Windows not supported function(join_paths joined_path first_path_segment) set(temp_path "${first_path_segment}") foreach(current_segment IN LISTS ARGN) if(NOT ("${current_segment}" STREQUAL "")) if(IS_ABSOLUTE "${current_segment}") set(temp_path "${current_segment}") else() set(temp_path "${temp_path}/${current_segment}") endif() endif() endforeach() set(${joined_path} "${temp_path}" PARENT_SCOPE) endfunction() HdrHistogram_c-0.11.8/config.cmake.in000066400000000000000000000002231442262567300173620ustar00rootroot00000000000000include(CMakeFindDependencyMacro) find_dependency(ZLIB) find_dependency(Threads) include(${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake) HdrHistogram_c-0.11.8/examples/000077500000000000000000000000001442262567300163275ustar00rootroot00000000000000HdrHistogram_c-0.11.8/examples/CMakeLists.txt000066400000000000000000000013731442262567300210730ustar00rootroot00000000000000if (HDR_LOG_ENABLED) add_executable(hdr_decoder hdr_decoder.c) target_link_libraries(hdr_decoder PRIVATE $<$:hdr_histogram_static> $<$>:hdr_histogram>) install( TARGETS hdr_decoder EXPORT ${PROJECT_NAME}-targets DESTINATION ${CMAKE_INSTALL_BINDIR}) if(CMAKE_SYSTEM_NAME MATCHES "Linux") find_package(Threads) add_executable(hiccup hiccup.c) target_link_libraries(hiccup PRIVATE hdr_histogram Threads::Threads) install( TARGETS hiccup EXPORT ${PROJECT_NAME}-targets DESTINATION ${CMAKE_INSTALL_BINDIR}) endif() endif()HdrHistogram_c-0.11.8/examples/hdr_decoder.c000066400000000000000000000030611442262567300207350ustar00rootroot00000000000000/** * hdr_decoder.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include #if defined(_MSC_VER) #pragma warning(push) #pragma warning(disable: 4996) #endif int main(int argc, char** argv) { int rc = 0; FILE* f; struct hdr_log_reader reader; struct hdr_histogram* h = NULL; hdr_timespec timestamp, interval; if (argc == 1) { f = stdin; } else { f = fopen(argv[1], "r"); } if (!f) { fprintf(stderr, "Failed to open file(%s):%s\n", argv[1], strerror(errno)); return -1; } if (hdr_log_reader_init(&reader)) { fprintf(stderr, "Failed to init reader\n"); return -1; } rc = hdr_log_read_header(&reader, f); if(rc) { fprintf(stderr, "Failed to read header: %s\n", hdr_strerror(rc)); return -1; } while (true) { rc = hdr_log_read(&reader, f, &h, ×tamp, &interval); if (0 == rc) { hdr_percentiles_print(h, stdout, 5, 1.0, CLASSIC); } else if (EOF == rc) { break; } else { fprintf(stderr, "Failed to print histogram: %s\n", hdr_strerror(rc)); return -1; } } return 0; } #if defined(_MSC_VER) #pragma warning(pop) #endif HdrHistogram_c-0.11.8/examples/hiccup.c000066400000000000000000000106661442262567300177570ustar00rootroot00000000000000/** * hiccup.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include static int64_t diff(struct timespec t0, struct timespec t1) { int64_t delta_us = 0; delta_us = (t1.tv_sec - t0.tv_sec) * 1000000; delta_us += (t1.tv_nsec - t0.tv_nsec) / 1000; return delta_us; } static void* record_hiccups(void* thread_context) { struct pollfd fd; struct timespec t0; struct timespec t1; struct itimerspec timeout; struct hdr_interval_recorder* r = thread_context; memset(&fd, 0, sizeof(struct pollfd)); memset(&timeout, 0, sizeof(struct itimerspec)); memset(&t0, 0, sizeof(struct timespec)); memset(&t1, 0, sizeof(struct timespec)); fd.fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC); fd.events = POLLIN|POLLPRI|POLLRDHUP; fd.revents = 0; #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wmissing-noreturn" while (true) { int64_t delta_us; timeout.it_value.tv_sec = 0; timeout.it_value.tv_nsec = 1000000; timerfd_settime(fd.fd, 0, &timeout, NULL); hdr_gettime(&t0); poll(&fd, 1, -1); hdr_gettime(&t1); delta_us = diff(t0, t1) - 1000; delta_us = delta_us < 0 ? 0 : delta_us; hdr_interval_recorder_record_value(r, delta_us); } #pragma clang diagnostic pop pthread_exit(NULL); } struct config_t { unsigned int interval; const char* filename; }; const char* USAGE = "hiccup [-i ] [-f ]\n" " interval: Time in seconds between samples (default 1).\n" " filename: Name of the file to log to (default stdout).\n"; static int handle_opts(int argc, char** argv, struct config_t* config) { int c; unsigned int interval = 1; while ((c = getopt(argc, argv, "i:f:")) != -1) { switch (c) { case 'h': return 0; case 'i': interval = (unsigned int) strtoul(optarg, NULL, 10); if (interval < 1) { return 0; } break; case 'f': config->filename = optarg; break; default: return 0; } } config->interval = interval; return 1; } int main(int argc, char** argv) { struct timespec timestamp; struct timespec start_timestamp; struct timespec end_timestamp; struct hdr_interval_recorder recorder; struct hdr_log_writer log_writer; struct config_t config; struct hdr_histogram* inactive = NULL; pthread_t recording_thread; FILE* output = stdout; memset(&config, 0, sizeof(struct config_t)); if (!handle_opts(argc, argv, &config)) { printf("%s", USAGE); return 0; } if (config.filename) { output = fopen(config.filename, "a+"); if (!output) { fprintf( stderr, "Failed to open/create file: %s, %s", config.filename, strerror(errno)); return -1; } } if (0 != hdr_interval_recorder_init_all(&recorder, 1, INT64_C(24) * 60 * 60 * 1000000, 3)) { fprintf(stderr, "%s\n", "Failed to init phaser"); return -1; } if (pthread_create(&recording_thread, NULL, record_hiccups, &recorder)) { fprintf(stderr, "%s\n", "Failed to create thread"); return -1; } hdr_gettime(&start_timestamp); hdr_getnow(×tamp); hdr_log_writer_init(&log_writer); hdr_log_write_header(&log_writer, output, "foobar", ×tamp); #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wmissing-noreturn" while (true) { sleep(config.interval); inactive = hdr_interval_recorder_sample_and_recycle(&recorder, inactive); hdr_gettime(&end_timestamp); timestamp = start_timestamp; hdr_gettime(&start_timestamp); hdr_log_write(&log_writer, output, ×tamp, &end_timestamp, inactive); fflush(output); } #pragma clang diagnostic pop pthread_exit(NULL); } HdrHistogram_c-0.11.8/hdr_histogram.pc.in000066400000000000000000000005561442262567300203020ustar00rootroot00000000000000prefix=@CMAKE_INSTALL_PREFIX@ libdir=@libdir_for_pc_file@ includedir=@includedir_for_pc_file@ Name: @PROJECT_NAME@ Description: @CMAKE_PROJECT_DESCRIPTION@ URL: @CMAKE_PROJECT_HOMEPAGE_URL@ Version: @PROJECT_VERSION@ Requires.private: @PC_REQUIRES_PRIVATE_ZLIB@ Cflags: -I${includedir} Libs: -L${libdir} -l@PROJECT_NAME@ Libs.private: -pthread -lm -lrt -L${libdir} HdrHistogram_c-0.11.8/ide/000077500000000000000000000000001442262567300152525ustar00rootroot00000000000000HdrHistogram_c-0.11.8/ide/codestyle.jar000066400000000000000000000042671442262567300177540ustar00rootroot00000000000000PK S)G codestyles/PKS)Gcodestyles/c_style.xmlVQo0~߯@7=J8Uc&q܆S-;,$D;ߝQRJZ[\[[lRm},'Xje7}6` ޗ0X0c" qzi mkly>p s$`'4p.F X@X#AKQL2?yдCc34!7Y1300cc W4 8 QLp-ΤaǂO 0O!_戒)-9I˥UE)dYRjJe)C-E^CX}|hxS~(+z=4 Cld6x4_thi5u5nyK|6Y*f&Yb|mVr+6unqiy7ug|4/NwcIiUy]&tQJ˥.oqn}Ndwuvͧ}[̂rqL، Ac?FFpmLTVSZ4?_pۨg0=ne8|oCnJv_Yvt,'8 0'eQPp_{B/(v/S̙'('(x<'Owƽ PKVB$W PKGcodestyles/Default _1_.xmlVQo0~߯@ #include #include struct hdr_histogram { int64_t lowest_discernible_value; int64_t highest_trackable_value; int32_t unit_magnitude; int32_t significant_figures; int32_t sub_bucket_half_count_magnitude; int32_t sub_bucket_half_count; int64_t sub_bucket_mask; int32_t sub_bucket_count; int32_t bucket_count; int64_t min_value; int64_t max_value; int32_t normalizing_index_offset; double conversion_ratio; int32_t counts_len; int64_t total_count; int64_t* counts; }; #ifdef __cplusplus extern "C" { #endif /** * Allocate the memory and initialise the hdr_histogram. * * Due to the size of the histogram being the result of some reasonably * involved math on the input parameters this function it is tricky to stack allocate. * The histogram should be released with hdr_close * * @param lowest_discernible_value The smallest possible value that is distinguishable from 0. * Must be a positive integer that is >= 1. May be internally rounded down to nearest power of 2. * @param highest_trackable_value The largest possible value to be put into the * histogram. * @param significant_figures The level of precision for this histogram, i.e. the number * of figures in a decimal number that will be maintained. E.g. a value of 3 will mean * the results from the histogram will be accurate up to the first three digits. Must * be a value between 1 and 5 (inclusive). * @param result Output parameter to capture allocated histogram. * @return 0 on success, EINVAL if lowest_discernible_value is < 1 or the * significant_figure value is outside of the allowed range, ENOMEM if malloc * failed. */ int hdr_init( int64_t lowest_discernible_value, int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result); /** * Free the memory and close the hdr_histogram. * * @param h The histogram you want to close. */ void hdr_close(struct hdr_histogram* h); /** * Allocate the memory and initialise the hdr_histogram. This is the equivalent of calling * hdr_init(1, highest_trackable_value, significant_figures, result); * * @deprecated use hdr_init. */ int hdr_alloc(int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result); /** * Reset a histogram to zero - empty out a histogram and re-initialise it * * If you want to re-use an existing histogram, but reset everything back to zero, this * is the routine to use. * * @param h The histogram you want to reset to empty. * */ void hdr_reset(struct hdr_histogram* h); /** * Get the memory size of the hdr_histogram. * * @param h "This" pointer * @return The amount of memory used by the hdr_histogram in bytes */ size_t hdr_get_memory_size(struct hdr_histogram* h); /** * Records a value in the histogram, will round this value of to a precision at or better * than the significant_figure specified at construction time. * * @param h "This" pointer * @param value Value to add to the histogram * @return false if the value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_value(struct hdr_histogram* h, int64_t value); /** * Records a value in the histogram, will round this value of to a precision at or better * than the significant_figure specified at construction time. * * Will record this value atomically, however the whole structure may appear inconsistent * when read concurrently with this update. Do NOT mix calls to this method with calls * to non-atomic updates. * * @param h "This" pointer * @param value Value to add to the histogram * @return false if the value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value); /** * Records count values in the histogram, will round this value of to a * precision at or better than the significant_figure specified at construction * time. * * @param h "This" pointer * @param value Value to add to the histogram * @param count Number of 'value's to add to the histogram * @return false if any value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count); /** * Records count values in the histogram, will round this value of to a * precision at or better than the significant_figure specified at construction * time. * * Will record this value atomically, however the whole structure may appear inconsistent * when read concurrently with this update. Do NOT mix calls to this method with calls * to non-atomic updates. * * @param h "This" pointer * @param value Value to add to the histogram * @param count Number of 'value's to add to the histogram * @return false if any value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count); /** * Record a value in the histogram and backfill based on an expected interval. * * Records a value in the histogram, will round this value of to a precision at or better * than the significant_figure specified at construction time. This is specifically used * for recording latency. If the value is larger than the expected_interval then the * latency recording system has experienced co-ordinated omission. This method fills in the * values that would have occurred had the client providing the load not been blocked. * @param h "This" pointer * @param value Value to add to the histogram * @param expected_interval The delay between recording values. * @return false if the value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expected_interval); /** * Record a value in the histogram and backfill based on an expected interval. * * Records a value in the histogram, will round this value of to a precision at or better * than the significant_figure specified at construction time. This is specifically used * for recording latency. If the value is larger than the expected_interval then the * latency recording system has experienced co-ordinated omission. This method fills in the * values that would have occurred had the client providing the load not been blocked. * * Will record this value atomically, however the whole structure may appear inconsistent * when read concurrently with this update. Do NOT mix calls to this method with calls * to non-atomic updates. * * @param h "This" pointer * @param value Value to add to the histogram * @param expected_interval The delay between recording values. * @return false if the value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expected_interval); /** * Record a value in the histogram 'count' times. Applies the same correcting logic * as 'hdr_record_corrected_value'. * * @param h "This" pointer * @param value Value to add to the histogram * @param count Number of 'value's to add to the histogram * @param expected_interval The delay between recording values. * @return false if the value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval); /** * Record a value in the histogram 'count' times. Applies the same correcting logic * as 'hdr_record_corrected_value'. * * Will record this value atomically, however the whole structure may appear inconsistent * when read concurrently with this update. Do NOT mix calls to this method with calls * to non-atomic updates. * * @param h "This" pointer * @param value Value to add to the histogram * @param count Number of 'value's to add to the histogram * @param expected_interval The delay between recording values. * @return false if the value is larger than the highest_trackable_value and can't be recorded, * true otherwise. */ bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval); /** * Adds all of the values from 'from' to 'this' histogram. Will return the * number of values that are dropped when copying. Values will be dropped * if they around outside of h.lowest_discernible_value and * h.highest_trackable_value. * * @param h "This" pointer * @param from Histogram to copy values from. * @return The number of values dropped when copying. */ int64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from); /** * Adds all of the values from 'from' to 'this' histogram. Will return the * number of values that are dropped when copying. Values will be dropped * if they around outside of h.lowest_discernible_value and * h.highest_trackable_value. * * @param h "This" pointer * @param from Histogram to copy values from. * @return The number of values dropped when copying. */ int64_t hdr_add_while_correcting_for_coordinated_omission( struct hdr_histogram* h, struct hdr_histogram* from, int64_t expected_interval); /** * Get minimum value from the histogram. Will return 2^63-1 if the histogram * is empty. * * @param h "This" pointer */ int64_t hdr_min(const struct hdr_histogram* h); /** * Get maximum value from the histogram. Will return 0 if the histogram * is empty. * * @param h "This" pointer */ int64_t hdr_max(const struct hdr_histogram* h); /** * Get the value at a specific percentile. * * @param h "This" pointer. * @param percentile The percentile to get the value for */ int64_t hdr_value_at_percentile(const struct hdr_histogram* h, double percentile); /** * Get the values at the given percentiles. * * @param h "This" pointer. * @param percentiles The ordered percentiles array to get the values for. * @param length Number of elements in the arrays. * @param values Destination array containing the values at the given percentiles. * The values array should be allocated by the caller. * @return 0 on success, ENOMEM if the provided destination array is null. */ int hdr_value_at_percentiles(const struct hdr_histogram *h, const double *percentiles, int64_t *values, size_t length); /** * Gets the standard deviation for the values in the histogram. * * @param h "This" pointer * @return The standard deviation */ double hdr_stddev(const struct hdr_histogram* h); /** * Gets the mean for the values in the histogram. * * @param h "This" pointer * @return The mean */ double hdr_mean(const struct hdr_histogram* h); /** * Determine if two values are equivalent with the histogram's resolution. * Where "equivalent" means that value samples recorded for any two * equivalent values are counted in a common total count. * * @param h "This" pointer * @param a first value to compare * @param b second value to compare * @return 'true' if values are equivalent with the histogram's resolution. */ bool hdr_values_are_equivalent(const struct hdr_histogram* h, int64_t a, int64_t b); /** * Get the lowest value that is equivalent to the given value within the histogram's resolution. * Where "equivalent" means that value samples recorded for any two * equivalent values are counted in a common total count. * * @param h "This" pointer * @param value The given value * @return The lowest value that is equivalent to the given value within the histogram's resolution. */ int64_t hdr_lowest_equivalent_value(const struct hdr_histogram* h, int64_t value); /** * Get the count of recorded values at a specific value * (to within the histogram resolution at the value level). * * @param h "This" pointer * @param value The value for which to provide the recorded count * @return The total count of values recorded in the histogram within the value range that is * {@literal >=} lowestEquivalentValue(value) and {@literal <=} highestEquivalentValue(value) */ int64_t hdr_count_at_value(const struct hdr_histogram* h, int64_t value); int64_t hdr_count_at_index(const struct hdr_histogram* h, int32_t index); int64_t hdr_value_at_index(const struct hdr_histogram* h, int32_t index); struct hdr_iter_percentiles { bool seen_last_value; int32_t ticks_per_half_distance; double percentile_to_iterate_to; double percentile; }; struct hdr_iter_recorded { int64_t count_added_in_this_iteration_step; }; struct hdr_iter_linear { int64_t value_units_per_bucket; int64_t count_added_in_this_iteration_step; int64_t next_value_reporting_level; int64_t next_value_reporting_level_lowest_equivalent; }; struct hdr_iter_log { double log_base; int64_t count_added_in_this_iteration_step; int64_t next_value_reporting_level; int64_t next_value_reporting_level_lowest_equivalent; }; /** * The basic iterator. This is a generic structure * that supports all of the types of iteration. Use * the appropriate initialiser to get the desired * iteration. * * @ */ struct hdr_iter { const struct hdr_histogram* h; /** raw index into the counts array */ int32_t counts_index; /** snapshot of the length at the time the iterator is created */ int64_t total_count; /** value directly from array for the current counts_index */ int64_t count; /** sum of all of the counts up to and including the count at this index */ int64_t cumulative_count; /** The current value based on counts_index */ int64_t value; int64_t highest_equivalent_value; int64_t lowest_equivalent_value; int64_t median_equivalent_value; int64_t value_iterated_from; int64_t value_iterated_to; union { struct hdr_iter_percentiles percentiles; struct hdr_iter_recorded recorded; struct hdr_iter_linear linear; struct hdr_iter_log log; } specifics; bool (* _next_fp)(struct hdr_iter* iter); }; /** * Initalises the basic iterator. * * @param itr 'This' pointer * @param h The histogram to iterate over */ void hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h); /** * Initialise the iterator for use with percentiles. */ void hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_histogram* h, int32_t ticks_per_half_distance); /** * Initialise the iterator for use with recorded values. */ void hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_histogram* h); /** * Initialise the iterator for use with linear values. */ void hdr_iter_linear_init( struct hdr_iter* iter, const struct hdr_histogram* h, int64_t value_units_per_bucket); /** * Initialise the iterator for use with logarithmic values */ void hdr_iter_log_init( struct hdr_iter* iter, const struct hdr_histogram* h, int64_t value_units_first_bucket, double log_base); /** * Iterate to the next value for the iterator. If there are no more values * available return faluse. * * @param itr 'This' pointer * @return 'false' if there are no values remaining for this iterator. */ bool hdr_iter_next(struct hdr_iter* iter); typedef enum { CLASSIC, CSV } format_type; /** * Print out a percentile based histogram to the supplied stream. Note that * this call will not flush the FILE, this is left up to the user. * * @param h 'This' pointer * @param stream The FILE to write the output to * @param ticks_per_half_distance The number of iteration steps per half-distance to 100% * @param value_scale Scale the output values by this amount * @param format_type Format to use, e.g. CSV. * @return 0 on success, error code on failure. EIO if an error occurs writing * the output. */ int hdr_percentiles_print( struct hdr_histogram* h, FILE* stream, int32_t ticks_per_half_distance, double value_scale, format_type format); /** * Internal allocation methods, used by hdr_dbl_histogram. */ struct hdr_histogram_bucket_config { int64_t lowest_discernible_value; int64_t highest_trackable_value; int64_t unit_magnitude; int64_t significant_figures; int32_t sub_bucket_half_count_magnitude; int32_t sub_bucket_half_count; int64_t sub_bucket_mask; int32_t sub_bucket_count; int32_t bucket_count; int32_t counts_len; }; int hdr_calculate_bucket_config( int64_t lowest_discernible_value, int64_t highest_trackable_value, int significant_figures, struct hdr_histogram_bucket_config* cfg); void hdr_init_preallocated(struct hdr_histogram* h, struct hdr_histogram_bucket_config* cfg); int64_t hdr_size_of_equivalent_value_range(const struct hdr_histogram* h, int64_t value); int64_t hdr_next_non_equivalent_value(const struct hdr_histogram* h, int64_t value); int64_t hdr_median_equivalent_value(const struct hdr_histogram* h, int64_t value); /** * Used to reset counters after importing data manually into the histogram, used by the logging code * and other custom serialisation tools. */ void hdr_reset_internal_counters(struct hdr_histogram* h); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/include/hdr/hdr_histogram_log.h000066400000000000000000000220661442262567300225630ustar00rootroot00000000000000/** * hdr_histogram_log.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ * * The implementation makes use of zlib to provide compression. You will need * to link against -lz in order to link applications that include this header. */ #ifndef HDR_HISTOGRAM_H_LOG #define HDR_HISTOGRAM_H_LOG 1 #define HDR_COMPRESSION_COOKIE_MISMATCH -29999 #define HDR_ENCODING_COOKIE_MISMATCH -29998 #define HDR_DEFLATE_INIT_FAIL -29997 #define HDR_DEFLATE_FAIL -29996 #define HDR_INFLATE_INIT_FAIL -29995 #define HDR_INFLATE_FAIL -29994 #define HDR_LOG_INVALID_VERSION -29993 #define HDR_TRAILING_ZEROS_INVALID -29992 #define HDR_VALUE_TRUNCATED -29991 #define HDR_ENCODED_INPUT_TOO_LONG -29990 #define HDR_LOG_TAG_MAX_BUFFER_LEN (1024) #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif /** * Encode and compress the histogram with gzip. */ int hdr_log_encode(struct hdr_histogram* histogram, char** encoded_histogram); /** * Decode and decompress the histogram with gzip. */ int hdr_log_decode(struct hdr_histogram** histogram, char* base64_histogram, size_t base64_len); struct hdr_log_entry { hdr_timespec start_timestamp; hdr_timespec interval; hdr_timespec max; char *tag; size_t tag_len; }; struct hdr_log_writer { uint32_t nonce; }; /** * Initialise the log writer. * * @param writer 'This' pointer * @return 0 on success. */ int hdr_log_writer_init(struct hdr_log_writer* writer); /** * Write the header to the log, this will constist of a user defined string, * the current timestamp, version information and the CSV header. * * @param writer 'This' pointer * @param file The stream to output the log header to. * @param user_prefix User defined string to include in the header. * @param timestamp The start time that the histogram started recording from. * @return Will return 0 if it successfully completed or an error number if there * was a failure. EIO if the write failed. */ int hdr_log_write_header( struct hdr_log_writer* writer, FILE* file, const char* user_prefix, hdr_timespec* timestamp); /** * Write an hdr_histogram entry to the log. It will be encoded in a similar * fashion to the approach used by the Java version of the HdrHistogram. It will * be a CSV line consisting of ,,, * where is the binary histogram gzip compressed and base64 encoded. * * Timestamp is a bit of misnomer for the start_timestamp and end_timestamp values * these could be offsets, e.g. start_timestamp could be offset from process start * time and end_timestamp could actually be the length of the recorded interval. * * @param writer 'This' pointer * @param file The stream to write the entry to. * @param start_timestamp The start timestamp to include in the logged entry. * @param end_timestamp The end timestamp to include in the logged entry. * @param histogram The histogram to encode and log. * @return Will return 0 if it successfully completed or an error number if there * was a failure. Errors include HDR_DEFLATE_INIT_FAIL, HDR_DEFLATE_FAIL if * something when wrong during gzip compression. ENOMEM if we failed to allocate * or reallocate the buffer used for encoding (out of memory problem). EIO if * write failed. */ int hdr_log_write( struct hdr_log_writer* writer, FILE* file, const hdr_timespec* start_timestamp, const hdr_timespec* end_timestamp, struct hdr_histogram* histogram); /** * Write an hdr_histogram entry to the log. It will be encoded in a similar * fashion to the approach used by the Java version of the HdrHistogram. It will * be a CSV line consisting of [Tag=XXX,],,, * where is the binary histogram gzip compressed and base64 encoded. * * The tag is option and will only be written if the tag is non-NULL and the tag_len is * greater than 0. * * Timestamp is a bit of misnomer for the start_timestamp and end_timestamp values * these could be offsets, e.g. start_timestamp could be offset from process start * time and end_timestamp could actually be the length of the recorded interval. * * @param writer 'This' pointer * @param file The stream to write the entry to. * @param entry Prefix information for the log line, including timestamps and tag. * @param histogram The histogram to encode and log. * @return Will return 0 if it successfully completed or an error number if there * was a failure. Errors include HDR_DEFLATE_INIT_FAIL, HDR_DEFLATE_FAIL if * something when wrong during gzip compression. ENOMEM if we failed to allocate * or reallocate the buffer used for encoding (out of memory problem). EIO if * write failed. */ int hdr_log_write_entry( struct hdr_log_writer* writer, FILE* file, struct hdr_log_entry* entry, struct hdr_histogram* histogram); struct hdr_log_reader { int major_version; int minor_version; hdr_timespec start_timestamp; }; /** * Initialise the log reader. * * @param reader 'This' pointer * @return 0 on success */ int hdr_log_reader_init(struct hdr_log_reader* reader); /** * Reads the the header information from the log. Will capure information * such as version number and start timestamp from the header. * * @param hdr_log_reader 'This' pointer * @param file The data stream to read from. * @return 0 on success. An error number on failure. */ int hdr_log_read_header(struct hdr_log_reader* reader, FILE* file); /** * Reads an entry from the log filling in the specified histogram, timestamp and * interval values. If the supplied pointer to the histogram for this method is * NULL then a new histogram will be allocated for the caller, however it will * become the callers responsibility to free it later. If the pointer is non-null * the histogram read from the log will be merged with the supplied histogram. * * @param reader 'This' pointer * @param file The stream to read the histogram from. * @param histogram Pointer to allocate a histogram to or merge into. * @param timestamp The first timestamp from the CSV entry. * @param interval The second timestamp from the CSV entry * @return Will return 0 on success or an error number if there was some wrong * when reading in the histogram. EOF (-1) will indicate that there are no more * histograms left to be read from 'file'. * HDR_INFLATE_INIT_FAIL or HDR_INFLATE_FAIL if * there was a problem with Gzip. HDR_COMPRESSION_COOKIE_MISMATCH or * HDR_ENCODING_COOKIE_MISMATCH if the cookie values are incorrect. * HDR_LOG_INVALID_VERSION if the log can not be parsed. ENOMEM if buffer space * or the histogram can not be allocated. EIO if there was an error during * the read. EINVAL in any input values are incorrect. */ int hdr_log_read( struct hdr_log_reader* reader, FILE* file, struct hdr_histogram** histogram, hdr_timespec* timestamp, hdr_timespec* interval); /** * Reads an entry from the log filling in the specified histogram and log entry struct. * If the supplied pointer to the histogram for this method is * NULL then a new histogram will be allocated for the caller, however it will * become the callers responsibility to free it later. If the pointer is non-null * the histogram read from the log will be merged with the supplied histogram. * The entry struct contains a pointer to a buffer to load the tag into. If this * is NULL or the tag_len is 0 then it won't store the tag there. The tag value will be * NULL-terminated if there available space in the supplied buffer. If the tag is larger * than the supplied buffer then it will be truncated. If the caller sets the last element * in the buffer to '\0' before calling this function and it is not '\0' after the function * returns then the value has been truncated. * * @param reader 'This' pointer * @param file The stream to read the histogram from. * @param entry Contains all of the information from the log line that is not the histogram. * @param histogram Pointer to allocate a histogram to or merge into. * @return Will return 0 on success or an error number if there was some wrong * when reading in the histogram. EOF (-1) will indicate that there are no more * histograms left to be read from 'file'. * HDR_INFLATE_INIT_FAIL or HDR_INFLATE_FAIL if * there was a problem with Gzip. HDR_COMPRESSION_COOKIE_MISMATCH or * HDR_ENCODING_COOKIE_MISMATCH if the cookie values are incorrect. * HDR_LOG_INVALID_VERSION if the log can not be parsed. ENOMEM if buffer space * or the histogram can not be allocated. EIO if there was an error during * the read. EINVAL in any input values are incorrect. */ int hdr_log_read_entry( struct hdr_log_reader* reader, FILE* file, struct hdr_log_entry *entry, struct hdr_histogram** histogram); /** * Returns a string representation of the error number. * * @param errnum The error response from a previous call. * @return The user readable representation of the error. */ const char* hdr_strerror(int errnum); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/include/hdr/hdr_histogram_version.h000066400000000000000000000005051442262567300234610ustar00rootroot00000000000000/** * hdr_histogram_version.h * Written by Marco Ippolito, Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_HISTOGRAM_VERSION_H #define HDR_HISTOGRAM_VERSION_H #define HDR_HISTOGRAM_VERSION "0.11.8" #endif // HDR_HISTOGRAM_VERSION_H HdrHistogram_c-0.11.8/include/hdr/hdr_interval_recorder.h000066400000000000000000000053271442262567300234370ustar00rootroot00000000000000/** * hdr_interval_recorder.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_INTERVAL_RECORDER_H #define HDR_INTERVAL_RECORDER_H 1 #include #include HDR_ALIGN_PREFIX(8) struct hdr_interval_recorder { struct hdr_histogram* active; struct hdr_histogram* inactive; struct hdr_writer_reader_phaser phaser; } HDR_ALIGN_SUFFIX(8); #ifdef __cplusplus extern "C" { #endif int hdr_interval_recorder_init(struct hdr_interval_recorder* r); int hdr_interval_recorder_init_all( struct hdr_interval_recorder* r, int64_t lowest_trackable_value, int64_t highest_trackable_value, int significant_figures); void hdr_interval_recorder_destroy(struct hdr_interval_recorder* r); int64_t hdr_interval_recorder_record_value( struct hdr_interval_recorder* r, int64_t value ); int64_t hdr_interval_recorder_record_values( struct hdr_interval_recorder* r, int64_t value, int64_t count ); int64_t hdr_interval_recorder_record_corrected_value( struct hdr_interval_recorder* r, int64_t value, int64_t expected_interval ); int64_t hdr_interval_recorder_record_corrected_values( struct hdr_interval_recorder* r, int64_t value, int64_t count, int64_t expected_interval ); int64_t hdr_interval_recorder_record_value_atomic( struct hdr_interval_recorder* r, int64_t value ); int64_t hdr_interval_recorder_record_values_atomic( struct hdr_interval_recorder* r, int64_t value, int64_t count ); int64_t hdr_interval_recorder_record_corrected_value_atomic( struct hdr_interval_recorder* r, int64_t value, int64_t expected_interval ); int64_t hdr_interval_recorder_record_corrected_values_atomic( struct hdr_interval_recorder* r, int64_t value, int64_t count, int64_t expected_interval ); /** * This is generally the preferred approach for recycling histograms through * the recorder as it is safe when used from callers in multiple threads and * the returned histogram won't automatically become active without being * passed back into this method. * * @param r 'this' recorder * @param histogram_to_recycle * @return the histogram that was previous being recorded to. */ struct hdr_histogram* hdr_interval_recorder_sample_and_recycle( struct hdr_interval_recorder* r, struct hdr_histogram* histogram_to_recycle); /** * @deprecated Prefer hdr_interval_recorder_sample_and_recycle * @param r 'this' recorder * @return the histogram that was previous being recorded to. */ struct hdr_histogram* hdr_interval_recorder_sample(struct hdr_interval_recorder* r); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/include/hdr/hdr_thread.h000066400000000000000000000021051442262567300211640ustar00rootroot00000000000000/** * hdr_thread.h * Written by Philip Orwig and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_THREAD_H__ #define HDR_THREAD_H__ #include #if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) #define HDR_ALIGN_PREFIX(alignment) __declspec( align(alignment) ) #define HDR_ALIGN_SUFFIX(alignment) typedef struct hdr_mutex { uint8_t _critical_section[40]; } hdr_mutex; #else #include #define HDR_ALIGN_PREFIX(alignment) #define HDR_ALIGN_SUFFIX(alignment) __attribute__((aligned(alignment))) typedef struct hdr_mutex { pthread_mutex_t _mutex; } hdr_mutex; #endif #ifdef __cplusplus extern "C" { #endif struct hdr_mutex* hdr_mutex_alloc(void); void hdr_mutex_free(struct hdr_mutex*); int hdr_mutex_init(struct hdr_mutex* mutex); void hdr_mutex_destroy(struct hdr_mutex* mutex); void hdr_mutex_lock(struct hdr_mutex* mutex); void hdr_mutex_unlock(struct hdr_mutex* mutex); void hdr_yield(void); int hdr_usleep(unsigned int useconds); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/include/hdr/hdr_time.h000066400000000000000000000014311442262567300206540ustar00rootroot00000000000000/** * hdr_time.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_TIME_H__ #define HDR_TIME_H__ #include #if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) typedef struct hdr_timespec { long tv_sec; long tv_nsec; } hdr_timespec; #else typedef struct timespec hdr_timespec; #endif #ifdef __cplusplus extern "C" { #endif #if defined(_MSC_VER) void hdr_gettime(hdr_timespec* t); #else void hdr_gettime(hdr_timespec* t); #endif void hdr_getnow(hdr_timespec* t); double hdr_timespec_as_double(const hdr_timespec* t); /* Assumes only millisecond accuracy. */ void hdr_timespec_from_double(hdr_timespec* t, double value); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/include/hdr/hdr_writer_reader_phaser.h000066400000000000000000000022511442262567300241170ustar00rootroot00000000000000/** * hdr_writer_reader_phaser.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_WRITER_READER_PHASER_H #define HDR_WRITER_READER_PHASER_H 1 #include #include #include #include #include "hdr_thread.h" HDR_ALIGN_PREFIX(8) struct hdr_writer_reader_phaser { int64_t start_epoch; int64_t even_end_epoch; int64_t odd_end_epoch; hdr_mutex* reader_mutex; } HDR_ALIGN_SUFFIX(8); #ifdef __cplusplus extern "C" { #endif int hdr_writer_reader_phaser_init(struct hdr_writer_reader_phaser* p); void hdr_writer_reader_phaser_destroy(struct hdr_writer_reader_phaser* p); int64_t hdr_phaser_writer_enter(struct hdr_writer_reader_phaser* p); void hdr_phaser_writer_exit( struct hdr_writer_reader_phaser* p, int64_t critical_value_at_enter); void hdr_phaser_reader_lock(struct hdr_writer_reader_phaser* p); void hdr_phaser_reader_unlock(struct hdr_writer_reader_phaser* p); void hdr_phaser_flip_phase( struct hdr_writer_reader_phaser* p, int64_t sleep_time_ns); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/lib/000077500000000000000000000000001442262567300152575ustar00rootroot00000000000000HdrHistogram_c-0.11.8/lib/benchmark-1.6.1.zip000066400000000000000000007576261442262567300204250ustar00rootroot00000000000000PK Y*T benchmark-1.6.1/UTaPK Y*T#= DJ benchmark-1.6.1/.clang-formatUTaIK/MLOR.{~~zN*W@~f^IjcNfz^nj^OjZ PK Y*TA. benchmark-1.6.1/.clang-tidyUTa 0yބފZ<絝`)Oo CDfsCsEXzbaP* nj$-K|v^T.̅U ;Ujkں=#VWaʚӱ 0[19w 9@ŔyPK Y*T benchmark-1.6.1/.github/UTaPK Y*Tg( benchmark-1.6.1/.github/.libcxx-setup.shUTaR[o0~8KvSEКU<B&6rQ[v`[FDQڡKi>>>߹~oF6&| 8%B$02):#m NrRyR`l 6cZܑL `RDD50kKD #ndx*[P%*Q+;./d3703ㆲdu)ρrR~W6cÌ 5`A*LlIn;0t^fMGKt?{8OGzam;K¾ x!fjbOc]9!5%Y$rlIO,X}9!?ur3Sb4lqmӫ":P, `}^zgeDP>v7ڠH6W^d3@ MPK Y*T' benchmark-1.6.1/.github/ISSUE_TEMPLATE/UTaPK Y*T`,Mk}4 benchmark-1.6.1/.github/ISSUE_TEMPLATE/bug_report.mdUTan1 E{}Ņ õ;=$u4seᜤR{ Se)0qX %T_j8׆J|N恋?0fcn1e:Q=+mTU{n퍪͉uaRqH7@\ܔ'SjKm[9%x'$lQѵ`ZŸǡEZfe$i=2چ|ַ9-s˔jQgh*xGC`lQ .@>6@Wyݎo)y*6R(9DZէ@PK Y*T71W9 benchmark-1.6.1/.github/ISSUE_TEMPLATE/feature_request.mdUTaN0 y kJMIqvpw dIu{{&8)o'M(GZšPH}"md /B@B"`^%V\j_B9lJ!=xH5II\: ٭<;B&0]-V+R2&C;{b<$te Og f0qbErNk 5y 8F`F/yǑS@'==QJuHoB/97 _dMc 45aI|HPK Y*T" benchmark-1.6.1/.github/workflows/UTaPK Y*TrVj+ benchmark-1.6.1/.github/workflows/bazel.ymlUTaN K} tG[KS>119((@}-`T׈>dxʧ1in,$gĀ ile=z 5jZe/7,A%)]=9ၟy 2y'3[ٞքzVp*yΔ9Z܍c:o\&TAǭ wDJqT_t'sT:/,BS՝taqMHRRJvxp>1հ݋zM8葽] keuz7΋!zpzN]MEQc+ R[P xjE81T\h1bJ62eS!h"t-`0~D aΫj5JQeYKVxlVB;#i5+Ģ#HJͽ׶Oyk+;@~nn g (X^V*| M3I`$YU*J"kd3NV K+t8}07sLGͧ@sIԍGO7 >MEYXPK Y*T#]4 benchmark-1.6.1/.github/workflows/build-and-test.ymlUTaW[o6~8h EB'K -AR;H0-6TyIfd%EYͭ;~xFy4Q$b8;j)F)=7' ޛM>!f0pm2C%Da2:ʌoZX\')`VrCņ̝CDxVgWW0ZҿButGz 2"qJ oTi5}X1 +3EcoP*?(W3JnLUmߥƩ&C4/\' ՏD Ԍ~Bm?n ZAVeChki۷zД<-uiixN[0*՜ZHZYŰ v*(x~p)1֗XJ)QJf0LߺԽShFϓ4A>ZOm[v {rjD~-G\> PK Y*Tuj0 benchmark-1.6.1/.github/workflows/clang-tidy.ymlUTaIo0sr = HQ-tbX,qO-ѶjR0 :SOC||Q3*N>x^+|3j/9'4LhWA ziPrR*Y T[~ Gk<֔+6@SgQL@+ݴBV[VZ>}JSa2u `:ux%;2 FbτtapԍdnG&?jNubp:ݒ^mӊu1yej;tPc>e~x|>+ s8`>#8 ,q&.L>iXLw8̒U_;BVKkofwB4*?ILJ!B خp`|OӅ1(/[vsHu\0Zg),q7:RYa0^Qx4?H6Y/yV&'O<4[D,ӓ/'b*@jPK Y*TN , benchmark-1.6.1/.github/workflows/pylint.ymlUTauAO0 > MBJpA+7GXښ5uBUꏧI[&-Ky߳֐d"pXJj xN$,m` ]dB $V5t<4]7AݢSAKp?$κ%8i.#˒̪ѳ5XtBF {#єrb4$2y˜еZ5TwBØ뜚()?*&լ|0Eδ ۉ:aqYN\)Ԉ`]ဖVE A'p9e3MK5L7 7VhEw Ar:J#y?{WۚϴB,Y8l~C3cs;gi5&i1yG:1p ΁F^T̗>Uj>݄*oc1x A} kme3{婔SȄeQRu) gGrp r_cfP %uuG ĒiȤIJtaaKmIB ]1,q%emiLAz`^I#i0)]VcLǧ^/nE_#x?;X߷R%sB<\ 7n³ۂ7Q~xLo'vod#U_jèHAQ2wumG[ ".b<-Pyl)i0vnaAS6ת,z=}8ݴV1a1Y%Ō*H-;>-+.jܲX*ʳ[E#!mܐjFt0PcKf3A J4 ¦M7 Z|'8Bz㫰3"X][g? b̗HZjki.vG8WD )`ӓbcʭ!1W^5Dnk ky=V7y"ֻAJ#Dv:Zm^vg4ETͣWc֡}9D4žXpZr)xjӇbϠMeHx1n!= ȩ?Eһsb\_Iykywt:nsPm(ai?Y0)P <=*+<#H;l@^/Q-lwi'PK Y*T[Ho benchmark-1.6.1/.gitignoreUTa}RM1ׯxkD(2m@T7j! uVHRV\*7~P=ѲF,xF)Ma+lJmkRHN͘X`3Ͳ ^}.Ի7o}C,)1l젯|v 9u֏ҿR'*㭃{ytK&tz&PK Y*T  benchmark-1.6.1/.travis.ymlUTaXoHbC6.),]GՄ!k8^wmZ7~%NVR8>D浶2dK7|4J_5BF4Ihɗv!,}D#*L(4!D|_.VNzPB &O^RGI &Ἧoő 5m+hNƚ_J¨s<`6u& ~vuWS~Gᔅ(0l8Og}u=9:owm돻þ;fcE5K1k&# )L}' .,JUDh/+bNdKv&nuv gU_) IJЕ'h7k~v~(Uq- `Xѫwn޽o ua}aSǒ>0ss,d6N"Wi‡ A$gvTc"!qHX=pnD F ܈wC⹸Cg Ɉ֙X eoYl'G >7y?KVcs!y&a/c|OMK,.THP+aĊieƞs[&Bʲy6a{=Ꞿq#it8f+(knr"Aᡏ?FϟW@kH*07T 5Bһ\&js7is :j& gbm" c,-͔.)ހidh0"F]}_S%gyW]hGL4;{k5@;\,l*.T`eZmRҎ" مc0u'SwAMY6&Ft 4d4߲hYFI j*,14ނѳ/( 3FSV~+ݿ MNοVk~1}*Nx c6MHⳔʚ=4IpּjZϫϋ[=폌`fTA,Z0JS=.">c_9 xkk{925I#rڥe*V-+mdkf*d>z8ķڭ^sLn<踝_aHh j ljjG?ŚR#!¢' /vQY,>ꍺon冶kUUc+TT \UQ+J"۵Gw{O#fChsn啎 Zr)pmW\<P{p$ Bz,ȳւ\0W-t/Aı0124+O( Ɵ&) DzamÕURxz*R:2Uqŭ@'0yT))bPK Y*T^8" benchmark-1.6.1/.ycm_extra_conf.pyUTaVo6~_qkl7ao&N-8V@Kń"5c wGʒM1À$(qm$&-TEGpsˁ.9,%[Y\eBJXp,@(H YPaslA',w_l KVI78p7Q|z=n'{]<0lf w%|}Ocx?Ov6}2]G%ɤ -yƔ_~ͺl{_Kqňԝ0)jgr5ALe6 Js KmzV"gХgf4[T,'r9IV[5-]MfwB9Nnpɟ>=9g7h%PStFW̼֕a}֡ %~b D„>Jeq E Z>9ޞ)_#yG"-P2oZ9П~ A1gxQl`)q*[ݵN/F=8PXT``"g;WXʧ"fuԞ6M/3 ]!#DNڒoC>cQP(e *Ns& m S^g\uRaiGdIz(K,19#xge`G E\Znu$泏wdx:̦sJ|)0Ff3[RS#J*2a&qYg"'I`qD]u`=d[=3&]k4#@x1`}ŅHvI-#bHnqÐ'J;_OphFAT=FPl"#h˾"+*1Z^*:7oS8 rdHYrjGf{AMś c cJ{ __@r{;a, $kЭ>MhX6USuL/W}_^)WQ1[Jp{ 썭hW9g??gYg3kq]LRc;uvj́(rAy5t Ҝ=q n=EWhacа& Еލa}{d&<FmUF- [b,0ŗs:l:+3XW+,F WJl&oCRȟxEsqvɦSFoEhhfXaB:$g;H>_t ^(ڡzmju٢=gT?bؼf\UjY U┢C¢ylj 1OOA/h艾3+^bֲS(&jώK>Tī`HǠ@oL'GѽX0b+g7wWoVDjUKt7V9 ;@Q4' )CU}LrWʙc !)c^\I(<}K#v΄ABGK*h6}޹P}FN&/|=E&1dQEʧɚ`^#Tg?8 .Eކp@#PQX/Ɇ^LfG̴B )gqv7at8\3Ɖ ,dd_dťLk_̭iČ)5[[@`<#59 mk@*(wHZ+3Q> =">a#sĴ-ϓϘqzD LJ3Bm(Jldg&hoL kgbEuP0Ty2LAY h=P3'kQ 36f/./|ګ0;7[W+< y!r\9,~'`A]`\YB`b\NޙcAb ax;:^G$ _k`=1YeRt:]l30vMSҪ.swYlɇj9pSF\b4}΀l02ؗ3uXswycORz*K)&Pn"r0%s<Џ¨ %a(2zeXoy/<}Ou(a)<SU -־"|Svb,CGCFPNA0OPK Y*Tw benchmark-1.6.1/BUILD.bazelUTaSAK0W:" Žz*%[h$u7iveK{^rLXw l2\bI X&S$[vJ\v2V3~0тqSrFL7&%ɔln+`KPj\1^ >kE6QN|X<ݜ 5C9H^CR_& 9L|1Y'㼝zU@K&hpnPa,랆ݓPK Y*T%kG5 benchmark-1.6.1/CMakeLists.txtUTa;koH+rHHhykI*vn dK"u$[>$R3&6]'sAk7a wò|;,QoޜgBNb⅌&dfMW#Ie^1=n$#ƭ7r#mh#,yrmT6 $X;ĜF!%4#_Q 0Ȟ,%"aH2,Y;?#!- @qt{$ۂk ־.է9C3-b;Ϲ6"l>PiJ4l4Ȃ{)+݆ճy D!iڏ'S:bۓݏ+ӱs ? #`iIv3VQ$5 WH KQ*|߇2rFZsYHỈhQn3AV#U#ˆ2y Zo"oaOo ۏE8~dQIn72R+Dymfs6@}+@oSb E0*αHF*IM䅃6"?2iSD0!sh\(Q8IdP']:H*ek Yl0فF\M[i=$>{BY՝gƜbgSq" (NZN?O#v n6Py@G>|%p]DѵYoك*;>~p/>WJou񩣬$6Ҕ@^Qwیr,+]wW&)8&!Kq3I9oۙb{&_\A{DI`(LNv:YtI"|5 '%̱ Gz06.lfRP.Sy:?t~}wFDE 7P0 F:2p D )Ǟ Jx$^&td ۭAK+TR݇&XrpLi9פk8H!9b]CV2gw38VPblף !*[Ev)O3˘8.8Hr^|QJ%Q] `x}sA~,.h[\Ho~3khW2v&1ғ0H6IZxڟ.y3s,#8 1Ŀ P-F}gA$J_U$$pC&a}_;'7]@J&\ND1') b4SHukhhP{߃ZJUs65Am*Wa4agEp4g,EM.]C.!)Ȑy*İL%U Ҟ_0l=9'r9Jgkhes.DN~, omHTc w!]?djBnV\kyRZ/ɡ`B}?o㣫.vwC))GW,l- ܠcOJ2-H!2{w?-ZWVOϹKnDF|>>ޥCnNfM@ @2ad?ʸN/5Dj9%Vq]}\чx!b_ Ԅw xH7s7` DEFaNtC6E_xE{FoTt_v"[&wor zІ]( #@\ w{]ia詽KÀb",lGL||Cle3Ά&Y J5ǦEuZw݂.TڬRgF [J o$QU~b=D;YN/d]ڕ=n 깗yO +wScu3IG.QEG+ R4N/{ELǚަWue;.W]+k/Lν:đ*INM]?i_͎ %({$ٖy& xf|B#x4"ѓY)U g !?FnJ,{^эsmZߵ*j!.o1+@^!tiD1X|bނ  _ fP:p̋^Fd.;nY(b>YS/s,FIgb 2SYr*c|)V?Z<) )Ge ?Mm~Ɯ4V_k韓ۉkvòܽw"h0na]*ETy꺫Ydy](D+ԗrᓗX~VYRȼT*RuVAQRKUFꤣP]@|"% &@WOo/dwrtlpj>DY4{lw'n8*\UNuggg?Q0#d|%xNXW516?2zԿ͗]@5FK["B*F*TZ*/`Bv7 .$Wgwe># >"& g57^@,ޭ ^*]iB__kͅ0\W1X<—*BVAxExOsҒ+<@_74[F[\cU\N^hb. B0`$IXE@;:_ՙa1 O mn.qt芕VU{X;e3|Znb}@4`uaD?~r!ו'{HdN,T@ܼ&,ӬOѓS2+Sد<*{qB4EKc8ܱ&o~R}xLHy>]/s2(N%\Y,-V GE^h`$buۇki_1l>/9ww//&Axj([bթv?\}4տ[ ^mD)E!h3]da(bB<+#ο ݍt1y[~KCh2O+XnvxM-uLspRCێf GSQ)5dX;) 3E1[+;Ry*R.W@(eDz-./FXV.![G\c#hOA ?PK Y*T*|  benchmark-1.6.1/CONTRIBUTING.mdUTaV]o6|ׯXNp>~sݏHk qPtsҢ ç#ggggG7@Ql#EQ5gJU&7zT:l|E;`tO\ cǞIy.}C$E (jG]X&\ DqMQtpm`m=s6x޽D:^P/K6\?(Q@>G;NWnnHWW*Z9vu")~0zϡX5:+Fhk2*(|$@N.5$Y-i[뽮GeuԶ%ArsY\ĭ0ThD`p"* |e=Lk-wϵۏ,?a>i'OT<+u:z^%AyKGe9_[ck%㛊WЉt{ +Y|.r]8 SZZ7 #fZR(Z;{kԉjx"_"~C]Cnk32i6nvGڞBt]$k/GZֳ^jD4)b K8 _T)497~x|= {燍66y)g Nb˾a[<5r74U׸ӏ9.ٗbe8qZJdQ#R$j\.eQV6Ѩ⼝6)%F<0mL, pu>oMc34'e;9mY fI+2e~% ]cCy`N8eh@nfUI/D9*Aqd91{l8CV{.zZzLCCX;C+jmԨ:e[@kr`L,trQ/5)'meFL?y=e2|EE\N!v\/;C*ie=mr-aY%Bb[I`8'dsŽsHӣstF/x)~ Qf+f.{xEUN쥍O>h\,Yw,m{4MG;d!ҏ 6 s \ ؁r fE\.{854s_dĵrfK$sEѭyHR428.'S'`FU|)lƚߚbkyXoPQU-oţwl@C*%~K*` <Ơ6դAǮFŽ ,3*qʡ ھyrv~O:Oc9a"$1bռ*_yBO׸7=M`Æ\6ߓn"8ep E yH7дX=}ҽ^ YWѠ V,ZCtҠ[jMq$rep7fxۙ76B6fCi]BKi-7&"~d;2<܆y[Wʲǹ;0ʵ>qA/&qNMUz@i5|E+#>'\Y""3.[Σ:WqP^5G&}Y@v>xR2gń(M3 ;/\sǢt* i+8<ۄlor34B\کvBvHf9 fNLWH8fy1_-[pv *2Т#-\j/܁F\7=kPK Y*Tm^, benchmark-1.6.1/LICENSEUTaZ[s~rSi4i牱䆭CiDn&% . =dwVM5Iٳ E/˝u:^ qw}{ws-~]SW j.T;=rnk3' M#Z%;1Ie['dWtbtVTc_^>[i7X{!pKUAUB֌۝N>hxΔcX/cO+Mzw P  8s+lv[z!S@me#Ic$핐%I ZY/^Ao i ! RcWҴ$arxùxg,я71ɪG3/eFGqB_RWY*;w!#J N,`E+;U<׍+VN$ٹe \hЄvGI%/i;aA:d AFu`R+'3=6L\Z]^&Qy|x[<'$ְ[ )GZoUkM[p4IY3htqw3r!8#A^ ?Pv;Q|lpcl(?jkZ Q9|RoRyH\1=qtLH^cBRs g' NPn*-pc4 (KҘp#-1bZYdąn`x8[ dV9 X[BA[/eΰœⓋW#$Sc Wh7; $AP|#:Tp~*܊܅r8kiՃ&Wbi|66|y6yaX唃H!K4LouNՓ/ı0HVRT)h:Fj'2㤓 ND%"Ѩ'Ju"9S6/'\Q6 pHd6 ~J"KQMm7n;h#ZLjDe}5ie^f^˰H5腍l(uD>[_`FWPhd!R+K:"7@)AZV"r75wTXBJ v?V>f+kF/2DAfmprtTiǖȏx4`YC ʾo48U+lv8" ɭquNZMY[@(j_`)_DVOˎq-$obn.5?B c::e[VAn%L T"ƹd0)Y"(Ifb<2Aŗ5sgJ2%S/I 6}ԔAddITgu>Iy=@ ]'MTũezٔgTe Y V/s0#Pwa_fM[8"5P":LflȪ[w̤ս$ Gg~ UjlmDL;1 `D*虘80O[5Q*Ұ +s UƑF:ag|흹2b1]hSY<<ъӹJ$ΦyI۪IgD1&cةu|K͎ ^5@7:aRcK 88l]%;rmӚyEjf"Vׯ̀ ՗ vKR͍P_ad.1)X1D[(>C#S 7Ī|t{?3]B΁)wv#jL_5lqn N}:CC6ժFo; tr)~4jVQ+bӁړlȦ7_ ΔԟJ;jҶ]1 7yc`HKa>]Rušq?ˉs/q?[r=?,u07bu^ZX~_h~K'ф+U6&MDsRpM."{ `z\[z?]߽\|B~u^N~Y_so@6t@73NOB˝1<I䲝fjExPGʮT|ǠwՒ4c6Awa6Boy̗ZcsmhJЮ `ՙѹ-!Q ъ)Gkm&CW*QӹF:-l>ƌ6F]8WWXWϽG/no?ߠ iZz/o>%.(kiBB>F:Zr $;o)D_gh2!Nz..L@A.uԦ: @;vv7"zVp6/i?' (Nr@!c嶋hfqZݨ ݐM.r4F a|_PM<½kϤ!o9e/UBzG>HgO*.("#\{{H2W՝5&KGHGvu]xae3.2=k[3vJ:r6p_j%ׇt,~پt9ٯ)Z,VLovX 2hf KڹۉCvqwD׵uVƍjR|+WjW4v+Џ&e.2v\Һ=e{O0Pf"WY[ĦZ”P:LUt)L-`.{>"Kg$kp/=:,*j&+kRyt1)1Ƀz +{]mK릔K]icEMA_YY@Y\xk?n\!zK:R X~B˲K%su#y谮Gl gCgY& |%Sj.u"ތ&V}sާV&s0#9bw_!S3bO/ur'mS߳If -?GSK@ERjI=yAfPAQ7!b$h"t{|Ar[W9daCDjEfCY%Ki9'ۂrO'M"HF'MGO7|?y{3Q4e3:zzH KJRi?Kzt-#9:aFy3ڍF-f!5 |gBy1f3n2E1w(Լ {:-m®efzIńqU OS*K (¥9vXN PIͯ#.l תGZbm3er&\, ƶ&CZ֠U4tO1P2+]:B͍xQC &xmׅýjme}wKv'm*B J|P w\6 59u> I@LiXBϘN]&GfJ7Ă:'OYȕMU!ƷGuS'%)N]廒Ӱ\T% !Zͨ*akQ CǸsXx'[(Qօ`QNhKyRhҢ@JQCB2\q7Jc!(<-7ޢ f56N-"I<*fHd"L2F >/ώbK"QMB '+퇽95OqMw |1p=?JN'!=ˋֽT;{7,Lh{ā6>!x-oHA`N!S }Z;u) ~#€DKC=d Ov B+&HcLs#0ziƙAȈ N~nvt m2f'z4Mhᖖa!' EtZ";28,FoXQՖ8MfjTFa֡ ݰ0[2/ v@g~vf/ o9˳ISX-Ң_➮C^O*m "RH 4oZ2fR+,US=>ԫnNS:/կK;R "z]}Z%[n~^|_TMp? %$3`73:!b ǑHۀASX!v:+AOh'n's/jNކ~ŃNkrHxqJ4US˗2l-$rMEfdB&G/{G罤!4QmFYY/od|O3] Wq̶ 8,"~/7 r Z[ע:i@(tS 3d:׮{„9Ce,ZƨD5*5P_{6w_ PH}:WG?1FĽ~v8m+"NݴѻPuΐ%}p30((uP <+ܙb#4wd}:[W}8 8D_N]3낞D`7#m9Tw&&2F-g.u4rn窈9{YX,h**OU2.'$4K Ҥ bQIJSNEE)]:yoj^ư_-#bh}~L\3ȧg>R>AN o|d,~~9ns?Ҙq:Q4H [(E$r-C*|kjd|x6ݭ/_?(P"fx,x2RedDTUɈTDEQb"" ֿn\37Bpu)\{^,Su"Qx7C #G)|{s4s)'Y͠s3]7j|K'Y\vv\ RWNj%v(D1㒃"W8ʙY%HD,Y:)'Z˥{]tͺMk!_Ǹ.Sgi*M ?:;ɃwWȽ)PK Y*T0*+ benchmark-1.6.1/_config.ymlUTa+HMRJͮ-ts3S23JrS|PK Y*TrL benchmark-1.6.1/appveyor.ymlUTaT]O0}1\ Tԇ҄* RNzĮlg'VH{%㬹(E^f_G`Rކ' p^?FH,Eiq @!"- 8Ӝ.֨ȹ0&gFE* 3ڐuLϚTer-Ϛe h5>jWq5?Î8ENWR'O,D{xV,d{Y"M1!#]lJ2ѺA_׫ڋю;?ϣIt>]8n~Oy´m+F(aYv@L/Y+hؠYB%+* xQ_577}VXT]ɬfVh]v|xO-{+DŽ&ұ•C*e2'Woɯʜ^2Aoн w<;=U8 (Mn86>tFCϡU5Ulo"ʋ]ff \.uѪ0T 0 eMqW;Vts-uzRdZPRymY㞞X6!uM~PK Y*T benchmark-1.6.1/bindings/UTaPK Y*T benchmark-1.6.1/bindings/python/UTaPK Y*Tp:D% benchmark-1.6.1/bindings/python/BUILDUTaK(/*)OI-HO҈Vs qQJEQTVTTPK Y*T9. benchmark-1.6.1/bindings/python/build_defs.bzlUTaQMk0 WZv 찱vZ J1P3 Jdu"$=}=t: |d[-5ǶͫXR@()˰t {"lۊeo; įnH:jZCT}=Л[zřӏ!n%/͜˜sCqA4Э%Pw`[[}R<b ]Ӵl@t\kd+ق9Ǥ]mje9\:/Jr̾PK Y*T1 benchmark-1.6.1/bindings/python/google_benchmark/UTaPK Y*TKW)6 benchmark-1.6.1/bindings/python/google_benchmark/BUILDUTaRN0+"s)R'pEY~lmy*qiiO3̮f8W =Чwja`GlS 8BjU_\N6PlނPmFL0!a =#*gox: P υTdkˆg)ƥODONJNCHY^2|I)N()zgF-84EMk缾~Xv{˝aKJ#N6T\)}!nmZEQhD\$R%)ޯI 0}Ex| nTubWR\f ̊ܒ ;'YtEƥ92ìb ŵJ$0 K/j(P*WLU!8ݺc_ W8ZY~O((x?],o_"`,!ÿB dl( m45^ +fFiZraՠC.&a4[|9|9A}zϳa~{[?8 f/|n]&R]`Zy@X 풛m8lԎk@u)  Y7sbTFEkV\fےGS[QICPCg]E@x*e_f:%]D kC-6I1=Ia^<ή8~i7JUH+JWl4>XeN!M%+yt /ҴM^qgMcre*Lx O+t3O%[bF]:qL) 1Yj$T^c7WV>j$X$GQ(ȡ-y9y6ÞT\kg; ಛނ݄`Dwrv~#whS& şwȵO1̨eGo^+SE3ۥ (Մ2 j,Lif;2G^> P髉7?MWX3:xO $(nhc%k98qO¦ilx8qw:=7Ƶ[r$gz:?c A葿$){A;R‹N{asf'TӒx4$dq\FF!mC|ō @a'KP8h`Kr'Ө^kąJoke.$T1|*3YI˹Y @I2mT6NZvy% &NF>0>]҇p<]M.ǯGOp~_*JY 4фy\zB8g1*ZLgU"XԠ%ϊV *Ap m5ޭb]ӌxQuGs% ^Juv:SI.}?]RkP6=iݦQ5m C=j6uV>%rYR$6&x4J8*Ec%hHB8F;D':kIt:Tʢ}2YIM:s%M. Nz/Tɰ𜸨̪ >{+raέW @uY.M{ Ʈ!BFPppbѡH.ι^ mz8BnPUvBs*@GpNsdmZod C/ANȊF}~=hnqU.ŷ$EJТG'VzwYUqlNSUsJKx$BdR8_JI =Cw|=:nLjlV6;DAK\9`aZWkX&7dC[#/DY|_覷vZ|V>BIQG۳(+Q6XNB#f#ss;,3m5c&3S]fhX?KI=xzK\J0G4OaSpcػJv[N%n)-cK#H[r S3i  Qk DdwNۅnol{\h2hfO?V;Y(33g:LEܧ`1OU~~\KGeq.<}Ow>dkMV*XZqT) -ڏ[ob#o-9a߾v\[;>c%5Cl%XfY{95۳6B.=55/*PU\zvA#/|O bun2@u%'W>Kc0[ >8YhD=-`Tb\w- D( ( W PK Y*TOp. benchmark-1.6.1/bindings/python/pybind11.BUILDUTa 0>EɊ*D$?knB}{ۚZlJ J/|\dH42:˒G>vesi bZR6uZ78?oMcJ [_~ʺ^ ?wh)xYh>EcBU̼a6FG>u1AEoc*q] 05b0tY0W{cBgKlPK Y*T 0 benchmark-1.6.1/bindings/python/requirements.txtUTaabsl-py>=0.7.1 PK Y*T benchmark-1.6.1/cmake/UTaPK Y*Tc . benchmark-1.6.1/cmake/AddCXXCompilerFlag.cmakeUTaV[o0~WT&M*yZԪШaq}v./} |wn֩PpXӀ/@,0AȶZVQBK~}d('Pҵ]dSX.ɨ"o(bbr} \ZFM?PoE}⡙ +:_,s7XzLћ1\Jf*ٸA#ߍ T(60adK_Ff>1xUSJf b2zd+X|ݾi۸ݔYp*ȳjy9峀xT`0vcGiP !AB7HNpV#:;N 6ZĠ4&e 4=2|0>?H2?d :Mg }'z1T2amCUL:kLluܵ3H:h竼 ƺu+^'G/9GvDŽ#{,=N^Dbn6[[eKgP);bY ^Ei ܞFhGjQ W=d_TNA{۽ݑ]ULnJ-Gs5gHޠ=I0I6}>jΙtK `>ȶ/]N240>injn`~҈{[Ea=2b{qX.LC[d%l^?|ӻyefPK Y*TJ0t+ benchmark-1.6.1/cmake/CXXFeatureCheck.cmakeUTaUMO@W G4@8UBZ֛`8*`ة׮@(n>P{j.=3o޾}3ك.tb^@V$ু<IЃڞS$!,?DbE / TE '{'P eO3^I%pA{۷&#vU\:B ɯ(KH//n-!N(ߢď@_SU[ r6`7*"B'89z;9д(4\wd Bug ^=Rz/INAg+a֑p[Ue x^ۄsfӋ.:Z%rtU=vQGTOR˵o"2b{~M d.鴂AȳW4cg*s&kZx+7:g2vTQCXë*]vC0 mudٜRCжׄۨZ7 5-Џ( X-jelLE i|fX1PB/+&CW"Aqm O[r nޥcb׏ϾP*t n#U[v*4~9rw]>Wc7PK Y*TuRـ% benchmark-1.6.1/cmake/Config.cmake.inUTa=A ỿbz8 Y0;~ը 迷Ӯ$d+ t'OXQi} N"1>r]u>liJ#ZbAoNj7,3{s0,?PK Y*TTI) benchmark-1.6.1/cmake/GetGitVersion.cmakeUTaU]s@}W<@28INCbĔA]uNҌ\ 6ܳ{əH2aD2)x2H'Pd<̴V`3̒a<ɦ'3#q2C RQlMEqX[ARN3c0cV!EJŞ!L'ό:(b G DZPv?e*qC@M]o~X ϒULJ nAF4-(́iU8zsTtuw)]u1s꾹 ]%R-+p;HgQt`42Cυ||g> {=u.l:'*zk7>tZI ֩~0؜! 9ߤھ nkE):3z|u$2~/$\|ƚaOGni/)p1''m7\M 0)+wpKKYeh c:>L8}Ąy ev xQDy@zA!n[x@$p=$3+;c?FfwQ¿{,-LUZ|pOm] >buKyqenX(}Eg_#a ډwXeyMZ< iA= &B8*jKdอ7e!J {ښ&˺-Gf89ϴL #ɬz AHoڕqs0?Ҙ+aEJb V6Ekl$KQTVS6|Jsdr6=Aw@t]P ϊ*- LJ5XuNG%;x5=/xHqy2Gb`R)2PR`*`*VAT{0tÆ#Td%QeB0 Ih` 椖b)LL{ZLMNV,y]JRk%Ϟ@ i=&Գh\9V҃T9ԱU*- 7abj%2Q*U[D[ nkQ:?n>%i_28{+V`ok92o';MuW&6Ƭm0kosGH<5hːϿpD;׷/z/f{*yaFQ 3ӽjd}FtфK9N5+A?s竐$`U0[חVD{Adߠ ZH:uBA &qZP; ay;{٠{rKĩ&>vz bF2N#wğ/Sҕ,12wIԨLtWb8\=G|#J"vZT fu<ء@2ӧN3a-lu>܍,mȌϣR;dE뵕r Ps>y-h*ͭu{ki2Ll/v?xԔoq ;Od@ @ɳԴުr$tk {bNUwT+Yn+cc ЍIn4 a.8=G_n< =2~PK Y*T benchmark-1.6.1/cmake/Modules/UTaPK Y*T6{. benchmark-1.6.1/cmake/Modules/FindLLVMAr.cmakeUTaePn0 ޛK azVqb!I(UwѫYd Ajcw#8£YxUsDPK Y*T@l. benchmark-1.6.1/cmake/Modules/FindLLVMNm.cmakeUTaeP1r0yō+"OfΤt%H"wFDx\۽ݽCF r?ZܞWQt`'k:2_]+Iu`RnСܧ{?=o.$+H}>A(>nEb;/8's3@ę<&95+h)'%5+9+}IzKIX?T9ޟ}ݰ6i]Ad{ն,t~a L󆭇Tuc̯YEPK Y*T[S2 benchmark-1.6.1/cmake/Modules/FindLLVMRanLib.cmakeUTamn0D|ŊS8#(,TY؀UTDׂT͡ΎZߺ͎py1|gIr3_7B D5GͶ'+nK@)juYS;OxrFK܈~bOo;GjCB-ֻ>e^lcGMqud+dM-y O]BURuiON| 0PK Y*TZT+ benchmark-1.6.1/cmake/Modules/FindPFM.cmakeUTaTMs0+vdpcnc6fC/@Tq_؉m9V= )tyƔ{@(( ^|/QH {K`|E2eH ZFl(L0XPAcuAT R۲V&M.dB}d!aymq5EG6(:^Q ZժEm֫,Zoho^a<IJV͗ШNX*]aؠ}6umU >Jp  J *% 1ۭ&gptJL(E5'm/aPcOjNMv"3\ 9e ./߿%iM&[DPd+^"鄇)Jl/&Kb/D|'&u27#jwi]YFaƢ6?|;|~[v6ī)14Ww$Җ{bq‘nr^Ի7PK Y*T;l1% benchmark-1.6.1/cmake/benchmark.pc.inUTa}n0 yݑ&A6eKӊvn(F $2lx1Vi,lmW^ ?R?wF +k1gqǖ1#3Y2'JP+/<;*pFr 0X%ZΜ[,~y#`ȋتyUXFDc.ӻS؅ጠk5N~< PK Y*Ts ) benchmark-1.6.1/cmake/gnu_posix_regex.cppUTa=[0+UŴZWoEb[YIS/I d2|gUsR(tcTߜjmM9+Xj?=%I`Ϫڊ$䷤Ru[VH?4aa| N0; <"PK Y*Tw )% benchmark-1.6.1/cmake/posix_regex.cppUTa=NM0WuYZL%`Ų7"񩅚4/x̼73ƖtjgKs8 v, -&N ^ш֩p<=Ǥyis:ϖ$j{+׽H=+|1縶pzMZ=b6LBk{!.C78P;͐A[-?JnyMPK Y*TH]& benchmark-1.6.1/cmake/split_list.cmakeUTaML.(.,,.Qy\ %EyA>ή JJ R STRĭUJKPK Y*T0# benchmark-1.6.1/cmake/std_regex.cppUTauM @+e?D,lFAm+d4<üjꯓBpEn(G v{-Ŷ *gܟ`9+ce6ilM:|UGlę*xhKO~=/{4ui ABVT%PK Y*T~^m& benchmark-1.6.1/cmake/steady_clock.cppUTa5 @ ^v_!^|M,5msfC U~MAaDc%. 09!^ '|FDbǗxg_LׄaPK Y*T]OO2 benchmark-1.6.1/cmake/thread_safety_attributes.cppUTa#define HAVE_THREAD_SAFETY_ATTRIBUTES #include "../src/mutex.h" int main() {} PK Y*T benchmark-1.6.1/docs/UTaPK Y*T^ջx% benchmark-1.6.1/docs/AssemblyTests.mdUTaXko7_A8[Jvbn u uCPrJr${cFv] l(u8'EyZ.׍7V +쎷lT%\wBZn|+߮Rشcmg[4Rg%!Q]̹WCL,lSFsQUrVrƌ5g)PPXMޕ1`rV4~؏؁Ѵz=9=Ej4y-"~De:>c/0;ej:&2,M%ٲp<6Rڰ2eGqdjCfDhq>η3m+}+-K6V?›&$ \ 85yٺ#^Ic;mfvrH 6Ş #)+4tљ!Jy}Ċ(_d,49;(Xz t1y`~|~pǟNkÊJ?fa);ԃV1BGY?Z=#G(ٯob cW(}<\{fuiƮfM;$=]1s"BHgg?\+˘ *6ΙΖ(*hw0'# 2CI0sC5F4>7A4"H+EE6 "tXV7є*7J ce V[W ~SX 8p bb Lʍ2c+.ZkyȬ AtߐBAj1c^E&,> `$޽+ EjQWΎeg]t GӐS_V5/&՗ 9}]r ֤QXM S4vt-|sS(kiRcF2 n9Cg!BB$@NU~Q<~{ӕvѩJy~FrosE#%ĸU.2T}Lʦ1@#]4(3)0S e8I m2?;9]H“A3بv^ n(xJUtNmfŃpO ވW)ǿz+ 0IH@ ?3%<̲ ߾W\M_|HDao@?}t[jo.a\IgOvzbP\}'c  [kS~ q\_@o[Z 4 TkzL].gƚX߫~n[ I;Ctn|7OBi\0ݓ{QG{kϿ Az>擻/'\;>4w6 sW-HzaF @UM$_&OEjA,Z0|A}RGK|Bu-d;:IzGwD9Y58Y7Q4W}Gޑܯw{V_p7|ͽ+I/K^; M =  t!2br F\<]EfݺYz eK1a90 44tyDi%c0I'BՁ@ƓΗX9Xc*ZgyM&%UVdA)&KQ4PK Y*T> benchmark-1.6.1/docs/_config.ymlUTa+HMRJͮ-ts32ssPK Y*Tʚ&$ benchmark-1.6.1/docs/dependencies.mdUTam[k@WKa5iytJPRIhzWK}gV\B@ 9ߞYa3yd۳fnVj6$ψz;u3-ڬqPD7zs%BƀqO{޽z7i1#; XQu" z'm5n5YX;N[a0$qrxn D0J=&F#dq&B:;}N:qNڪ׷Ȩajq.'ב ' |MVjES >e"uens!~ὰE4WԙsRau8QH6e 7^w-1UؿJ 9'p:HTe{"PK Y*Tr,]G benchmark-1.6.1/docs/index.mdUTaM0 w"Ka(H AP["S oSw5+ikڲL? Xُvg&AGJS@\L\w r1ٙM76PJKv|A9N'D6Q\-xmt 荆l_~ 32*4i)* uI>PK Y*T$H% benchmark-1.6.1/docs/perf_counters.mdUTaT]o1|X%/PqT)JմDTUQƷpVq}P}> UJ<@;3; BɄM@/`KXxt @5inX؏ iF#J݋@(jB Jk=B<V)AZvê3vKS:AmjgGrShCF\{ZvoS#MN`!nJuMN^&u5@Q]KKoQR++< +H= &>N2Zm02kd `Aߡ0YVWR2몲.AuG9H<$IuϽ2j8hkN An17xiv]KUD@1ꃝ<%dcC;-G9uܹog%7Ew< rK$8[86@ YUȤIׁ[W V wY0T@lk=6u/DU-܌xz}s7^<|i8mYNJ;3$E\xchQ5&#KSaEQˠU?ZD24v 츪*8Aqr'?Oƹ..ECg9Iz=NS-?8~K,)j~PK Y*Tϐu < benchmark-1.6.1/docs/platform_specific_build_instructions.mdUTaUQs6 ~WOZCR/&,zMAgTIrlI$rUJWZ^6D߫ BL&ò5lulbA A0z߁&}`K2yբ$:}x1٨q hc"t0/2x#SFDza}onAaio ;yGKgs.&D;2X!:m㴉 y^S:SkjjZ7y2˓::HQJ/"_@ZZi \9oA iT<:zDΖȃؐ28_3]5S9,K/[*1oWOTiB$^C{Vd]+V,9.H#Ng#6d%~F:,/ Ivk[CL$^f({U]U<*9fxlfd5}3М'b_j/~8`hRqclJgLOsĤWVmUXHUXk]kR:GpuOQGg.&EAfht"`21[.#X#0aD8v6xKSX !`3E;6^ۜ m6githT.hQm)ֆQRxb!619Vڿ;Cu0?0>.Scs8q3(P&ɉR SCs s7¶J=:U"S'@m{ &^:OŘtYPK Y*T5p! benchmark-1.6.1/docs/releasing.mdUTaSN0+FP]d饇TZTRqg66xv;vX{oO־AP#e"!;575cz&:"@)]T30ܨЃ(^ RV;e;ykZ,˄8/㏁$p`>He!{!4$KPe6aw5zT缪.hxEGfШMZ+nFJa[EWPA "!ZǛdMoȒXTL@GDvH}؈4PP9M۵5K6xEWXu;NΥ H,dNJcj/Z2՚EcmuQ.,gH="䈨=_RҚ`[̳1MqE=|*>pyZݬyz2 XQ}QYv,\Ib:819aev{I(`jaPK Y*T= 0 benchmark-1.6.1/docs/tools.mdUTa{oܸק`;,>DQ]$"MAw^No! ^k eG$pGLuT\Yg<*oJy0C(Eե\*  eKj-]^2]XZg]I\mMPj yo?=^UU^l6W?r:hn$qZVQp2NPl6ʕj iUJUlGymꪐWQǕF(7qΎ:M SBc*DiۨԔӬXG +YDU%)uLa%C)B^叛:-fm6h|nuYuxpwFK7'j7ijMlZ\{`3d@f3f:I;滌ëy: .3i6 ،qXfwt:堣.|~.Gv0p_d$:tR0-gcȊ9l`5#\P'PF1 Wg Fq̳g+r{((*H(AUTYAxUzUu v Iv>sǧ]"H80 YBN .p8?$Y㉲N fj@)Fja vjO"03 Ra&vkmO{k^vn 7eaF:R(-wΥ +ʀ|6*I4m'F; %5gN֐O!STY|%ܵy!&kxYT"Wp w:3St,})j`Ϭ6U"v*/DY{]¾^E<)4ւݦ6?\>83 zPS'a _rX<ވ/R՛ e7kM^F8Tx,7K>*>Tǜ)z\oҁX?%Fz +?y67v LScF}HmQq=q$?1pa| mކsCPC`%ew9F}2; ͟*w9 Oi|pei 5q1^6>!a[F- M[&F8↞ho ̫X_oEh򲼐7qV!'G&&h`ź;R3d4_)zoqIQY/>QY߼$*ۋjHGmONZCʻڂm6d~ʟk5"Ddk!<ҘMCȰl.Nd**dQӺPwB3miIr?']g28N"od$_EG/GE໬]vfT-+*Β?v?WPMV,JQZ[/ip0 &xxJOKtxw^if:<@ilxY zN~ PK Y*Tzl2" benchmark-1.6.1/docs/user_guide.mdUTa}isHwZyM E&myC}-̆A@$(laˣ.${f#'"*+y-By@$3,L Blv@|؜a!e}SVM\(Ai]kaE@ (3&4 XByӬnBЖE{XZ*0bجN [W_K 860!̯]+PM^+%&XPxN rZ A< (Y愰84~OBx pQBLƫdDKf\Baʢ< Ew ]oZ= 1~#z,RC|Lg&D@q\܌^"e{Z?6a(|fyhb og , Ǿ]c-!M/+A^0D.sښRY9-0߇g*@ g&Q_``Yf} úi+W õb 鳵o RL!XE1-P W"<߈ _-*ʹqW^퉃|qNfb"߬ǹ B#@se4㯇O_q߁Sc_>2D#2E翼>z٫_V (KdX :l"E0R97)u(52S.A>B*EJOpS|D-pybxv m 042ڊ3c{i"hFlP2@~NP% f":ᚷ̠MBqt<{=t(NPw&1$ U $CW/ ˋ ?wSk_O^u%(;xRK(Vg7nDAȱ{i {HdЇ JTتOzQgRԒ|9 :ږqo*H41Sc[^IC4_ u. [ ! ŧ"i@WWE:'!Z:tJPݯ| QE\<$$c/%/pU3 ДW -:]:9-"x)n H!q$ !{R\0$e,V$Kґ޺K Q8\_-}Ƿui6<MfIH tQ\%qp1>yHR{4slcnèN`a3+AExo (VLVBt熀-d< VnA(ma0?,7\F9I (8A : Ccs :ȟ"ޮbqXQ91б+ |)͋X0 &:Ma}1QRnhj~,b͘5\C,qpC=jʮqQb"o&WM΃tH&8VeB$e Fc"5'<)o*M;Nc\C4sc@N\Ơi@"ZmVTE}_^q:ץlDopK3";u gOMn3Q߁I`- aPQ$B @@(=H58HRDo^ǶiU""aݑpsy ֦ vҲքryUcT䦷U[{7> `UVP +G I%Z6-іLu8?)JJm#pB/聾fPiDVZiPiC7%J. $-õ]nim-tl0H>oylVfH-6PQ:(#jey%n91DŽ Sylc ԃ{yvX&꜋4ZIHm+lq;OD`&}u9zj*h kmMl==ۃ'7z]xaG]sP:X8NX֛+|YϧsPߚ뾔sQЭPMQLRpfL _4ճkVpmK8 Ce!ڰ 0W A5!Il.֧t1š)f!`ܼ i b.h{A7S,JrGgd&gy>]RZþA5پȳ8 (f 9 Ǻy{9hXaCW4 b#gb*;Cwah2u }tuh8Ϡenv_nZ;Sz>R y/ bOxU~?6[ r` #/C78+r/m.`%2y`u4Wzy^g)Xa *&Bumzb))Z5#=M%ԔrXOJUuFgV֕β+OZ]tB|/[䚠eCyqmKzP\k ݉7镅3lD 9q;ʁf <_XC%? +d[~SbHX%ɥϨo29aN,RÕXkRQb1^´ #e&<M #y{|bt4n=OSO<RJ雴\a㲍+rAuHʓ̀u a܏:6j x2dDLYт;.|Ldv mv'-QbD]qd!}f TDo -{]"~ގ,. "`FW⿾Պ$3R+D#u-nKE/I 7P06i8\8fK6V™}LjS"8⨸AybPc#^S`ktg6&-"]58UPۅdC|;* 3yܫx{nSY#Ƿ(޻p~lב+\9m0hgb$@7L9,P(Xё{nl!a@GIo,}.e /ӕd@YM=' ptwUf kEJ7/"XnkTBuMIrWJ7uTrV8\ay8]XoGo|ڃ6, V+ D AvqfǙ ~ËB)a9 4#4Q` a\.+%ViP!2( 㩣t KCwO焪0~ KW)U Tt XFD rUFRi۔PjKWܠtްJ͗KkZ񮈎"'0v$' ҅ ғ /o&f]n0ܽ|h<&;) i!Hj;Гp <<Zjqf+MmO~uPӴh r ?Z4qVnJ);<I5̞<('=m̞H+Ɗ!3l;8Os@͔AJ#X@wZ_ehƢοHb9D& [3֖-CÐEe:+-Ѿ8UTKZސA`ƕx|'/(Kv?7 oS 6+7 |TQ8%msoR[c+ƦWizo2aEU1W喅SmgAgr 1vNdM7LPJj^UjfT׉f81wQZuDH* ]sb'OfqRe O[m meOlL:UUjz2@`̒"X,)4s8t:aY%{Ł@{ęח=TBuBj#e&4h~Bwt [ѻD(@AW9Ck dW}/ȗ}h/e3d*X;QLamO9L,OjShD_dRYA HWA\^NDPa>YcM2&of2#'}+CClр ,@Na\1z3px/&&fPv+h[)nl资uE[LM4341 ~1Ƥ՗G: 0Mu8ldt>XTU,ppQr.7Kk(*t; yg0mѠ9: B:Fut};n$XҙR25䅻0N@M!P<ⅅTPy'h*O\ݾ-x2An4X[#]Qome D-A.ôU6}1Tn\t^{5NL9 4QTfB9FC&-a3 U %x;LBӉp4p͋`]ATU[Oaῇ6cY|Qm\b.vNvm*;y9Qk7JY9KT3'$gNLx` &88a21X%+Q@G_,`Xٴb`MY; 8=)2]v̤%R@hg=I_Cr:M:͂_\zQl^E)\FNAwE ){_#X%>+J4lbNJZr㯔-B7pm"orskvTj?JCE|]8{-vE#qHb"$1'cB/+Ha6&JIcJLs$i*Nhhz'v!GS/5y0){CZomG3 QDï׎MHE[<|*Ś+&!O"RR*@>8jneϛ|%? &+1;Wrtq0URL䩋D6'G'4O˰+ 5!z&QoB-1ZE48N)dã/dPHd^,B˕6E0P@5NKTZ4՘ Mִ55Mqkҝ\JnfMZGRy1 m(%Lp:Tu0s*?-'/T`[F$TKV2+̷#7Py!pZ*#i$Tuv F l 7G"!7BπN}Kh@vWPxő\10@|޿n xE(42UӡӞͲEp#MpGWmr2m-`뀵<,#2ׯcS[ݚ# ݖG;(32,n먚b,MT 'h*O"b=ͰQu+=mm"F\bz^rP}iL2#`:k!F.:fq,)[24D9cM me=YU` ktAA=YyTԫN5QHb6v|nZaB WI/n%w\ZNy9z*bd]ᔘS2xGD5)hI腂\Q9@'8ujړylCS.~of[qI[㜤BLehd[d" J -t3$Ύ[ vvr=D-w ᑒ~J?ʰyrt[r,\GrE BŹ~}KBּH3v#B<ㄌ?"$'a3C#/W ,X8jpf`V7/*ؽeυt8:ggu1 M.zSқdƕ`v~])6)9O D&YRHMlԨrt#n `IͭM2\v_MMcxD6 d[)5ЖDHGF5VIxX+c^wn&{}H ]V!yu@M1;Lg e!XSEcz6Ee$n|A^ "6B!0Tt(I!Ђ0p"{薜hד{Oɕu(|嬘eddrޞƤ%D NrW9 ;S"WH$v%D$"L ls[s֢Qo):yϫ̽tWQFүD8xd./N/#Vs+p:ϠCn%ҁW.㐭9i1_s/׍KqFFߍceC)b_^Agg0<8r#%AwR2Qrs 3yuopdK>ZgQ_SXL =zQɡiiZ/S@#cJDzҏ"J]  o:egNOQa8:e, (쇜EƑa8;(,oI`uv7GgwS9j5rҹB_`jʷJU:Jfx'۽Iww[R1Rfnىa>փ!*sŧ2!IO uU429L&@I)ÃthqW=/eD7UZ4eFq䮣|;*ȋXqZ97g?0 fW霬nc;Y,F)Ќ#UnY682TXx>)5,gl2x@J * O $ν ] s3HlC:NC`H59ء ̌c?/|md;cB)HHkrw)r#k߆Ŷz)ɂ据mD6\f *;[ΩOK겝N\&-uK:dI\he$ZuWCM]yЮ$x(g|-cJ}:@4e`ށ袱}|p8Q6_0-jnm6HZCYGOE[MAѷ1Ub7z{#qE髺VXįrJa)k,Aq{tWN8>xKaH7ŭGj+*[ndF`.5SW${Vͧ*P?h厝YrKOz]n(ǺuLL46F;F@lBRYjΊMSňHB^H.7O =Xo [v%V)}HUj&K]'Ҭ@ǢybG Ec#9eWxe`Rc1 #ZAFh~)]ݠPbU} ZЎ)cdOUW8*gKб?dshyRҶ vIr÷ c@^QnAMqw| !?ry!fbfl T;\7}3^e5s&R /"ՊVj:Sr o߿|Y.vh0'%3׳.[2~ ~GnQcE ٛMpiX7`EyLa}"y0v "o;2t/W$n yEnū16$iI.xyks$C.2+0dy-9GjI*ޛ. &f8 ӥZg<ݔxT#hDdy@4&PܯK^P@q/2):Z!Ɋˆ74E{, )4 "\2łDBゎAkTJaJTٳάguoZSv,Ϯ(uPLf$)nvq>d?A!ϲNMqKʞփi j3U[Dj<4PDGuh|JaHE$#7Z5U hE 3$ Y/(2h<$O{2i0:;*GT9Q0d,2 ߎ޿9~3"M #I2MʨGqVl%W08Ghq:F^]5"LRNJ_<(8 Q1cL @$JMpX"vyL ;;Ch?V>+9tylV㝝 x:+Bhr*t x" %jh$©6 cx\?gj:Le|(j%  t,ϮhBt]I. 7IDnlF!()0'p&Pr]:]Z(5 iRӔ Emk3אz^VQQW|}t:s}h;skj:CMAz^۔_q9Sy{Mc-hLH#OQ93: R*)FVD5d0{y6/qI=LAuߦP KW0.ɳK8 p9/$@$._~v/賦p~~ miK7Y?²9ǬƴF PW32AE# 'HyvR5ݙiF4tlY2z"6l'@j qHΘW?_ic0~T1@{-$<9\Efutr 1P*hϔg`C͂ [/C`"a{1.= b\>Q &c գoA|>*l:DY3s0+> .''ήDr=&A} OUZӄPGo{IZ |FOZ<:B0|\  zB)tA0bXgQfWDhOUav@NS-SIuLBBU`;@ST0r;IYUfځ @)u 11m'q˞Rkؚk j b7]1pv5袈qϏ:>)20RSOG;=$6aXC 񏝝h2C|nQ޴ pccW7MU{ o ߈V ebTA I:@[j狭+U³7]HccZe:6Ad=?NRX`cRvޑ/I|Jln#+f{ ՠ8ϓl٭ ;7U y멋l|T?qlppXFhG`^ov@zyh8NJ\l@7cRgż\ LPOc5ɲKj FTR`Ӌxޭ0|ЌIYX8/h@Pwj]D Ge#mD{q:q1.WC-JgXvowTgB\*ajH`gF e6[=-J6<*`bi4.T gy? ѥ B(تL5d(t&)XS夘W;0ϒUM6^R5&Jq(t'8G<{(]rreu}ifAN`Gd ='L90@w?#o&WYzs<ZGIV\ގ'.'h~[}2ݛwsҗJSa:JF'h`WpRZ̔y}xPc},qªÁi}q4mxpE?gaXa m~}\Y  >)?5ػTqY ʹa //pe8`wW0ڇ#QfA kCڦ֓0L^֖VɃ)}_1A:*8yrucr.8Wȁ+gAjFU u쓼({ Ust `6Y0Aҋ{hM~rez~ StKnGl+^ťKzʞr lptżP㌼i_9!F8fv^5 $s>!;05bg洀h =cI%͝q.E9ρhM$7W{K`EB0Lh:lkD'h."9BФ8=<;? w&6>0xl=eqWhp(%uU{{]Fwe10}6&c9#q<(,G oƐ8HJl2A $<Քi X8("}e,>jW$#}/@ LY6(,BcvMNI!C,Ki!WyYfe4 et>i\q4 춼6U?,qC{1h!oчe6M;],cT2|#hEd!Zc6I-)&J&h_5·"xh10{~Ԇ<Ǖ7_kxsOM㹧~žu!d6@)Ñ$-Ylgx x .ک(2:*L.q4^q4~yaps^uvq^gQ<}vǯW9k {v>{Җڜ~ck) ֬ɼu5uI ZQ [81}|$ br/2QHGB0 䀍n+^gg|uUsB[9RVԞĸtaL|7 p$d$^%ȖNNf3P w k;˫hΎCla h4<GS$P ;eOn;N(*{-Z5,w"XY3O$9dHͲ_sF8L3eNޜ=r?Z{d]0d^\+ E=JRu"S#NL87>1]΅>jՍa\I] , {: o`N(;Ջl'23ulGœLEлOlgSi DP3pXbfLG E]!äc+cDYNhf;E$PTyJk޻7ӟ﷿϶<6D5rl;Z:)*F`ռ;] Z j8X.HmBn[7;56}Z|D MRO}eYY?@zpӆePj3W'jcO%#phVI6OuhZYq97#hgBi~j.S}sF2Giw.F@ 1Qf͕ilÆi, 52P=wD,i?y7)`ueb[f-pvL:Gc캦ݛ9:Ϗқ(OuZ {Rex<j DΡ6XrwFU-Fnr4Ta lZ{A9\z$} 5u-͔0|&lY >`)*QxTOBP;5nQZTʶ03sa,N./:.1!$=g$4\czWbA 4 xXdlbUdSL-Fy2Co xG ͊y-ZGz79)7{ǔ1 V? qi{[C4c2CH mp+.Mv9$TNנ iyDƫmA}luc/H!vv_]1gPx ߢ)Ri3 } 2<(sjG&y՟_АjT?4Wփ%ӱd*<:I[Z'eZvo:jMf"[ɝH}&`)5^9bL36Ey7| gZ]G\'m19F3NӮL=|983gu3w Z5Yb@Jgp舰$$p `$`*bNz \D )ih k끼FN0F-kl}^RaHף*: Xs_VLC7$)]nEgŅ,:w۱dX5Q6"x0]@ ђHBjdeJsҌ⋥B3`䂲5,)83u8У]!Ƶf:P㐶ѫ*&[ p\?D߇xP~BC;,/a}x~a`Y_sLRRzƙHw^)U[Q̀02☴22!kV慝4[FH Lq,~(ɗ$1:7R9v%2%Pcg{SC_IzROp1߁:0P=~.(GdU3Ƨ0UBdXMѦL$'ĤG./2\mZI2Y٨p*Fk5uf\u>1$R"JRbx]ZuU?=D k_CՁ~6V6@5.f.f\m“XpjZ o^\XOm=sP$T4ĔE)Nv7Jk}0,j0;/.zz[9Vh@RQ*_Z(}d Iތ#-?On}2#_`j3M?O<m^pceync47^z` HLI7,ixxB;M*1~ʖ+'2 k:aK=l 7ڠ<\?[ӵ5׼\.C}A錄N ѡIh} BC /5K)jvV%,x -,Tc#"6x齪ՕJ7rv0eWe3LNu;:#> շ,# #6onXF@[/->$V{")>۔sg OG1Ӝc.cIB Quн zBOLC*u6K"CJTE׹y4mq-yujS<3U7y44.}RujTxek%9geEy:ڔ5D6Ѷ<2z2#gkfL ڏ quI~hM٬keH-8O CTYrV'6oT]^rN vMYQ7,l*E)X+YoAP߲.$AߏJSjcCy%yuw< |4z(FTzcErW۩UV,b^p?K-% ]}6DbRhVor\ ^ʙvgd:l|?p\XJD^ 6 Cd1%P ưr 4de1ݍQ Ġ:OdMpU2tA`"jraMT4` Acl5^56{)4 ~d-2*D1̮bMkHnHJ8ݺr*>lq!={ϱtW1|K/d?ztï ZAaj3s:~$McG$t#dB5 s#5Fea%,\OQ6Uk4\Apq&i\j-!e dRz%հlѫH00 5djLPuv chS89뤏w|Nm!F詧S0vV۾nT %JJT*>@S̄Z۞Z ͐0lޏzJ뭢~+VR:֐D z5*n'`CyDf|67vSIy8Tçx_EYQt#Ҳn:QI ]Dv0 [;_nfYV:FTeBMK}7$fPpUg{\#Iw˧4<8c(I&^5mm DFBUr{) 7ĉ"bטD]ē nh$na+TNיh[}\OBܖVWK{^LS 7|o1LŝI<1Uu;Vkwe8TykoD妪squدk um%T S}k4%:'UsΕ燋& >׊D;2MYU[3bj0@. Y9OStƸK@uSub5M:sI`KL*e}7s]!4]WSrd*{-Cw4 nOm,Z(>Qȑ5f:H}>Sr`,4DHNg2,:jm mֺ^n4 ŹޜKMasohZL(aizgEj"Ч$zyfD{%۔P^4k`*fMpgxQ_8Qla4g4*-_q*)O!M\T^ 1?'ɝa[,I{w4@FۡZlaIuj|6"iaw$Vp o:>l{־txaDO~*'3 W76 ^5+ NnU= 8/XgySZ)!ݘ<86_&kK9>·%? K10ll?-MZS:-.q:Fۛtҟ7ͯ0URR*e y_g mz7s# ;e3J!naZ&N|1KFx]zGǗ>aD-d=fmЩl%.7-1= y2e+ ԝפW&\| w΀F 5m+M!O"ȮQI~db75^P:ƐS8qN_fYgcqno:8#kl4z_P>Cx⇶9ojbܹ8g 3'/2ا.~wMXc|=uB~:|)<ӤVIW}O"r5QRtYwAS ܋?;Ms&fsYK@ ?[NYIV-n2|8[2Qٰ:(GgAZPEu{P[  RԳ2VOVCm* h%ܕ% 0G򾃣 VG཰L er> qNig =kMVfͪ^lnaR XC,tbgU'P1ڜXb1'jͰP{ wT᥉k$S.A9w{6\k5Խ-w-VMkjݏ|`Ch~#o2]]Ժo㒳滶jnұ[W"l.( Ǐ犒xG;VJYK«Aʋ$xLn&;5|vI}CTЮLw#-)Y/mjikEAVi.dѓgG"k_4Lx"<,aR;_5p zewqky< uQbŘjq@#[l&SSiY~谑  3 Kpm8\aDg/kx8ڰPOx -oVOVek{ b&W)I>;tsC%n+. LS\PὧhIP01MtT{_@7Pɓ-*H:zAL6͐ݫmxt2`ԓh[O'{LҌ]>~SP˹ Vsǿ<*LAku95ПB*]vOG/WGó4 ei[Urĺvfuhse/(qyaVW}!/0Ch3=c<[%bпfzekRiezjh"aMf tӻ܎ n:rq36,E*yOp=P4.˒c)م;d[bW޹\ǣ ÃBȵ82GOgwOןR2g[ǤUc)wwFr7|JD{V/b؜ۭNrç@?j=Og VEݵ G5h7O(2OvEq{C6kQ``vv +Z˿TpjH7CC_#G $]KۦɽlS=ztȲmS]ǵT6xHP(툉$:V!~Q?[uSeLvh,fWMr^hGJ4BˊA -F0-hus#]a2I|"M:x~2opq4ۣXf#x| 46} _ Î?ןZဢmez3G_/#zn "̌ժ&Eȧ1!ީu%sZ3:s'](X.FTB#$LJh!o2_EآHhUSGUن˯>ҖڸmܯÜ& av/`v<Bseё.nج0ҁ.71O{|s>Rg0 /*xZZSHŠ4o?$`.o}M2u?L϶@U!CtSG5Oę Oh(͵ΣG*׌Ju޷ _6)(Als$se.[ [cއݢ$ǷHQ&hӗ +AN/i a}n<$HtzپN-éf%"Eȟ?x/~-^?BąUO͟heZqc} c`5yX-ƾk2&K 0WYl6/a%q%j "_'.;p mvK/gu/ y y:'^ȃG7T5@2W\=H_gOWV9TWqs\p(y'=[I|OO}!JӰagP*jȹ烿Npዮzq44)GS*Nn4nϭfaqU@nT,͕d|F\ncXիX'E^rIyg7 z-h7 / uphC*1nF2s8vSnJ3^Լ :No4&̓8m=i$hc&C- @luZ+U.0k ΧEi<L%a1Tz[:Wj69%Wo_C,#kw̐ۼn3ͭvkY|C ҝ\ᐒN|.1p/g2͉H~b.aUg:\LFZ4I îԤ1Q917jhQGd k=݀+]5K5[7&W)ך!zh xl") H')X=oJmhjti£qK룮8-ldUֆMS=*}VZ5_dh¤K]k)r*"ʗ5 0f?l=rl^|aK^-{vU%Dߤ+Qem(hGS-k#K8K4楮1Ƶla]3ۻN'eG,jWGl2tb찴b9ۤ ;٘x572^lJ;8mB>^ܞuUחÑ׵3jE+-'3fa7 \ʸIդ(xrD9`5n龄ZiˢKSCϠ`ܠ W pޱ-5]/ 8S8'UkL5;6żO-=)dcZ$K *<3lJւoNwy_^4nFYڮByXN|nreA XmK*̿.Q4IlDM=^O z1ZUI0ղ% {N$mQjeԷ$8!9$Eeu2֊Q+^,Yۆo E\K` 0?Dވ8 Oĩ@{76xPȡvWO .u>~e} z'tu=\qA"F\0FM/):r~wf,\d[1^7h>do}ɥZ+~ڇ.Yk}isv$m\Si{X6{fˀ %O {i4IWG<]l'3{rk5QW?8& *T<9.3/w;/xP! 1f%ռd^ " 1\ub܊Rg6@S-]nmUHZ ?ZSÅHcol+Kbܥwކ zWepVE9 Ofs#]&yQ:uW5+Mx..p7g/+.Ck'sNl TWr,ٜr^'&WKϧMgO/ph_j\aȵp2 :sc>ʄ=/lZDqC:M.Vw6IpZm[$0n1"@.dRX/sWؗSwˑm)*X@/ݛ|Ul>orN=*KVœ%Mt5|Ťao,-Ц{0^iluUkIWmgmw- vOf][Tz}so}nkf؛@݋@;vAzxםK"8APK Y*T`$/ benchmark-1.6.1/requirements.txtUTa+-TU033*N΄M܂ļb)PK Y*T%g benchmark-1.6.1/setup.pyUTaWr6}W`Lm&M5v6NăHHB[0ɿw4I᲻=8X&;+%v5~!gz]ɢKލԶ"g{5eUL(; [iUŦ庩uUj 8YjDQӓ%I3!KV𰛳ҵ9Q:[vooApbAF 3&t5UF _L*Nv(-E!&JE)4qA(iRռ T 1 V `\*q e-5Eȸ!/s>\(l@e"fv(QںߥVWRs4I&׿YK)+%e \ CCr} C~mOC rB=rYx ΃R ^j"ZZ 9B #g.Ul=xe.I"3п^]\3"3BˆpƛL)r>ryiI~qȩsb݂b9DϬMr% ?M+pZ9#+TV<PCS_PafgV} e'v ] UQGyHG#SU#Sww;} }Wh )ۻ#Eݎ:pc 3OOQ!K;w- 'p$Լ?؞8]־e13M6g뙓40<PnӶu"*3lҼ#T.=~Prln`h 2᫜}*. ȩ4gс)HZɥEqc, &@y@IPڵr:Q>v' ܵl(*>${ (YUՐ(YA!8h2Z^\y;nWA:I|}+Xt t({>}u*E ESJ%= Θ(e8pL ڐU.5<ƪ:m %mʑgjCNwg')JwCQ7MnIƢC=da뮭/$'\~GHǾ7<yFFL&mx<9ǛͶUL < Zj1o ~ͭBiy;Ix3NT)Zŭ"k ]efzLz=]ieO (4jP`+Wek@"ɧ X :jr,+P*^˄' <)Z8eX2Xd)UNdUg}ORVҤ.JF+b=$:&o'j4bOH5`Ͱ/lͿ%LUyv -&B˟{]#Ynh'$s˝g܍iDz$aIj/Jӷn=lt9#袤qRYM׽̸Ɏ&f^.HMHiJ2XvطtgYQEkR3lbC˚hgtzMA^G^ a?0]"c8#V0{]d Cދ(Y./Ee xz/Y?fTBʜy76?'J!/b8R_V"_NPpi5ML\jfB/y8s/6=E9)u *rtxm@jl-$P9'j֣H,A  Ǭn!1\ 7 1=rRoLOwϋ3NeXP\sLsZ5My3~ $EĞ9g쬅tk:~ T&A:SM"*Roޑ3t<^},qLcD!/N^g䷠w&גM~"uٕ-5f@23 ,8FpMEk =%^7BE&t\@Fo%\1XjLL8n|QAL (oE)u8+Q٩Dd*< ?\ZS'ts)k^}urG4 n!uw]aGY| ,[1Rڗ0TjCĠ0?jK !~F'hR[yy2ޏдMG"5 ngq@ ]'*0e+i cxMg@0}=^)CB H9O|^-5fԔa)r7 >,y⟯mS?j&KE !ZpTAXm&,m(݇bמQ5V,= 䌃Pd[B)3OHVBjkC+x/>h%/?#M&擕U?Ob0m8XO% rKRI=K8؈۲.gKW+{"FƣR `{6V+cY.IRoTlJy 18J&Ϥ7 1Pܠ #.{<\ ~Ha[Ԟo{کLҤ/掟Hp" tڽr6BPy/g 9F7)WQ'g6/< L/pW-xXJH+^c)2,YMvo[e+d)k~M 3EJܬhUUl5 K-Xg,g1u0*ai?SB$iaZ,Q $֓BV-F3ZxD4r$F` X`}4'v)B@Sn3r ( z+!`UµR8'W tT@psxpRA@<+? jA(Xt+B'h*)耲ܑ/502P,ůec΃hKr"B q+!]7ml&flF" dȨ7K46vr\%Q?97Rݒ;,eěslg@KIJ^{I;"pGdwkV&%n8G / abfsbn h_ps#,B4 P7=o^=S,z/ps3"Vb$ )lϒP@VFJH0 2fA .,сX ,Gr9cP6K&,bТ(16el2?MjAǶdi=T*6@E;lD/ȀD@tC8-8ص VՕC$UEhƉ"`h oWL)Rq2[d&r)TZ f.GD Jx-e6l/Vչ D,p-@W!e/P1P~ԁ|!UG_j ǯ?˳? ߤRFn};}ʅ:%VtPPi 91[0 5 0Tpt;aI)X1y]U`2Z횠DZHڧayb/f!OBEӁq4r>P1_vP*i!(=;LzT\VNN:+~ȓ 5d;C×;=*@S\Cԓ&U* C?[`Y0a*O Dn V^;u8okLDY[$Y,o툒M۫bGF܉F3u<5V.|R;xeO?2p6>J2-}(M+"pmoa3WQ1*%`Do[C>*Zj:!`zz*QF{ NV ~ є*>Jls6{ZjNaӜ@/A!lre9D>*zBNΖ>,솁W&%FqO i*g q)*i1ůP1 t([E})`p /˾?Јr 6Ub*XQz +W5qL $iCޮ,HOΤf 99D(<ʉubVg1Z/G`KYPx-۞\ܜ'oMOzYB,YVZ S3ӏH%\?r8* 2l@t`@sKbr35 \1fİpA3Q}9T茀P>]-=x#!ϸ9ę@SKSd ݸ\? ~ Bk(xٺ%$f~+U{ l.e.dg+h`I;q%^䮛UG]aDA΢JC,!0@zl_H.aR'MoQ6`î4^0jJ-3C2s e7uY>aWjwG9s `0oht{^M|+q%lU6^ٚ߬ej \z/]"EJ٘B, N,piy}pv+| 0W:VOI9,p$6c*rO穘6kz>2k޴UI4)cqGUPu܁T;0).)՝"(PM썔ѕJt^4o 1yQ(+Bh317Ʊhs+ AZQ(P;:\Cy{菬ܾqcVoQ 4Y._bC$P+5L[L6Qe7Tc:O $L{ */k$hk[3K6tNT/\ 6R}aZ92Z&>&+r'7;bwSobh7 GEgVx_&D/ _WⰔ z*`҃6=m;G)7[2I;* T{]<<|1aP]#.g|@ 6P: +%5 5YlТ;oxF[uX@4}R-$Yٺ=/7(t(pnca4i7"[]|+l/k rG7{RƄ-a}LWJ|v{ ƭq=偟9YRynߍ4m\5&BW % p \v ^47얖I AZ|,քڑ笺Xƚ KT]zf-3F&]گ&xE `얤J~ +vs'ƒ%žlbx*^@ªőE.ѕ\<^*sQ~^*T4y (s+]< z^~8UgP0UN=oY䌡qj<@>s0*"l@&.> Uz:7k檞nJe>e˘@v}yqeIYHXlB33]16]!\8cwV3 No. /m(.nu:t$-P9̕:ĂLJ ;IȊ D=b/y'\= {P+*K[_<=g+@\F Ҷw>V 3poVLqnZT3sgwf,k˄.)/b$jj.ݼ&ugPu+.siElG%Bݰ+*ͅz_0zĥ2G"P%lgs|sBiI0 }RO&4QfQ.oҬ˽cig e {3o2tMas.q2f`:[B(i} KO,XwC±M~9Ms9U>syI~uf Z\@S"h:ube- N6R w1Z9Sp/9%hH>]iPt^:趶v B芴eIʷ `I`n5Pq6HBݰXvK~[̤A%@D0i3 CIFSCs.2Cg"6[' _4JY4o'uݲ͚͗ :0V6RXRi_WLy5V\[5 z\m_lb :ltTLșRqO.X8pߞ#ւ~e\Wqݔ0kJՍ-GRJmIP).^`^hS1Z;m81ExL@0%+-'*r(*ny yBT_`kM9VDmVEM]qVUvmG"`uذ(:Hh~,.w P8!¯m!+nNjǁ{;s,YgkLںʊ8W!P'(WZ:>$pEGƇSWgPʡSa0}i} οI+0LJ_f"4g,3B3ٮ6bEtW P?L!x!ׯa&VQ3{ƽwN~ $t;‰ Uxf~.¤1 'v aCß ǽOYpw(cjB!Sug4)Wa#k>͟*ک;!?D([ARUE񝖪VW{BԽesuj܊p@/Sˮ=al=slJ{ADcAV(ܴy PRL% %w-zlh,ɇ%mġ!smީlL=&֤Z92`Oˠ{I1 Dai ƔCFpcKZ!=xyiFDo6_vT~Rta-`VUkf t:w(?i4MSgv A7Ϸ6eJCfgAAW@ęgTkuֱCJoECT"[tW)>| |^_HٙѨZ~ͣqzm$C(l$t#4c&9} @(N)qId{N+T|5ٳ≚ӂhQ JL\$7~@Cq5Ls5Ȣ|VSʢetliV`1$]w2\pC,)Q?h}ch\~.WV( xKv2>N/*v&#`\-Ζ, acIr *V쪹D:|.]ਨZҢ.@pmeTyo5d4\cCl z鏲Y~u):q҉满sF}KW>k, k-~PK Y*TW , benchmark-1.6.1/src/benchmark_api_internal.hUTaVn:+0l#h6](m$H[6NnZ9DHj)Y-h9sF<*"W7믷 X>//ѯ \8!;=^$mR%w6HlRuujyisnx!{,i5,(8j{#[RQ\UEZ'Jkq56D u3sȱ`"(VMf04䃣z zOI iQR.*Qȳm\vE ;XoےwP/p/ʛ wucRiP!~@h [TԒbkdЙWtE7S DF 2%i5L OFQ_OzSBsPK Y*TL q% benchmark-1.6.1/src/benchmark_name.ccUTaTo06i!H|iǤ,01irkbH`; Νn6*5>߽{8] ޾OZ%BFe ~˂A(cLQY̠Vp¨);!|EcV.:>'[{CXb J;-RH^V*EXIW>- 3o-;A *Z- \K¹jǫ*pMM/ nT YKCkJŜbڀ ҞLze*[ I댜n˳ ERM ׄ.4ddv>r4%gS\d|̒ɘVa4_iHQ + lS- Pr!SZEHThT-Kg x%UZUZ,?EQ(DK@xn1eExx(_ȳ@i?ͺl0`Un޾q>놅7F!auQd!lQL9XJOAዚdI䬈~.ŽY&'<zplr:+$ 0FpeB.F~$v `qr?&z=&& džC6C^uX]v[?k4Gʙm$؆[21>_/(?O΃e>{ 凳e={l>ܭ1(9ڐQ/u:ER709QX'y<[RmN6'8fa^`x?PK Y*TB<8) benchmark-1.6.1/src/benchmark_register.ccUTaks6~ɔ-vƎu(vilg,^.$aL*HqowI9V>x5.|0jܱD`*9e 2}'E&i$ $G4cfR\#E R bq_8yK>rٛm M˓.paԼy~f4<.QH]cːf<I siV[ &>d\J(,{XYLĿ @;qvH+,I4%86D>+q>e;f27jlB54XDvD. XX9^=D'Q0Mkߋ]/ IPL݅98ҽ$ݦ:3Q Z$Vy 3#h/?sOI3&H2n(LEr1xYeUZj-N1.f5vAQ ]X#bnES9`pE!C|)jD${l8Qۈ9Q/1C,l ቘDȥ79 O}[Kƀ:x%3"[|w[e! bY Q!c2xJ0EYQsPEc<0,0SNf kK mC sȯ!*Am<1y{[K]d,2Mbؐ @@5"/N_c7, "@ڦA .n1V]Z>A BqZwOnA !,D~TiƮ$b 0]Q'8m5[(A0K,!oY~,[DJB[yM^=.[-jC8tQ%kc`h+() cr X&@eM+#>FoEW簴[eGzHә0OX dt2ֆ )K!2n,'"MK@b-cZڄkk8GS]?xs2+ב ϒ6‚з֡78!Krrh]`°ZiR&ҟSD 4+H,"=S[~*$R >}bGGlsgS]dz#Hu^w݄5adNwP cЏp۰)(^`$ԀaхW$?`e]rFhԡq1sUq TXUa@L~p=/)c5W޵G.2Ai^TQF] PZ'<7uQQEyAljV`NXNA 6_B;ڼfoi5ZG&jEu j:=ׅ,-= 9ZgKQOaU747±} .zARm@&4&Nhs"/0iDh6 XbzV}G z -p`,Ap<\[2Bo9T[%SLIۛrpҮZVhӥ;< uB #T&yh)D>{d[ x0Vy`j~s8tv/sT:Lw 2R~E wm_ؤ 2Mvx!m3l[w1_WUiG:qgG6#pȷW$%[tй\UK2]eŪ, @Q, k4Es\oWj:ߐugZb= CY` LjQXB$BsK_Z T5~S_Yx9+=mMOΨ?11J3Sz gܢq*xJ`:ƒ؇ܚ̟'c:<Ǧ60Jݜqr.mc@nU й}5*&LԖr -x?\![܄*_]}/9شq.]`r8 `d0J\: cQǥU90Ư t@Oa=\&&٦HQ`4,moi((>iD4Td&=i JLyy g{9ja} }zOx~YF3zf.1N #6-m/piަ(=~̻~9Ōkid(Vb遲!q2=_|x pg j. FΑUOG M4L f}&ӋEы*o+,"sՆ SyRZ[2 -k ۝}6jҽHJћ<@! !{iYV# מR_| wou]΀^oqNa)bӮivQϧ?4re/p_()<3#ַ%bEl 5 ~8q=rNp^dndf@PK Y*TNj% ( benchmark-1.6.1/src/benchmark_register.hUTaVmo8 _KYه;/"X݆Cg> r,Ėr\?ӼZ-c\g2ɷ7_ɧCr9BucHl2 W㭕L[Nݴ|Xt;-*i"0:-*QykUi'k-J\윝b!u0+Y[09TMNЕX%(M 8Z[Ph8A։^=jgrqZ!cn;g벋 *_\lɲ8hd!,x"BÚ~M'w_O;]x2mчhd|1V:dc2EN!$y%E/J*M< h qXS83vFE)]zb@5bP;:5.qkG !R0&a t+ӔTfɰBv1y%Nʗ,;C)5frLrtԃӝn\vu:.ʈq mJ=2!%h@ 4 {ThmN. G RdCy&?9c{"^g~|?UN-[b&\;Es*SDYHf8(T+èhFlvG 7&(Mlv,<[yDCH3`gn}χ0Dژ(Q?:hKXs?輗’x`enQ-Jf Ckjeb;M=@IQ.ZWr!ۓ'Nɒ 2U8qxW& ,}a~ 7hK p <gK6hLKb88?$DVJȔMkр?~j DCT7nwd(=6J <^bwsMG`n-vA[ask0 Ǘ.PK Y*Tnm?25' benchmark-1.6.1/src/benchmark_runner.ccUTa[{sۺߟqȴ}zڙ+ȏ$I̹m cM HJvr4, XKXV엣㿲7EHqitbP*p2 DZ 6^Lϐ&J% vMYe|bC*60xŪb2gqRX{Y-< J~7n>O7wtv:7|_:%upy''r!dFaSoE*2-qQW^JV/E%3i%xkY2oA~KQIkLeü]Sw6/.Ң\۞e`I< ]wk'LE!nGugx)ڿd Łh9rcgB8 loKz>}Fh'b,tU'xW^B``j}\>Gέ\bU@69T`WOѬd4ҏFHl j(ﴎ*a2CߊtV`4!"|-Y~N{vȒFWO2רW)B^1H 6NuEή]@Fڙ3eT;L$Z`-mmeYQunJ*5B|&Ro;T*CTf IovOi^i _-DAl7mVK] #YB ؈}gu J`DD]N;xU?6;@.5o[7,r ߛy{D&ʹ=8cgH @g͌n6i:pdXE8;;5Kkbgm:z}z<:fĎYY6n䵄lu4?pm}]ت.D  &( Ϻ7(gF  1e< 䂙 ̮nk!.eC >?ZS}eTfH&CV >Bua6.E&rp­8 \"kw71=f"Y$63e;rHc ?( *}iN](.^] T ,N)y76as%FX;G4HD0~__X8{#*7&0cB疽8.MHMw;Alu{z2/e=-N!JĄ~8rZ.*9_.\*T}$e~y/?G`:uɅ78"0TQ,E :}`PKɜD( \Nz~f5 Ϗ1b9 Hk5;0ͫUɪ9* L !P7pUi98v]1zM-#oVd *0ctb9dχ . Oec?Vv?dB6 ٣HJ9FQ:E)yvN-߾YDxa)i~L&C mc|!@]Yk~I ƎUϫ)I:bGOK(&<5(E*L.>~b5VjpتWREyNrma#ntmTiwTc5| kĵ{9%^%FA 0E~XR9q> oYſEp\r#7ixMT2s1 ݩ9%vF}\ЬL՚W#}˦6ܦ<ŭ_̤N5;%XDu!ĆK51t^|f5X?jÓޮPZ@v,Flg ?˄?`Ȏ! Ñ(I$޼}>;Ýڀ8|uR .<h1RP4]!h7@B<0QVyA| GsK3҈m8 *RrcQh%Xu櫼3 Qxdvs b+!2UKpg -|%\H(.+~5U8YP<7V ==6h06x񨎤  L<ǻ!p;Kǵ@PVʰs%!_r ^ȡxHpp 9!7g˞~S $Di{T-ec] 9|5j `G>bqbϴ!a@31G]`~8>>j2%:9` 212Zx^%C/enA5{u{{&TKRhRfsu[*T <i0:=v錚JkPX4~H3<=Mg@%O`QMcħ=.&3ާK4ByDy#lBDD yȧ,fG?sg,:baKpSIxjlK=VC- %K @Eo;6[<9a,B-lp"sb/ަsjFWVywxeQJ pFXijegPS$"Oxt:k85Nbpk:ʋ{L]q EK}%m]ɋ2*/|zj@;qFq('=v>ѣ^R[V4`3/$iTq'QdϜ]+{*Q3+ܲdhd>f-:3i^?'u+':c(:ݶ+c|zפ6жcM9m*rKl g<N00žVQ蹎7~8Ō} =11Mu/#va(_\6ƃ%YpT (U Zʠ5ڢ;)a zHp"jMUь_tu":|4 Ch؜ͱrY'm(x ~c@"D?XJ0MZdk3mˏfJvm3su-ح =4}vtwCqy!d:>]^}]]FǷד7[^ϼ=x{5ѡ˗>`a5k6޸GMfcݫ_2΋>z8O&hn>2CnnZN0~)'oDez+x=ɸt7X+0ZT6pBobn'IC氣ޝ,H@`'^ l}EdsCϝPK Y*Tiw k & benchmark-1.6.1/src/benchmark_runner.hUTaVmo6_qu <;˰/rqFhrZ:$R#8F#bqIGF0F')/!L IB ao4?1 "Af0)XLjBp>HN"Cm^lD*f 5HllFZk h5Sh$\ѬHwПr2ps_'a8 CW5LoυMnլs (cR˒- @sm`bd<M^^=Ok `zs7 ?Gc&'xF"Y)dEF@rX#. Qfp`Qb%rKXg 9QS Kwy]ͦp%9ʹ ϑ#NwP 4 \H2[R-AIm~BVdlcۄbх=mls6wRF9rel ,EhI<*fe}AcBtk/Wb`eF:GHYq\_+3F{mK%YP;أ{jm}yB}1xhЃ7Aurm>*nRg=qВ MPEf T^ǔTZUڊxt 1l;s,k>(n~NnIWLstd/gupZ ֐,&v8*_,r8D]? qknJgb:ÂӺnW{mCep ؙ_j7d Xnԇ@O\LHbFڴ&0s nڃ)J&mm:Q̨̲ >tߥn..X"V;p m TtZO;dT#3^|k鴮w}¨Zn7n[C`ۊN{|R&D⾽EkAٯ{Q vVXRI= wvW̒j"௮oƂ"?ES9tPK Y*TN`  benchmark-1.6.1/src/check.hUTaVQoF ~ׯl 'd'EIP2$Q-p:+췏w<ٖtz%#!Oe)L:t%gp\ƢJ&k(u"x5VVs.5*Db˓lq|i d+, #D(l#ݱ dt 맜'E+}d"P-<;԰ysW&#,R3`78#*q)\lcq.c8{00aʄɻP7tl pz )X:i2y20~l3X84*֘@8[mh' H@\P%s DT Kpla)KM{LE TrZgLAהr;J##0-:~~~(|>9E?=?.m{FE9i7'eQi1-Akzr`M^fz"U?p2Bd+;U t8k fE%_PK Y*Tc-! benchmark-1.6.1/src/colorprint.ccUTaXmoHίFK Ն$!$A@d(7kloUw%!$pwUSn4gsY .$O,t+~,," 5gNdBGػG%1wqԋ,Uddad~$')˂yꋯMtj3ڼ.66;p>a8)Xm̘vwKwؠY$ڬ<|T^Rrrb\aFjN%v'K\i R=d| Bslξҽ`+9bid+=zA2KYKusfBf381THxxZD#.u0D t#S7:QUZCB)ԃڤ&9vLI]1L믇}l!(׹v>U 4x,zViZ"6h%d?6Z) iI٣%uRN$ZZucoƳa)+)e GXذm T6CX xGAbFy_0OǏ_Ռ-IZkٖҝ1U9rlV\US^r]פS9l tjܵu<4G5oU ^l"_=qnN/GOߡGU[r}GqH1'XZ+OXm,}vFJ(jxVĬ,r3YAiԥ$6gߴ.E02y6hF?VǓKۻgEɤ[m@ge}FHb7 7raFy4g,I$n<9X34kq2?$$q$ _ ->(:U|`w ;epi<0 Fl72>zАQv#""N"i9 6|Eɻ,)8qPHV?I c73IBєlϝI0F;"<=89:n}NQ-丯lDztN鄧')al’\j%sDنHLS6&-me$;GS{ӽmX8p?7i"mbxQ).Cˣ6~8ܵY)@EP`!f:,P)EF+ 1W *69䱶/\҂Y|BL;ƸC=*DԬvf{GN)# Dž"dxZL怸\ZSǨoe&Es(\kfLg_9_'Rjxa"guDZV.Bd!MeQ ϝ.$ Q ng~kTqr~կE<ʰиg2X~SƦ1Ar ҂$H$$7HV+geXbh G?eV+athΗ<4':):Vh@OznkYb:FU3ZmZے~F7GF?=.|әu?瘳'Xٸ >yprb&oVJ[i8X?GQΑ>3U?,jEA6[;&8eEϹIMԽ)cͧTo@] 3IHLn+IC0\حLo A;P;8xv}ꗋ7L2~. mԶQÖG~, vZ [ϡt(ͽF1U*J)(%D OGzy5[9uhYd@iSMuo3j ])9At0)>d!)nb^&qK>"Ըf5 Ro꼅>2LTVz<'oiAX-kZt.LK RT#e]XbL=.i-0֝@;x)3 ]YdOdAF]]}6zf#?ۇCapja^㫿x`ڔ/KEwoE \f/w_ taYUX)/̝0 >Mo-\ J_ftQJ=-[fYf,/8:a)'Bŕ_+[XU1tLDBb|GZߺuY*J%G!IL I9˯4ǪQ],cՂO A` mXJ2?42|jjPO2۽LJiJ7)$2)z Rq% 5ddt+Ya/mWj/K !0A .>oޅjiRQ`\]4D 4`7(+fMR׆n3`?dapmn+ ALY[Ĝ ջ\o6mYT~W2@-cfŝTᆔš;+L'KY= 7pmy9ƏڐZ=L%& benchmark-1.6.1/src/commandlineflags.hUTaXQo8~WtЊvOwon%-jiW>@Fmu~3BV<@b{x&Mb1\?Flts7OF|w$N7Q/8|Y$\C[ڨD,/;w`"%! ")S%6)8nQTl~3=ORn@#B ?j:p&X?o,Qڛف Ƈ t|zɋ8;l؊;,O|R#Dh.tb矢kk%,} md˸e’͋Wq//8QĤ5PK Y*T0! !! benchmark-1.6.1/src/complexity.ccUTaY{s6_$P˥FqTWGEu:"! g`Њw]!AnuGVdMoI*)$\%OaC)SuplZ{,fy@N@OKPeJl4n6jĐ|:; BC҄I4 DM膈8g 90)jCsl".Ủ`5xF&.y1MfdwW۷|F.ߒr Oxy2}9 ,YiHfDX #Xȗ<Ҹ1#ay k.ѫM\Q :&Q,f"# NAb\Ǡ aeA¨T2G4SƼ h 5ͯ;x&E#}6XucZzᚪթd:,!# R'k&!=|_?gOɳ#< WdG@L 1<%M@'3Qi<>u7~vtF90Qfﴗݑ|h4Ħb]8?irVPl[Cc !0N\$*+7f*e)u^k7-;"Ԥ)pz`M#vĖH}t[+ut2rQtuЯL˰K)L~ڑ_Ti Ң;a']hqcѴIuФ-AP>id, Gs_AX了@Ry⣠8 "5O|X5}&kz<ci):&t+iC47xrOuU-P Y ոRR]6s ڒX(e聉]窒\o[F$tV >Q@-`va{V 5^FtFsC q㦇4G${15z{-3{Om [X띿CE!Pp| *01Ņmxm-P]J޾Ur7XL H{͍9K|^Y BH5Bq6Dbaf7rCJ#MRjP(.?䪇_+>|GpTx `{A<":l\(1.T0(8xmv룧gB)jeV<"%hm^t~=}EOܣ o5 ;6b*GCP ; _ 7|CGAȗ~HNN#C# @0M?oؾnPu4雴W{;B8N pK#ҁ]mNw' ~PIqfA!P3EJớ2~15&v(ۑgj4qfu̽ T*(+e[CTe_+e[@}4z[λN;8gkIu ]%Tvj_})JL/b__0,"AC;uE4`F]XwYauz5Dw{Z=@āx.C8p;>&ݗ<үas̔}9Sg쌗Y!W 8 :,rq7K٤y,>rWQfP=hi6+Vs3+heV @ -ҹl\24CYޮ1ָ#knUwͥnU7{,梼w#߰RE2fRaCo( ^HfsIew*zLi$;}Fu)杊ys:V&Q]͙ŢFPܫw<]_u]1 c-ʝ=y|ڐO =U'Zqꤞ >G? OZAnͱPn91ݎ% S\dFD- (Ts Lhi5nA_*+BDDņû*l2d3πlGGlC/Hu=af񸢍etK( uxSoAcMMRe\"8G+RbcƊÁE 5t.4/HJc ݑo"J&e:{q4ܕ woz8Td+ Wv`Jl*L I+ PD{g[.(ۅ?xtDtQeퟶUWΧIq~hLMuPְ%3O[tpNW8l 1Uz&[œMwn@Rk@|ߵ1AyĈ-N4W~S֎,)׏]͓YShmE[:W@bCAu|( 3k PiƉ*JiA{mİS2ݦX+q%mӮ;^MԖӵNA 6H渀8OX+t vx2e= e*0NCq fJ{^yxyq zaa!~3K%^SL9sR吰H3 C(X ܜ FH!̒M,Xr 6Z\8|Z6h{v3cU/w3M4Xt\Q /mШ-Ԙm!VZ+T[&9R,r݊Yi"zs.#%Ʒwi8 '3NǷp>'pÿm$yf M"9o̬IjC!rL#pEYUh`Djbʹt~i 2:y D7DctK|=u&4r< _{/4#Pgr$"˘,M<\ ,lG4ȵZ$Xu4IY"CYdY5,3$n_878x:ƚ2?K(؊H9ʛ((Xs %S>(WƜI>ҪKDXt둔]ҹ.G>y `i\7&A1X مc8FhݦfA` 3H p:2 Vu td 7]Ʒ"J ~ -}_RH2@Xa2/S;T/<Ē.e Z映N>>XLrޛ|P1'P'-RLB]#H`@kQ0`')yK!Дb٣~US*49pUyL)TC.~1OWzMtm o2؜~9E1XR7"#RDJR (M[(gpY)"&ZC+r-9TUe`˱8~KRVMOZ.sm5:>TeeN=1WyM0Iz=ߩFx_3*L,݁*EmG{pg5`胤XlY *'29gAj'8LZQ] =_q+k}kcԉ`96 6(Gc@j]lSE58TT[ $'-bc;"á8,yu-m>*o;w_{',œ$cW@w"LR]#HTV ! 4*M.%ć"JWW<2s]*&w;r~*>ϙ6[*&IIt;F(a: ZYw<@>m+//Nt`ӨUqs,ǔp-_x` z.͓t~ΤǦ8tYneR1Z4R#r{MdQFv} EV~\ (8UƩ@bY}ZE:\l\xndx>)`<,R7 udZ̨ɲ%BQKV-ꆌ۪a!+z+3*8Z<-~DlIv8CO'UfuCUп׷x "k=GILuҢ>X k@9J4k L  aHQ3nH jb~@/GC:Xjk(r×c7PcҾt`oT )N驲t`P^w2j:3T 5'PK Y*T6G# benchmark-1.6.1/src/csv_reporter.ccUTaWmo6_qӀ^/vqhqҢ@6WYH*Nb;Ŷo ,{߇q=*\xM.cI``4(Ԩ1}2DcyBe"b Pi&ڬKAg&@lH IC@X$DHV |)ls#H]ІuE?+cAlzjُ/.tĨ?s#@bNPcTX*52荒F&.ta6B!6JsC$ ĚH Ma2 |4Ll |]_.o&S^ \ct>d= tA)b"ut\Ȑ\KX",{T yUM#6˵4Xю_Vgq!x3YMjE2%"P4ԘdY<.Фvb0$\/z@Eq cSr#悑kJt19ʵ02 Tt0|a>"t?ǜnQ5jM6|y|b c\cB{JZo PҠr+ؕJ59K<iN04g3aD۲X1fPT0/; y)݂a ,nj>X_Pd&@mt]7lH"]{Z/rÕP!3tx@(VAD; xN~.DM^Whrig՚i kRE 8M >ڢ}pn|$Z̹2o\pڝncX0*G{}*}_牮HPVǧ +a,7İEr2Fl:GrD{lptifF 'r/REzVPV`4沞vc̳wJާhDfhcRhxa6~{1~pTiIAAB|irpx -]x# SM"Mq v>{E6vm'R;Mr@Ă ̑Enʫ)خʺ#+aD4l5< ]gެt˲.ZfElc(v#{~av_\{m՘:U-wk kyкSOs?LqiR88PXX2VCb0ưݯ:xIc'}rN=S;wܩmv!K Țr0,`yFf;]pǝCR߰k Q6kV$9;NoCm{zGk i_\v\yrں!c9zZw7: |;k PK Y*T1# benchmark-1.6.1/src/cycleclock.hUTaZks۶_*X)q7U+Ν@$$l%gKRv3Ԯb٥ hj&}ÿƐUjJ /,Sq. R"D;4ڱB-2 WfbO4W^apxJ'E.Dx7/$\*!^\EƒH!cFQAn@+h*b2%Y4SY0D yZ 8Wc!q:hFR<TSD1[d2W"HEY5& d [7VXI&ǭ4}JjDS!f3EAbnl!f8,4&Ybls$~ttQ0 6Î|eA 2+}%2%}JXet|)mc>býdM2o .mBh:%pdF7ok5ׅC8ah2 >p$"`Py"kN^RRq;u} _d"S!$B%+yp @1]TQ[ex`A'0K޼"rɑ> MJD]y|0F1bӉd;d.I^A2һ*AZ0_ߺt=|^_ 7n/ǽ@&:(pᱛw{';L#YۣkJb=WOz?>o-|Pyl5ôc;6!r2߼9j,T U\H >NnI[ م q/#o#y#77$2L} `CMS;wtpwlW!%Pxt%)BKV\@/cGЙNj(`pl9΁MFeg0 9eER>6qa  [=-g Aow|u1:]%+vB@5bb(T'O!(9]\KI|Jn$4cp ;oq#}#٘4pkS0 3eV!S0mc  Լ.R@&DX4\vU)]UG0 Pl@~]zא3#-`,25l Ù\>qոCR&`,L "(TVLx?3k}Ae1{T'a+` ?W5lSG@NAW%%r^H+1,Yp]&KP# ʸNOLyDzR/lU=q]`u|eA ]W&&v;蜞uԺuZɑϣX]0W7.&MtNN8:Ķ$wS/FP,1sEqF&p=eJU4PxMR;ڸ|J" V!4p#tiG营iϿ6D;74ヵL:,*=} œS湤K^-NOY=MPJyt([::]j{0,[s`TX^7U@I =5ޝfLWgG}>>wWM%QdA+]%Ƚ0$J8>dMָNͭ\Ttr{;wsdvq8Lc$c **+hwDh)RO=lbʈ?ɖԼ\{DkC}`vl{[1nT2-&l3U֪Ң\΋:eN he_ *ܙ쓿re`^ͣk<($MM|/c(L8!qVZ@ɅO$/$BrY3 @4 Gx(jb#e٤uCQb VER6O0;|Wi)m/>^X1~O}Rl,ennf1TXc<KQA˜ҁ@]׻cT ts֠m jYSZe#ASSMiR@D\~r9:/`.m)ʵmMGi%E6A`1}U@dgaZ9g(90:"|>k"rksC'%Աy-O.\F1%+?'|n"Eх~J~ a%y[dܢ ԡ]|fcԼ5vew36rƊOB"OTbIq$Dxb>K(Q^$2&CS#ۈ1wJTA8eDWn$rR 8s I:Kmǒw9CV/L/4 a-N]um'켩:77^ώ>;=)2Tá)oj= ~tq0|O.hKҟG.|Ѹd )! }r8f x(7}hL9GHBr!R <K!x, =BNÅ4? h$.gH^Lg*eۻ0p'J&{^} gPiCt<%' <Q)PՀC$dDJ'Bp҆4{pbT&bɊrr{z?t?lˏWxp?N>?8mG'd)țzayEqUJcдp ItǓ-'3ҮOl1I5bWx.B/|,DfLN+E(!X(#Gj\I E*ЃU+R{N'RЛXrW|LkB*r^L:! !ȡ`?Qn p?W@'u3/ZF0  \/Bk,lA? k5 erz,M\J-\Y!L;7[-]jzSݜ 8x {=^s}=rzWR kGZ*YK%LS9|>fY Wp!U Oߚy 2`8#5s^;]ПN)ku<5[B_\E[OW[( SiJ*/^I mg]џ$&ߺZ39)>҈C8MȖk4IJQF=ȯRb ZHC,tVL> @PKS2iXXJKn\@dY3b>XU K\]|r^UΒWy0vg)*Yh{RuOŐի4װnXAH7LT!APА EͻV5Eh\Qv7py8C5LZJi i ο١rN'[RUQh\f&@Eª6gwN1S]Dz\ߕ]Ӵ*~C;U .E'kINǁIK4|)rQ"߁>+^=⋼TTOߡoUoA;42Uzo;M?y=(Rlq6ȲV-\hmP؈"<*;MUTvSt ޖZ~S9 .(;8U d|Ug'"$\ܳI8/|2ݲ  ϑDڂ$LKq; 8#9u\|Mi<%s䁘)ZEʯ9y!̂ I0}PlazCyP8:3I*ȿ}zN,'A jQ+Cc@qyٓnZ+\ikJFv "vzYV]_|Q^.rNXԮr4nꪶngj\-]*!(R1+Kqe*6ȵ-U0R/.F51[kRbW'M YP >܊UwsY?7JBY.ʥ4)Tcv<$|gUf,"O#uZ\ :$wz9R墒) m,Vʬjyx]bueٸ7sB!wUCSlp۽;%gZq1[Y ;$QF% *YhOS2ff5f`NHLvvLf&y9lC]LC+СCJٯulsX?TrO:}-6+z'_ g%;4剬:SKpi^`,@)5 gfݘJk&],$P|vꢼF_&ݽB]Io͗k`#:m^٨NL-/[O%ۥ\X,*G\[uY2r8/?ztѰ"<}'<͂JEM}a!ƞ: `bKo[W_R uuh)䩛TT 9wc*F_Amђnv؈eZ&%W^FQ*S9[$A&W4GdGSe(e[`XQ-Y#*ҝr$/WqhW`e6XRe'[j-541߹;d ֽ=o4[C6=ZynPK Y*Tջ :` benchmark-1.6.1/src/log.hUTaT]o0} JЀ=FiR:XMqP@:B[iK{O y_͂tO,.BHs8M 0KMzGE 38qxnBj$$wƍ\@sǶTT="b\5ԅ"{.sM%6.lMJ_Ddp;0 CS(t iByTcbl"f\Q*ϳkR(muպΦW˔ء*CX=c׼?{ Anﯾ׫/?&ٲ{ok1McӰqωl/Ыk\BIS"dlmcxS6y]kt}]Uт)b3WqJof㱊-iN/-pҍQQF`F4Fhu g_h?hl_XsuEaM?JUB5Qt;75'Je]RDMlD2O%VY?=V<A&&"PK Y*TV&Dş benchmark-1.6.1/src/mutex.hUTaXmS8_GgniI 3&%8ǔvn4Om9@[رc Hv}ZxxfpMW׮\7rE7pܖ&QZ >F9,HhnVJtް?,19qr.3&W@I<]c"? O0gMrE[&hbx3Q-4!s&"cI1]_=\{I'/N G_Sa-&pdcEzO} +K 7`^o0^2 rz|u,)CL2 4tOP4hA}L\9U~%0V=, ~}o},eY=|w Xk?,1{g}."FaO5wJh:3iQ0!ɮi [k`wxj ''Ĭ R'6~&t4}=Zi*9X'Gq  " tVKStO=,Xg,DLP81P(繤RM,3ΙBᗅ6UZ>RLz($:i *Vt(R1J?8,9(;Zq*z<(ך_,0M,^O<.\Y?ueXrkZuڴ1ƛ \22G*R2DJ<;NejBKQ !|`o\Fvz&lzYJz`+#9&0i6hqAHp:m.. _\ZK7j@=iBiT] ")t9]W:-̪ TwU"W!QJA؀_@gؤUgMjc7H%k2_8+S+gU^q9 50Z`Z+u%F!nzoosz}{y[%F>g]yܪH4̅'<yݺstgUeʦʬotܱ%Au!ظ!IP-hg RL"6%3C=k+mjPK Y*Tͽ$ benchmark-1.6.1/src/perf_counters.ccUTaW{o9O1T IwA]]TUZ]be}{1 iJ"6xs{=l#Yr>"N(x<0IHarECyH%aF|\P-,I؈R.4䊢 bx9hqD%š镽b, d+rhYi{z%ஐq/)XU' 4: U/9r$CDS!Ē"M cZ2x%"&5!SZe0LD]Dph͛f8䃷x?=_l6,3M'o7cN>_m("LLf,sJLDah"kC^컒$)PnˣOsh2ϜM2FoX*T a5@Q"u qdE[@ Od"w-f P-8pΊM 8v)a. f(N0ruj!cp;2ͿđD!D$Qȫ-Q4nnN-Տ`RfI[U1*&po~^N4oTW( U(cXP`!`PyfHSeW_c]5csv1K [}A'DFyg:zYxЮjB#4}t SVcojX"֗ԍSTuV1aIJ&žRHሱL]&{Cw3褵ݬ;pp|o:Ǔᛓq۠ݩ~<'kD75ی;;TWy-@jh:Bzd=h+ KopnPoeK'<N#cg=n~un Όz4 $O/R{#ԯ*PK Y*Tq# benchmark-1.6.1/src/perf_counters.hUTaXmo8_1r8ip8/n&N'E!ms#ZJ rfHJl']>]$63όtxY/ ?z~rqIYvK⚫v[ ")y~w:WZw {~k}L*V%[A. a&r=C"E&XpxfaZuȩax@fA`M? ccYR3wTdxF{<G):<]+ШMԌ=T㞑dFh93LqR mD< aw}Fxn=kW6FxB`R>+}:)ǁ^ c<\(񀹡 ̔i+7Oӕ?l"RljtJZDV (׻ƚƧ^:ILx`M2bwuTڇIqKX&N6N,lnwPC,߆A S~b+Sxw\b0!gURIХ{zV2˨|.nWW*Reb0Ķz4612d+O#)h0bנ+ut!jElyZIX{KSk AW~d={tSR!8q`mRfp?q2JXl?ڎBJ@%6Lu&S"rd cQ Wva^=h`z=nty/}GvjR3KrRO}]~Yd :?x2K˜cYBmh?N\-3U(uU' w'3 MolV[|Ϯ R)t߷j' %DSV'2 *=Do0?ģh]Jk(P(z}ءO / 0Lz@~(q<cw"a_TAi60 |ކMmrlHű׀tR/)K-l'4K>=χ^O@}1plv21&;'1k?Ǫk-\xkPK Y*Tp{3? benchmark-1.6.1/src/re.hUTaWoG#YGTU4Fq2v>Veكmޞ1Mܿow|RU+|yvi6fK-3C/~7i:MoP'IȽI\[1i&ЅBbBMf&1_::C ^jֶ!iAs$*r2X""3$t%).h!)X$ 9COqՐ)A۟1Y\, 7R=m&4o^wХӍJDnG!5 /ePTjw&Zu,6DFqa6zʫSQGQTA>χ7su\{#^Qw88_|:O?8@ǐGeVvFBl@S)(MM 64MoV22Spb$r. 3V] x.c<7螿\zyC75ߧ_;M7r8]ږҀSqGH-hD,c2hbXGEp߾~ݹU#_$ES?IoNώpUO}R:V.-8:K/>c1XG}Vf;yzЋqˎ{S| ׉@ @w\-22B b~W9}ޚpZɩN#K(OE^m4cngzpZ耎>jʂ};,ZI?4Ɨ!ǙV;CW~l?zpfz%(͜/+PK Y*T#i@R  benchmark-1.6.1/src/reporter.ccUTaVmoF _X';%`;nju8Y7`pI;ndEv6!/CnElRpv.eFa̓Y%APIŚLXB)hRjE_UFd#W,unTl 9/hIQ`h>$T8$E^f†Si1booӻh70^7Sza<E}(dMDQ¢p.ɒ&l /5YRXk*8F%9&LLeI =5IS Ti +0fJ&-'eӀ—MeF5MT!.9*'K~ W~CX+3˱ $ˆB5+dH0(˜.싳с%Y1'YxA{7ةe!PS=#-TtVV2X R[XB␅|;n#v`)9 P"Y2tHZh=\*xS.x~4Hs \gBD5|ss'EB+tf?ofHhIjno^84t? tdRؐν=քa\1JJˆ $U5uЅ O]W`_%mx'|,/w[63f %JW=8uizZ: .IC E m; O:&+ftM3GoPնQj&07.Z$~@?. 'g+bSk 'kLAZmes+.+H2yA 2ϱ)}Esd8vg}8մbW`TiN }O mٗ(_No":&ŊXLD:C㩣5:S,"0X#jt!TJHuL_6XS1HwhJ#^1npdUPK Y*T᧹ benchmark-1.6.1/src/sleep.ccUTaUmoF _yXj藥* ]}1%"ݩw'Y>RRlql<>$Lp;#ӝ W,ɂAf7N eb р! O2?Xai8w\܁JCZH$%HE&*vu6 W_z r(HJ \[4vOUUy.&f~AxAEN_TVJC o@TT$Tj&*Djޜ+#TN\% rXZgt=JλP0Cx3pAn5Wy!,Wp kWo'Lh6CWBlLdD)Bhu\Zc\:jգWi6C,ݰ{1J_u5řTNx %DEdm&1&f\4_}, ᰼ ;*b]%@_ˮSh6qG-U˅ZOBHh!Y&-FZńI{-6:6#4ᨧ~uɋ{Dm"akJz5 ʼm8x~DG}OdJ@͞᧮xvp`O!ĚdeQh@ =#E u1/-"i5N7jps^nQ4H0U+!3 HgXc&b Y,d]zÌ5n 48 `=4;{c=2âڶ 1fΠU~^Lob2rdٰMuj\{@o'du+AaUFg';GJ&դHII R^d3Q01Lr?o;hy:f}:I1 }>M  NPK Y*Tca benchmark-1.6.1/src/sleep.hUTaM0F=$l &.`HB!6@K(1݂Cq;ߛ7ӎ c[?tHiK׹@SDQ5!d(عm W¤PpAuȫuVz_k@?2 _;~L?oMx\$!|AZ p2q MP/bfB,bd PK Y*Txny 7! benchmark-1.6.1/src/statistics.ccUTaYoۺav*אn^\@KMD]"CR%]h"Q}wxؔr/N\$2祖xu0CX)(W"G=<{'f"\NF"S"fU`}_Dd }:M^oXkV)RL_"Qh&3iHE^=N7'#irosq팦z18QbIѻvLD( JpxaQԄY^2(霌^a_zKAbbt)gĬ6pp=ewzz7_~~x` 0ˆ6h[g5"vH26݄QWK:1֟62 E"Ч;1c+D0Z%_ ^ 6RŁfIF1UyV[Rѧ&FL9*HF`I?jAYI 0|^VLG'v./IC+ob'^:Nt*>|x@EB+hc͔uU:u$d2,<"uZ @stZ >g^>Ur +a :f6DO"V]Iمr7 r_+X}G-q)\N9QCk2Q׼ i"І1DŽP~w*xXE"i+f_{k!B LP ECrnM-t{&urh]y ;r) ]Ay =TĴ\Bp@SԶ{x_@3+-l75ÿ` @DvKeaWf,r\f)S^w<0*󰎷jͱz-) BF% qhyvav4܆cb {j =uH{vP'T͵< Q$5 !f{`jzUO~&"HD!ZUħ="`.Q`nDU9c++\4r3<5rDscZI0˦ [(h?;6m+j~8̔ M&%6-vcWz MRfIhʋ ;yy uFv#3P5fhlܑOn'F*}8lmyV]Qܨe?`"Ѿ2g&Z_o~y{Q)y3['J+wP0pel%[iMs> dz)QY֑сek[uD]sL lGOFNZmIAx ¢G!:;^ϒ 8$|&J ̳#{LmvWCj:Սi, !s`]`:XQv?\vYupPGgxy' l"s͜axLUTݺLi(C/\7,Chg34n:@잦~Rv` u2P˗[<&DQ/]bP(O4vp%I"8w;_u==yz$Ǫ- A_Gƈ,7B`|y&ގ snd4vAQsX|6T1PK Y*Tձ benchmark-1.6.1/src/statistics.hUTaSO0TQ0>0CH0 Z)) >!7;n4E6!=Lt6X:8MtV%ZG# 5XT*D-h0HgN3HչkA.I\4f[R0Im4]6p:0MϢy4 ;MF݃d5'(zC֘\Ԛ*Q zFQGPZ"qRV ׅ^{ގ)C2Q2&ŽC!r(%l2N'U<(cn1ư+6m0 7#q;`}ɀߵD$Yn%Ԛj{h^RA4SvZg}r7\gd[jzj7tbV[o;lHn3Ϻl<ďO %hQ'ΫФw@7~زWeasjM4#PoXwݰͿ op0yNd<7PK Y*T ] " benchmark-1.6.1/src/string_util.ccUTaYkoF_q$K¶p7 qEEYC}ϝc(Y E} Luud9/rWN͡e@___c~|!E% T" d辈|u.r4M$ zHUek~t<Ԑ^7"q=ϸD䯼?iFoO޿0Wr!5__ s\OܿS 3XFbg>\S8ǏHFj?(jIzn %KP&~/d&(_y9a;n2!zV%Q2^˥?Yޫsէٌo*C/K*c!?-5 7 0j`#>HR>IF9.@zd@:UH$x%XD.hH=E,LRKl+ |rmfRн5}ln8ԧCX2Fh~eqov5]EieQ$RdPeևV_%M2% =]D$xgW3BE0oJ7cWc:t2 rKFlT3F@|`  eF1`PcW)" f[7@:lB}Զ ;y%$2qЩ}/̮ =Q2q $94=YIۓYCdhX:ݭZzˠ(&iΫ687[3YR=v*ԎqeOLpRm#NN6#mDq(=$Nj:VXu4eӃ#ۨlòL$-s3U(,Pv-7SՂ.LW5JE$o!jDϸ['PkjBJTkhф^MiF0˱@BU⯮؛{0?8e6[;MF^Wv G%qL-AP?n/Eݜ,3 bcD"_[olj̀M'OO~ + SMm+S}y4yT#,tmm47(=DĺETʑ8Mkg <8! &"N| HUB2c"<xњވ'f"՘hQHEY0[tJh e=Дv-Di2?tDLEԸf O'Gh}ԉ5C>`K1 8:fGPc E2ѼYm2:J5ֽ{ T*=G˽^hFd ®2Z=-qntjfCW*,59Q\ե dE劘$[() d"f"Ⱦ}*A>7` l/*H]1,7MXyB6梀^^1񨗈+?M *EK߁qkS|Z'4KCǶբ,DMBZy¯VquvFKTl:yJo#C)ps3/ؤ\QI Sv%zA\3ᓍC R=+7Ɂq?IٹǽNC_@8-j1N f[dTUT}7 ΃>>th@x <1-+B\i2ZłMyKьyQ\ThN1g>&Ů3 ̰9Uyᆴm1 }SiCSL@ETNʼL@cNZ p"lhճ9 /E8g {bg˅R9oKh Y?Iml5ozAm*"*9+ LԖ>U۷02q *#+~4g+ İCe|O-lBȜ鋓*p:g¥|y%Khb8S0{rS͝⛖aREb?ھn|tT 92j[^‘Ku2J,[pZ40F-kZhu+ {%_㎤ Rb3#sl>{t@S:|M|YxۤJ !HiX;K,WP۪>?c|en4m]ʚPK Y*Ta&6o! benchmark-1.6.1/src/string_util.hUTaU]o9}*(!MڧE@dRef.clOU^,YsϹ~NGnt<ϧ7wZ.km7uH]D9-jܾVM㥒q NjV +QXwiQEF]l+awc?,aRר˛zkqEڧ]2ֺ#PTkYi:h; >~29=ƹļn$aAj*q& 4*z~?}:XbcU+᩶%:?~AvBn ԋ*FDHE8PO>"}EΔ#wS$OSwRX\Պ=d#9A:$K #QK8P?4].hYľS qz 3 Sl؅HtV؁AEĜHJV)l]xI+n<^a^[>g,;iAtaK;}%Ե> rBvwi0Q!FrߑTDSTX-BBB">1s&7~+| Z'pXV;"OC29ev(Cb ?>~ҍR5]SøǨ2F<6*sR(S^CdtII4<)P %Q _y>cWocͫ˿PK Y*TQȶ]SW benchmark-1.6.1/src/sysinfo.ccUTa6M5iv:wCv acvwk>^8P Oa+4]Dfr^@a;u`i4MG"hƸ1 8F0;w;Gu5*\1'DAܘUu2v鵮nVߴ.o ni'lRAa\٩nѿd A߻\IkWM2?EmmP(bY< \3zjC8m(\;gMbOR?(K';Zz?#nt@Ixyc{\2 *,9.Gwg]dT:ڣg̱|`Z|{Ktjl-X܎wJ$%yh%vX&5?)6`T* n'6h 7:F x &ucA1 eԠKOiș1krЏ00eqf4Etwqrj .@d%ThT擛Oݡu^ :˒u4ؾGŹϚ 522dg 8p,$jt &B#wtdn#TR`QF1uEJvb7rVM`N p3#~EX/OJ$b)$:%1mcT;;T!z)71) \ j#-IC5)\g8wВSԨc`SLÐ}A%")L Z| Ϻe?&&=> h.FUhX_Ak60I ;%Oi!{oxA&$d<,wrJ?Bn0<;>&8lk C{Mqܟ-QelK%צu4IU+R  =5M|Z(Fn|TG( ĠaJHM@ു7aggY[ɤ1 !BЩ]p#0_Q-TGLEMș̀Y!L00#G͆DVAc<B8>`7gQ60ެ"35Ϯ]?}Sp 4%6AcZ Es:E:(!bxu'=F".XN @>[,A>ԧLl! t^`d O$b*&u8%` q:$A,R@"$0+%XGA< xЦ.yel/rvהi߆唭CP,LCha؍]Pjc_ؓ߾:QC-~PHJWL؀Xl+AGwv8,U ^ z}3(I{mx>^>=Ke~! –3;c $%?2`. lFl?6 eH8 3kd;sARv[LU%* Wg1Iˌ#{!;VLiC|ea(PdREx<Yk{A$d ,߿#Fј"% eRrGn-bWFkر HG,VCr;СF9sQcP$)A  OYJWKRDk!l~6Im~HEŏI]?hSGV%քG|KtO9XnymiVw4l&ՒZUjw֠{;HEV4s+` BF8\quQ;MVD(yg{5yw,dW|ޔ'YrOA`"A!fʎ8,q4!sbp$G$o^Nv_B%>Ah,BRـxQ&[i `Kv8Xpq4oF5j١0`aNf?!G.V'(SLVpq0:1IЕ AZՒ-BǔCBXg׹Nk)& o)~U83fC2g 18ڴHAٮUpt*,4y}u0j85-t=ڨٗk?aO+IY &H6/;V7|6nAA,!(sݹqP\`+h*sEi2'’kϞlKy &]5\W6S>M9le-^i,Im9 v&$y*"YT+L{% ۴Zp[+?[߭Ņ\}뒡qCBoȃu1X6`d+r5wxJPW]*a1)gMҩQ"tz,giտ asoVn7ӻ^aG ѿ` N0 FQ(p% }b+i#Z~)9UU3y Y SKɛZȪI#r7˺[og~sQ'겭4t5IVrK3LuWy<-$Zlh# ,Jy8&g-=I 6UZ >cǾ<+@Pf5l^u]C#EʁG8rn컿WadO6_mO!r)v4 !y/ՍkѪv-m,x̄UyUc ,g%1dZ N>o}ZS2sPkV+$z3FQ[8sU"~cbIGUT[GE kv$2+9Ht }<@ަ4aRO lY,cZu/Gx%nGPY61%Vq])^I)Ӗ&C|nGsYl+fSeJhһANvAzgA}3>oﲚ0%?}!lէRKbkB?4.g^NٕBq!UvTHCCv  %eT+ۇ.)FE4]) sܸ,|N^w "6_~`b9:m̘0wf2xhZu9}p]>[ϱ4 1݉C@( I +<..; F|IlǯͬRU"zRJ.#eX}s/`UUTAAቚǠP++`CYQ D`& ?Q ;'] _(+@cgAꍙ4# v 9(T`i؈z6HIbYy{`,-2ORqJKVX^VI[~t%S KSRigTZ Vn˭aDF[Ojh)syGW<3\p. %'&-W$.IMWh2q.$U\>KJ@ o-#(D_{(3ʜ_" /bkժOQu~t %,0ZNiE%i\}|X8xl]u{uq9h7/_T`E|i *|9\dWM~X,w'[oVp<3 Y[c y_@&Z |m<> |p`ogn򃳝w Xq8̦! Cݫ7a^LJ^COL@-pD1B 樳uM?X7]^r=IgD?̮ŶIheae,r"G(g6Tdu{y[CjB cV] 41\r6i.24\8qHq x^;SPIҍJ9Ț^ST@n}ɍx.HK ^Y"|=gj[] SCu=wNNy ]쐿,b1M\Atz+X^<+/ӳs̲^%Bh{|f@Ɩo3ʙ]rO&W!ion!&?kڃ~-rw~2)jUԋxlh] mBNB(1eo! o.q++ ž5a/" DnJE,@f8wT%'z B= bZ>+`OT-wn tdLC:\ci:<RiT&5ZԈ7V 2;T˻PZڜ>p.1yPK Y*T+&$ benchmark-1.6.1/src/thread_manager.hUTaTk0~_q0h==$mI #MB/,INSJ8Sǹw;sz;?vG6FMCm% K PK Y*TJR1C " benchmark-1.6.1/src/timers.ccUTaY{sHOǖH@dowTm*|<ΛڻR*u1w@Ns%6#Z m^O a8 ǂs{*@$ siy,0VjDP5[)؆ l A(!y. $8y. WÅ4φGx+3<e4JZʨjm6)0^KUD5@; ALn|7ɤ; SO7 fCw> Fg 1,@5]"L9/ J"⎻t4-X%la8@ @s}W2*F_>f@"o>s0].>G˫=7hf|'ކEP/a*Yq.bXȽNYkҀ:jn:Lvsu)?6n7z{綖N =M 8.- O# 5PۈbU=k(~"$h1g9F :CwT1&~8nj8=LLх 67@E&>?(?t/ƣgG Oݳ7<礝yLu~nʢ/(:F̑yOizXq_8It};n,"Ͻ[T/,Q 8kE|EtL%/\y/>q<17g~(\J"WIPA%aB}1ll3W*@c\@^mh͔SuLߟ/F"L \;>Clpǒ <;7oڪ,;ۃѬџt5u Y m1M)9IJNΊ6's v?Ԍ~K؂Sv@ݑeF›?V:c RDŇA\M q"`ʼn,+N(tyo |ۈ3: gwecσ}e%2L2[o{,P0Xo[wwiH?ӛ?Y&)'z2Sw='g\5DI{y*wI RKQ&_Uy4A%ۼ,#FI6_@gry7X\YSJfKJmӡA?'$?* _Y>I_)U xWR\ǡ]6j՟ٰGDಗ8/JïV'2@ܧ6_!Ws[Xe05l$RtEiqA~IqyĤ. m+#&c[5*f:akRgg3tйW\'ˢeՍ4J}&[l4NcT lģ!3+f$0 %@hzsrnajDp AHw*v2CF| 쉹ӢJ2SjaE o[>Ɗ-'J\يB>DTMb:@l$\wX1: ݹdt?l{R|@ h/wJ8k7M#twp(ۆIlF+ך 0(}<0Uk5];v~B '7o޼>ş7e3j5GO@zQj[ jЈrc^IIƭΛv"GiC#Gukki4:GמQ|_ zzr$֭իtjv )Qiօ؇6N]) -$ ^ {3['ܟWfOT3F1O~&A[,5,%IkҫՒ>M ƈ=kT٢zzWpuWՁL$9vx62l&P5SRP\.zGFN|]|4wEK'DBqDUnJ鞘FI ɫ˫+*&}hR4waN/:c0 0hCbs"#Vn)o쫊BuzDWvf|Zi*J1Z"ŮjΦTGaz B/@Օ< Is*I$f$DfͣI`JYC(g!63DE1j>a8;i5G.t_7L(|<|86E)7 +_7*P,B]Z*)?7bvt9M(SEQIK$+)dfaFa.*42ConܝypoPK Y*Tl benchmark-1.6.1/src/timers.hUTaM0PvJjH)YK-diU$R+nvf Qҫgf(—czXa.I¾Px$B19œuF+۱ Qm0 *5:oxzo-n A7kO2ȟ:fI<.IO : C'->tjQߊ8qVbۭ+|8ǔv6hNhU3 v$x %imqQ|p=^_fه2>oi18Ș);AEK @`[3)SC~b4B(h!֣fGT2rXς0#/ii7MLf>tbx<@31}^ a2׬Ki\|;5kMh{.a2)pfdנ9kPK Y*T benchmark-1.6.1/test/UTaPK Y*TʪN|( benchmark-1.6.1/test/AssemblyTests.cmakeUTaS]o@}WL,mm UviŽ%+3c~Yc$8sga Qe$Y*X$aDfKk"]k7B -*'I DϮ,ȳikiG)6Z7E:kإznħC)dL̊QY򁒙0Y~nJ]OT\?ṯ&$Ok>:ڮl+gLkL yLyiĻI#ɄDE3#U#1rVHaXb|g g:V 6KB?RU!%W˔S  EQ*+Cjlj 's:YLNBy'ˠeAzAr Ez\ 9:H5 u`Te&Ղ*&֏{\q PwG-pMIM~*+2J|T*!PB8n9V,FY)4-"fx?4xɄӻe|qa[tE.JM3-4UnV67[z&oͯy{j]ߢa.9[M PK Y*TOr benchmark-1.6.1/test/BUILDUTaU]O0}ﯸ / M;"x` Zi*rµ3i}ΗlЇV^s?/BX~rF os_sI ҅\k5>h&R{ Õ#2]vrfL7{[ \jxb&/4wabIi)C Iaa:q"4>g4,J/U{نhDdNƓ#؇$ * Nn^}Ш[-<9VR;:=#JSϷ*E+t2.TQGzB҈Xܜ$vZ䅩ܢ yiR2imъF/Kԁ8kouypT̵J 9E'#VHnAtgYuF0^o)-g>G1J UHlқnR*qzqXFP^?􁄕\-߭srR2 V]y,v8fe]lXgJ.UO#zzIs]a-q/h0b|C\ptvv޻Ȍ,Rxl)5ԛ3hL& 2ZzZNv-E5܎٫gⱒ&èvekaw{PK Y*T`d +# benchmark-1.6.1/test/CMakeLists.txtUTaioFŃtTv-ю^=RH"L*T}1d7Yi7yz`|g}{q|t S?i8Bcs΢ a͢y ]0,bUc[ GaJᲹ1F9 bBu4X(R7Ko}ҭo@Us,فS #$wv] /€+^eˠjԧu{G ͸>jSk>0C;Qv"lJtN `KS~ Ol=+EY+XK;M`9ߛEv`Aآc-U4!]).vPiX,Wvt' W,/rȜ$֪B %x@"]b;ZU 2< iy3?֧f1すK=[^V6vonWF KAy`]+2sA?͌f>ЧgE$Xk},-Gr)ȓo` ЛFW-U*/bo>tOQ3KkXLXȫ`W=[χ52,h_Ɨvnk'H)j!a$"E!}Cp2p&rnnꬌ=ҙ#ױί{]B/ PP܊~հig-Ac{ b"m9 E(ds=Z@$SAqDlb2)N}`+.}x׳AcϑVj5/Yu:b( #2".@7 ˜rj25^_¹Ix'ɂ~$tDddl9!1}lFfu`ش.%)r0ԳKmSV |Q&>E.N"& zV J/_ ;ݣi ZhRK$~Ѭɫ\.@UN&N,բPЄ<_v/=IըB j_MecX8u |1ñՎ-'*4i?W1Nh<-s| uBwӿ>m#X|й T"Q[;2ZZKl9sUs=tnpKc,mӎVe^uq2LUmM*s[U=as;T]$*MrVqnfh(sq Ɓq"P:G1yi8915NǂМcz-xzM漹^/fLa7 }1] fp:`jn{>|3D=),<0{5.d;b]UkP ݨBo8c n2J @li  N-`+dWpFvqS <EI@-h={ˆcP=ǟhۉOh2o-Y t-ϙ]i#"g^,_.J&F+/6ɯÅLR u9G$h cpO~`rKxXB'w*(ɍ eTps}muZ )ÅEe@wnn3F? ڂ>f{>R(v[I2pujҚܝFߠD4j^ tbt6=: u >isI+9k6tØ!d8`h)mzG&]8Gbߢ]!uV]qIT"(PfgtV95 ʗ0?pƱI|\.p!B/C L=ͮ'dSӼ_#Qpr I7@zIbm`NȕE."{\&adH_,X+Q (P9zN y{B\.muc}-+:p0NyKEctͧ_>PP]@PqbvTtret!#Fv^Y05`~t9|MUvUcD"ӱJp>vQ :I{K}]T3˕M!Rd s'#YOF8K7适b}.M+GԵҩQ[YiԮi0 M91ne[2^1"kTC:F)yz^UHO8`P.k/bt Mҋ_iGU_Z#}:n%( ͥmpn֌1)W؄$ K} :)e*egaRWSbN`LPK Y*TBS) benchmark-1.6.1/test/args_product_test.ccUTaUmo0_qR o APaJ)VC9e>; `mqV$|wGwh:a(k)G&!YȲ@e|wp:(M;JnEAa,kaYXɗ-haZ4hx 86t|2 1l$zq9Nr%`.˱Ռrt&YVf9[r%m5Kz]pd-I4cOa}1cK/v=>3c (#r"7ES9=ݹ TyT\1h6b;c˯4rPȣDrzlي|&'X,eł*$]Aڝ}{V>lJW+AA`u-NtV j7?''pIftIAA*_{=|A۬)xCLtޥ\O[AW'rvBxU.PK Y*T" benchmark-1.6.1/test/basic_test.ccUTaXmoF_1J BJ= ENVZ1x]wolsMZ)3̬yp6/Xk,E{}?ړwƺ ?f_/77MZ E6LŸ@K<AJ =sxSF" #dټO֓u27OK/y($T8-CCϷKk5]nRvĂ6:kXb]'kqc,hOB84X^,?Ve&WZc?G<0R>kU 4e\1xzdduÝFVmn(d8FiBv 4irַPΰ!S0WW0 !L8HN(+A&! +PxPIt;-QK_;m;Okf"@(`o !z9U4gREbSIp tbŗh8ݓle4}fP<_\+P&i6P$N@%ӑɝˆ)\ǯ,ͅc %MSpH69~)HW:*QI2'RjHYa3.aA_# Qq!\LE)*(< Qg 'zLFwQ./ J[gdG_K{>4R7ZqZCZ!1x=AԦ[ۍٟ:8r$80;sZy9\?@˗nR4|R771i/ $xa m ACz RSy/9t~:GrY1ugS*A J!Upu> H"ppO*ނ9.UNU҅.qiNIK#Ǘ P>RhN<<ңVhe!%L"ƕl[Tz fjUrKH[2?F[n(Lcu4[w7PK Y*Tw 2' benchmark-1.6.1/test/benchmark_gtest.ccUTaXk6ίXّДUigԡR/$^6j; ,: 9?r#.īևqGj˚<צMQ?' 12d3NͲ]cK?=2px?VCV%DJvh$qno]zG9fn Su]5?O;# G 2&=쇫t2,;y *<:?xE!]a4~Φ(*〄$lDIGxte%aZ"c33^vhGG.2gBL9^|u L ^KsSO=}$$(~sV8mGn⁶euݾ%MՍV|"L2pL.mhNjQ?:f鶝k Cr ݺD3a 7kA u}0uu`9aۦړI}$ (5IS`NU. ۝U6a<){5ۆ!ޙ:睩+Xl=$r0F4eh 'EK1Ŧm kKsĊH$IgcIQ>]yd1(x[ R %KcƀJh|#]D*[Ee\ u/pym$qUzWhgpzI]3-z}gE%Ug\(a ozgD(%ATXB z!ȋ9r=Àn>E<"y*ʉ5x2 o{fA"=pR0pcB>]#~e?!c<ΈR휋owHґ\!i(q[*,P]J3xWurJNkANaP()jCx>dGjCSXtڟC9zWd@}<hxPK!0Pq7{t 6WSNVbN~'0y;>}X˗8'OPK Y*Tp{e*, benchmark-1.6.1/test/benchmark_name_gtest.ccUTaUMk0+(ZCp><&5FI⡌%Z^>yIb2,g!憰 1e4LcRv . D8 02ATc]B2I8axg=K ))pTl%@0!dG[JܟOKcfBr˞!CT:l;v d,4a:S^PuY g6fwg-,\j9+V]IL|=@ `=eRw1e9F#m~Uk_BKy FșwM~_$%>56DsgXW@xST8&BZ `Dpt‹9ѣ!,đa /,ĩ,'X\X8pDĜWWY*j3DS * dlC }EEg]w\wYjQ&z3c5yhܝ@dTg,xɆ Ev5)l8#Kh+QKֵ4Y_H#nR*bj,#(4/-_9a>i6ߎlk9.QaYmb=G̩VMRk]9~jIג:rt6Ww,«=,n#6Q R{ ĬR;ۅ'K/ AaQ"s*yyF Sm+֙@sl(ajԌf6@h)2Q!Tӌ'lpBSuh!FnL0u]||3g.Wyނff5<2c8LQ Hq =(WK>G!&n_܋1A텾_ Un|팟EݫW%!ϾBƟr[kw؇S0D1b@qA5-]PKZDg_ w w2NW/,'61O4!`K`cE{) .Zr.RA+fYT65y~pU2/K;"r2`'k%U^lb-tJ+n~盎VjZ!'{*d ,-*6lNHefy*س ֪N9,$ǂ"7+Eǀ-`p=}e:&˛1lrly< Scsa2Ԡ_V9kO j:P&t:4ΐm> `l߻Q)wGl# 2 3iEx~j KŶ9\:jޟg{/PZdNي)Wώ^#"owlm{kɯŵrp.PoP4{3ֈp=K"`y>/5[-&HUa7Tܮ ΂{gٜi]tsk6vǂ˘rdh%V֞]mN˂Ckd ZmRI086F>_ϗ3P+t*vw*m>;-db^#@EJ8dϲy>û;D;o:#.8$u?RlƸle6>VCJ'=ͽ=0V 9`vi5фJaz?PK Y*TC-tv& benchmark-1.6.1/test/benchmark_test.ccUTaYmS8_ԱB-*\1,KP s\VGY2,d;puEw=6"Yi瞋`:cA;i>'LJt͘VW #a`&"qѽ%Rܵ8EJVWZ0|beXă ݕLEq^ܥ'$5nN(H_~.߮n^^ g :a{H" &K"&`3.,j!MjŴ _h(*KyNOߦR$#h[[&}A3o"O \Mb)&IJ̬vb9FYQd32hTLE0NA6,ċ5aHfX'`e{W&ysbpv{ڀ#w8NGy",PLW^G2[`iN |}VN=NMAP=djThcoϮPrC`|N%*k ׂWƖG/uZpomlzıߙ[Axn$'!xHY4uk K7\dZj7MC?75QA44D'G|ce;0yz ۑˏDD`. \'t'c%SNLG$&4xkZ_LEK"ՈeCObjm~3jPc}͋C?^(g2ae29҅mB;2nѻ|IăN:`nh_m;/ʸXD`.TX"ܾa)c_@ λ#]ְΫ$:rÁAȅJIHM)% 7\{.%HBȏіZ{{6Ŝ\pHОᲊS=kw#e g:KJ;t$Juci(a*DIJ/CS]g D:jsD^ː<8l←8hZ<VG EaJt|jwܴTDhe2aiwv.q"t,Jm{}YC|:PK Y*T5-|P4 benchmark-1.6.1/test/clobber_memory_assembly_test.ccUTa]O0+NLd&85"\HKlܺ24wLJsd1ޝ7%.Wz^#TbcB`ۮĶQ)xcX0zYgUf$GZ' LXO9\ڑLZ;O)&ƚmeF֨`3tq3A19hl!*!׊t: @ǹSLV`@8jo?TqYWPK Y*Ttg. benchmark-1.6.1/test/commandlineflags_gtest.ccUTaXn0Sx&]IeLmPQWm$q6Ļ6BJtA"N$BGs/q0o+U*՘yUF$)APz)$1ATADUuM=(Uu #@!'/(b|n_^7Wnq[νcB Gddzx [F'I#Yȑ%8T*hwz)(t7a @  )B9#b$G D!C3>Hu@ͅO&;kvT95pP$$#Q*Y5Aa y2uFvzhdQ\&O7\PQkJV7귄eDnH\1T W2 qs0w(.G۸Ӽ–mԌ-mDǎ~J?WM팁~U֟^X;MQ'&\;ȭQ.5SYE GGωbؽ7B*v| B(xA)vbomSo1ڔҭ2ZjwrlK-E&7E# }hֲ}Ur:9Χn.hǨ2tX [YTJG\Kigag!r `j*dk~yqxЇlYtF70dq!.iT<̓9X1#0S72\F V!(x I\am{]kj$þI%E~pu-js*wn e>bhh'$H ibsbu8O:7PK Y*TD~!' benchmark-1.6.1/test/complexity_test.ccUTaYmsFίءu"lNb'!ic'NHotN$n HNmK8h}Eܡ^9^XLLggM C̭%p<6o--଒ު)3+X_էUM<DPnh8l _89.޾w {C^`T`\@wv 'ͮM ~tܣ_B7!;s*-c<)"`܅G2D"3g'Gg\o f7)Ě10\/5,'a4`k|Zݓ&-$J|#b%J'7jT?}؛x% r$Ґ?^u+ҽ. Ai1`pz%M_M#(Kh46|XϽk-gOHn,*+_26M|~dFUijT=ȣMaT;JQ'T؀F@IXӀCaqzAĉ:qq=_[P*tNq-"p7 i@-G ~_1wPFq&bʳ}:0QSVG0cB!kȚ.Lh˝tyyy1mwbl -=vV؀2o`jK>3Gϖ uvrF@EphVRJ\? 9:H4ѪJ4g F-c=0 < W8ꑜNSzfX"?qs)51NJqvJ.5\W~f.óK%2/0gx+s[h_*VX|GZ#.IXbٕxV>餇P zV(nED =ʣYy*Q E|Ep d}1Ǹ=*RB-*9ԉlR 1O ^ѸJ ] Èv&tiRcm``l=k6v,]iJ8Wb+ȒS@X=oe49[[QzMhrѬA-p͉Eaʮ_N`U`w˷/@Dg#GɈ1o).$/œ؂*pg6PRU.i]yNز?ؒΑ8{Z^B yH弨C/kC$|8aA30tl1(eB2E -IY AlFˠ#؇i9kұ*XeܨX`*g8Oy3|yy=FAE Щ2Ke78~4z*Z5޴ę衢*x)˓~LKxةY0Uh¥f\0H|Y6Qq<Ud2uМxr*Γ;x{ Qg?9|k^.}zF۪{'ǥHW w~o@rC11f~׹lC\DX onد)@(倵7A6s7l~6/(#[||KƸrj|3uf uO 49nePpԲ)8/"FrwZqTc,9ez"M9n:@^&z_LC=m+]|(ߪ^F|^(JXH>b3PK Y*TZ߶cM" benchmark-1.6.1/test/cxx03_test.ccUTaTak@_1(Zz 鵴JQ 1Yut7iZF-Ju͛7o6[LxH0mQRJQ!C6m0dB&җK 0)("$XGc.k'̏/E4PzID6kA;"Xs,PSOmۨqߕ&L!nY2UN7~0TS?0Ek|9SeU 韄I\04#=Ҡ8R6I13X'7n Ӗ\,+\f<,U<};' pAn$ Wx}MJ?/'^:o#m9g͖LڤΚCH%3)3a^ۅq ֋f]V~DױVoݶݪKX2+A$젘} 4J y}yDGT*-@= $bj;ݗzd~Ax<>_$R`.*'`Fd? =! ߞ `u=0w?PK Y*TQ]`( benchmark-1.6.1/test/diagnostics_test.ccUTaTo0~_qK Z *U7J2΅X 62VBu/}&!wwj.w7k¨˸x4~ka+]&"Nj+ɲͰw yO geS5fV(U\MdpkX.ě@*>uֈPu,2i~Z;HB.k 8 γp#̡Q< 8; Kf" q5VӭoՐ%*>~yH!T*LB.'C"h͓ue8Y\M'(8;a1/ظ?gi P%2 {-}\%9RR,FoqWR04FՊz9H>%ʗڸUEgvL{˄m$1SNMH:qjSz"[6M5t5g_ ;'hEC\V4WuZ{O'2OuLC枼.QЫ{4P#-7~WNcU(=á})`u^&J CJ |VOPFD0-^G=nq*#i-?&6 &Gg /|{AZvGGjc*OB\pAdܼ~ըy_{:Ю^3JI' >/RuA!Sh~oPK Y*TF?4 benchmark-1.6.1/test/display_aggregates_only_test.ccUTaTo0~_qdJhJJŐ@P:ZbGb9']FA 9{Nq7/=eQGQ`* pZ楰?&E(W xwuXvBh2 sA. }f@e2[^Yt\˓, 62tI hC ES hg m(7R UbD(,t Q)^Ou/GXh]8ǒHԜ͋>89{w}2v^)f/r"B>??i qܾ*w8K\Ѫ@P34E P0$|E6<;pwH~5RX;(nS\p~\ׅhXo#[d "T$.\|P +U )kk}:ߵfVq^rW|"D'CvTG5񹧻ɔ=0t!)t>v;ݞ-vɭUJV66vbh@Q>kGbDs^-ҽ53i\1?10H,⁋natAf(x0|^)y?K=jٖF"Uv]F0W }y0B˥R.,5-Ԣ`ͫI7;UQ }#d"g G /$s :(x}7 g渔 Vs*pG*I-|JF>JQ]t&OT%=oMzn]~VM c6Zk }Z>l9KXf/lf\zc=* N7[Uht[LEҾ4E.?`B'4ֈ6C]k$ 7򃗤 ?<u0=?VѾ$2l9/\r{;Rƽ?ݲxy&igݼ.gl{G30Dg%:Eϡ^q5u*pUGڃ= PK Y*T6( * benchmark-1.6.1/test/donotoptimize_test.ccUTaSMk@Rj[5%Mu!P1b%%ҮJ{f%ۭ 7o>Ljs\i$(EWr$5FfFc4A/$,-}%i 2q !I$UiK$ ù8C6`Z [+8ONb }kH@O :#gE߱Xd$TX6j~**J+HN'/. uJK.ȶl0ɱN=pC!+=p.4\b8=| e# .f;Q;fL}p s?m}N֒'8AtcP@qo9=[Z*q\ {T*<5ZU(fFU\ 7{}4%.0qLۢ@{FbGe4y3?Nҿ,Ivqi${Exn` 9}'p\񒡿CxJdX8j-+.pҶg0b+PK Y*Tg  # benchmark-1.6.1/test/filter_test.ccUTaUێH}WAlѹvFh/hduE;nK_ 6/N:U]~DΫ% R1*gژ2-SI̪efɄ8[4MLj(isV2wB `,W%Q/ )^CG͜2TA jYuXBKNk(8)S )9x7tk !!/^9z>BOQS)|iڃu8cٍda^ ijX rrJlJ R25cbIL8:L4F33{Χ!ݧy (<6[',O3%}h]Sx+ #ڽn~-}K/]#֊mvvʐ{̃权>Rd\\K:!׍[^тm0s:FB*Ie$dh`zD=6{)壤PG\X xã*ͣfIp0SWD={f_6>ڭ'δɤ_a ᚎ m$Ch2-wGqߧ.9/p.Y]Zb 7=Haa@ksx4k ohs#a*WNo͒fK {_2s׫^]Dk>i FW{-\`a:Iؖx og" 0+S^˻iEBI{Ll?rgX'Ӯp`S`2w7 k +~+`6eQ1Z;k|F=􆝯]0c23+.ۚbміܝ._D_U"HH66_c:uGUaH(tNz)P?nCO=}~PK Y*Tw$ benchmark-1.6.1/test/fixture_test.ccUTaSk0BǚONkH5YqұoF/#o#M:llj06w޽{'c!H.稍G69Ε~&t2͹~<{̎,"ʼn~}|Ϯo^%B/VHH>{`.,L$ຯۖ i.D #4 (%# @^}a7EU\5cfy :puN h)73Eee n s! TZ|*]ϝ{4/oh sn!S _Z;Q]B6stgO+]4qq-. O mVr[Ԁf96{٣;Z>V ZdZ"=rQnјE]:zzJ.\zk'P_/nq`X~PK Y*Tܹ/ benchmark-1.6.1/test/internal_threading_test.ccUTaXQo0~ϯ8Re+^T(ڪ V `#)9qJ(!@<9w瓭SydveRN}@ θ sbF'JU YTr4ྚjT’ +˙T gf B8kxs:k1b6Cʆ}db9\8cWi)g 'N=<7}ܟST+Eۚ%c_q  mŴܝtP1CJ`$P_lXAx.gsf':!,oZexR۞ȞF{lw[?:W(RY.M kϤs'Ii0:t D60+7ldvYm8rx- xp%o.&DRf\7i$Fvm uxԄg.|m ThSP침ݽN-浈23j 㞃;K0~з|+|i$2FT?PK Y*Tkn#& benchmark-1.6.1/test/link_main_test.ccUTaSK)MIUPJJKM,և23S|Ss J*5rVV%%j JSKA!-HA#$_!^ YBAIK_~AIfnfUX^fIjQbIf~^5PG-W-czPK Y*T@ benchmark-1.6.1/test/map_test.ccUTaSMs0W$ӎP7C L ҫGhGN:YB`zwչT|u\yJX: l)Jt7aS""RndELt2e),sb@,b!iY ž )A#a_'HϴKy4?BCNMH\X+V6 ! ,s2 g7~b^A:P>R` Ot_X-=R(l-tk"scS?7H w(fzIvRop!E[ĢU[l;(Ofa<;:P.‰_v3O"vbYw%7Yq'_PK Y*TbpE+ benchmark-1.6.1/test/memory_manager_test.ccUTan1)MZHz -QnJk3BѾ{ms$m]gƇ )\u+.?V.>Qd.8QW@Z[ h͈}<}"jN2F,+6BKɦhd2Iv {iCQ$$m3sTx>O8ZrLLR>KANVxv`aFkf 6i3PBΏH3 $AUg1L Tѡdޅv;Qoup255?BTVKeEu4q,qDx1kxhF8֘)xS9.1%O jqk*3uxW_iNQ,-@/9t@߱< ̃gY`Cm(p@pG\}'bWR>$%!!wilKz%KM9;rvLbʲg[OTcfT=!,Kz%KtPAecxqZ M[k 1E'al:~S&xQ?@b^kH>&] kJth3!+N3V758kHqWbĖ;̉"?4 Nq\CJtXRXwRȄSFĶGģ"˝P "ePn )FDXn^_N&hpo&Ԏ-ͷH"k`e<:APCxJp7<W=|l}ϊ*SWWėXP5SeH]SDڶcuN=Xq0gs[SE$PF(Pb+UJ7q`ql·O-F<溆z̋$}9?T]IaR04YRD?6= dCG򝮇X㋲*h1 *bDs7jѡ f'Ȑb)_<,#8$W*'#/F$hH- h=Z"" $Ge9Qu 'Y~*wnxϗfʮzn_ťPK Y*TU-$ benchmark-1.6.1/test/options_test.ccUTaUko0_qWF)PV[5>>G&a*nHMB=>隐~}G2X|Gb*&(ٜǏ5;JSp*$l|y5f[Dd@L7}ƚ"pM>ˉ]VsA,i㉎w`i-w<FlJsB@ ^\H2cӊ|@ֶ^ et݌L< oI.ۖ 1G7?}:۳{j"8mZK7#8@a$(J8L7m9oL|DPE(0f.Q*\ pN*[ӀngY`o8eeH;12n})ܓF䡁aLeg*q?1X$d7@-ҒV~a7"9ƔP̅V}!ڙ0{ˬ |nhgY0j'3#TUU55C [~=UߐQUR7S4H 7|XuO0٘gѧ}u%E"bBA.0BQ)Y(zSPi3!GҔ_/xz\šr~0c̈"BHZ2|DQB>Exp bCc>l#L$8!]zFՅ :leUj0gg`^.~G:RX#faʨ\nWIYP\Ʋ0FtPK Y*T " benchmark-1.6.1/test/output_test.hUTaYs8~_&Dj{3N븭wc+}v4DǼȒG,Hi^T$..~8.Sm_iƾLL42KäS2L7T>7,_Gҹg+C:u}2zeݭtwˡ={E.^mJt7/',] {]_&,\X3+rӠǎy.Tb6[4!~nB%Aw~3Km/ߎ.V [cŕRDZ N$,x7rif$AA)(R L2g4 WZ7Y4dQT䐥RbeL0QN#r3%x`B52ŵڸ?n4FEJQ:n pI_ГK`Url8Zy&X8eKi\'#t z,n >.m96,f 9h"g1ːM@#"à3  Ct)Y5HՂN*j N9L%,%t s"|3,p)CEBiT$΋Cy^!6Xc6r 2?ѥYNf눜$S !yɘ.x\Q"$=~b0aMtTW"'{>4Ю pt$XYj=Y|&l}j֠ "'bWp'&2 g9΃HëDM\"!K5gc֮jb.JH] 2eC#x>wG;kkngZU0xAeu[ 2:UNRS%f- \ )e.lU-0I˂J4KbCIi<HIU e [2jmxB'*gc nä"|~߰3.VkNJ*OtlhϺ@TnMo^r=ӗޖ;/CCAEI^Jw>V`-<h$xk"Z siŽ˝mrO !n2 [Q^'pwJlgs Idz?zP^)1F C柘f}Fa-oJx8]-ə=k X>g#P: <{]er\X]l =dvjT\?IPo sFoFbc9smo_>{_/gû=_Cx-PK Y*TE@F* benchmark-1.6.1/test/output_test_helper.ccUTaS;LO&"], q&U$ū(8;tfMaH {(y,G 2gJG&SvE>4/ λ\F釋PC".4˅.B,McIᰰF(r0(p1\V_ʢ5v7o#Nw)i2e-{kө Uq|8ӣэ ,_ B(r# ȅLB9E"(t! !(,":zJ |xQbVDAI?U%X,9gq.jRqY!»>}+$I.=uW}`]z>=ԹmpW%B }|"H`&#<xbUT ؅v! ~yIT*~#BS XfŁ/1Q>x"I{8Ӑ׾5O0g*ކlφ^(~-ؒ2%d/4Mگ'i6qdq$Ƙ>ctm;0g@|NZ&b'\W`=;OIFM,m98e^Ƀ vPfS!ۜB+|]eYLHd Od<z9?֢z{z*8z64a& e8^?AqΉ1[!һg):a\|&(lf5 - R@FMQ F>lEC/2Gʣʼn;s*u \XB(WZͱ&ua!9~;;rCm>Ա$F H=$%gxη׋d:^YTPdX֮YNqPDLz(h? bm lkq1 z_gCu-cx.bOfD8U{ }V1:L@V(ZE2c&I S ~_ `p{xvJ,cՖ_>Xd7h q|AYlCB!~<>}Wç㳳7JV_6jz=;p~]UHdp(qv&C_ӗ0BGQ<\ Jr!ZŠZDU>5 )= ,=v6I["%" OqJEAШ.&(aGVrG)wDb7$`*"kFooI$PI\ 6Y`&)sxMTûZNJqׅ܉eS҂ '=I'T&DiTa)>RC#}F?15=mw. DӔ>L}; i׶bd{GeX*Ba!?44f/y8h*GZvL"XQԶj0s&W]W#Qі[=4\od深RWF`)eTΗcmä毸VªACQT) : S̳I"EED]wӑUOlѣןBpUz(s,;0^ ͲFAԦ)WU/:;fƁ8muÍU:cW=99]XC=-3޾ JqNBX I$3JHxR^#iv+f 6; bD%.w/6T86UCTqmXai<.C#HukўTXpZu"%`}ς4Eі{,9}zgE]-3.!Wd.phSHjR̓[ȇz5P&Y.hsh(=Ff7 FÊ 8R wkٺ&a rGn<_ït J lIpP)@+As}s'Z1 #7A=׾*n PqtXW&g C|nƮ2=Vf0q${k!L?oMc=8v+NܿRL=$X)ޔX(fVyX㪎t*9ovi1_]٪/WqxFqIq# I< %*UVʢiăZI@Ir[Ub.裸0FX) n=lİ+wA!w'jݑ1Jľ^`BSE 6؁j1@CT-OkTnPc[נj+4djÃ|zn*N݇\<ȟɂeKFl"ИG, [P-GX մGjq1o1_{%fGF*/DahvxkT^pv\zxVq2 Z=S3p6ޓN8%(GUx˖ȉQ EOx]IG^)2-bpn 0KoPeE)3$8J+@(98~ P]_B5Z(~P<5f@vxἮ uCFGCE))[ĉ4C9xIǟ7wVen2&Y ;sVאdtdz7۩ 3?rFN 3um428;ƞ#au FEh_y5maոyt}-By2[JN@[}@#MX $Teu:fy/xOܭI;3Vn^1vڝ"62Տml\As_wiek '5+0)LT&ti;vo@$1h/+ j?>*)n+bpDffp7d*Խ7'|w9xv<~}qgս?TB.4A.: ʛ+nl< T ҉Qfo1"{gKɚ g>0iYϞd|U׈q|)JM_?_Κxx DؼӠ+>J|)ׂ[[8`u2A R"oY_-͋l߾InP^ VזǬ%H7kCZIN-=cjlc$ak9 Mӯr~2nEc_S&*gօU[I jȭ㲁OQ;3"#D, 4A^n)(]{U:碮*Fǹnjw3>XkZ@~aC3x0Y{BA1UiVQwE W9/AuLgSpR]v-:N hqmMA_6*#dA=w>W\do9wXx/~P~T9vw*LX6=a[c~A勗//G̿|#y~VUci\d'F#@}?VX#O?ʼn< a=?^dzSSt\ 16Өn\}CæpMT ;)@`˲8V hGȐN91NU{L. 'iHlUCO6)T!3Z\ x6#W~֞@4FBPX-vw$x8,BY!15,:ǰ:\%e0N# 'z ),k$#%ã~/)TVxT,JGݠu>-ejTb* @D yj+5Y);4&Mk51N+l$թuH;L!jk-+U?=`D`>'qq w[2H"ɈW0J`LnWKSЩ59wWNVHX&Hvյ.&Ņ6gB|Fp0?06I"Ӵ&+| XVjX`6''P3B\hPhWL` 59͵-,8MMz[aY)Y} yw>u6⇢_23sn%SH$Jzf³S%f6?]6qΡ{^mwV[ۛ{ACKex6[`^v&8oy/z7AX=npW^a:m,IheHRE!fIu4INӭ#?Yϧ/l0ξ<[IBL^t|{|Z;.vvkS< /Ix|_f׼-i /t4D(ˡ Jj#eD:xppL3bŹ^C6#JT*i-d!ySends_ػ Ȼ8N̂2d1 &s.R`eWOsgBlŞ,  DSl23ijH44=1#("uPpA k*"#`|ݡg}!Ɩ.<2!bLǙM15)שS!^11I\^#Yt9"ɍeR 1Fc$y|44:R\Msm ,6i9'֪&j4֬+?0_27#ͺ m$Y %2*᰺9߭SUxwd7!=`1؎Z6`]p<aX$C .;,Hb$Zc}) 8p,`Bze |7r^*&vPK Y*T0c* benchmark-1.6.1/test/perf_counters_test.ccUTaQo09"}fOA*L*M˄q+`#ca}=WtϽ?@׻Gϻն `ij>LYi#K޹dǦԧ4 @YZSޙLi%*XT4m!uAǗpJ.QP@8q(F4ǣ*ncgdo[ yzgTʾD0?dE. .bB8`1x#C3ر_Kq|7{y1CukQDm*mx]%<\ 2ztb8X PK Y*T;f/ benchmark-1.6.1/test/register_benchmark_test.ccUTaXmoH_1%RdZj\?ȋDMD\U_6!]U!ٙg"_Nit2< "/|IHңh)4VGV%j9N7Q^כIڙ]_ {(Hh+ TH%(}Qr)#o6[~1ˊ\& I,/Gt!t,9" e 8Ν+,e N,'2΢(${=GJGp<>;]|D \'.ȷvDvnC,Ćý^ͯ\Z[VK5HH^AtE (3z3^R(.eB>8=ĵDB7@86R%XX"^S:Sqv5ɉ;O N+޾S+jI, jѵ+y[H"p\B-]Hz-YD+4OdHl~1;c@5>)өv6E)p6P dh> ʣ|60L dJxaU\oF㧝+c<[ s>#.RgHɇ*_ Z0f,,L:QubEAr Iks , \r,wi*. 7rY2s/wm&V QZA 48 CaJ,f!- pͷB1ybSݬUȇ#mg;M.cTJNZVvwi[p[ g"O5 q)}"9U?:%ѷ {q%ܵR-:!&KXrqWߴd$ ! 'ϙm Džxs:Uv +q2Jss^NB< nz\4,IxLI/$jV (.77}fFgOz?U_} +^ji:<ƝE`t7C5[ C_"ύokM~.f)]V jwmKV VIt~AeP'V"0zW}2ADFQ^O\p!R6Q ΃LrC c.j^Ԣ|LVSN浣aMހt" ms8_ΎН@#8>=EpҾYQ6w6`{ChY/?9.mnY%6mZ@4|)[Z1$"\|9[F럑f jCY)\ш ~OYDP(WYF?J<÷'L|S+  ~ҜQJBysDC{)@|*џAMm])elN{+ ozPK Y*TMȪ, benchmark-1.6.1/test/reporter_output_test.ccUTa]{W8Ou4!N:3 0ΞChc+rZWoɱΜ)`^]]#k,Mcpzx3ETKf͠H, ?FP3Ѹ~L@Bs 4y>[[f\*m4tUXQQRS_}><|[]3ubINry'S ݷ@wu Mp y%q!"W0Zƻ5a6P4>27 Sߠ#t׵9nz\z?W?XԄ6 疦2\7pۇ7>eU]DT`#UX꟝ i|0jѝ0$[*1)&2` d&j J,$Tkekldu :d(-@NR|6>z1 =C# zn-d>az^WZ; e:v]2/;p6G )&B@pe1hw8D׺xt ,"xحDrg"U6-9OOU6u1"-|1osp?@υwY- w>nԂZ">j3,8/5e@yv=]1 $Hخ}@@<pU)IO" tKN~վnwk,a>6Ey(.& 2#̌܂`] Q́v6gĮ假8Ljkh,v!frBJ87\`!> Sd;F "X9D = nBGSo^Y":D$B#´nhi H{qxiK?ԑg5ǝ[ ClrS֓!hLjR! :5bKab։@ӵ霃4"^V 7GP?cw_! 3b &[ݍw1Wi-׍D02b D?qusb2[&0,9Ju<_Oz*~8WjƆ80a?_`ql僅Bx"Uh`m-`,KQ ho"t~CAu9Q8GԴ5-p@ q_M8hZ0}ޜp5p'M< BEEw?{D R#&W89U_x+uV4Qӗ c)D/1uܜos"[w*q_=w't ZG't9spf>\]^__y}*oZqBj:gdTgI&}xgƾQ[fvѰ_ư6B˶*p'Sӎ=ٺUUк=nҷtxIj`WeaA^u*`'S%2N~sZ2!go $K$NRB⤪m(IP#gũcHvNvF)%̠i(>v'Ju[;rW98;8k~S|M'^_E5q| j(%>v6'@>ku/`w _ "Vw۝ '14A6;ݽ7{ow{d$\tʈؗbx}z: vP}bvG~RtrNt1_//./N-r;HA+pҽng0h]morܶ YL|~w `=aO0PKπ+ d.afX&X|L 8IMC EOYD"x2پdzs!h 捾 sA@.9"Qð2晐,UseR gP|RYz haf%+13,3>ZK>cc>ގEӝD?V9[Ylprb Ђ}<=/5hv`cǏF;kh1?mcZݕ1pュ8aI>^ӱxv;sV2LpۀNDM$d,m`@ j:)nf)nҶIRLwY1LY1MwqD(JP^\8Ը@ ҩq:@1Su#O e8p#CbHŚ`qّX<;ҠhCv$pH|O:g: JI얔^I8yYaD_!\@mKe5#h}N:Ev=-e@2 M^%-̊!-ʌ)-\Z&@ M|Hl&dWХS$-@XiZ@ ҴL:@iK gʘr)e8Ģ53sxfAc-X\ܙAqLS`PJjo^Vj/|.>lgB䅉U&K4-?%Y@u 5d~BeHm& F$gHaPn:Þc>HnkE򎃙gXL=v-N|0|˷airkk>Rf B*DH^I6 #Sʪ0BUaMv̓OV̹*BC(N.zĽ: (wWDY}Mn _ٷ!uJ78h]μ.HG-Bt:hyhWVrp@ySBp \6~s^3ˌv_52h#I8YNPa4!Qh0pah)(C D^2v}a2BGg.) *h 0HWt"zo [>crݠf Eewai#e2f 3cdW^ < kؐ]i',2hգ?i?Bm V( JSmr%É/lT VdGX?l~a-c'%Nco@w{[&46NiЪDU]$B͗X/puݲ_cz (!x/H ;6 ,:#Q!yw^r,z{c Hn÷aI&6p Cpak 95KTi3r봅6< cX+I꒨JJ6E]R8ƒ٩tM]&agsti &+ rF"m UT\ GKɥ4jH|{֌=cy@:P3Sk1Ȯ8 =qd]U,tYiy*f]<s𒮗ĤCh#Z(L )zł0[ZoR3od *6Ğ0OWtK8"?S!8pHU#CӢO N iNe)+-ppJ ԀR69^(yL{g8)qS╹M/ 1JwʦeC t[z0\@ydѐnBeN[x?!A /D!.݉Cf9"(ӒѽHWws*j )'i#Pa\(A8-|WF$tX?[/=U_xբJy'JwpF\%Xߗ^u+?N 햏`)n|L J5%E#XXZKO35=Υ2ƶрY(nK! ~Х!րK's/W/l3o$颺bG`X}K8ePJr^=z !VޔGƑ)sH0gl@NhH2Y]Y$2z &3KEʦhn"ʦD0']^Yrn_ nF@4 r&~ @Md tIp{@aT >Lz!=~h8<`3 P$ C\&Ȱ #r̠iⰁXXn?߈Ϡ&+B:0J/\Ѫ;pSu`3 @u~_!f@*FҡG @[N3{T4f/1@K83zٲ pPK Y*TlB, benchmark-1.6.1/test/skip_with_error_test.ccUTaXmo6_quLZ\Z#Adp0DDdɕ('n_;qc $LJ{'4.ϝ )z$Ih̻%҂z[iE7E~SdL N+9kOcM3aq]1߈UQ|԰|cr zOcJ|az}YƯ*JV\]r*|6A:5wΪBjcjz7~s$w=:n ~PQo=.O*p'{_;N:dwC@<T2ώ:Ƚ[jǞ o)iC@ RL*)`m~Ϡ_pi`g}#+)I89`#Cƃ]'{(V ,t?vG0UxAvylìSɘNɂ!Ŭ:[G4 B+fh OuK@0 ) "H(Ӻ̥Ov2Ch?4K~&^e*w0S pҌ ڴ'Ly:DQw]Fjα&}w REIZ]e.v{+u%\ k"W\ܹhYisuOgl7|e{{m۹۹۹{'Gk[4|_")\ibV~= scթ`rSM<̱^rw _ӽz_Q׎1l up;X\+ёJiuvQPK Y*T쁽 % benchmark-1.6.1/test/spec_arg_test.ccUTaVn:}WLU[GIENo_r),$67pE4x3sy+Z63CRkU8z#%R2LRxg*t$x5MF#[KJOYEO)-(:>L* 3zń}QXazWg3{R1}ljf*ISc492IӴFQEL. eE@f>,iK?+YDΩP )aZ%XWJ()po 痷O7g/ݷťNT#*ة5yDUgNA:}o9uoXQ%/ta4((ZY7UFٔ'p򘊦ͼ4ip;|C:_{7Nԍmcm{XXb)(EZC5JU3z"BoZZ* x>ڕu NGUNJɠӁݿp{ElfPAu6P_iSWW~M{@ "޽/+j' yI081gktf1<* R 79hf~ G޿]'Cb hI|i%6p)n'_Kb>W\qR۱5l3.}QFCH 6B,aAktջf;׶ox+CT6csf 9ez=0~bt!f?-`e|8v/x5מUW=Ҙ)WW EZilylZf-e_CڪܷA+e ;p J)QMp i-~r`5Xqփi`^PAWA?4 ^/PK Y*T`2_+ benchmark-1.6.1/test/state_assembly_test.ccUTaTko0+覰5@=tD!U#ӶfQdna>; @`/`^{Ϲ.jSCCm?KR <˲]DG%<Fԟ0b;PREM#.IeL2Z-Q~!p(9RO@%/);הT/Y+|.,w4Nv;yLy5oq*0ևO[DԜ}FVWpd͆6r]92#s.qE72i6!‹h0?w CvXZVmB@*J$zu5ZdžrWW,i9|M/L!d@Mi'9N?(/!d(irϓVEq"/K2ZϺ#yqqZ;f`; WX@hDBg߷B]T콿4煫jDw 6юgEwaG1#Z1' ~ ! AndQ'<,>" Aӥ9e7T)@]v2.UB= >q)".8N$^>*7 0 Hr>QD^N=?2M)E|1*uknMۙ.1opT%ߩ|{B>Ox/|f0^amV/Nt$c"OG'&aeQ.GV#PK Y*THw. benchmark-1.6.1/test/templated_fixture_test.ccUTaN0F)nĔHq[ѢD!tf@I)d»['~_Nml/$^6>,Q-khM~~O ȺZوZ"!afz-b2GJgҩ=gM8+dqlYrcYpd] rlCwƮzq>4uM),xqWGݱ0J~HBX(/z3qg/7 JPK Y*TIn2 benchmark-1.6.1/test/user_counters_tabular_test.ccUTa\s8_C i tȵs)׻H_2m~ !e4 #+Ugwd2O,ǰ}CGe1+:2"NI*ۿ>ڳ<0zظ=o@ouTP61-AYt {,*~v>F?~rla} k7e{\ CR@}ȶ6 SzҬ5s^%Gl||&r/% k؄`.o.F&jЫco >cL@ pr<8{'̛rV*#*˓a,M1Gkk~!Z`bY6vV17c$ &N8Nc?5خZBiqy~6Ra2çkLZeLeA}˾-?y}]9%X}9'5`Ԁ56A ƟSjh鎏:ÑȐgj<d tO(OXw,)k1ru u/ ! vE[B o#F%; 1"Y jYk$u.2s-/!^3!Ew'J*u*u:*΅R J%lK%+ JؖJ0:H:0Rwo )0} a=Aۀ:eԁ1ALJ5iV¼k,W*a^R7KL_AR clT"zJ%L UDO16e*a#=&*v% a>$<.ޛڟzo>;E|48A^F{2z@ieH/s,9gX-]bKlZ|&Vȶɏ䬎ܥJa<<@`~DܮgjՏz7j͋z;$qU{M= utF TA V>_r8ܝQvT<Ark2 (xx=Di"iސ*=DڏNkmiIT89?!MC,n(H[\T!x|\>^c$g 5L|ؾQKSrFX8+rb ?͑NTq)R)di$RH?N,)B,Rpd0%& ףbxq ! .c!wvim3kL.(0#E}/,cRT*KPFĔ2tERN iN::Gy^ <:ҙ8Uxˌд3-Jn^,|+U{RsOȒtbiY# CrѪ=E-2=0UJB>FINGg^ESar)19/ix`rb MNy&gI{&h+&gL0LNəvhr^&29RL`rfLo/`-tȏYYKm߉FmE%m,+^MۗïU/+ ΧsvjACTd趆~cj(#Vl|@1b.)Ш^GqQD](IGzZt3V ; GiBr@XU Z0PmKh/ܢǚ]^ ނ曐h]#\SIMױnf^\A+w[8:>4t*&L%i-p@ޖdA3~x\Yo~EMËb \qP,"PG*ٵiTwf4$;Dv [bg!`˺^2RI`+$=(Zܱj`y&Y 8NlMu;$+>&ɫnn9Y#n ;8x[(~5X&t ȳXS[SG,dӄc @3y>@6.9,l5vK^֒\qog +7i,Dd=nbu!Pхzԗqfu蜝ݾ[U\ݿIcc頼fM!X3$B xMfFY¿MT,4Qg!=0IΘG5*2h4Igy$d'>ԽSdѴsIz4S M4l.dh@K 4{r63(ءVmkc* yD>تqkv:v8{p TptM+On-P' -Cvh ѭ@|ϖ|^ \w<]ohDPGJuDH(#lLػ6ڌ_ܠa 7%|%B'TPn|p9A#&r~1#*`EP'4ݸqxK?CDtK(tX!ˎRG4E %Ȥ `M!2,kc-a =XhQYx%Ɛ  !8ϯ6"/֢,ffaS܅h] FVmH)plҪ`PPۭehXD[Ѽr}ӬlNM(iϒ|r 6 Rh~ )A(K&oyy+//eFmKQL3t]'"LLE*d^Q.(>vU&4{:p4hA-=FicC~8rD*; 83@,B>W^Ȍ5¥pqMN6t25{5Šj =S*'w*Gq+L!_5_3lDvQ|)XpA0x;h|CGPf[ !Quw!\A;sCx;])2$ M(3SluUs>eDx%¸u[8ns܃D*L95{s>2iJUj{;9AT9S9/ l_{y1CoQ%``і|6hɗ@(u_FAΉ7&'XeGSח_ӂGpf:_7)Rv(;TEv%]I{r) ~_I;r!0FPtCD][H=9H[ʃ#!R6TAIiBI}5n7Xhϛ^il^v%9")4>anxB l} = ݗ%)HQ#,D !vO)&<4&y}&t^Up"*&A ;,I*y!A<[|;̅UlI^^JU*`[mD챬 53,JŰml &0/lQ+&Lb zIGqܜN=$0jJ!ȅ;,{ PlU8(|^Zɀ\g0 a*4g_bhzP՟tAYAR>$> C@w>8U?W(^d)-ۚ$cF2 PK Y*T%4 benchmark-1.6.1/test/user_counters_thousands_test.ccUTaZaSF_^:r"z(^/eְHF0ٍ &D!z+q41yIȮ#}ؠ;th瀕JUqpb6T*A_ȥ9j>+^#}/i|1nFQ܌r!V>9x2oFYr3or[Bސvu=bfƾN0nilH6t1KȐ ޳ K#FrA))^GlTJT$RyW~z RdP ,PKj ,Ҵs+v|*=<1]kؼCa7귨IJLeg*7sg+oo+awƲ3X;;cykc}g,_+1m%#FdH|$isW-=>G8 lD |wIͿffUfηpwR?Lbn:^:)/6G,9pa(}@&xPSvafѹvF6bqBS1w b~C ]d93%Gݑ:,q1Cx'EOhq @6 Wq_oYk]7ysvyp~<_yz)w~%//.i?KZxE&7KZ+n㊃p7\P$5:]wh4BE6a0F6/q++)=Ғ뮺2A9w 3oPK Y*T benchmark-1.6.1/tools/UTaPK Y*TbG! benchmark-1.6.1/tools/BUILD.bazelUTam 0E~EU,ХP't[D$jvv s" 1mzn}UՎ'z%}J(l2ȳ,RPG\`\)PܬUu(m6_`$@hsT$WL|#*3F;N.Kex3{pzAh2xPK Y*Ttk {G benchmark-1.6.1/tools/compare.pyUTa\[oF~ׯ(Hk{/Ѻ8 ܑ8fҪZ93Crx8vnk@Ĺ9|sE?Ps.g⚤|%`שrRLp8XuJ3[2!,S4 #s&5YiێR&c)fKPlgr]}[{-5+,>+PV[U\Q SRc1p(= bC.@msq<&\IХ+2[.\,$_1R$5XD(BED"NB}Tl LsraEceEBhfnd;TNv81LXt!4kX,DS}o2K+} ȷBtmqe-N,<-]V_aBiE_Ϯ./.>%[(lxPI n(e"JV]YBay3" B G䉫.eeUy„og,Լ6 0~%'bjq٩w y0d-0sC,[af*wͨfoB;6VvS0 !pL"̬j"a% t | _—f/~ _.f//_Nť[;2ȣIUzFH'o؋P1V]4N$[/9xb8fQ8@O4Y zDnLv15D1GCFQ`XЅFk=h^*mo·6'Gxk:\-/bn(A5ɡ.40t"k 8Z2eE؜vH4!aikk6SzTә |>YP~.$4L(Zsuvl=6,)a1SJYL`sӔ뙶m'j݅υt6K+hKTݨLG-Sݸٸ 0SJCIe/iAγk^bLR:Y|zEuAjhiN^fY<,]6! YO2܀[׷ŋ35\?&{zi<>0&x/Fͧ'k@BwC߯˃p=f9sF7v:複T MmjYK·GA׬%OUbNyJW&VՏ>h;m)3&[YfA퟈$=c:8FxBXH&^Pr8۶>']3#ri'jCRuqGvg%$}|S=!!B~ r]++Y$xFV4MLKVqH)_X`pOX&?ۯ$.ӧ) :w {eM3\I5+0L?P Ñs*5:xvGmjX8:<;]RrRJlx"@h;\6sv7 6n3ֶ ߵL2؟oݕs5FϡVs|,Q6ոOҽcr:nѮDO{##>!5(3;0#zGq44B'_>7Qg:ns9d{;`+ )F!1DC{4SH󄭹('dq`]@[;ٰ֯:ޗ#"ڽ38 ;2wDJo < 3l;>ܬfGwHnpk2.&^Vp? ˝pmj&LU.0DP? Cdz#jؼե1Sӹe:}F)|qQb%jFtnqJ=/&L9i )SDJm_p[kQ[NT 1gPK Y*T benchmark-1.6.1/tools/gbench/UTaPK Y*T$ benchmark-1.6.1/tools/gbench/Inputs/UTaPK Y*Tv" 3 benchmark-1.6.1/tools/gbench/Inputs/test1_run1.jsonUTaVMo0WD\ 㚯UoiMzZ,֘5*}mM.iԴo7ch@Wuu9O=0]8?Qտt#QCGqh/ԉHxA+"l0\a$QH`nN5}g,dC.9^x2;%nPK Y*T% 3 benchmark-1.6.1/tools/gbench/Inputs/test1_run2.jsonUTaUMo0+P-8&HW{[-,`51Z؊vtY73fN%eaA`&4; z(!ʼ]Jy\U&|/AYآDxL)BL3*gdrJf37˺ DDo Eȅzmե;Ɩሏ߉̡ړ5QA -Vb!@d\˺)j*3Ϫ}#.*Z"$t8+7!( ՠJ,uO(t;uȏw#ږYL: M@ ~kX6:?d|Api v}&;<)I0MTv 13<@G70DLB3~?c0L#f?YN+(aHFGSv~>It#&QpܧC{,P 0b^ރor>eɽΣ₱PK Y*T I2 benchmark-1.6.1/tools/gbench/Inputs/test2_run.jsonUTak0EY1ģ]v!O K-}I-nB6R7yaeܸv e B7VS6ͤ J\[r֡LQ~W[1)~#.5n",UP~c,$r]i}ZOU4PW4uc6.0.yǃ1]8bDK"UM8D 7RD0B|I/wDc$C^x4W1 OZXL#q 3)BBn>:n\Pr ~:=>giK&CPK Y*TO%y3 benchmark-1.6.1/tools/gbench/Inputs/test3_run0.jsonUTaœj0> QD]^z+%:$JLhXJ^|ge I)-[FGQV$Ip(+YŒ=4y6T j*(.b9!xAYi9€eF$%_OS كYqmFc/ls oQJB F+Y=bVq?EM|<|TpBj[pn&e%mE_G'?Bc|PK Y*Tʟ 23 benchmark-1.6.1/tools/gbench/Inputs/test3_run1.jsonUTaOk0BrnKz}!; Qbd}ۃe]l^>Aj(^J7 coxuj󐖁,.K(EwG΢[-X'}H%`>߼PK Y*Tܲ 2 benchmark-1.6.1/tools/gbench/Inputs/test4_run.jsonUTaŔ0<ņ/*Ɛ+6J%&[1Ŋ4Mg~L+]aaNnj4S4~p[3&{ k aws|Z`ći =a·C8tO=YuݽPK Y*Tb3 benchmark-1.6.1/tools/gbench/Inputs/test4_run0.jsonUTamn0E|l҈_"k0Sj Cmtэ%{^5S XWK`c xSm^gh6K8ѦmGz>x<FMQAۚ;4ydd=Z5>S\8 s.1(). pL mt"F+*?:gs#".^NګPK Y*T23 benchmark-1.6.1/tools/gbench/Inputs/test4_run1.jsonUTamn0E| iįT5j Cmtэ9V5 X_ߨ$0B@X˛_N׾̞g!h6K8Ѷ%m@ `<*(u<{2fp[z8 s5-cPR\%rzE.HFlj:ъm'Ctb` s0(*Eh<Ҍ3}PK Y*T.( benchmark-1.6.1/tools/gbench/__init__.pyUTa]A 0}O1dKƥ zM309YߟG)ue +/́⤔jc;,YB+b)TՎ]RAIđ-Ў={AOئ,m@Wޞ uvo>PK Y*T!& benchmark-1.6.1/tools/gbench/report.pyUTa=s۶s#ɑv{n_;8׹ph HJR} ArF6&bX r?!8uh}y$qb0,4 ǩ\ǫ̺&xOY.,#i?i~n/ ċi/t.m1x"YE~նn$lZ*H/aP4dBY7ij_NYhςkB0od>m[Q mxB8 ^XecuL  '&*!*ISb}o-JW -haJ{,SQn=(RxN8{?;?;qj m`qm5-z{ʼn ?Nr[&ρ囏&2Xh-)t<'?7`o'^jhkDN/Là|9yg?2cqpؗo~6bqx(E]ъNNjgw/^}9wvdYϬ7-( zNP\mb)&=Q:㟝E`"pEH*" n&?n/Tt=[.ٌphSaS@ڕbk`5F`a< ,Pi7 z,!o <P,a]:@ ņz8V8buscˑiA;cjXt6sT9pza5Y]y1dƭA\9!sP_~1A qZpuXw1d#)\!6eLA}J6PNS !w  e Zq@r\6j+!tqSAyFAIS$BBUi(L+)P[wBoO -ϱuv~a-I8L9ofDy%uSU¦KMJcUx  "B^Lh &:wLвF F F ȄOY:R\'k2b˻U.quܺ)͈X' :l+`2i ]l]ɼTqօ02D鶩v4JvvZ0pXY2qK1hŭSH*Cq ˆ0aױa8b>h[tvBL> NO%L˟|3Բ0>. AN1w|sA@5sc%X#+,bEb#:a2 ?:[765ҒQ߉hB̲NڻIK&W 1qDh)$ˏpiEeSnSrh!e:چXbsW ZH@őPϬw1tEX4 X q}R17Y?jN60,3zI,{:~k]mMAPI!۷]Ѻh{8rxU(!]ٿ+3@]$^k#%\}__W|tvwZzyTVeHUXUl1*VSi, !u]P i S^עKtMv 1+l]IQEYDyڪ.8O_.'ً; @LO% @&O7(Y|԰Uy|'+ل@ieAeW^bq ]I{lNM~xyRDMn1b\1wLLJ$zƨo,)HI iա%G#}iy)s uVAҳaነ&7G2u;2]/ɦpJTQR~g v_&i½Ř蘁 (K9.|!D[)_p؜fIֵcASa~LÊPO[JEdI-QCvT=N3&Dɜ0C6HI|=Vze&x}C_>f^Ш>n1}jF |h-s[OMqWNd# Kk*kIyq_O޼=={GU0m.7xYfHCm7vPM(#P:}PPy e7R}2$ɖT'0gQ8ߛRd6gNFjB>0>`=XfߴB;vl'՘nO=cHXfIX :SumcFf5nʠT04d-E}4u/Q)ҋX/Mg013;[)3^ĸΔ{(OʴDM.qەP Y &H/:9WzV zjv[P9q'h?#`kc&/RR( UEU_zGү'tdDOvS!ShfjwWeS@꠵䋱l#lȄWSfp|ٴvT<ʻaRPLN[ S%(}wEF ;x}moa Sij̕+^OJ\-\qUIqMRq0+O8*1Y]Gf`/(#HƬxb-&ܓrG[&WS?I)WSI+io%=j`[YfyZ%[pksjrm9O h!ƟjSɡbyIWv{ZDۉ2o0NɛkdDoTDZFUn=̟?=OV0G u~n3$N_ ۃn:Ƙ6F{4Ga4zΐ"ٝѠ z=: XW1N3w4tJGѨu53 9:H#"E`L2JfF}KO 坍zF@;E[ۊPH*ҳ*5B hvKv|oYfv_lnmܕpWT{R#uH/].k>حxn}ٹMVޔ]IJ=Ӷ_tt֓z_B.!B<ϋN5kSk& v]~DeWzA+ z9y-lN?Yyt#[bЮ9 !h۩*O'AxD~t*-OGqAd ;@ P#CL {Z 3ѦKHߩ0Ь/wNG؝3*);2w)7,2~$#?%=qSуc5N#-\Fv;pӋ Å}oH?ِxU8w`hkO6ǃmZR }\T~\+|.YW?ײʥ״FKEK?une?ѰyBٶe(5zM~J3:jQ_`T|F2!;sW0'`.sƈ_9wZg-MPؚcR%'Kk@MAryur: nT憣fXE@=%`G`]wIJaD鼡|0Ky/_F"׽˓A}I'딫H 7wkCxܯ3,<`6 qdouuQv] [yFgYX:k(:}u;C;yC3zaj?.z~y$C7V=ۃzynƪk]wm7Vi]guUG9 O@;Uw*t!c}ݜ9fۊwnu%wpQ}R@v]\٥ٵKR5FKRy.u< S珝ˮ%JxԾTLZ.M q*'a].˻/y_ℿ3*!"پK[h>JKx$](/إv)0!nos6'9u|ܪpOOGͿ{؃-}wnCbf\p.* TIFVwo9",:X~[k2-5] owSԤLUؤN敷I*ؤ*WѦ&%CcAd> F -hХiZM⅝VT6U9~x<+H[eBfP]j"iVRö[emT g[?6~L~fw#YjI8/*SGTµs9wps;}#I3?L?[eQ,}uPd U8).f~HxO{R;T [%p/B_JAD I( : 2>=x{M$7К #NukZDk`ORӭe$iQMK-bxܥA1\im h1knyY!` !3+ e fցC6㣜g eಡ>$YUKp+=ݰ$,65#Ff3Bc0X;l$ww|~ o"N yC.~/N;wvCK|8?xs~y =s2Nn(qG(?7X:Њ/So~9m!k ̂B^H\SP"=Fm[r,2'ɴo7T+|n_Z6XrR(m(_@l |B P\D< >x [ ")2#2bFxQ</;J A|%)!j遦$jj7:e-猶u쭘v|WJM4[b6V9쫤ɼ+2Jz) "hǓJȑ\jA6,z\@]11 f+ne@ b@Rw>[uVe2GLD@ñjDnTqnq؄2LR@9&bsH˺kTd6bYAM /rWn*:;dQ_f eě)\m0SK^ǎAwTJvB:k!pQ{ !y~2hv]G)tLcHm1|1`$QCTV<˿^+4ɟ\a4LۘMάs"nսKznC~<&4&|T ga #˯<21`Ywz=wۭ}Y]y)R385vR}""!hI9@wnP<'C1KYY|ܾQ(`@>ؙpgpwT!TXʰ|A5Vi5z]\ Dm@?y5[:K{w;!  X"xHͅ;v<}D-?F " "b2 Ɏ[=`Yy;p5p9e3ac[va NQX̻VoazhksG8wMQ`R`jt7ë2q7H;qJF^l9z-Y5^^^..롐|ͅ:v shqPAm~1̯o YwD{=}3ѡc?L|5dy®h|scˣRnfw*n#{՚=/+{kT̈́ \_\rRlW}#8#ƞ"{6tAv}#sڃ.KN s=1.5.0PK Y*TgB" benchmark-1.6.1/tools/strip_asm.pyUTan6_:-$%}x]е{I ScW%,Iq!usAQIs3G/^Zs;RlR^QbC]ƨ( r#)JCRY2 󔳄!}tx(vr\8B|?Nxs[uEuXyw⛅c`ՆyvKm 0~ r6O`gRYUV߇S4svs1 2R fŒ"1"[<LX0483v2b+Sy%3ޓwPfQeS %c,7=CABtNP\&<@ȉdIX ͵d"h9VQd`=z(/>Xi -@vO"co01 f(hf$Lj옚+T'$7KIZ)[-͒p%U+VIA8:*i wDv0*,}/x6uF\;Wv4{fS<]œnB5wzdϸؐe$X0$\1#چ}j@Bb666c=pDn.R,!4Y31]޸uLU3sݽe?F'pO~Gąu'I?@qNy {.29o3xoCQg6B&C}_i*)[c`77m6ZdIf%>0%QeiXY*z {Kо5hS\ ۾3vKӚC6 3˛w/1x^;Mv:ev͡fBl;ڙ}!9 X{X> dv XKwt(t]}^NS^{] 1t@WoS#V@Z|scU9Gr di j̦``bbenchmark-1.6.1/README.mdUTaPK Y*TF;y mbenchmark-1.6.1/WORKSPACEUTaPK Y*T0*+ pbenchmark-1.6.1/_config.ymlUTaPK Y*TrL  qbenchmark-1.6.1/appveyor.ymlUTaPK Y*T sbenchmark-1.6.1/bindings/UTaPK Y*T sbenchmark-1.6.1/bindings/python/UTaPK Y*Tp:D% "tbenchmark-1.6.1/bindings/python/BUILDUTaPK Y*T9. tbenchmark-1.6.1/bindings/python/build_defs.bzlUTaPK Y*T1 6vbenchmark-1.6.1/bindings/python/google_benchmark/UTaPK Y*TKW)6 vbenchmark-1.6.1/bindings/python/google_benchmark/BUILDUTaPK Y*T ڨ< xbenchmark-1.6.1/bindings/python/google_benchmark/__init__.pyUTaPK Y*TTf= benchmark-1.6.1/bindings/python/google_benchmark/benchmark.ccUTaPK Y*T쵛; benchmark-1.6.1/bindings/python/google_benchmark/example.pyUTaPK Y*TOp. benchmark-1.6.1/bindings/python/pybind11.BUILDUTaPK Y*Tm5g4 benchmark-1.6.1/bindings/python/python_headers.BUILDUTaPK Y*T 0 tbenchmark-1.6.1/bindings/python/requirements.txtUTaPK Y*T ۏbenchmark-1.6.1/cmake/UTaPK Y*Tc . benchmark-1.6.1/cmake/AddCXXCompilerFlag.cmakeUTaPK Y*TJ0t+ Obenchmark-1.6.1/cmake/CXXFeatureCheck.cmakeUTaPK Y*TuRـ% benchmark-1.6.1/cmake/Config.cmake.inUTaPK Y*TTI) pbenchmark-1.6.1/cmake/GetGitVersion.cmakeUTaPK Y*T ',& benchmark-1.6.1/cmake/GoogleTest.cmakeUTaPK Y*T{me ) #benchmark-1.6.1/cmake/GoogleTest.cmake.inUTaPK Y*T benchmark-1.6.1/cmake/Modules/UTaPK Y*T6{. ]benchmark-1.6.1/cmake/Modules/FindLLVMAr.cmakeUTaPK Y*T@l. benchmark-1.6.1/cmake/Modules/FindLLVMNm.cmakeUTaPK Y*T[S2 benchmark-1.6.1/cmake/Modules/FindLLVMRanLib.cmakeUTaPK Y*TZT+ Tbenchmark-1.6.1/cmake/Modules/FindPFM.cmakeUTaPK Y*T;l1% benchmark-1.6.1/cmake/benchmark.pc.inUTaPK Y*Ts ) ѩbenchmark-1.6.1/cmake/gnu_posix_regex.cppUTaPK Y*TN* benchmark-1.6.1/cmake/llvm-toolchain.cmakeUTaPK Y*Tw )% benchmark-1.6.1/cmake/posix_regex.cppUTaPK Y*TH]& benchmark-1.6.1/cmake/split_list.cmakeUTaPK Y*T0# wbenchmark-1.6.1/cmake/std_regex.cppUTaPK Y*T~^m& gbenchmark-1.6.1/cmake/steady_clock.cppUTaPK Y*T]OO2 !benchmark-1.6.1/cmake/thread_safety_attributes.cppUTaPK Y*T ɯbenchmark-1.6.1/docs/UTaPK Y*T^ջx% benchmark-1.6.1/docs/AssemblyTests.mdUTaPK Y*T> benchmark-1.6.1/docs/_config.ymlUTaPK Y*Tʚ&$ Lbenchmark-1.6.1/docs/dependencies.mdUTaPK Y*Tr,]G benchmark-1.6.1/docs/index.mdUTaPK Y*T$H% benchmark-1.6.1/docs/perf_counters.mdUTaPK Y*Tϐu < _benchmark-1.6.1/docs/platform_specific_build_instructions.mdUTaPK Y*TIC+ benchmark-1.6.1/docs/random_interleaving.mdUTaPK Y*T5p! abenchmark-1.6.1/docs/releasing.mdUTaPK Y*T= 0 benchmark-1.6.1/docs/tools.mdUTaPK Y*Tzl2" Ibenchmark-1.6.1/docs/user_guide.mdUTaPK Y*T ?benchmark-1.6.1/include/UTaPK Y*T" ~benchmark-1.6.1/include/benchmark/UTaPK Y*T=_A- benchmark-1.6.1/include/benchmark/benchmark.hUTaPK Y*T`$/ Ibenchmark-1.6.1/requirements.txtUTaPK Y*T%g Ibenchmark-1.6.1/setup.pyUTaPK Y*T [Pbenchmark-1.6.1/src/UTaPK Y*T0" Pbenchmark-1.6.1/src/CMakeLists.txtUTaPK Y*Tҧ'T Vbenchmark-1.6.1/src/arraysize.hUTaPK Y*TNjX +Ybenchmark-1.6.1/src/benchmark.ccUTaPK Y*ToB - sbenchmark-1.6.1/src/benchmark_api_internal.ccUTaPK Y*TW , wbenchmark-1.6.1/src/benchmark_api_internal.hUTaPK Y*T[Z% zbenchmark-1.6.1/src/benchmark_main.ccUTaPK Y*TL q% |benchmark-1.6.1/src/benchmark_name.ccUTaPK Y*TB<8) 5benchmark-1.6.1/src/benchmark_register.ccUTaPK Y*TNj% ( benchmark-1.6.1/src/benchmark_register.hUTaPK Y*Tnm?25' benchmark-1.6.1/src/benchmark_runner.ccUTaPK Y*Tiw k & ٦benchmark-1.6.1/src/benchmark_runner.hUTaPK Y*TN`  benchmark-1.6.1/src/check.hUTaPK Y*Tc-! benchmark-1.6.1/src/colorprint.ccUTaPK Y*T^3g benchmark-1.6.1/src/colorprint.hUTaPK Y*TS %' benchmark-1.6.1/src/commandlineflags.ccUTaPK Y*T>L%& benchmark-1.6.1/src/commandlineflags.hUTaPK Y*T0! !! Jbenchmark-1.6.1/src/complexity.ccUTaPK Y*TeÄ  benchmark-1.6.1/src/complexity.hUTaPK Y*Tv ' Pbenchmark-1.6.1/src/console_reporter.ccUTaPK Y*T,hQ benchmark-1.6.1/src/counter.ccUTaPK Y*T`hZi `benchmark-1.6.1/src/counter.hUTaPK Y*T6G# benchmark-1.6.1/src/csv_reporter.ccUTaPK Y*T1# ~benchmark-1.6.1/src/cycleclock.hUTaPK Y*TC % benchmark-1.6.1/src/internal_macros.hUTaPK Y*TQU5 S'$ benchmark-1.6.1/src/json_reporter.ccUTaPK Y*Tջ :`  benchmark-1.6.1/src/log.hUTaPK Y*TV&Dş  benchmark-1.6.1/src/mutex.hUTaPK Y*Tͽ$ benchmark-1.6.1/src/perf_counters.ccUTaPK Y*Tq# 6benchmark-1.6.1/src/perf_counters.hUTaPK Y*Tp{3? 3"benchmark-1.6.1/src/re.hUTaPK Y*T#i@R  (benchmark-1.6.1/src/reporter.ccUTaPK Y*T᧹ .benchmark-1.6.1/src/sleep.ccUTaPK Y*Tca 2benchmark-1.6.1/src/sleep.hUTaPK Y*Txny 7! 3benchmark-1.6.1/src/statistics.ccUTaPK Y*Tձ =benchmark-1.6.1/src/statistics.hUTaPK Y*T ] " @benchmark-1.6.1/src/string_util.ccUTaPK Y*Ta&6o! Jbenchmark-1.6.1/src/string_util.hUTaPK Y*TQȶ]SW RNbenchmark-1.6.1/src/sysinfo.ccUTaPK Y*T+&$ jbenchmark-1.6.1/src/thread_manager.hUTaPK Y*T7M$" mbenchmark-1.6.1/src/thread_timer.hUTaPK Y*TJR1C " qbenchmark-1.6.1/src/timers.ccUTaPK Y*Tl }benchmark-1.6.1/src/timers.hUTaPK Y*T benchmark-1.6.1/test/UTaPK Y*TʪN|( benchmark-1.6.1/test/AssemblyTests.cmakeUTaPK Y*TOr benchmark-1.6.1/test/BUILDUTaPK Y*T`d +# benchmark-1.6.1/test/CMakeLists.txtUTaPK Y*TBS) benchmark-1.6.1/test/args_product_test.ccUTaPK Y*T" benchmark-1.6.1/test/basic_test.ccUTaPK Y*Tw 2' Йbenchmark-1.6.1/test/benchmark_gtest.ccUTaPK Y*Tp{e*, ,benchmark-1.6.1/test/benchmark_name_gtest.ccUTaPK Y*T~Wq ; benchmark-1.6.1/test/benchmark_random_interleaving_gtest.ccUTaPK Y*Td|5 Фbenchmark-1.6.1/test/benchmark_setup_teardown_test.ccUTaPK Y*TC-tv& benchmark-1.6.1/test/benchmark_test.ccUTaPK Y*T5-|P4 benchmark-1.6.1/test/clobber_memory_assembly_test.ccUTaPK Y*Ttg. benchmark-1.6.1/test/commandlineflags_gtest.ccUTaPK Y*TD~!' >benchmark-1.6.1/test/complexity_test.ccUTaPK Y*TZ߶cM"  benchmark-1.6.1/test/cxx03_test.ccUTaPK Y*TQ]`( benchmark-1.6.1/test/diagnostics_test.ccUTaPK Y*TF?4 benchmark-1.6.1/test/display_aggregates_only_test.ccUTaPK Y*T 73 _benchmark-1.6.1/test/donotoptimize_assembly_test.ccUTaPK Y*T6( * benchmark-1.6.1/test/donotoptimize_test.ccUTaPK Y*Tg  # abenchmark-1.6.1/test/filter_test.ccUTaPK Y*Tw$ @benchmark-1.6.1/test/fixture_test.ccUTaPK Y*Tܹ/ 8benchmark-1.6.1/test/internal_threading_test.ccUTaPK Y*Tkn#& benchmark-1.6.1/test/link_main_test.ccUTaPK Y*T@ |benchmark-1.6.1/test/map_test.ccUTaPK Y*TbpE+ benchmark-1.6.1/test/memory_manager_test.ccUTaPK Y*TVZC= , ubenchmark-1.6.1/test/multiple_ranges_test.ccUTaPK Y*TU-$ benchmark-1.6.1/test/options_test.ccUTaPK Y*T " Ebenchmark-1.6.1/test/output_test.hUTaPK Y*TE@F* #benchmark-1.6.1/test/output_test_helper.ccUTaPK Y*T({+ benchmark-1.6.1/test/perf_counters_gtest.ccUTaPK Y*T0c* benchmark-1.6.1/test/perf_counters_test.ccUTaPK Y*T;f/  benchmark-1.6.1/test/register_benchmark_test.ccUTaPK Y*T-J-( benchmark-1.6.1/test/repetitions_test.ccUTaPK Y*T:Uh703 wbenchmark-1.6.1/test/report_aggregates_only_test.ccUTaPK Y*TMȪ, benchmark-1.6.1/test/reporter_output_test.ccUTaPK Y*TlB, )benchmark-1.6.1/test/skip_with_error_test.ccUTaPK Y*T쁽 % 0benchmark-1.6.1/test/spec_arg_test.ccUTaPK Y*T`2_+ 4benchmark-1.6.1/test/state_assembly_test.ccUTaPK Y*T_+RT( 7benchmark-1.6.1/test/statistics_gtest.ccUTaPK Y*TL<) "9benchmark-1.6.1/test/string_util_gtest.ccUTaPK Y*THw. Y<benchmark-1.6.1/test/templated_fixture_test.ccUTaPK Y*TIn2 =benchmark-1.6.1/test/user_counters_tabular_test.ccUTaPK Y*T2 g* Ebenchmark-1.6.1/test/user_counters_test.ccUTaPK Y*T%4 _Obenchmark-1.6.1/test/user_counters_thousands_test.ccUTaPK Y*T Tbenchmark-1.6.1/tools/UTaPK Y*TbG! Tbenchmark-1.6.1/tools/BUILD.bazelUTaPK Y*Ttk {G 큸Ubenchmark-1.6.1/tools/compare.pyUTaPK Y*T jbbenchmark-1.6.1/tools/gbench/UTaPK Y*T$ bbenchmark-1.6.1/tools/gbench/Inputs/UTaPK Y*Tv" 3 bbenchmark-1.6.1/tools/gbench/Inputs/test1_run1.jsonUTaPK Y*T% 3 ,ebenchmark-1.6.1/tools/gbench/Inputs/test1_run2.jsonUTaPK Y*T I2 gbenchmark-1.6.1/tools/gbench/Inputs/test2_run.jsonUTaPK Y*TO%y3 =ibenchmark-1.6.1/tools/gbench/Inputs/test3_run0.jsonUTaPK Y*Tʟ 23 jbenchmark-1.6.1/tools/gbench/Inputs/test3_run1.jsonUTaPK Y*Tܲ 2 =lbenchmark-1.6.1/tools/gbench/Inputs/test4_run.jsonUTaPK Y*Tb3 mbenchmark-1.6.1/tools/gbench/Inputs/test4_run0.jsonUTaPK Y*T23 nbenchmark-1.6.1/tools/gbench/Inputs/test4_run1.jsonUTaPK Y*T.( 'pbenchmark-1.6.1/tools/gbench/__init__.pyUTaPK Y*T!& qbenchmark-1.6.1/tools/gbench/report.pyUTaPK Y*T5kK.$ Abenchmark-1.6.1/tools/gbench/util.pyUTaPK Y*T: & הbenchmark-1.6.1/tools/requirements.txtUTaPK Y*TgB" 0benchmark-1.6.1/tools/strip_asm.pyUTaPKxC(0d98dba29d66e93259db7daa53a9327df767a415HdrHistogram_c-0.11.8/src/000077500000000000000000000000001442262567300153005ustar00rootroot00000000000000HdrHistogram_c-0.11.8/src/CMakeLists.txt000066400000000000000000000043271442262567300200460ustar00rootroot00000000000000 include(CheckLibraryExists) check_library_exists(m ceil "" HAVE_LIBM) check_library_exists(rt clock_gettime "" HAVE_LIBRT) if (HDR_LOG_ENABLED) set(HDR_LOG_IMPLEMENTATION hdr_histogram_log.c) set(HDR_ZLIB ZLIB::ZLIB) else() set(HDR_LOG_IMPLEMENTATION hdr_histogram_log_no_op.c) set(HDR_ZLIB "") endif() set(HDR_HISTOGRAM_SOURCES hdr_encoding.c hdr_histogram.c ${HDR_LOG_IMPLEMENTATION} hdr_interval_recorder.c hdr_thread.c hdr_time.c hdr_writer_reader_phaser.c) set(HDR_HISTOGRAM_PRIVATE_HEADERS hdr_atomic.h hdr_encoding.h hdr_endian.h hdr_tests.h hdr_malloc.h) function(hdr_histogram_add_library NAME LIBRARY_TYPE DO_INSTALL) add_library(${NAME} ${LIBRARY_TYPE} ${HDR_HISTOGRAM_SOURCES} ${HDR_HISTOGRAM_PRIVATE_HEADERS} ${HDR_HISTOGRAM_PUBLIC_HEADERS}) target_link_libraries(${NAME} PRIVATE # ZLIB::ZLIB ${HDR_ZLIB} # $<$ZLIB::ZLIB> Threads::Threads $<$:m> $<$:rt> $<$:ws2_32>) target_include_directories( ${NAME} PUBLIC $ $) if(DO_INSTALL) install( TARGETS ${NAME} EXPORT ${PROJECT_NAME}-targets RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}) endif() endfunction() option(HDR_HISTOGRAM_BUILD_SHARED "Build shared library" ON) option(HDR_HISTOGRAM_INSTALL_SHARED "Install shared library" ON) if(HDR_HISTOGRAM_BUILD_SHARED) hdr_histogram_add_library(hdr_histogram SHARED ${HDR_HISTOGRAM_INSTALL_SHARED}) set_target_properties(hdr_histogram PROPERTIES VERSION ${HDR_VERSION} SOVERSION ${HDR_SOVERSION}) endif() option(HDR_HISTOGRAM_BUILD_STATIC "Build static library" ON) option(HDR_HISTOGRAM_INSTALL_STATIC "Install static library" ON) if(HDR_HISTOGRAM_BUILD_STATIC) hdr_histogram_add_library(hdr_histogram_static STATIC ${HDR_HISTOGRAM_INSTALL_STATIC}) endif() HdrHistogram_c-0.11.8/src/hdr_atomic.h000066400000000000000000000075051442262567300175710ustar00rootroot00000000000000/** * hdr_atomic.h * Written by Philip Orwig and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_ATOMIC_H__ #define HDR_ATOMIC_H__ #if defined(_MSC_VER) && !(defined(__clang__) && (defined(_M_ARM) || defined(_M_ARM64))) #include #include #include static void __inline * hdr_atomic_load_pointer(void** pointer) { _ReadBarrier(); return *pointer; } static void hdr_atomic_store_pointer(void** pointer, void* value) { _WriteBarrier(); *pointer = value; } static int64_t __inline hdr_atomic_load_64(int64_t* field) { _ReadBarrier(); return *field; } static void __inline hdr_atomic_store_64(int64_t* field, int64_t value) { _WriteBarrier(); *field = value; } static int64_t __inline hdr_atomic_exchange_64(volatile int64_t* field, int64_t value) { #if defined(_WIN64) return _InterlockedExchange64(field, value); #else int64_t comparand; int64_t initial_value = *field; do { comparand = initial_value; initial_value = _InterlockedCompareExchange64(field, value, comparand); } while (comparand != initial_value); return initial_value; #endif } static int64_t __inline hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value) { #if defined(_WIN64) return _InterlockedExchangeAdd64(field, value) + value; #else int64_t comparand; int64_t initial_value = *field; do { comparand = initial_value; initial_value = _InterlockedCompareExchange64(field, comparand + value, comparand); } while (comparand != initial_value); return initial_value + value; #endif } static bool __inline hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired) { return *expected == _InterlockedCompareExchange64(field, desired, *expected); } #elif defined(__ATOMIC_SEQ_CST) #define hdr_atomic_load_pointer(x) __atomic_load_n(x, __ATOMIC_SEQ_CST) #define hdr_atomic_store_pointer(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST) #define hdr_atomic_load_64(x) __atomic_load_n(x, __ATOMIC_SEQ_CST) #define hdr_atomic_store_64(f,v) __atomic_store_n(f,v, __ATOMIC_SEQ_CST) #define hdr_atomic_exchange_64(f,i) __atomic_exchange_n(f,i, __ATOMIC_SEQ_CST) #define hdr_atomic_add_fetch_64(field, value) __atomic_add_fetch(field, value, __ATOMIC_SEQ_CST) #define hdr_atomic_compare_exchange_64(field, expected, desired) __atomic_compare_exchange_n(field, expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) #elif defined(__x86_64__) #include #include static inline void* hdr_atomic_load_pointer(void** pointer) { void* p = *pointer; asm volatile ("" ::: "memory"); return p; } static inline void hdr_atomic_store_pointer(void** pointer, void* value) { asm volatile ("lock; xchgq %0, %1" : "+q" (value), "+m" (*pointer)); } static inline int64_t hdr_atomic_load_64(int64_t* field) { int64_t i = *field; asm volatile ("" ::: "memory"); return i; } static inline void hdr_atomic_store_64(int64_t* field, int64_t value) { asm volatile ("lock; xchgq %0, %1" : "+q" (value), "+m" (*field)); } static inline int64_t hdr_atomic_exchange_64(volatile int64_t* field, int64_t value) { int64_t result = 0; asm volatile ("lock; xchgq %1, %2" : "=r" (result), "+q" (value), "+m" (*field)); return result; } static inline int64_t hdr_atomic_add_fetch_64(volatile int64_t* field, int64_t value) { return __sync_add_and_fetch(field, value); } static inline bool hdr_atomic_compare_exchange_64(volatile int64_t* field, int64_t* expected, int64_t desired) { int64_t original; asm volatile( "lock; cmpxchgq %2, %1" : "=a"(original), "+m"(*field) : "q"(desired), "0"(*expected)); return original == *expected; } #else #error "Unable to determine atomic operations for your platform" #endif #endif /* HDR_ATOMIC_H__ */ HdrHistogram_c-0.11.8/src/hdr_encoding.c000066400000000000000000000213641442262567300200750ustar00rootroot00000000000000/** * hdr_encoding.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include "hdr_encoding.h" #include "hdr_tests.h" int zig_zag_encode_i64(uint8_t* buffer, int64_t signed_value) { int bytesWritten; int64_t value = signed_value; value = (value << 1) ^ (value >> 63); if (value >> 7 == 0) { buffer[0] = (uint8_t) value; bytesWritten = 1; } else { buffer[0] = (uint8_t) ((value & 0x7F) | 0x80); if (value >> 14 == 0) { buffer[1] = (uint8_t) (value >> 7); bytesWritten = 2; } else { buffer[1] = (uint8_t) ((value >> 7 | 0x80)); if (value >> 21 == 0) { buffer[2] = (uint8_t) (value >> 14); bytesWritten = 3; } else { buffer[2] = (uint8_t) (value >> 14 | 0x80); if (value >> 28 == 0) { buffer[3] = (uint8_t) (value >> 21); bytesWritten = 4; } else { buffer[3] = (uint8_t) (value >> 21 | 0x80); if (value >> 35 == 0) { buffer[4] = (uint8_t) (value >> 28); bytesWritten = 5; } else { buffer[4] = (uint8_t) (value >> 28 | 0x80); if (value >> 42 == 0) { buffer[5] = (uint8_t) (value >> 35); bytesWritten = 6; } else { buffer[5] = (uint8_t) (value >> 35 | 0x80); if (value >> 49 == 0) { buffer[6] = (uint8_t) (value >> 42); bytesWritten = 7; } else { buffer[6] = (uint8_t) (value >> 42 | 0x80); if (value >> 56 == 0) { buffer[7] = (uint8_t) (value >> 49); bytesWritten = 8; } else { buffer[7] = (uint8_t) (value >> 49 | 0x80); buffer[8] = (uint8_t) (value >> 56); bytesWritten = 9; } } } } } } } } return bytesWritten; } int zig_zag_decode_i64(const uint8_t* buffer, int64_t* signed_value) { uint64_t v = buffer[0]; uint64_t value = v & 0x7F; int bytesRead = 1; if ((v & 0x80) != 0) { bytesRead = 2; v = buffer[1]; value |= (v & 0x7F) << 7; if ((v & 0x80) != 0) { bytesRead = 3; v = buffer[2]; value |= (v & 0x7F) << 14; if ((v & 0x80) != 0) { bytesRead = 4; v = buffer[3]; value |= (v & 0x7F) << 21; if ((v & 0x80) != 0) { bytesRead = 5; v = buffer[4]; value |= (v & 0x7F) << 28; if ((v & 0x80) != 0) { bytesRead = 6; v = buffer[5]; value |= (v & 0x7F) << 35; if ((v & 0x80) != 0) { bytesRead = 7; v = buffer[6]; value |= (v & 0x7F) << 42; if ((v & 0x80) != 0) { bytesRead = 8; v = buffer[7]; value |= (v & 0x7F) << 49; if ((v & 0x80) != 0) { bytesRead = 9; v = buffer[8]; value |= v << 56; } } } } } } } } #if defined(_MSC_VER) #pragma warning(push) #pragma warning(disable: 4146) /* C4146: unary minus operator applied to unsigned type, result still unsigned */ #endif value = (value >> 1) ^ (-(value & 1)); #if defined(_MSC_VER) #pragma warning(pop) #endif *signed_value = (int64_t) value; return bytesRead; } static const char base64_table[] = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '\0' }; static char get_base_64(uint32_t _24_bit_value, int shift) { uint32_t _6_bit_value = 0x3F & (_24_bit_value >> shift); return base64_table[_6_bit_value]; } static int from_base_64(int c) { if ('A' <= c && c <= 'Z') { return c - 'A'; } else if ('a' <= c && c <= 'z') { return (c - 'a') + 26; } else if ('0' <= c && c <= '9') { return (c - '0') + 52; } else if ('+' == c) { return 62; } else if ('/' == c) { return 63; } else if ('=' == c) { return 0; } return EINVAL; } size_t hdr_base64_encoded_len(size_t decoded_size) { return (size_t) (ceil(decoded_size / 3.0) * 4.0); } size_t hdr_base64_decoded_len(size_t encoded_size) { return (encoded_size / 4) * 3; } static void hdr_base64_encode_block_pad(const uint8_t* input, char* output, size_t pad) { uint32_t _24_bit_value = 0; switch (pad) { case 2: _24_bit_value = (input[0] << 16) + (input[1] << 8); output[0] = get_base_64(_24_bit_value, 18); output[1] = get_base_64(_24_bit_value, 12); output[2] = get_base_64(_24_bit_value, 6); output[3] = '='; break; case 1: _24_bit_value = (input[0] << 16); output[0] = get_base_64(_24_bit_value, 18); output[1] = get_base_64(_24_bit_value, 12); output[2] = '='; output[3] = '='; break; default: /* No-op */ break; } } /** * Assumes that there is 3 input bytes and 4 output chars. */ void hdr_base64_encode_block(const uint8_t* input, char* output) { uint32_t _24_bit_value = (input[0] << 16) + (input[1] << 8) + (input[2]); output[0] = get_base_64(_24_bit_value, 18); output[1] = get_base_64(_24_bit_value, 12); output[2] = get_base_64(_24_bit_value, 6); output[3] = get_base_64(_24_bit_value, 0); } int hdr_base64_encode( const uint8_t* input, size_t input_len, char* output, size_t output_len) { size_t i, j, remaining; if (hdr_base64_encoded_len(input_len) != output_len) { return EINVAL; } for (i = 0, j = 0; input_len - i >= 3 && j < output_len; i += 3, j += 4) { hdr_base64_encode_block(&input[i], &output[j]); } remaining = input_len - i; hdr_base64_encode_block_pad(&input[i], &output[j], remaining); return 0; } /** * Assumes that there is 4 input chars available and 3 output chars. */ void hdr_base64_decode_block(const char* input, uint8_t* output) { uint32_t _24_bit_value = 0; _24_bit_value |= from_base_64(input[0]) << 18; _24_bit_value |= from_base_64(input[1]) << 12; _24_bit_value |= from_base_64(input[2]) << 6; _24_bit_value |= from_base_64(input[3]); output[0] = (uint8_t) ((_24_bit_value >> 16) & 0xFF); output[1] = (uint8_t) ((_24_bit_value >> 8) & 0xFF); output[2] = (uint8_t) ((_24_bit_value) & 0xFF); } int hdr_base64_decode( const char* input, size_t input_len, uint8_t* output, size_t output_len) { size_t i, j; if (input_len < 4 || (input_len & 3u) != 0 || (input_len / 4) * 3 != output_len) { return -EINVAL; } for (i = 0, j = 0; i < input_len; i += 4, j += 3) { hdr_base64_decode_block(&input[i], &output[j]); } return 0; } HdrHistogram_c-0.11.8/src/hdr_encoding.h000066400000000000000000000041131442262567300200730ustar00rootroot00000000000000/** * hdr_encoding.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_ENCODING_H #define HDR_ENCODING_H #include #define MAX_BYTES_LEB128 9 #ifdef __cplusplus extern "C" { #endif /** * Writes a int64_t value to the given buffer in LEB128 ZigZag encoded format * * @param buffer the buffer to write to * @param signed_value the value to write to the buffer * @return the number of bytes written to the buffer */ int zig_zag_encode_i64(uint8_t* buffer, int64_t signed_value); /** * Read an LEB128 ZigZag encoded long value from the given buffer * * @param buffer the buffer to read from * @param retVal out value to capture the read value * @return the number of bytes read from the buffer */ int zig_zag_decode_i64(const uint8_t* buffer, int64_t* signed_value); /** * Gets the length in bytes of base64 data, given the input size. * * @param decoded_size the size of the unencoded values. * @return the encoded size */ size_t hdr_base64_encoded_len(size_t decoded_size); /** * Encode into base64. * * @param input the data to encode * @param input_len the length of the data to encode * @param output the buffer to write the output to * @param output_len the number of bytes to write to the output */ int hdr_base64_encode( const uint8_t* input, size_t input_len, char* output, size_t output_len); /** * Gets the length in bytes of decoded base64 data, given the size of the base64 encoded * data. * * @param encoded_size the size of the encoded value. * @return the decoded size */ size_t hdr_base64_decoded_len(size_t encoded_size); /** * Decode from base64. * * @param input the base64 encoded data * @param input_len the size in bytes of the endcoded data * @param output the buffer to write the decoded data to * @param output_len the number of bytes to write to the output data */ int hdr_base64_decode( const char* input, size_t input_len, uint8_t* output, size_t output_len); #ifdef __cplusplus } #endif #endif /* HDR_HISTOGRAM_HDR_ENCODING_H */ HdrHistogram_c-0.11.8/src/hdr_endian.h000066400000000000000000000050641442262567300175510ustar00rootroot00000000000000/** * hdr_time.h * Released to the public domain, as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_ENDIAN_H__ #define HDR_ENDIAN_H__ #if (defined(_WIN16) || defined(_WIN32) || defined(_WIN64)) && !defined(__WINDOWS__) # define __WINDOWS__ #endif #if defined(__linux__) || defined(__CYGWIN__) # include #elif defined(__APPLE__) # include # define htobe16(x) OSSwapHostToBigInt16(x) # define htole16(x) OSSwapHostToLittleInt16(x) # define be16toh(x) OSSwapBigToHostInt16(x) # define le16toh(x) OSSwapLittleToHostInt16(x) # define htobe32(x) OSSwapHostToBigInt32(x) # define htole32(x) OSSwapHostToLittleInt32(x) # define be32toh(x) OSSwapBigToHostInt32(x) # define le32toh(x) OSSwapLittleToHostInt32(x) # define htobe64(x) OSSwapHostToBigInt64(x) # define htole64(x) OSSwapHostToLittleInt64(x) # define be64toh(x) OSSwapBigToHostInt64(x) # define le64toh(x) OSSwapLittleToHostInt64(x) # define __BYTE_ORDER BYTE_ORDER # define __BIG_ENDIAN BIG_ENDIAN # define __LITTLE_ENDIAN LITTLE_ENDIAN # define __PDP_ENDIAN PDP_ENDIAN #elif defined(__OpenBSD__) # include #elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) # include # define be16toh(x) betoh16(x) # define le16toh(x) letoh16(x) # define be32toh(x) betoh32(x) # define le32toh(x) letoh32(x) # define be64toh(x) betoh64(x) # define le64toh(x) letoh64(x) #elif defined(__WINDOWS__) # include # if BYTE_ORDER == LITTLE_ENDIAN # define htobe16(x) htons(x) # define htole16(x) (x) # define be16toh(x) ntohs(x) # define le16toh(x) (x) # define htobe32(x) htonl(x) # define htole32(x) (x) # define be32toh(x) ntohl(x) # define le32toh(x) (x) # define htobe64(x) htonll(x) # define htole64(x) (x) # define be64toh(x) ntohll(x) # define le64toh(x) (x) # elif BYTE_ORDER == BIG_ENDIAN /* that would be xbox 360 */ # define htobe16(x) (x) # define htole16(x) __builtin_bswap16(x) # define be16toh(x) (x) # define le16toh(x) __builtin_bswap16(x) # define htobe32(x) (x) # define htole32(x) __builtin_bswap32(x) # define be32toh(x) (x) # define le32toh(x) __builtin_bswap32(x) # define htobe64(x) (x) # define htole64(x) __builtin_bswap64(x) # define be64toh(x) (x) # define le64toh(x) __builtin_bswap64(x) # else # error byte order not supported # endif # define __BYTE_ORDER BYTE_ORDER # define __BIG_ENDIAN BIG_ENDIAN # define __LITTLE_ENDIAN LITTLE_ENDIAN # define __PDP_ENDIAN PDP_ENDIAN #else # error platform not supported #endif #endif HdrHistogram_c-0.11.8/src/hdr_histogram.c000066400000000000000000001111441442262567300203000ustar00rootroot00000000000000/** * hdr_histogram.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include #include #include "hdr_tests.h" #include "hdr_atomic.h" #ifndef HDR_MALLOC_INCLUDE #define HDR_MALLOC_INCLUDE "hdr_malloc.h" #endif #include HDR_MALLOC_INCLUDE /* ###### ####### ## ## ## ## ######## ###### */ /* ## ## ## ## ## ## ### ## ## ## ## */ /* ## ## ## ## ## #### ## ## ## */ /* ## ## ## ## ## ## ## ## ## ###### */ /* ## ## ## ## ## ## #### ## ## */ /* ## ## ## ## ## ## ## ### ## ## ## */ /* ###### ####### ####### ## ## ## ###### */ static int32_t normalize_index(const struct hdr_histogram* h, int32_t index) { int32_t normalized_index; int32_t adjustment = 0; if (h->normalizing_index_offset == 0) { return index; } normalized_index = index - h->normalizing_index_offset; if (normalized_index < 0) { adjustment = h->counts_len; } else if (normalized_index >= h->counts_len) { adjustment = -h->counts_len; } return normalized_index + adjustment; } static int64_t counts_get_direct(const struct hdr_histogram* h, int32_t index) { return h->counts[index]; } static int64_t counts_get_normalised(const struct hdr_histogram* h, int32_t index) { return counts_get_direct(h, normalize_index(h, index)); } static void counts_inc_normalised( struct hdr_histogram* h, int32_t index, int64_t value) { int32_t normalised_index = normalize_index(h, index); h->counts[normalised_index] += value; h->total_count += value; } static void counts_inc_normalised_atomic( struct hdr_histogram* h, int32_t index, int64_t value) { int32_t normalised_index = normalize_index(h, index); hdr_atomic_add_fetch_64(&h->counts[normalised_index], value); hdr_atomic_add_fetch_64(&h->total_count, value); } static void update_min_max(struct hdr_histogram* h, int64_t value) { h->min_value = (value < h->min_value && value != 0) ? value : h->min_value; h->max_value = (value > h->max_value) ? value : h->max_value; } static void update_min_max_atomic(struct hdr_histogram* h, int64_t value) { int64_t current_min_value; int64_t current_max_value; do { current_min_value = hdr_atomic_load_64(&h->min_value); if (0 == value || current_min_value <= value) { break; } } while (!hdr_atomic_compare_exchange_64(&h->min_value, ¤t_min_value, value)); do { current_max_value = hdr_atomic_load_64(&h->max_value); if (value <= current_max_value) { break; } } while (!hdr_atomic_compare_exchange_64(&h->max_value, ¤t_max_value, value)); } /* ## ## ######## #### ## #### ######## ## ## */ /* ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## #### */ /* ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## */ /* ####### ## #### ######## #### ## ## */ static int64_t power(int64_t base, int64_t exp) { int64_t result = 1; while(exp) { result *= base; exp--; } return result; } #if defined(_MSC_VER) && !(defined(__clang__) && (defined(_M_ARM) || defined(_M_ARM64))) # if defined(_WIN64) # pragma intrinsic(_BitScanReverse64) # else # pragma intrinsic(_BitScanReverse) # endif #endif static int32_t count_leading_zeros_64(int64_t value) { #if defined(_MSC_VER) && !(defined(__clang__) && (defined(_M_ARM) || defined(_M_ARM64))) uint32_t leading_zero = 0; #if defined(_WIN64) _BitScanReverse64(&leading_zero, value); #else uint32_t high = value >> 32; if (_BitScanReverse(&leading_zero, high)) { leading_zero += 32; } else { uint32_t low = value & 0x00000000FFFFFFFF; _BitScanReverse(&leading_zero, low); } #endif return 63 - leading_zero; /* smallest power of 2 containing value */ #else return __builtin_clzll(value); /* smallest power of 2 containing value */ #endif } static int32_t get_bucket_index(const struct hdr_histogram* h, int64_t value) { int32_t pow2ceiling = 64 - count_leading_zeros_64(value | h->sub_bucket_mask); /* smallest power of 2 containing value */ return pow2ceiling - h->unit_magnitude - (h->sub_bucket_half_count_magnitude + 1); } static int32_t get_sub_bucket_index(int64_t value, int32_t bucket_index, int32_t unit_magnitude) { return (int32_t)(value >> (bucket_index + unit_magnitude)); } static int32_t counts_index(const struct hdr_histogram* h, int32_t bucket_index, int32_t sub_bucket_index) { /* Calculate the index for the first entry in the bucket: */ /* (The following is the equivalent of ((bucket_index + 1) * subBucketHalfCount) ): */ int32_t bucket_base_index = (bucket_index + 1) << h->sub_bucket_half_count_magnitude; /* Calculate the offset in the bucket: */ int32_t offset_in_bucket = sub_bucket_index - h->sub_bucket_half_count; /* The following is the equivalent of ((sub_bucket_index - subBucketHalfCount) + bucketBaseIndex; */ return bucket_base_index + offset_in_bucket; } static int64_t value_from_index(int32_t bucket_index, int32_t sub_bucket_index, int32_t unit_magnitude) { return ((int64_t) sub_bucket_index) << (bucket_index + unit_magnitude); } int32_t counts_index_for(const struct hdr_histogram* h, int64_t value) { int32_t bucket_index = get_bucket_index(h, value); int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, h->unit_magnitude); return counts_index(h, bucket_index, sub_bucket_index); } int64_t hdr_value_at_index(const struct hdr_histogram *h, int32_t index) { int32_t bucket_index = (index >> h->sub_bucket_half_count_magnitude) - 1; int32_t sub_bucket_index = (index & (h->sub_bucket_half_count - 1)) + h->sub_bucket_half_count; if (bucket_index < 0) { sub_bucket_index -= h->sub_bucket_half_count; bucket_index = 0; } return value_from_index(bucket_index, sub_bucket_index, h->unit_magnitude); } int64_t hdr_size_of_equivalent_value_range(const struct hdr_histogram* h, int64_t value) { int32_t bucket_index = get_bucket_index(h, value); int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, h->unit_magnitude); int32_t adjusted_bucket = (sub_bucket_index >= h->sub_bucket_count) ? (bucket_index + 1) : bucket_index; return INT64_C(1) << (h->unit_magnitude + adjusted_bucket); } static int64_t size_of_equivalent_value_range_given_bucket_indices( const struct hdr_histogram *h, int32_t bucket_index, int32_t sub_bucket_index) { const int32_t adjusted_bucket = (sub_bucket_index >= h->sub_bucket_count) ? (bucket_index + 1) : bucket_index; return INT64_C(1) << (h->unit_magnitude + adjusted_bucket); } static int64_t lowest_equivalent_value(const struct hdr_histogram* h, int64_t value) { int32_t bucket_index = get_bucket_index(h, value); int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, h->unit_magnitude); return value_from_index(bucket_index, sub_bucket_index, h->unit_magnitude); } static int64_t lowest_equivalent_value_given_bucket_indices( const struct hdr_histogram *h, int32_t bucket_index, int32_t sub_bucket_index) { return value_from_index(bucket_index, sub_bucket_index, h->unit_magnitude); } int64_t hdr_next_non_equivalent_value(const struct hdr_histogram *h, int64_t value) { return lowest_equivalent_value(h, value) + hdr_size_of_equivalent_value_range(h, value); } static int64_t highest_equivalent_value(const struct hdr_histogram* h, int64_t value) { return hdr_next_non_equivalent_value(h, value) - 1; } int64_t hdr_median_equivalent_value(const struct hdr_histogram *h, int64_t value) { return lowest_equivalent_value(h, value) + (hdr_size_of_equivalent_value_range(h, value) >> 1); } static int64_t non_zero_min(const struct hdr_histogram* h) { if (INT64_MAX == h->min_value) { return INT64_MAX; } return lowest_equivalent_value(h, h->min_value); } void hdr_reset_internal_counters(struct hdr_histogram* h) { int min_non_zero_index = -1; int max_index = -1; int64_t observed_total_count = 0; int i; for (i = 0; i < h->counts_len; i++) { int64_t count_at_index; if ((count_at_index = counts_get_direct(h, i)) > 0) { observed_total_count += count_at_index; max_index = i; if (min_non_zero_index == -1 && i != 0) { min_non_zero_index = i; } } } if (max_index == -1) { h->max_value = 0; } else { int64_t max_value = hdr_value_at_index(h, max_index); h->max_value = highest_equivalent_value(h, max_value); } if (min_non_zero_index == -1) { h->min_value = INT64_MAX; } else { h->min_value = hdr_value_at_index(h, min_non_zero_index); } h->total_count = observed_total_count; } static int32_t buckets_needed_to_cover_value(int64_t value, int32_t sub_bucket_count, int32_t unit_magnitude) { int64_t smallest_untrackable_value = ((int64_t) sub_bucket_count) << unit_magnitude; int32_t buckets_needed = 1; while (smallest_untrackable_value <= value) { if (smallest_untrackable_value > INT64_MAX / 2) { return buckets_needed + 1; } smallest_untrackable_value <<= 1; buckets_needed++; } return buckets_needed; } /* ## ## ######## ## ## ####### ######## ## ## */ /* ### ### ## ### ### ## ## ## ## ## ## */ /* #### #### ## #### #### ## ## ## ## #### */ /* ## ### ## ###### ## ### ## ## ## ######## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ######## ## ## ####### ## ## ## */ int hdr_calculate_bucket_config( int64_t lowest_discernible_value, int64_t highest_trackable_value, int significant_figures, struct hdr_histogram_bucket_config* cfg) { int32_t sub_bucket_count_magnitude; int64_t largest_value_with_single_unit_resolution; if (lowest_discernible_value < 1 || significant_figures < 1 || 5 < significant_figures || lowest_discernible_value * 2 > highest_trackable_value) { return EINVAL; } cfg->lowest_discernible_value = lowest_discernible_value; cfg->significant_figures = significant_figures; cfg->highest_trackable_value = highest_trackable_value; largest_value_with_single_unit_resolution = 2 * power(10, significant_figures); sub_bucket_count_magnitude = (int32_t) ceil(log((double)largest_value_with_single_unit_resolution) / log(2)); cfg->sub_bucket_half_count_magnitude = ((sub_bucket_count_magnitude > 1) ? sub_bucket_count_magnitude : 1) - 1; double unit_magnitude = log((double)lowest_discernible_value) / log(2); if (INT32_MAX < unit_magnitude) { return EINVAL; } cfg->unit_magnitude = (int32_t) unit_magnitude; cfg->sub_bucket_count = (int32_t) pow(2, (cfg->sub_bucket_half_count_magnitude + 1)); cfg->sub_bucket_half_count = cfg->sub_bucket_count / 2; cfg->sub_bucket_mask = ((int64_t) cfg->sub_bucket_count - 1) << cfg->unit_magnitude; if (cfg->unit_magnitude + cfg->sub_bucket_half_count_magnitude > 61) { return EINVAL; } cfg->bucket_count = buckets_needed_to_cover_value(highest_trackable_value, cfg->sub_bucket_count, (int32_t)cfg->unit_magnitude); cfg->counts_len = (cfg->bucket_count + 1) * (cfg->sub_bucket_count / 2); return 0; } void hdr_init_preallocated(struct hdr_histogram* h, struct hdr_histogram_bucket_config* cfg) { h->lowest_discernible_value = cfg->lowest_discernible_value; h->highest_trackable_value = cfg->highest_trackable_value; h->unit_magnitude = (int32_t)cfg->unit_magnitude; h->significant_figures = (int32_t)cfg->significant_figures; h->sub_bucket_half_count_magnitude = cfg->sub_bucket_half_count_magnitude; h->sub_bucket_half_count = cfg->sub_bucket_half_count; h->sub_bucket_mask = cfg->sub_bucket_mask; h->sub_bucket_count = cfg->sub_bucket_count; h->min_value = INT64_MAX; h->max_value = 0; h->normalizing_index_offset = 0; h->conversion_ratio = 1.0; h->bucket_count = cfg->bucket_count; h->counts_len = cfg->counts_len; h->total_count = 0; } int hdr_init( int64_t lowest_discernible_value, int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result) { int64_t* counts; struct hdr_histogram_bucket_config cfg; struct hdr_histogram* histogram; int r = hdr_calculate_bucket_config(lowest_discernible_value, highest_trackable_value, significant_figures, &cfg); if (r) { return r; } counts = (int64_t*) hdr_calloc((size_t) cfg.counts_len, sizeof(int64_t)); if (!counts) { return ENOMEM; } histogram = (struct hdr_histogram*) hdr_calloc(1, sizeof(struct hdr_histogram)); if (!histogram) { hdr_free(counts); return ENOMEM; } histogram->counts = counts; hdr_init_preallocated(histogram, &cfg); *result = histogram; return 0; } void hdr_close(struct hdr_histogram* h) { if (h) { hdr_free(h->counts); hdr_free(h); } } int hdr_alloc(int64_t highest_trackable_value, int significant_figures, struct hdr_histogram** result) { return hdr_init(1, highest_trackable_value, significant_figures, result); } /* reset a histogram to zero. */ void hdr_reset(struct hdr_histogram *h) { h->total_count=0; h->min_value = INT64_MAX; h->max_value = 0; memset(h->counts, 0, (sizeof(int64_t) * h->counts_len)); } size_t hdr_get_memory_size(struct hdr_histogram *h) { return sizeof(struct hdr_histogram) + h->counts_len * sizeof(int64_t); } /* ## ## ######## ######## ### ######## ######## ###### */ /* ## ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ######## ## ## ## ## ## ###### ###### */ /* ## ## ## ## ## ######### ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## */ /* ####### ## ######## ## ## ## ######## ###### */ bool hdr_record_value(struct hdr_histogram* h, int64_t value) { return hdr_record_values(h, value, 1); } bool hdr_record_value_atomic(struct hdr_histogram* h, int64_t value) { return hdr_record_values_atomic(h, value, 1); } bool hdr_record_values(struct hdr_histogram* h, int64_t value, int64_t count) { int32_t counts_index; if (value < 0) { return false; } counts_index = counts_index_for(h, value); if (counts_index < 0 || h->counts_len <= counts_index) { return false; } counts_inc_normalised(h, counts_index, count); update_min_max(h, value); return true; } bool hdr_record_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count) { int32_t counts_index; if (value < 0) { return false; } counts_index = counts_index_for(h, value); if (counts_index < 0 || h->counts_len <= counts_index) { return false; } counts_inc_normalised_atomic(h, counts_index, count); update_min_max_atomic(h, value); return true; } bool hdr_record_corrected_value(struct hdr_histogram* h, int64_t value, int64_t expected_interval) { return hdr_record_corrected_values(h, value, 1, expected_interval); } bool hdr_record_corrected_value_atomic(struct hdr_histogram* h, int64_t value, int64_t expected_interval) { return hdr_record_corrected_values_atomic(h, value, 1, expected_interval); } bool hdr_record_corrected_values(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval) { int64_t missing_value; if (!hdr_record_values(h, value, count)) { return false; } if (expected_interval <= 0 || value <= expected_interval) { return true; } missing_value = value - expected_interval; for (; missing_value >= expected_interval; missing_value -= expected_interval) { if (!hdr_record_values(h, missing_value, count)) { return false; } } return true; } bool hdr_record_corrected_values_atomic(struct hdr_histogram* h, int64_t value, int64_t count, int64_t expected_interval) { int64_t missing_value; if (!hdr_record_values_atomic(h, value, count)) { return false; } if (expected_interval <= 0 || value <= expected_interval) { return true; } missing_value = value - expected_interval; for (; missing_value >= expected_interval; missing_value -= expected_interval) { if (!hdr_record_values_atomic(h, missing_value, count)) { return false; } } return true; } int64_t hdr_add(struct hdr_histogram* h, const struct hdr_histogram* from) { struct hdr_iter iter; int64_t dropped = 0; hdr_iter_recorded_init(&iter, from); while (hdr_iter_next(&iter)) { int64_t value = iter.value; int64_t count = iter.count; if (!hdr_record_values(h, value, count)) { dropped += count; } } return dropped; } int64_t hdr_add_while_correcting_for_coordinated_omission( struct hdr_histogram* h, struct hdr_histogram* from, int64_t expected_interval) { struct hdr_iter iter; int64_t dropped = 0; hdr_iter_recorded_init(&iter, from); while (hdr_iter_next(&iter)) { int64_t value = iter.value; int64_t count = iter.count; if (!hdr_record_corrected_values(h, value, count, expected_interval)) { dropped += count; } } return dropped; } /* ## ## ### ## ## ## ######## ###### */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ###### ###### */ /* ## ## ######### ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ### ## ## ######## ####### ######## ###### */ int64_t hdr_max(const struct hdr_histogram* h) { if (0 == h->max_value) { return 0; } return highest_equivalent_value(h, h->max_value); } int64_t hdr_min(const struct hdr_histogram* h) { if (0 < hdr_count_at_index(h, 0)) { return 0; } return non_zero_min(h); } static int64_t get_value_from_idx_up_to_count(const struct hdr_histogram* h, int64_t count_at_percentile) { int64_t count_to_idx = 0; count_at_percentile = 0 < count_at_percentile ? count_at_percentile : 1; for (int32_t idx = 0; idx < h->counts_len; idx++) { count_to_idx += h->counts[idx]; if (count_to_idx >= count_at_percentile) { return hdr_value_at_index(h, idx); } } return 0; } int64_t hdr_value_at_percentile(const struct hdr_histogram* h, double percentile) { double requested_percentile = percentile < 100.0 ? percentile : 100.0; int64_t count_at_percentile = (int64_t) (((requested_percentile / 100) * h->total_count) + 0.5); int64_t value_from_idx = get_value_from_idx_up_to_count(h, count_at_percentile); if (percentile == 0.0) { return lowest_equivalent_value(h, value_from_idx); } return highest_equivalent_value(h, value_from_idx); } int hdr_value_at_percentiles(const struct hdr_histogram *h, const double *percentiles, int64_t *values, size_t length) { if (NULL == percentiles || NULL == values) { return EINVAL; } struct hdr_iter iter; const int64_t total_count = h->total_count; // to avoid allocations we use the values array for intermediate computation // i.e. to store the expected cumulative count at each percentile for (size_t i = 0; i < length; i++) { const double requested_percentile = percentiles[i] < 100.0 ? percentiles[i] : 100.0; const int64_t count_at_percentile = (int64_t) (((requested_percentile / 100) * total_count) + 0.5); values[i] = count_at_percentile > 1 ? count_at_percentile : 1; } hdr_iter_init(&iter, h); int64_t total = 0; size_t at_pos = 0; while (hdr_iter_next(&iter) && at_pos < length) { total += iter.count; while (at_pos < length && total >= values[at_pos]) { values[at_pos] = highest_equivalent_value(h, iter.value); at_pos++; } } return 0; } double hdr_mean(const struct hdr_histogram* h) { struct hdr_iter iter; int64_t total = 0, count = 0; int64_t total_count = h->total_count; hdr_iter_init(&iter, h); while (hdr_iter_next(&iter) && count < total_count) { if (0 != iter.count) { count += iter.count; total += iter.count * hdr_median_equivalent_value(h, iter.value); } } return (total * 1.0) / total_count; } double hdr_stddev(const struct hdr_histogram* h) { double mean = hdr_mean(h); double geometric_dev_total = 0.0; struct hdr_iter iter; hdr_iter_init(&iter, h); while (hdr_iter_next(&iter)) { if (0 != iter.count) { double dev = (hdr_median_equivalent_value(h, iter.value) * 1.0) - mean; geometric_dev_total += (dev * dev) * iter.count; } } return sqrt(geometric_dev_total / h->total_count); } bool hdr_values_are_equivalent(const struct hdr_histogram* h, int64_t a, int64_t b) { return lowest_equivalent_value(h, a) == lowest_equivalent_value(h, b); } int64_t hdr_lowest_equivalent_value(const struct hdr_histogram* h, int64_t value) { return lowest_equivalent_value(h, value); } int64_t hdr_count_at_value(const struct hdr_histogram* h, int64_t value) { return counts_get_normalised(h, counts_index_for(h, value)); } int64_t hdr_count_at_index(const struct hdr_histogram* h, int32_t index) { return counts_get_normalised(h, index); } /* #### ######## ######## ######## ### ######## ####### ######## ###### */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ###### ######## ## ## ## ## ## ######## ###### */ /* ## ## ## ## ## ######### ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* #### ## ######## ## ## ## ## ## ####### ## ## ###### */ static bool has_buckets(struct hdr_iter* iter) { return iter->counts_index < iter->h->counts_len; } static bool has_next(struct hdr_iter* iter) { return iter->cumulative_count < iter->total_count; } static bool move_next(struct hdr_iter* iter) { iter->counts_index++; if (!has_buckets(iter)) { return false; } iter->count = counts_get_normalised(iter->h, iter->counts_index); iter->cumulative_count += iter->count; const int64_t value = hdr_value_at_index(iter->h, iter->counts_index); const int32_t bucket_index = get_bucket_index(iter->h, value); const int32_t sub_bucket_index = get_sub_bucket_index(value, bucket_index, iter->h->unit_magnitude); const int64_t leq = lowest_equivalent_value_given_bucket_indices(iter->h, bucket_index, sub_bucket_index); const int64_t size_of_equivalent_value_range = size_of_equivalent_value_range_given_bucket_indices( iter->h, bucket_index, sub_bucket_index); iter->lowest_equivalent_value = leq; iter->value = value; iter->highest_equivalent_value = leq + size_of_equivalent_value_range - 1; iter->median_equivalent_value = leq + (size_of_equivalent_value_range >> 1); return true; } static int64_t peek_next_value_from_index(struct hdr_iter* iter) { return hdr_value_at_index(iter->h, iter->counts_index + 1); } static bool next_value_greater_than_reporting_level_upper_bound( struct hdr_iter *iter, int64_t reporting_level_upper_bound) { if (iter->counts_index >= iter->h->counts_len) { return false; } return peek_next_value_from_index(iter) > reporting_level_upper_bound; } static bool basic_iter_next(struct hdr_iter *iter) { if (!has_next(iter) || iter->counts_index >= iter->h->counts_len) { return false; } move_next(iter); return true; } static void update_iterated_values(struct hdr_iter* iter, int64_t new_value_iterated_to) { iter->value_iterated_from = iter->value_iterated_to; iter->value_iterated_to = new_value_iterated_to; } static bool all_values_iter_next(struct hdr_iter* iter) { bool result = move_next(iter); if (result) { update_iterated_values(iter, iter->value); } return result; } void hdr_iter_init(struct hdr_iter* iter, const struct hdr_histogram* h) { iter->h = h; iter->counts_index = -1; iter->total_count = h->total_count; iter->count = 0; iter->cumulative_count = 0; iter->value = 0; iter->highest_equivalent_value = 0; iter->value_iterated_from = 0; iter->value_iterated_to = 0; iter->_next_fp = all_values_iter_next; } bool hdr_iter_next(struct hdr_iter* iter) { return iter->_next_fp(iter); } /* ######## ######## ######## ###### ######## ## ## ######## #### ## ######## ###### */ /* ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## #### ## ## ## ## ## ## */ /* ######## ###### ######## ## ###### ## ## ## ## ## ## ###### ###### */ /* ## ## ## ## ## ## ## #### ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ### ## ## ## ## ## ## */ /* ## ######## ## ## ###### ######## ## ## ## #### ######## ######## ###### */ static bool percentile_iter_next(struct hdr_iter* iter) { int64_t temp, half_distance, percentile_reporting_ticks; struct hdr_iter_percentiles* percentiles = &iter->specifics.percentiles; if (!has_next(iter)) { if (percentiles->seen_last_value) { return false; } percentiles->seen_last_value = true; percentiles->percentile = 100.0; return true; } if (iter->counts_index == -1 && !basic_iter_next(iter)) { return false; } do { double current_percentile = (100.0 * (double) iter->cumulative_count) / iter->h->total_count; if (iter->count != 0 && percentiles->percentile_to_iterate_to <= current_percentile) { update_iterated_values(iter, highest_equivalent_value(iter->h, iter->value)); percentiles->percentile = percentiles->percentile_to_iterate_to; temp = (int64_t)(log(100 / (100.0 - (percentiles->percentile_to_iterate_to))) / log(2)) + 1; half_distance = (int64_t) pow(2, (double) temp); percentile_reporting_ticks = percentiles->ticks_per_half_distance * half_distance; percentiles->percentile_to_iterate_to += 100.0 / percentile_reporting_ticks; return true; } } while (basic_iter_next(iter)); return true; } void hdr_iter_percentile_init(struct hdr_iter* iter, const struct hdr_histogram* h, int32_t ticks_per_half_distance) { iter->h = h; hdr_iter_init(iter, h); iter->specifics.percentiles.seen_last_value = false; iter->specifics.percentiles.ticks_per_half_distance = ticks_per_half_distance; iter->specifics.percentiles.percentile_to_iterate_to = 0.0; iter->specifics.percentiles.percentile = 0.0; iter->_next_fp = percentile_iter_next; } static void format_line_string(char* str, size_t len, int significant_figures, format_type format) { #if defined(_MSC_VER) #define snprintf _snprintf #pragma warning(push) #pragma warning(disable: 4996) #endif const char* format_str = "%s%d%s"; switch (format) { case CSV: snprintf(str, len, format_str, "%.", significant_figures, "f,%f,%d,%.2f\n"); break; case CLASSIC: snprintf(str, len, format_str, "%12.", significant_figures, "f %12f %12d %12.2f\n"); break; default: snprintf(str, len, format_str, "%12.", significant_figures, "f %12f %12d %12.2f\n"); } #if defined(_MSC_VER) #undef snprintf #pragma warning(pop) #endif } /* ######## ######## ###### ####### ######## ######## ######## ######## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ######## ###### ## ## ## ######## ## ## ###### ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ## ## ######## ###### ####### ## ## ######## ######## ######## */ static bool recorded_iter_next(struct hdr_iter* iter) { while (basic_iter_next(iter)) { if (iter->count != 0) { update_iterated_values(iter, iter->value); iter->specifics.recorded.count_added_in_this_iteration_step = iter->count; return true; } } return false; } void hdr_iter_recorded_init(struct hdr_iter* iter, const struct hdr_histogram* h) { hdr_iter_init(iter, h); iter->specifics.recorded.count_added_in_this_iteration_step = 0; iter->_next_fp = recorded_iter_next; } /* ## #### ## ## ######## ### ######## */ /* ## ## ### ## ## ## ## ## ## */ /* ## ## #### ## ## ## ## ## ## */ /* ## ## ## ## ## ###### ## ## ######## */ /* ## ## ## #### ## ######### ## ## */ /* ## ## ## ### ## ## ## ## ## */ /* ######## #### ## ## ######## ## ## ## ## */ static bool iter_linear_next(struct hdr_iter* iter) { struct hdr_iter_linear* linear = &iter->specifics.linear; linear->count_added_in_this_iteration_step = 0; if (has_next(iter) || next_value_greater_than_reporting_level_upper_bound( iter, linear->next_value_reporting_level_lowest_equivalent)) { do { if (iter->value >= linear->next_value_reporting_level_lowest_equivalent) { update_iterated_values(iter, linear->next_value_reporting_level); linear->next_value_reporting_level += linear->value_units_per_bucket; linear->next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(iter->h, linear->next_value_reporting_level); return true; } if (!move_next(iter)) { return true; } linear->count_added_in_this_iteration_step += iter->count; } while (true); } return false; } void hdr_iter_linear_init(struct hdr_iter* iter, const struct hdr_histogram* h, int64_t value_units_per_bucket) { hdr_iter_init(iter, h); iter->specifics.linear.count_added_in_this_iteration_step = 0; iter->specifics.linear.value_units_per_bucket = value_units_per_bucket; iter->specifics.linear.next_value_reporting_level = value_units_per_bucket; iter->specifics.linear.next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(h, value_units_per_bucket); iter->_next_fp = iter_linear_next; } /* ## ####### ###### ### ######## #### ######## ## ## ## ## #### ###### */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## ### ### ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## #### #### ## ## */ /* ## ## ## ## #### ## ## ######## ## ## ######### ## ### ## ## ## */ /* ## ## ## ## ## ######### ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## ## */ /* ######## ####### ###### ## ## ## ## #### ## ## ## ## ## #### ###### */ static bool log_iter_next(struct hdr_iter *iter) { struct hdr_iter_log* logarithmic = &iter->specifics.log; logarithmic->count_added_in_this_iteration_step = 0; if (has_next(iter) || next_value_greater_than_reporting_level_upper_bound( iter, logarithmic->next_value_reporting_level_lowest_equivalent)) { do { if (iter->value >= logarithmic->next_value_reporting_level_lowest_equivalent) { update_iterated_values(iter, logarithmic->next_value_reporting_level); logarithmic->next_value_reporting_level *= (int64_t)logarithmic->log_base; logarithmic->next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(iter->h, logarithmic->next_value_reporting_level); return true; } if (!move_next(iter)) { return true; } logarithmic->count_added_in_this_iteration_step += iter->count; } while (true); } return false; } void hdr_iter_log_init( struct hdr_iter* iter, const struct hdr_histogram* h, int64_t value_units_first_bucket, double log_base) { hdr_iter_init(iter, h); iter->specifics.log.count_added_in_this_iteration_step = 0; iter->specifics.log.log_base = log_base; iter->specifics.log.next_value_reporting_level = value_units_first_bucket; iter->specifics.log.next_value_reporting_level_lowest_equivalent = lowest_equivalent_value(h, value_units_first_bucket); iter->_next_fp = log_iter_next; } /* Printing. */ static const char* format_head_string(format_type format) { switch (format) { case CSV: return "%s,%s,%s,%s\n"; case CLASSIC: default: return "%12s %12s %12s %12s\n\n"; } } static const char CLASSIC_FOOTER[] = "#[Mean = %12.3f, StdDeviation = %12.3f]\n" "#[Max = %12.3f, Total count = %12" PRIu64 "]\n" "#[Buckets = %12d, SubBuckets = %12d]\n"; int hdr_percentiles_print( struct hdr_histogram* h, FILE* stream, int32_t ticks_per_half_distance, double value_scale, format_type format) { char line_format[25]; const char* head_format; int rc = 0; struct hdr_iter iter; struct hdr_iter_percentiles * percentiles; format_line_string(line_format, 25, h->significant_figures, format); head_format = format_head_string(format); hdr_iter_percentile_init(&iter, h, ticks_per_half_distance); if (fprintf( stream, head_format, "Value", "Percentile", "TotalCount", "1/(1-Percentile)") < 0) { rc = EIO; goto cleanup; } percentiles = &iter.specifics.percentiles; while (hdr_iter_next(&iter)) { double value = iter.highest_equivalent_value / value_scale; double percentile = percentiles->percentile / 100.0; int64_t total_count = iter.cumulative_count; double inverted_percentile = (1.0 / (1.0 - percentile)); if (fprintf( stream, line_format, value, percentile, total_count, inverted_percentile) < 0) { rc = EIO; goto cleanup; } } if (CLASSIC == format) { double mean = hdr_mean(h) / value_scale; double stddev = hdr_stddev(h) / value_scale; double max = hdr_max(h) / value_scale; if (fprintf( stream, CLASSIC_FOOTER, mean, stddev, max, h->total_count, h->bucket_count, h->sub_bucket_count) < 0) { rc = EIO; goto cleanup; } } cleanup: return rc; } HdrHistogram_c-0.11.8/src/hdr_histogram_log.c000066400000000000000000001055741442262567300211530ustar00rootroot00000000000000/** * hdr_histogram_log.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #if defined(_MSC_VER) #undef HAVE_UNISTD_H #endif #include #include #include #include #include #include "hdr_encoding.h" #include "hdr_tests.h" #if defined(_MSC_VER) #include typedef SSIZE_T ssize_t; #pragma comment(lib, "ws2_32.lib") #pragma warning(push) #pragma warning(disable: 4996) #endif #include "hdr_endian.h" #ifndef HDR_MALLOC_INCLUDE #define HDR_MALLOC_INCLUDE "hdr_malloc.h" #endif #include HDR_MALLOC_INCLUDE /* Private prototypes useful for the logger */ int32_t counts_index_for(const struct hdr_histogram* h, int64_t value); #define FAIL_AND_CLEANUP(label, error_name, error) \ do \ { \ error_name = error; \ goto label; \ } \ while (0) /* ######## ## ## ###### ####### ######## #### ## ## ###### */ /* ## ### ## ## ## ## ## ## ## ## ### ## ## ## */ /* ## #### ## ## ## ## ## ## ## #### ## ## */ /* ###### ## ## ## ## ## ## ## ## ## ## ## ## ## #### */ /* ## ## #### ## ## ## ## ## ## ## #### ## ## */ /* ## ## ### ## ## ## ## ## ## ## ## ### ## ## */ /* ######## ## ## ###### ####### ######## #### ## ## ###### */ static const uint32_t V0_ENCODING_COOKIE = 0x1c849308; static const uint32_t V0_COMPRESSION_COOKIE = 0x1c849309; static const uint32_t V1_ENCODING_COOKIE = 0x1c849301; static const uint32_t V1_COMPRESSION_COOKIE = 0x1c849302; static const uint32_t V2_ENCODING_COOKIE = 0x1c849303; static const uint32_t V2_COMPRESSION_COOKIE = 0x1c849304; static uint32_t get_cookie_base(uint32_t cookie) { return (cookie & ~0xf0U); } static uint32_t word_size_from_cookie(uint32_t cookie) { return (cookie & 0xf0U) >> 4U; } const char* hdr_strerror(int errnum) { switch (errnum) { case HDR_COMPRESSION_COOKIE_MISMATCH: return "Compression cookie mismatch"; case HDR_ENCODING_COOKIE_MISMATCH: return "Encoding cookie mismatch"; case HDR_DEFLATE_INIT_FAIL: return "Deflate initialisation failed"; case HDR_DEFLATE_FAIL: return "Deflate failed"; case HDR_INFLATE_INIT_FAIL: return "Inflate initialisation failed"; case HDR_INFLATE_FAIL: return "Inflate failed"; case HDR_LOG_INVALID_VERSION: return "Log - invalid version in log header"; case HDR_TRAILING_ZEROS_INVALID: return "Invalid number of trailing zeros"; case HDR_VALUE_TRUNCATED: return "Truncated value found when decoding"; case HDR_ENCODED_INPUT_TOO_LONG: return "The encoded input exceeds the size of the histogram"; default: return strerror(errnum); } } static void strm_init(z_stream* strm) { memset(strm, 0, sizeof(z_stream)); } union uint64_dbl_cvt { uint64_t l; double d; }; static double int64_bits_to_double(int64_t i) { union uint64_dbl_cvt x; x.l = (uint64_t) i; return x.d; } static uint64_t double_to_int64_bits(double d) { union uint64_dbl_cvt x; x.d = d; return x.l; } #pragma pack(push, 1) typedef struct /*__attribute__((__packed__))*/ { uint32_t cookie; int32_t significant_figures; int64_t lowest_discernible_value; int64_t highest_trackable_value; int64_t total_count; int64_t counts[1]; } encoding_flyweight_v0_t; typedef struct /*__attribute__((__packed__))*/ { uint32_t cookie; int32_t payload_len; int32_t normalizing_index_offset; int32_t significant_figures; int64_t lowest_discernible_value; int64_t highest_trackable_value; uint64_t conversion_ratio_bits; uint8_t counts[1]; } encoding_flyweight_v1_t; typedef struct /*__attribute__((__packed__))*/ { uint32_t cookie; int32_t length; uint8_t data[1]; } compression_flyweight_t; #pragma pack(pop) #define SIZEOF_ENCODING_FLYWEIGHT_V0 (sizeof(encoding_flyweight_v0_t) - sizeof(int64_t)) #define SIZEOF_ENCODING_FLYWEIGHT_V1 (sizeof(encoding_flyweight_v1_t) - sizeof(uint8_t)) #define SIZEOF_COMPRESSION_FLYWEIGHT (sizeof(compression_flyweight_t) - sizeof(uint8_t)) int hdr_encode_compressed( struct hdr_histogram* h, uint8_t** compressed_histogram, size_t* compressed_len) { encoding_flyweight_v1_t* encoded = NULL; compression_flyweight_t* compressed = NULL; int i; int result = 0; int data_index = 0; int32_t payload_len; uLong encoded_size; uLongf dest_len; size_t compressed_size; int32_t len_to_max = counts_index_for(h, h->max_value) + 1; int32_t counts_limit = len_to_max < h->counts_len ? len_to_max : h->counts_len; const size_t encoded_len = SIZEOF_ENCODING_FLYWEIGHT_V1 + MAX_BYTES_LEB128 * (size_t) counts_limit; if ((encoded = (encoding_flyweight_v1_t*) hdr_calloc(encoded_len, sizeof(uint8_t))) == NULL) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } for (i = 0; i < counts_limit;) { int64_t value = h->counts[i]; i++; if (value == 0) { int32_t zeros = 1; while (i < counts_limit && 0 == h->counts[i]) { zeros++; i++; } data_index += zig_zag_encode_i64(&encoded->counts[data_index], -zeros); } else { data_index += zig_zag_encode_i64(&encoded->counts[data_index], value); } } payload_len = data_index; encoded_size = SIZEOF_ENCODING_FLYWEIGHT_V1 + data_index; encoded->cookie = htobe32(V2_ENCODING_COOKIE | 0x10U); encoded->payload_len = htobe32(payload_len); encoded->normalizing_index_offset = htobe32(h->normalizing_index_offset); encoded->significant_figures = htobe32(h->significant_figures); encoded->lowest_discernible_value = htobe64(h->lowest_discernible_value); encoded->highest_trackable_value = htobe64(h->highest_trackable_value); encoded->conversion_ratio_bits = htobe64(double_to_int64_bits(h->conversion_ratio)); /* Estimate the size of the compressed histogram. */ dest_len = compressBound(encoded_size); compressed_size = SIZEOF_COMPRESSION_FLYWEIGHT + dest_len; if ((compressed = (compression_flyweight_t*) hdr_malloc(compressed_size)) == NULL) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } if (Z_OK != compress(compressed->data, &dest_len, (Bytef*) encoded, encoded_size)) { FAIL_AND_CLEANUP(cleanup, result, HDR_DEFLATE_FAIL); } compressed->cookie = htobe32(V2_COMPRESSION_COOKIE | 0x10U); compressed->length = htobe32((int32_t)dest_len); *compressed_histogram = (uint8_t*) compressed; *compressed_len = SIZEOF_COMPRESSION_FLYWEIGHT + dest_len; cleanup: hdr_free(encoded); if (result == HDR_DEFLATE_FAIL) { hdr_free(compressed); } return result; } /* ######## ######## ###### ####### ######## #### ## ## ###### */ /* ## ## ## ## ## ## ## ## ## ## ### ## ## ## */ /* ## ## ## ## ## ## ## ## ## #### ## ## */ /* ## ## ###### ## ## ## ## ## ## ## ## ## ## #### */ /* ## ## ## ## ## ## ## ## ## ## #### ## ## */ /* ## ## ## ## ## ## ## ## ## ## ## ### ## ## */ /* ######## ######## ###### ####### ######## #### ## ## ###### */ static void apply_to_counts_16(struct hdr_histogram* h, const int16_t* counts_data, const int32_t counts_limit) { int i; for (i = 0; i < counts_limit; i++) { h->counts[i] = be16toh(counts_data[i]); } } static void apply_to_counts_32(struct hdr_histogram* h, const int32_t* counts_data, const int32_t counts_limit) { int i; for (i = 0; i < counts_limit; i++) { h->counts[i] = be32toh(counts_data[i]); } } static void apply_to_counts_64(struct hdr_histogram* h, const int64_t* counts_data, const int32_t counts_limit) { int i; for (i = 0; i < counts_limit; i++) { h->counts[i] = be64toh(counts_data[i]); } } static int apply_to_counts_zz(struct hdr_histogram* h, const uint8_t* counts_data, const int32_t data_limit) { int64_t data_index = 0; int32_t counts_index = 0; int64_t value; while (data_index < data_limit && counts_index < h->counts_len) { data_index += zig_zag_decode_i64(&counts_data[data_index], &value); if (value < 0) { int64_t zeros = -value; if (value <= INT32_MIN || counts_index + zeros > h->counts_len) { return HDR_TRAILING_ZEROS_INVALID; } counts_index += (int32_t) zeros; } else { h->counts[counts_index] = value; counts_index++; } } if (data_index > data_limit) { return HDR_VALUE_TRUNCATED; } else if (data_index < data_limit) { return HDR_ENCODED_INPUT_TOO_LONG; } return 0; } static int apply_to_counts( struct hdr_histogram* h, const int32_t word_size, const uint8_t* counts_data, const int32_t counts_limit) { switch (word_size) { case 2: apply_to_counts_16(h, (const int16_t*) counts_data, counts_limit); return 0; case 4: apply_to_counts_32(h, (const int32_t*) counts_data, counts_limit); return 0; case 8: apply_to_counts_64(h, (const int64_t*) counts_data, counts_limit); return 0; case 1: return apply_to_counts_zz(h, counts_data, counts_limit); default: return -1; } } static int hdr_decode_compressed_v0( compression_flyweight_t* compression_flyweight, size_t length, struct hdr_histogram** histogram) { struct hdr_histogram* h = NULL; int result = 0; uint8_t* counts_array = NULL; encoding_flyweight_v0_t encoding_flyweight; z_stream strm; uint32_t encoding_cookie; int32_t compressed_len, word_size, significant_figures, counts_array_len; int64_t lowest_discernible_value, highest_trackable_value; strm_init(&strm); if (inflateInit(&strm) != Z_OK) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } compressed_len = be32toh(compression_flyweight->length); if (compressed_len < 0 || (length - SIZEOF_COMPRESSION_FLYWEIGHT) < (size_t)compressed_len) { FAIL_AND_CLEANUP(cleanup, result, EINVAL); } strm.next_in = compression_flyweight->data; strm.avail_in = (uInt) compressed_len; strm.next_out = (uint8_t *) &encoding_flyweight; strm.avail_out = SIZEOF_ENCODING_FLYWEIGHT_V0; if (inflate(&strm, Z_SYNC_FLUSH) != Z_OK) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } encoding_cookie = get_cookie_base(be32toh(encoding_flyweight.cookie)); if (V0_ENCODING_COOKIE != encoding_cookie) { FAIL_AND_CLEANUP(cleanup, result, HDR_ENCODING_COOKIE_MISMATCH); } word_size = word_size_from_cookie(be32toh(encoding_flyweight.cookie)); lowest_discernible_value = be64toh(encoding_flyweight.lowest_discernible_value); highest_trackable_value = be64toh(encoding_flyweight.highest_trackable_value); significant_figures = be32toh(encoding_flyweight.significant_figures); if (hdr_init( lowest_discernible_value, highest_trackable_value, significant_figures, &h) != 0) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } counts_array_len = h->counts_len * word_size; if ((counts_array = (uint8_t*) hdr_calloc(1, (size_t) counts_array_len)) == NULL) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } strm.next_out = counts_array; strm.avail_out = (uInt) counts_array_len; if (inflate(&strm, Z_FINISH) != Z_STREAM_END) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } apply_to_counts(h, word_size, counts_array, h->counts_len); hdr_reset_internal_counters(h); h->normalizing_index_offset = 0; h->conversion_ratio = 1.0; cleanup: (void)inflateEnd(&strm); hdr_free(counts_array); if (result != 0) { hdr_free(h); } else if (NULL == *histogram) { *histogram = h; } else { hdr_add(*histogram, h); hdr_free(h); } return result; } static int hdr_decode_compressed_v1( compression_flyweight_t* compression_flyweight, size_t length, struct hdr_histogram** histogram) { struct hdr_histogram* h = NULL; int result = 0; uint8_t* counts_array = NULL; encoding_flyweight_v1_t encoding_flyweight; z_stream strm; uint32_t encoding_cookie; int32_t compressed_length, word_size, significant_figures, counts_limit, counts_array_len; int64_t lowest_discernible_value, highest_trackable_value; strm_init(&strm); if (inflateInit(&strm) != Z_OK) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } compressed_length = be32toh(compression_flyweight->length); if (compressed_length < 0 || length - SIZEOF_COMPRESSION_FLYWEIGHT < (size_t)compressed_length) { FAIL_AND_CLEANUP(cleanup, result, EINVAL); } strm.next_in = compression_flyweight->data; strm.avail_in = (uInt) compressed_length; strm.next_out = (uint8_t *) &encoding_flyweight; strm.avail_out = SIZEOF_ENCODING_FLYWEIGHT_V1; if (inflate(&strm, Z_SYNC_FLUSH) != Z_OK) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } encoding_cookie = get_cookie_base(be32toh(encoding_flyweight.cookie)); if (V1_ENCODING_COOKIE != encoding_cookie) { FAIL_AND_CLEANUP(cleanup, result, HDR_ENCODING_COOKIE_MISMATCH); } word_size = word_size_from_cookie(be32toh(encoding_flyweight.cookie)); counts_limit = be32toh(encoding_flyweight.payload_len) / word_size; lowest_discernible_value = be64toh(encoding_flyweight.lowest_discernible_value); highest_trackable_value = be64toh(encoding_flyweight.highest_trackable_value); significant_figures = be32toh(encoding_flyweight.significant_figures); if (hdr_init( lowest_discernible_value, highest_trackable_value, significant_figures, &h) != 0) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } /* Give the temp uncompressed array a little bif of extra */ counts_array_len = counts_limit * word_size; if ((counts_array = (uint8_t*) hdr_calloc(1, (size_t) counts_array_len)) == NULL) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } strm.next_out = counts_array; strm.avail_out = (uInt) counts_array_len; if (inflate(&strm, Z_FINISH) != Z_STREAM_END) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } apply_to_counts(h, word_size, counts_array, counts_limit); h->normalizing_index_offset = be32toh(encoding_flyweight.normalizing_index_offset); h->conversion_ratio = int64_bits_to_double(be64toh(encoding_flyweight.conversion_ratio_bits)); hdr_reset_internal_counters(h); cleanup: (void)inflateEnd(&strm); hdr_free(counts_array); if (result != 0) { hdr_free(h); } else if (NULL == *histogram) { *histogram = h; } else { hdr_add(*histogram, h); hdr_free(h); } return result; } static int hdr_decode_compressed_v2( compression_flyweight_t* compression_flyweight, size_t length, struct hdr_histogram** histogram) { struct hdr_histogram* h = NULL; int result = 0; int rc = 0; uint8_t* counts_array = NULL; encoding_flyweight_v1_t encoding_flyweight; z_stream strm; uint32_t encoding_cookie; int32_t compressed_length, counts_limit, significant_figures; int64_t lowest_discernible_value, highest_trackable_value; strm_init(&strm); if (inflateInit(&strm) != Z_OK) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } compressed_length = be32toh(compression_flyweight->length); if (compressed_length < 0 || length - SIZEOF_COMPRESSION_FLYWEIGHT < (size_t)compressed_length) { FAIL_AND_CLEANUP(cleanup, result, EINVAL); } strm.next_in = compression_flyweight->data; strm.avail_in = (uInt) compressed_length; strm.next_out = (uint8_t *) &encoding_flyweight; strm.avail_out = SIZEOF_ENCODING_FLYWEIGHT_V1; if (inflate(&strm, Z_SYNC_FLUSH) != Z_OK) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } encoding_cookie = get_cookie_base(be32toh(encoding_flyweight.cookie)); if (V2_ENCODING_COOKIE != encoding_cookie) { FAIL_AND_CLEANUP(cleanup, result, HDR_ENCODING_COOKIE_MISMATCH); } counts_limit = be32toh(encoding_flyweight.payload_len); lowest_discernible_value = be64toh(encoding_flyweight.lowest_discernible_value); highest_trackable_value = be64toh(encoding_flyweight.highest_trackable_value); significant_figures = be32toh(encoding_flyweight.significant_figures); rc = hdr_init(lowest_discernible_value, highest_trackable_value, significant_figures, &h); if (rc) { FAIL_AND_CLEANUP(cleanup, result, rc); } /* Make sure there at least 9 bytes to read */ /* if there is a corrupt value at the end */ /* of the array we won't read corrupt data or crash. */ if ((counts_array = (uint8_t*) hdr_calloc(1, (size_t) counts_limit + 9)) == NULL) { FAIL_AND_CLEANUP(cleanup, result, ENOMEM); } strm.next_out = counts_array; strm.avail_out = (uInt) counts_limit; if (inflate(&strm, Z_FINISH) != Z_STREAM_END) { FAIL_AND_CLEANUP(cleanup, result, HDR_INFLATE_FAIL); } rc = apply_to_counts_zz(h, counts_array, counts_limit); if (rc) { FAIL_AND_CLEANUP(cleanup, result, rc); } h->normalizing_index_offset = be32toh(encoding_flyweight.normalizing_index_offset); h->conversion_ratio = int64_bits_to_double(be64toh(encoding_flyweight.conversion_ratio_bits)); hdr_reset_internal_counters(h); cleanup: (void)inflateEnd(&strm); hdr_free(counts_array); if (result != 0) { hdr_free(h); } else if (NULL == *histogram) { *histogram = h; } else { hdr_add(*histogram, h); hdr_free(h); } return result; } int hdr_decode_compressed( uint8_t* buffer, size_t length, struct hdr_histogram** histogram) { uint32_t compression_cookie; compression_flyweight_t* compression_flyweight; if (length < SIZEOF_COMPRESSION_FLYWEIGHT) { return EINVAL; } compression_flyweight = (compression_flyweight_t*) buffer; compression_cookie = get_cookie_base(be32toh(compression_flyweight->cookie)); if (V0_COMPRESSION_COOKIE == compression_cookie) { return hdr_decode_compressed_v0(compression_flyweight, length, histogram); } else if (V1_COMPRESSION_COOKIE == compression_cookie) { return hdr_decode_compressed_v1(compression_flyweight, length, histogram); } else if (V2_COMPRESSION_COOKIE == compression_cookie) { return hdr_decode_compressed_v2(compression_flyweight, length, histogram); } return HDR_COMPRESSION_COOKIE_MISMATCH; } /* ## ## ######## #### ######## ######## ######## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ######## ## ## ###### ######## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ### ### ## ## #### ## ######## ## ## */ int hdr_log_writer_init(struct hdr_log_writer* writer) { (void)writer; return 0; } #define LOG_VERSION "1.2" #define LOG_MAJOR_VERSION 1 static int print_user_prefix(FILE* f, const char* prefix) { if (!prefix) { return 0; } return fprintf(f, "#[%s]\n", prefix); } static int print_version(FILE* f, const char* version) { return fprintf(f, "#[Histogram log format version %s]\n", version); } static int print_time(FILE* f, hdr_timespec* timestamp) { char time_str[128]; struct tm date_time; if (!timestamp) { return 0; } #if defined(__WINDOWS__) _gmtime32_s(&date_time, ×tamp->tv_sec); #else gmtime_r(×tamp->tv_sec, &date_time); #endif strftime(time_str, 128, "%a %b %X %Z %Y", &date_time); return fprintf( f, "#[StartTime: %.3f (seconds since epoch), %s]\n", hdr_timespec_as_double(timestamp), time_str); } static int print_header(FILE* f) { return fprintf(f, "\"StartTimestamp\",\"EndTimestamp\",\"Interval_Max\",\"Interval_Compressed_Histogram\"\n"); } /* Example log */ /* #[Logged with jHiccup version 2.0.3-SNAPSHOT] */ /* #[Histogram log format version 1.01] */ /* #[StartTime: 1403476110.183 (seconds since epoch), Mon Jun 23 10:28:30 NZST 2014] */ /* "StartTimestamp","EndTimestamp","Interval_Max","Interval_Compressed_Histogram" */ int hdr_log_write_header( struct hdr_log_writer* writer, FILE* file, const char* user_prefix, hdr_timespec* timestamp) { (void)writer; if (print_user_prefix(file, user_prefix) < 0) { return EIO; } if (print_version(file, LOG_VERSION) < 0) { return EIO; } if (print_time(file, timestamp) < 0) { return EIO; } if (print_header(file) < 0) { return EIO; } return 0; } int hdr_log_write( struct hdr_log_writer* writer, FILE* file, const hdr_timespec* start_timestamp, const hdr_timespec* end_timestamp, struct hdr_histogram* histogram) { uint8_t* compressed_histogram = NULL; size_t compressed_len = 0; char* encoded_histogram = NULL; int rc = 0; int result = 0; size_t encoded_len; (void)writer; rc = hdr_encode_compressed(histogram, &compressed_histogram, &compressed_len); if (rc != 0) { FAIL_AND_CLEANUP(cleanup, result, rc); } encoded_len = hdr_base64_encoded_len(compressed_len); encoded_histogram = (char*) hdr_calloc(encoded_len + 1, sizeof(char)); rc = hdr_base64_encode( compressed_histogram, compressed_len, encoded_histogram, encoded_len); if (rc != 0) { FAIL_AND_CLEANUP(cleanup, result, rc); } if (fprintf( file, "%.3f,%.3f,%" PRIu64 ".0,%s\n", hdr_timespec_as_double(start_timestamp), hdr_timespec_as_double(end_timestamp), hdr_max(histogram), encoded_histogram) < 0) { result = EIO; } cleanup: hdr_free(compressed_histogram); hdr_free(encoded_histogram); return result; } int hdr_log_write_entry( struct hdr_log_writer* writer, FILE* file, struct hdr_log_entry* entry, struct hdr_histogram* histogram) { uint8_t* compressed_histogram = NULL; size_t compressed_len = 0; char* encoded_histogram = NULL; int rc = 0; int result = 0; size_t encoded_len; int has_tag = 0; const char* tag_prefix; const char* tag_value; const char* tag_separator; (void)writer; rc = hdr_encode_compressed(histogram, &compressed_histogram, &compressed_len); if (rc != 0) { FAIL_AND_CLEANUP(cleanup, result, rc); } encoded_len = hdr_base64_encoded_len(compressed_len); encoded_histogram = (char*) hdr_calloc(encoded_len + 1, sizeof(char)); rc = hdr_base64_encode( compressed_histogram, compressed_len, encoded_histogram, encoded_len); if (rc != 0) { FAIL_AND_CLEANUP(cleanup, result, rc); } has_tag = NULL != entry->tag && 0 < entry->tag_len; tag_prefix = has_tag ? "Tag=" : ""; tag_value = has_tag ? entry->tag : ""; tag_separator = has_tag ? "," : ""; if (fprintf( file, "%s%.*s%s%.3f,%.3f,%" PRIu64 ".0,%s\n", tag_prefix, (int) entry->tag_len, tag_value, tag_separator, hdr_timespec_as_double(&entry->start_timestamp), hdr_timespec_as_double(&entry->interval), hdr_max(histogram), encoded_histogram) < 0) { result = EIO; } cleanup: hdr_free(compressed_histogram); hdr_free(encoded_histogram); return result; } /* ######## ######## ### ######## ######## ######## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ######## ###### ## ## ## ## ###### ######## */ /* ## ## ## ######### ## ## ## ## ## */ /* ## ## ## ## ## ## ## ## ## ## */ /* ## ## ######## ## ## ######## ######## ## ## */ int hdr_log_reader_init(struct hdr_log_reader* reader) { reader->major_version = 0; reader->minor_version = 0; reader->start_timestamp.tv_sec = 0; reader->start_timestamp.tv_nsec = 0; return 0; } static void scan_log_format(struct hdr_log_reader* reader, const char* line) { const char* format = "#[Histogram log format version %d.%d]"; sscanf(line, format, &reader->major_version, &reader->minor_version); } static void scan_start_time(struct hdr_log_reader* reader, const char* line) { const char* format = "#[StartTime: %lf [^\n]"; double timestamp = 0.0; if (sscanf(line, format, ×tamp) == 1) { hdr_timespec_from_double(&reader->start_timestamp, timestamp); } } static void scan_header_line(struct hdr_log_reader* reader, const char* line) { scan_log_format(reader, line); scan_start_time(reader, line); } static bool validate_log_version(struct hdr_log_reader* reader) { return reader->major_version == LOG_MAJOR_VERSION && (reader->minor_version == 0 || reader->minor_version == 1 || reader->minor_version == 2 || reader->minor_version == 3); } #define HEADER_LINE_LENGTH 128 int hdr_log_read_header(struct hdr_log_reader* reader, FILE* file) { char line[HEADER_LINE_LENGTH]; /* TODO: check for overflow. */ bool parsing_header = true; do { int c = fgetc(file); ungetc(c, file); switch (c) { case '#': if (fgets(line, HEADER_LINE_LENGTH, file) == NULL) { return EIO; } scan_header_line(reader, line); break; case '"': if (fgets(line, HEADER_LINE_LENGTH, file) == NULL) { return EIO; } parsing_header = false; break; default: parsing_header = false; } } while (parsing_header); if (!validate_log_version(reader)) { return HDR_LOG_INVALID_VERSION; } return 0; } int hdr_log_read( struct hdr_log_reader* reader, FILE* file, struct hdr_histogram** histogram, hdr_timespec* timestamp, hdr_timespec* interval) { int result; struct hdr_log_entry log_entry; memset(&log_entry, 0, sizeof(log_entry)); result = hdr_log_read_entry(reader, file, &log_entry, histogram); if (0 == result) { if (NULL != timestamp) { memcpy(timestamp, &log_entry.start_timestamp, sizeof(*timestamp)); } if (NULL != interval) { memcpy(interval, &log_entry.interval, sizeof(*interval)); } } return result; } static int read_ahead(FILE* f, const char* prefix, size_t prefix_len) { size_t i; for (i = 0; i < prefix_len; i++) { if (prefix[i] != fgetc(f)) { return 0; } } return 1; } static int read_ahead_timestamp(FILE* f, hdr_timespec* timestamp, char expected_terminator) { int c; int is_seconds = 1; long sec = 0; long nsec = 0; long nsec_multipler = 1000000000; while (EOF != (c = fgetc(f))) { if (expected_terminator == c) { timestamp->tv_sec = sec; timestamp->tv_nsec = (nsec * nsec_multipler); return 1; } else if ('.' == c) { is_seconds = 0; } else if ('0' <= c && c <= '9') { if (is_seconds) { sec = (sec * 10) + (c - '0'); } else { nsec = (nsec * 10) + (c - '0'); nsec_multipler /= 10; } } else { return 0; } } return 0; } enum parse_log_state { INIT, TAG, BEGIN_TIMESTAMP, INTERVAL, MAX, HISTOGRAM, DONE }; int hdr_log_read_entry( struct hdr_log_reader* reader, FILE* file, struct hdr_log_entry *entry, struct hdr_histogram** histogram) { enum parse_log_state state = INIT; size_t capacity = 1024; size_t base64_len = 0; size_t tag_offset = 0; char* base64_histogram = hdr_calloc(capacity, sizeof(char)); size_t compressed_len = 0; uint8_t* compressed_histogram = NULL; int result = -EINVAL; (void)reader; if (NULL == entry) { return -EINVAL; } do { int c; switch (state) { case INIT: c = fgetc(file); if ('T' == c) { if (read_ahead(file, "ag=", 3)) { state = TAG; } else { FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } } else if ('0' <= c && c <= '9') { ungetc(c, file); state = BEGIN_TIMESTAMP; } else if ('\r' == c || '\n' == c) { /* Skip over trailing/preceding new lines. */ } else if (EOF == c) { FAIL_AND_CLEANUP(cleanup, result, EOF); } else { FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } break; case TAG: c = fgetc(file); if (',' == c) { if (NULL != entry->tag && tag_offset < entry->tag_len) { entry->tag[tag_offset] = '\0'; } state = BEGIN_TIMESTAMP; } else if ('\r' == c || '\n' == c || EOF == c) { FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } else { if (NULL != entry->tag && tag_offset < entry->tag_len) { entry->tag[tag_offset] = (char) c; tag_offset++; } } break; case BEGIN_TIMESTAMP: if (read_ahead_timestamp(file, &entry->start_timestamp, ',')) { state = INTERVAL; } else { FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } break; case INTERVAL: if (read_ahead_timestamp(file, &entry->interval, ',')) { state = MAX; } else { FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } break; case MAX: if (read_ahead_timestamp(file, &entry->max, ',')) { state = HISTOGRAM; } else { FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } break; case HISTOGRAM: c = fgetc(file); if (c != '\r' && c != '\n' && c != EOF) { if (base64_len == capacity) { capacity *= 2; base64_histogram = hdr_realloc(base64_histogram, capacity * sizeof(char)); if (NULL == base64_histogram) { FAIL_AND_CLEANUP(cleanup, result, -ENOMEM); } } base64_histogram[base64_len++] = (char) c; } else { state = DONE; } break; default: FAIL_AND_CLEANUP(cleanup, result, -EINVAL); } } while (DONE != state); compressed_histogram = hdr_calloc(base64_len, sizeof(uint8_t)); compressed_len = hdr_base64_decoded_len(base64_len); result = hdr_base64_decode( base64_histogram, base64_len, compressed_histogram, compressed_len); if (result != 0) { goto cleanup; } result = hdr_decode_compressed(compressed_histogram, compressed_len, histogram); cleanup: hdr_free(base64_histogram); hdr_free(compressed_histogram); return result; } int hdr_log_encode(struct hdr_histogram* histogram, char** encoded_histogram) { char *encoded_histogram_tmp = NULL; uint8_t* compressed_histogram = NULL; size_t compressed_len = 0; int rc = 0; int result = 0; size_t encoded_len; rc = hdr_encode_compressed(histogram, &compressed_histogram, &compressed_len); if (rc != 0) { FAIL_AND_CLEANUP(cleanup, result, rc); } encoded_len = hdr_base64_encoded_len(compressed_len); encoded_histogram_tmp = (char*) hdr_calloc(encoded_len + 1, sizeof(char)); rc = hdr_base64_encode( compressed_histogram, compressed_len, encoded_histogram_tmp, encoded_len); if (rc != 0) { hdr_free(encoded_histogram_tmp); FAIL_AND_CLEANUP(cleanup, result, rc); } *encoded_histogram = encoded_histogram_tmp; cleanup: hdr_free(compressed_histogram); return result; } int hdr_log_decode(struct hdr_histogram** histogram, char* base64_histogram, size_t base64_len) { int r; uint8_t* compressed_histogram = NULL; int result = 0; size_t compressed_len = hdr_base64_decoded_len(base64_len); compressed_histogram = (uint8_t*) hdr_malloc(sizeof(uint8_t)*compressed_len); memset(compressed_histogram, 0, compressed_len); r = hdr_base64_decode( base64_histogram, base64_len, compressed_histogram, compressed_len); if (r != 0) { FAIL_AND_CLEANUP(cleanup, result, r); } r = hdr_decode_compressed(compressed_histogram, compressed_len, histogram); if (r != 0) { FAIL_AND_CLEANUP(cleanup, result, r); } cleanup: hdr_free(compressed_histogram); return result; } #if defined(_MSC_VER) #pragma warning(pop) #endif HdrHistogram_c-0.11.8/src/hdr_histogram_log_no_op.c000066400000000000000000000072501442262567300223350ustar00rootroot00000000000000/** * hdr_histogram_log.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include "hdr_tests.h" #define UNUSED(x) (void)(x) const char* hdr_strerror(int errnum) { switch (errnum) { case HDR_COMPRESSION_COOKIE_MISMATCH: return "Compression cookie mismatch"; case HDR_ENCODING_COOKIE_MISMATCH: return "Encoding cookie mismatch"; case HDR_DEFLATE_INIT_FAIL: return "Deflate initialisation failed"; case HDR_DEFLATE_FAIL: return "Deflate failed"; case HDR_INFLATE_INIT_FAIL: return "Inflate initialisation failed"; case HDR_INFLATE_FAIL: return "Inflate failed"; case HDR_LOG_INVALID_VERSION: return "Log - invalid version in log header"; case HDR_TRAILING_ZEROS_INVALID: return "Invalid number of trailing zeros"; case HDR_VALUE_TRUNCATED: return "Truncated value found when decoding"; case HDR_ENCODED_INPUT_TOO_LONG: return "The encoded input exceeds the size of the histogram"; default: return strerror(errnum); } } int hdr_encode_compressed( struct hdr_histogram* h, uint8_t** compressed_histogram, size_t* compressed_len) { UNUSED(h); UNUSED(compressed_histogram); UNUSED(compressed_len); return -1; } int hdr_decode_compressed( uint8_t* buffer, size_t length, struct hdr_histogram** histogram) { UNUSED(buffer); UNUSED(length); UNUSED(histogram); return -1; } int hdr_log_writer_init(struct hdr_log_writer* writer) { UNUSED(writer); return -1; } int hdr_log_write_header( struct hdr_log_writer* writer, FILE* file, const char* user_prefix, hdr_timespec* timestamp) { UNUSED(writer); UNUSED(file); UNUSED(user_prefix); UNUSED(timestamp); return -1; } int hdr_log_write( struct hdr_log_writer* writer, FILE* file, const hdr_timespec* start_timestamp, const hdr_timespec* end_timestamp, struct hdr_histogram* histogram) { UNUSED(writer); UNUSED(file); UNUSED(start_timestamp); UNUSED(end_timestamp); UNUSED(histogram); return -1; } int hdr_log_write_entry( struct hdr_log_writer* writer, FILE* file, struct hdr_log_entry* entry, struct hdr_histogram* histogram) { UNUSED(writer); UNUSED(file); UNUSED(entry); UNUSED(histogram); return -1; } int hdr_log_reader_init(struct hdr_log_reader* reader) { UNUSED(reader); return -1; } int hdr_log_read_header(struct hdr_log_reader* reader, FILE* file) { UNUSED(reader); UNUSED(file); return -1; } int hdr_log_read( struct hdr_log_reader* reader, FILE* file, struct hdr_histogram** histogram, hdr_timespec* timestamp, hdr_timespec* interval) { UNUSED(reader); UNUSED(file); UNUSED(histogram); UNUSED(timestamp); UNUSED(interval); return -1; } int hdr_log_read_entry( struct hdr_log_reader* reader, FILE* file, struct hdr_log_entry *entry, struct hdr_histogram** histogram) { UNUSED(reader); UNUSED(file); UNUSED(entry); UNUSED(histogram); return -1; } int hdr_log_encode(struct hdr_histogram* histogram, char** encoded_histogram) { UNUSED(histogram); UNUSED(encoded_histogram); return -1; } int hdr_log_decode(struct hdr_histogram** histogram, char* base64_histogram, size_t base64_len) { UNUSED(histogram); UNUSED(base64_histogram); UNUSED(base64_len); return -1; } HdrHistogram_c-0.11.8/src/hdr_interval_recorder.c000066400000000000000000000131141442262567300220120ustar00rootroot00000000000000/** * hdr_interval_recorder.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include "hdr_atomic.h" #ifndef HDR_MALLOC_INCLUDE #define HDR_MALLOC_INCLUDE "hdr_malloc.h" #endif #include HDR_MALLOC_INCLUDE int hdr_interval_recorder_init(struct hdr_interval_recorder* r) { r->active = r->inactive = NULL; return hdr_writer_reader_phaser_init(&r->phaser); } int hdr_interval_recorder_init_all( struct hdr_interval_recorder* r, int64_t lowest_discernible_value, int64_t highest_trackable_value, int significant_figures) { int result; r->active = r->inactive = NULL; result = hdr_writer_reader_phaser_init(&r->phaser); result = result == 0 ? hdr_init(lowest_discernible_value, highest_trackable_value, significant_figures, &r->active) : result; return result; } void hdr_interval_recorder_destroy(struct hdr_interval_recorder* r) { hdr_writer_reader_phaser_destroy(&r->phaser); if (r->active) { hdr_close(r->active); } if (r->inactive) { hdr_close(r->inactive); } } struct hdr_histogram* hdr_interval_recorder_sample_and_recycle( struct hdr_interval_recorder* r, struct hdr_histogram* histogram_to_recycle) { struct hdr_histogram* old_active; if (NULL == histogram_to_recycle) { int64_t lo = r->active->lowest_discernible_value; int64_t hi = r->active->highest_trackable_value; int significant_figures = r->active->significant_figures; hdr_init(lo, hi, significant_figures, &histogram_to_recycle); } else { hdr_reset(histogram_to_recycle); } hdr_phaser_reader_lock(&r->phaser); /* volatile read */ old_active = hdr_atomic_load_pointer(&r->active); /* volatile write */ hdr_atomic_store_pointer(&r->active, histogram_to_recycle); hdr_phaser_flip_phase(&r->phaser, 0); hdr_phaser_reader_unlock(&r->phaser); return old_active; } struct hdr_histogram* hdr_interval_recorder_sample(struct hdr_interval_recorder* r) { r->inactive = hdr_interval_recorder_sample_and_recycle(r, r->inactive); return r->inactive; } static void hdr_interval_recorder_update( struct hdr_interval_recorder* r, void(*update_action)(struct hdr_histogram*, void*), void* arg) { int64_t val = hdr_phaser_writer_enter(&r->phaser); void* active = hdr_atomic_load_pointer(&r->active); update_action(active, arg); hdr_phaser_writer_exit(&r->phaser, val); } static void update_values(struct hdr_histogram* data, void* arg) { struct hdr_histogram* h = data; int64_t* params = arg; params[2] = hdr_record_values(h, params[0], params[1]); } static void update_values_atomic(struct hdr_histogram* data, void* arg) { struct hdr_histogram* h = data; int64_t* params = arg; params[2] = hdr_record_values_atomic(h, params[0], params[1]); } int64_t hdr_interval_recorder_record_values( struct hdr_interval_recorder* r, int64_t value, int64_t count ) { int64_t params[3]; params[0] = value; params[1] = count; params[2] = 0; hdr_interval_recorder_update(r, update_values, ¶ms[0]); return params[2]; } int64_t hdr_interval_recorder_record_value( struct hdr_interval_recorder* r, int64_t value ) { return hdr_interval_recorder_record_values(r, value, 1); } static void update_corrected_values(struct hdr_histogram* data, void* arg) { struct hdr_histogram* h = data; int64_t* params = arg; params[3] = hdr_record_corrected_values(h, params[0], params[1], params[2]); } static void update_corrected_values_atomic(struct hdr_histogram* data, void* arg) { struct hdr_histogram* h = data; int64_t* params = arg; params[3] = hdr_record_corrected_values_atomic(h, params[0], params[1], params[2]); } int64_t hdr_interval_recorder_record_corrected_values( struct hdr_interval_recorder* r, int64_t value, int64_t count, int64_t expected_interval ) { int64_t params[4]; params[0] = value; params[1] = count; params[2] = expected_interval; params[3] = 0; hdr_interval_recorder_update(r, update_corrected_values, ¶ms[0]); return params[3]; } int64_t hdr_interval_recorder_record_corrected_value( struct hdr_interval_recorder* r, int64_t value, int64_t expected_interval ) { return hdr_interval_recorder_record_corrected_values(r, value, 1, expected_interval); } int64_t hdr_interval_recorder_record_value_atomic( struct hdr_interval_recorder* r, int64_t value ) { return hdr_interval_recorder_record_values_atomic(r, value, 1); } int64_t hdr_interval_recorder_record_values_atomic( struct hdr_interval_recorder* r, int64_t value, int64_t count ) { int64_t params[3]; params[0] = value; params[1] = count; params[2] = 0; hdr_interval_recorder_update(r, update_values_atomic, ¶ms[0]); return params[2]; } int64_t hdr_interval_recorder_record_corrected_value_atomic( struct hdr_interval_recorder* r, int64_t value, int64_t expected_interval ) { return hdr_interval_recorder_record_corrected_values_atomic(r, value, 1, expected_interval); } int64_t hdr_interval_recorder_record_corrected_values_atomic( struct hdr_interval_recorder* r, int64_t value, int64_t count, int64_t expected_interval ) { int64_t params[4]; params[0] = value; params[1] = count; params[2] = expected_interval; params[3] = 0; hdr_interval_recorder_update(r, update_corrected_values_atomic, ¶ms[0]); return params[3]; } HdrHistogram_c-0.11.8/src/hdr_malloc.h000066400000000000000000000011431442262567300175540ustar00rootroot00000000000000/** * hdr_malloc.h * Written by Filipe Oliveira and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ * * Allocator selection. * * This file is used in order to change the HdrHistogram allocator at compile time. * Just define the following defines to what you want to use. Also add * the include of your alternate allocator if needed (not needed in order * to use the default libc allocator). */ #ifndef HDR_MALLOC_H__ #define HDR_MALLOC_H__ #define hdr_malloc malloc #define hdr_calloc calloc #define hdr_realloc realloc #define hdr_free free #endif HdrHistogram_c-0.11.8/src/hdr_tests.h000066400000000000000000000011731442262567300174520ustar00rootroot00000000000000#ifndef HDR_TESTS_H #define HDR_TESTS_H /* These are functions used in tests and are not intended for normal usage. */ #include #ifdef __cplusplus extern "C" { #endif int32_t counts_index_for(const struct hdr_histogram* h, int64_t value); int hdr_encode_compressed(struct hdr_histogram* h, uint8_t** compressed_histogram, size_t* compressed_len); int hdr_decode_compressed(uint8_t* buffer, size_t length, struct hdr_histogram** histogram); void hdr_base64_decode_block(const char* input, uint8_t* output); void hdr_base64_encode_block(const uint8_t* input, char* output); #ifdef __cplusplus } #endif #endif HdrHistogram_c-0.11.8/src/hdr_thread.c000066400000000000000000000036351442262567300175570ustar00rootroot00000000000000/** * hdr_thread.c * Written by Philip Orwig and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #ifndef HDR_MALLOC_INCLUDE #define HDR_MALLOC_INCLUDE "hdr_malloc.h" #endif #include HDR_MALLOC_INCLUDE struct hdr_mutex* hdr_mutex_alloc(void) { return hdr_malloc(sizeof(hdr_mutex)); } void hdr_mutex_free(struct hdr_mutex* mutex) { hdr_free(mutex); } #if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) #if !defined(WIN32_LEAN_AND_MEAN) #define WIN32_LEAN_AND_MEAN #endif #include #include int hdr_mutex_init(struct hdr_mutex* mutex) { InitializeCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section)); return 0; } void hdr_mutex_destroy(struct hdr_mutex* mutex) { DeleteCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section)); } void hdr_mutex_lock(struct hdr_mutex* mutex) { EnterCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section)); } void hdr_mutex_unlock(struct hdr_mutex* mutex) { LeaveCriticalSection((CRITICAL_SECTION*)(mutex->_critical_section)); } void hdr_yield() { Sleep(0); } int hdr_usleep(unsigned int useconds) { struct timeval tv; tv.tv_sec = (long)useconds / 1000000; tv.tv_usec = useconds % 1000000; select(0, NULL, NULL, NULL, &tv); return 0; } #else #include #include int hdr_mutex_init(struct hdr_mutex* mutex) { return pthread_mutex_init(&mutex->_mutex, NULL); } void hdr_mutex_destroy(struct hdr_mutex* mutex) { pthread_mutex_destroy(&mutex->_mutex); } void hdr_mutex_lock(struct hdr_mutex* mutex) { pthread_mutex_lock(&mutex->_mutex); } void hdr_mutex_unlock(struct hdr_mutex* mutex) { pthread_mutex_unlock(&mutex->_mutex); } void hdr_yield(void) { sched_yield(); } int hdr_usleep(unsigned int useconds) { return usleep(useconds); } #endif HdrHistogram_c-0.11.8/src/hdr_time.c000066400000000000000000000040161442262567300172400ustar00rootroot00000000000000/** * hdr_time.h * Written by Michael Barker and Philip Orwig and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #if defined(_WIN32) || defined(_WIN64) #if !defined(WIN32_LEAN_AND_MEAN) #define WIN32_LEAN_AND_MEAN #endif #include static int s_clockPeriodSet = 0; static double s_clockPeriod = 1.0; void hdr_gettime(hdr_timespec* t) { LARGE_INTEGER num; /* if this is distasteful, we can add in an hdr_time_init() */ if (!s_clockPeriodSet) { QueryPerformanceFrequency(&num); s_clockPeriod = 1.0 / (double) num.QuadPart; s_clockPeriodSet = 1; } QueryPerformanceCounter(&num); double seconds = num.QuadPart * s_clockPeriod; double integral; double remainder = modf(seconds, &integral); t->tv_sec = (long) integral; t->tv_nsec = (long) (remainder * 1000000000); } #elif defined(__APPLE__) #include #include void hdr_gettime(hdr_timespec* ts) { clock_serv_t cclock; mach_timespec_t mts; host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock); clock_get_time(cclock, &mts); mach_port_deallocate(mach_task_self(), cclock); ts->tv_sec = mts.tv_sec; ts->tv_nsec = mts.tv_nsec; } void hdr_getnow(hdr_timespec* ts) { hdr_gettime(ts); } #elif defined(__linux__) || defined(__CYGWIN__) || defined(__OpenBSD__) void hdr_gettime(hdr_timespec* t) { clock_gettime(CLOCK_MONOTONIC, (struct timespec*)t); } void hdr_getnow(hdr_timespec* t) { clock_gettime(CLOCK_REALTIME, (struct timespec*)t); } #else #warning "Platform not supported\n" #endif double hdr_timespec_as_double(const hdr_timespec* t) { double d = t->tv_sec; return d + (t->tv_nsec / 1000000000.0); } void hdr_timespec_from_double(hdr_timespec* t, double value) { int seconds = (int) value; int milliseconds = (int) round((value - seconds) * 1000); t->tv_sec = seconds; t->tv_nsec = milliseconds * 1000000; } HdrHistogram_c-0.11.8/src/hdr_writer_reader_phaser.c000066400000000000000000000064541442262567300225120ustar00rootroot00000000000000/** * hdr_writer_reader_phaser.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include "hdr_atomic.h" #ifndef HDR_MALLOC_INCLUDE #define HDR_MALLOC_INCLUDE "hdr_malloc.h" #endif #include HDR_MALLOC_INCLUDE static int64_t _hdr_phaser_get_epoch(int64_t* field) { return hdr_atomic_load_64(field); } static void _hdr_phaser_set_epoch(int64_t* field, int64_t val) { hdr_atomic_store_64(field, val); } static int64_t _hdr_phaser_reset_epoch(int64_t* field, int64_t initial_value) { return hdr_atomic_exchange_64(field, initial_value); } int hdr_writer_reader_phaser_init(struct hdr_writer_reader_phaser* p) { int rc; if (NULL == p) { return EINVAL; } p->start_epoch = 0; p->even_end_epoch = 0; p->odd_end_epoch = INT64_MIN; p->reader_mutex = hdr_mutex_alloc(); if (!p->reader_mutex) { return ENOMEM; } rc = hdr_mutex_init(p->reader_mutex); if (0 != rc) { return rc; } /* TODO: Should I fence here. */ return 0; } void hdr_writer_reader_phaser_destroy(struct hdr_writer_reader_phaser* p) { hdr_mutex_destroy(p->reader_mutex); hdr_mutex_free(p->reader_mutex); } int64_t hdr_phaser_writer_enter(struct hdr_writer_reader_phaser* p) { return hdr_atomic_add_fetch_64(&p->start_epoch, 1); } void hdr_phaser_writer_exit( struct hdr_writer_reader_phaser* p, int64_t critical_value_at_enter) { int64_t* end_epoch = (critical_value_at_enter < 0) ? &p->odd_end_epoch : &p->even_end_epoch; hdr_atomic_add_fetch_64(end_epoch, 1); } void hdr_phaser_reader_lock(struct hdr_writer_reader_phaser* p) { hdr_mutex_lock(p->reader_mutex); } void hdr_phaser_reader_unlock(struct hdr_writer_reader_phaser* p) { hdr_mutex_unlock(p->reader_mutex); } void hdr_phaser_flip_phase( struct hdr_writer_reader_phaser* p, int64_t sleep_time_ns) { bool caught_up; int64_t start_value_at_flip; /* TODO: is_held_by_current_thread */ unsigned int sleep_time_us = sleep_time_ns < 1000000000 ? (unsigned int) (sleep_time_ns / 1000) : 1000000; int64_t start_epoch = _hdr_phaser_get_epoch(&p->start_epoch); bool next_phase_is_even = (start_epoch < 0); /* Clear currently used phase end epoch.*/ int64_t initial_start_value; if (next_phase_is_even) { initial_start_value = 0; _hdr_phaser_set_epoch(&p->even_end_epoch, initial_start_value); } else { initial_start_value = INT64_MIN; _hdr_phaser_set_epoch(&p->odd_end_epoch, initial_start_value); } /* Reset start value, indicating new phase.*/ start_value_at_flip = _hdr_phaser_reset_epoch(&p->start_epoch, initial_start_value); do { int64_t* end_epoch = next_phase_is_even ? &p->odd_end_epoch : &p->even_end_epoch; caught_up = _hdr_phaser_get_epoch(end_epoch) == start_value_at_flip; if (!caught_up) { if (sleep_time_us <= 0) { hdr_yield(); } else { hdr_usleep(sleep_time_us); } } } while (!caught_up); } HdrHistogram_c-0.11.8/test/000077500000000000000000000000001442262567300154705ustar00rootroot00000000000000HdrHistogram_c-0.11.8/test/CMakeLists.txt000066400000000000000000000057211442262567300202350ustar00rootroot00000000000000option(HDR_HISTOGRAM_BUILD_BENCHMARK "Build benchmark" OFF) if(HDR_HISTOGRAM_BUILD_BENCHMARK) if(UNIX) enable_language(CXX) include(ExternalProject) ExternalProject_Add(google_benchmark URL ${PROJECT_SOURCE_DIR}/lib/benchmark-1.6.1.zip URL_MD5 d061aaa421b628673cfbdd8b2b4a16a6 CMAKE_ARGS -DBENCHMARK_ENABLE_TESTING=OFF -DBENCHMARK_ENABLE_INSTALL=OFF SOURCE_DIR ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-src BINARY_DIR ${CMAKE_CURRENT_BINARY_DIR}/googlebenchmark-build INSTALL_COMMAND "") ExternalProject_Get_Property(google_benchmark SOURCE_DIR) set(GOOGLE_BENCHMARK_SOURCE_DIR ${SOURCE_DIR}) ExternalProject_Get_Property(google_benchmark BINARY_DIR) set(GOOGLE_BENCHMARK_BINARY_DIR ${BINARY_DIR}) add_executable(hdr_histogram_benchmark hdr_histogram_benchmark.cpp) add_dependencies(hdr_histogram_benchmark google_benchmark) target_include_directories(hdr_histogram_benchmark PRIVATE ${GOOGLE_BENCHMARK_SOURCE_DIR}/include) target_link_directories(hdr_histogram_benchmark PRIVATE ${GOOGLE_BENCHMARK_BINARY_DIR}/src) target_link_libraries(hdr_histogram_benchmark PRIVATE benchmark hdr_histogram_static) install( TARGETS hdr_histogram_benchmark DESTINATION ${CMAKE_INSTALL_BINDIR}) else() message(WARNING "google.benchmark - microbenchmarks disabled on WIN32 platforms") endif() endif() function(hdr_histogram_add_test_executable NAME) add_executable(${NAME} ${NAME}.c hdr_test_util.h minunit.c minunit.h) target_link_libraries(${NAME} PRIVATE hdr_histogram_static) target_include_directories(${NAME} PRIVATE ${PROJECT_SOURCE_DIR}/src) install( TARGETS ${NAME} DESTINATION ${CMAKE_INSTALL_BINDIR}) endfunction() function(hdr_histogram_add_test NAME) hdr_histogram_add_test_executable(${NAME}) add_test(${NAME} ${NAME}) endfunction() hdr_histogram_add_test(hdr_histogram_test) hdr_histogram_add_test(hdr_histogram_atomic_test) if (HDR_LOG_ENABLED) hdr_histogram_add_test(hdr_histogram_log_test) endif() hdr_histogram_add_test(hdr_atomic_test) if(UNIX) hdr_histogram_add_test(hdr_histogram_atomic_concurrency_test) endif() hdr_histogram_add_test_executable(hdr_histogram_perf) foreach(V 2.0.1.logV0 2.0.6.logV1 2.0.7S.logV2 2.0.7S.logV3) configure_file(jHiccup-${V}.hlog jHiccup-${V}.hlog COPYONLY) endforeach() foreach(V 2.0.1.logV0 2.0.6.logV1 2.0.7S.logV2 2.0.7S.logV3) configure_file(jHiccup-${V}.hlog jHiccup-${V}.hlog COPYONLY) endforeach() foreach(V test_tagged_invalid_histogram.txt test_tagged_invalid_tag_key.txt test_tagged_invalid_timestamp.txt test_tagged_missing_histogram.txt) configure_file(${V} ${V} COPYONLY) endforeach() HdrHistogram_c-0.11.8/test/hdr_atomic_test.c000066400000000000000000000041741442262567300210120ustar00rootroot00000000000000/** * hdr_histogram_test.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include "minunit.h" int tests_run = 0; static char* test_store_load_64(void) { int64_t value = 45; int64_t b; int64_t p = 0; hdr_atomic_store_64(&p, value); mu_assert("Failed hdr_atomic_store_64", compare_int64(p, value)); b = hdr_atomic_load_64(&p); mu_assert("Failed hdr_atomic_load_64", compare_int64(p, b)); return 0; } static char* test_store_load_pointer(void) { int64_t r = 12; int64_t* q = 0; int64_t* s; hdr_atomic_store_pointer((void**) &q, &r); mu_assert("Failed hdr_atomic_store_pointer", compare_int64(*q, r)); s = hdr_atomic_load_pointer((void**) &q); mu_assert("Failed hdr_atomic_load_pointer", compare_int64(*s, r)); return 0; } static char* test_exchange(void) { int64_t val1 = 123124; int64_t val2 = 987234; int64_t p = val1; int64_t q = val2; hdr_atomic_exchange_64(&p, q); mu_assert("Failed hdr_atomic_exchange_64", compare_int64(p, val2)); return 0; } static char* test_add(void) { int64_t val1 = 123124; int64_t val2 = 987234; int64_t expected = val1 + val2; int64_t result = hdr_atomic_add_fetch_64(&val1, val2); mu_assert("Failed hdr_atomic_exchange_64", compare_int64(result, expected)); mu_assert("Failed hdr_atomic_exchange_64", compare_int64(val1, expected)); return 0; } static struct mu_result all_tests(void) { mu_run_test(test_store_load_64); mu_run_test(test_store_load_pointer); mu_run_test(test_exchange); mu_run_test(test_add); mu_ok; } static int hdr_atomic_run_tests(void) { struct mu_result result = all_tests(); if (result.message != 0) { printf("hdr_atomic_test.%s(): %s\n", result.test, result.message); } else { printf("ALL TESTS PASSED\n"); } printf("Tests run: %d\n", tests_run); return result.message == NULL ? 0 : -1; } int main(void) { return hdr_atomic_run_tests(); } HdrHistogram_c-0.11.8/test/hdr_histogram_atomic_concurrency_test.c000066400000000000000000000053101442262567300254720ustar00rootroot00000000000000/** * hdr_histogram_test.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include "minunit.h" #include "hdr_test_util.h" int tests_run = 0; struct test_histogram_data { struct hdr_histogram* histogram; int64_t* values; int values_len; }; static void* record_values(void* thread_context) { int i; struct test_histogram_data* thread_data = (struct test_histogram_data*) thread_context; for (i = 0; i < thread_data->values_len; i++) { hdr_record_value_atomic(thread_data->histogram, thread_data->values[i]); } pthread_exit(NULL); } static char* test_recording_concurrently(void) { const int value_count = 10000000; int64_t* values = calloc(value_count, sizeof(int64_t)); struct hdr_histogram* expected_histogram; struct hdr_histogram* actual_histogram; struct test_histogram_data thread_data[2]; struct hdr_iter expected_iter; struct hdr_iter actual_iter; pthread_t threads[2]; int i; mu_assert("init", 0 == hdr_init(1, 10000000, 2, &expected_histogram)); mu_assert("init", 0 == hdr_init(1, 10000000, 2, &actual_histogram)); for (i = 0; i < value_count; i++) { values[i] = rand() % 20000; } for (i = 0; i < value_count; i++) { hdr_record_value(expected_histogram, values[i]); } thread_data[0].histogram = actual_histogram; thread_data[0].values = values; thread_data[0].values_len = value_count / 2; pthread_create(&threads[0], NULL, record_values, &thread_data[0]); thread_data[1].histogram = actual_histogram; thread_data[1].values = &values[value_count / 2]; thread_data[1].values_len = value_count / 2; pthread_create(&threads[1], NULL, record_values, &thread_data[1]); pthread_join(threads[0], NULL); pthread_join(threads[1], NULL); hdr_iter_init(&expected_iter, expected_histogram); hdr_iter_init(&actual_iter, actual_histogram); return compare_histograms(expected_histogram, actual_histogram); } static struct mu_result all_tests(void) { mu_run_test(test_recording_concurrently); mu_ok; } static int hdr_histogram_run_tests(void) { struct mu_result result = all_tests(); if (result.message != 0) { printf("hdr_histogram_test.%s(): %s\n", result.test, result.message); } else { printf("ALL TESTS PASSED\n"); } printf("Tests run: %d\n", tests_run); return result.message == NULL ? 0 : -1; } int main(void) { return hdr_histogram_run_tests(); } HdrHistogram_c-0.11.8/test/hdr_histogram_atomic_test.c000066400000000000000000000413231442262567300230640ustar00rootroot00000000000000/** * hdr_histogram_test.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include "minunit.h" #include "hdr_test_util.h" static bool compare_values(double a, double b, double variation) { return compare_double(a, b, b * variation); } static bool compare_percentile(int64_t a, double b, double variation) { return compare_values((double) a, b, variation); } int tests_run = 0; static struct hdr_histogram* raw_histogram = NULL; static struct hdr_histogram* cor_histogram = NULL; static struct hdr_histogram* scaled_raw_histogram = NULL; static struct hdr_histogram* scaled_cor_histogram = NULL; static void load_histograms(void) { const int64_t highest_trackable_value = INT64_C(3600) * 1000 * 1000; const int32_t significant_figures = 3; const int64_t interval = INT64_C(10000); const int64_t scale = 512; const int64_t scaled_interval = interval * scale; int i; if (raw_histogram) { free(raw_histogram); } hdr_init(1, highest_trackable_value, significant_figures, &raw_histogram); if (cor_histogram) { free(cor_histogram); } hdr_init(1, highest_trackable_value, significant_figures, &cor_histogram); if (scaled_raw_histogram) { free(scaled_raw_histogram); } hdr_init(1000, highest_trackable_value * 512, significant_figures, &scaled_raw_histogram); if (scaled_cor_histogram) { free(scaled_cor_histogram); } hdr_init(1000, highest_trackable_value * 512, significant_figures, &scaled_cor_histogram); for (i = 0; i < 10000; i++) { hdr_record_value_atomic(raw_histogram, 1000); hdr_record_corrected_value_atomic(cor_histogram, 1000, interval); hdr_record_value_atomic(scaled_raw_histogram, 1000 * scale); hdr_record_corrected_value_atomic(scaled_cor_histogram, 1000 * scale, scaled_interval); } hdr_record_value_atomic(raw_histogram, 100000000); hdr_record_corrected_value_atomic(cor_histogram, 100000000, 10000L); hdr_record_value_atomic(scaled_raw_histogram, 100000000 * scale); hdr_record_corrected_value_atomic(scaled_cor_histogram, 100000000 * scale, scaled_interval); } static char* test_create(void) { struct hdr_histogram* h = NULL; int r = hdr_init(1, INT64_C(3600000000), 3, &h); mu_assert("Failed to allocate hdr_histogram", r == 0); mu_assert("Failed to allocate hdr_histogram", h != NULL); mu_assert("Incorrect array length", compare_int64(h->counts_len, 23552)); free(h); return 0; } static char* test_create_with_large_values(void) { struct hdr_histogram* h = NULL; int r = hdr_init(20000000, 100000000, 5, &h); mu_assert("Didn't create", r == 0); hdr_record_value_atomic(h, 100000000); hdr_record_value_atomic(h, 20000000); hdr_record_value_atomic(h, 30000000); mu_assert( "50.0% Percentile", hdr_values_are_equivalent(h, 20000000, hdr_value_at_percentile(h, 50.0))); mu_assert( "83.33% Percentile", hdr_values_are_equivalent(h, 30000000, hdr_value_at_percentile(h, 83.33))); mu_assert( "83.34% Percentile", hdr_values_are_equivalent(h, 100000000, hdr_value_at_percentile(h, 83.34))); mu_assert( "99.0% Percentile", hdr_values_are_equivalent(h, 100000000, hdr_value_at_percentile(h, 99.0))); return 0; } static char* test_invalid_significant_figures(void) { struct hdr_histogram* h = NULL; int r = hdr_alloc(36000000, -1, &h); mu_assert("Result was not EINVAL", r == EINVAL); mu_assert("Histogram was not null", h == 0); r = hdr_alloc(36000000, 6, &h); mu_assert("Result was not EINVAL", r == EINVAL); mu_assert("Histogram was not null", h == 0); return 0; } static char* test_invalid_init(void) { struct hdr_histogram* h = NULL; mu_assert("Should not allow 0 as lowest trackable value", EINVAL == hdr_init(0, 64*1024, 2, &h)); mu_assert("Should have lowest < 2 * highest", EINVAL == hdr_init(80, 110, 5, &h)); return 0; } static char* test_total_count(void) { load_histograms(); mu_assert("Total raw count != 10001", raw_histogram->total_count == 10001); mu_assert("Total corrected count != 20000", cor_histogram->total_count == 20000); return 0; } static char* test_get_max_value(void) { int64_t actual_raw_max, actual_cor_max; load_histograms(); actual_raw_max = hdr_max(raw_histogram); mu_assert("hdr_max(raw_histogram) != 100000000L", hdr_values_are_equivalent(raw_histogram, actual_raw_max, 100000000)); actual_cor_max = hdr_max(cor_histogram); mu_assert("hdr_max(cor_histogram) != 100000000L", hdr_values_are_equivalent(cor_histogram, actual_cor_max, 100000000)); return 0; } static char* test_get_min_value(void) { load_histograms(); mu_assert("hdr_min(raw_histogram) != 1000", hdr_min(raw_histogram) == 1000); mu_assert("hdr_min(cor_histogram) != 1000", hdr_min(cor_histogram) == 1000); return 0; } static char* test_percentiles(void) { load_histograms(); mu_assert("Value at 30% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 30.0), 1000.0, 0.001)); mu_assert("Value at 99% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.0), 1000.0, 0.001)); mu_assert("Value at 99.99% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.99), 1000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.999), 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 100.0), 100000000.0, 0.001)); mu_assert("Value at 30% not 1000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 30.0), 1000.0, 0.001)); mu_assert("Value at 50% not 1000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 50.0), 1000.0, 0.001)); mu_assert("Value at 75% not 50000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 75.0), 50000000.0, 0.001)); mu_assert("Value at 90% not 80000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 90.0), 80000000.0, 0.001)); mu_assert("Value at 99% not 98000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 99.0), 98000000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 99.999), 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 100.0), 100000000.0, 0.001)); return 0; } static char* test_recorded_values(void) { struct hdr_iter iter; int index; int64_t total_added_count = 0; load_histograms(); /* Raw Histogram */ hdr_iter_recorded_init(&iter, raw_histogram); index = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.recorded.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Value at 0 is not 10000", count_added_in_this_bucket == 10000); } else { mu_assert("Value at 1 is not 1", count_added_in_this_bucket == 1); } index++; } mu_assert("Should have encountered 2 values", index == 2); /* Corrected Histogram */ hdr_iter_recorded_init(&iter, cor_histogram); index = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.recorded.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10000", count_added_in_this_bucket == 10000); } mu_assert("Count should not be 0", iter.count != 0); mu_assert("Count at value iterated to should be count added in this step", iter.count == count_added_in_this_bucket); total_added_count += count_added_in_this_bucket; index++; } mu_assert("Total counts should be 20000", total_added_count == 20000); return 0; } static char* test_linear_values(void) { struct hdr_iter iter; int index; int64_t total_added_count; load_histograms(); /* Raw Histogram */ hdr_iter_linear_init(&iter, raw_histogram, 100000); index = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.linear.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10000", count_added_in_this_bucket == 10000); } else if (index == 999) { mu_assert("Count at 999 is not 1", count_added_in_this_bucket == 1); } else { mu_assert("Count should be 0", count_added_in_this_bucket == 0); } index++; } mu_assert("Should of met 1000 values", compare_int64(index, 1000)); /* Corrected Histogram */ hdr_iter_linear_init(&iter, cor_histogram, 10000); index = 0; total_added_count = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.linear.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10001", count_added_in_this_bucket == 10001); } total_added_count += count_added_in_this_bucket; index++; } mu_assert("Should of met 10001 values", index == 10000); mu_assert("Should of met 20000 counts", total_added_count == 20000); return 0; } static char* test_logarithmic_values(void) { struct hdr_iter iter; int index; uint64_t total_added_count; load_histograms(); hdr_iter_log_init(&iter, raw_histogram, 10000, 2.0); index = 0; while(hdr_iter_next(&iter)) { uint64_t count_added_in_this_bucket = iter.specifics.log.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Raw Logarithmic 10 msec bucket # 0 added a count of 10000", 10000 == count_added_in_this_bucket); } else if (index == 14) { mu_assert("Raw Logarithmic 10 msec bucket # 14 added a count of 1", 1 == count_added_in_this_bucket); } else { mu_assert("Raw Logarithmic 10 msec bucket added a count of 0", 0 == count_added_in_this_bucket); } index++; } mu_assert("Should of seen 14 values", index - 1 == 14); hdr_iter_log_init(&iter, cor_histogram, 10000, 2.0); index = 0; total_added_count = 0; while (hdr_iter_next(&iter)) { uint64_t count_added_in_this_bucket = iter.specifics.log.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Corrected Logarithmic 10 msec bucket # 0 added a count of 10001", 10001 == count_added_in_this_bucket); } total_added_count += count_added_in_this_bucket; index++; } mu_assert("Should of seen 14 values", index - 1 == 14); mu_assert("Should of seen count of 20000", total_added_count == 20000); return 0; } static char* test_reset(void) { load_histograms(); mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(raw_histogram, 99.0) != 0); mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(cor_histogram, 99.0) != 0); hdr_reset(raw_histogram); hdr_reset(cor_histogram); mu_assert("Total raw count != 0", raw_histogram->total_count == 0); mu_assert("Total corrected count != 0", cor_histogram->total_count == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(raw_histogram, 99.0) == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(cor_histogram, 99.0) == 0); return 0; } static char* test_scaling_equivalence(void) { int64_t expected_99th, scaled_99th; load_histograms(); mu_assert( "Averages should be equivalent", compare_values( hdr_mean(cor_histogram) * 512, hdr_mean(scaled_cor_histogram), 0.000001)); mu_assert( "Total count should be equivalent", compare_int64( cor_histogram->total_count, scaled_cor_histogram->total_count)); expected_99th = hdr_value_at_percentile(cor_histogram, 99.0) * 512; scaled_99th = hdr_value_at_percentile(scaled_cor_histogram, 99.0); mu_assert( "99%'iles should be equivalent", compare_int64( hdr_lowest_equivalent_value(cor_histogram, expected_99th), hdr_lowest_equivalent_value(scaled_cor_histogram, scaled_99th))); return 0; } static char* test_out_of_range_values(void) { struct hdr_histogram *h; hdr_init(1, 1000, 4, &h); mu_assert("Should successfully record value", hdr_record_value_atomic(h, 32767)); mu_assert("Should not record value", !hdr_record_value_atomic(h, 32768)); return 0; } static char* test_linear_iter_buckets_correctly(void) { int step_count = 0; int64_t total_count = 0; struct hdr_histogram *h; struct hdr_iter iter; hdr_init(1, 255, 2, &h); hdr_record_value_atomic(h, 193); hdr_record_value_atomic(h, 255); hdr_record_value_atomic(h, 0); hdr_record_value_atomic(h, 1); hdr_record_value_atomic(h, 64); hdr_record_value_atomic(h, 128); hdr_iter_linear_init(&iter, h, 64); while (hdr_iter_next(&iter)) { total_count += iter.specifics.linear.count_added_in_this_iteration_step; /* start - changes to reproduce issue */ if (step_count == 0) { hdr_record_value_atomic(h, 2); } /* end - changes to reproduce issue */ step_count++; } mu_assert("Number of steps", compare_int64(4, step_count)); mu_assert("Total count", compare_int64(6, total_count)); return 0; } static char* test_interval_recording(void) { int value_count, i, value; char* result; struct hdr_histogram* expected_histogram; struct hdr_histogram* expected_corrected_histogram; struct hdr_interval_recorder recorder; struct hdr_interval_recorder recorder_corrected; struct hdr_histogram* recorder_histogram; struct hdr_histogram* recorder_corrected_histogram; value_count = 1000000; hdr_interval_recorder_init_all(&recorder, 1, INT64_C(24) * 60 * 60 * 1000000, 3); hdr_interval_recorder_init_all(&recorder_corrected, 1, INT64_C(24) * 60 * 60 * 1000000, 3); hdr_init(1, INT64_C(24) * 60 * 60 * 1000000, 3, &expected_histogram); hdr_init(1, INT64_C(24) * 60 * 60 * 1000000, 3, &expected_corrected_histogram); for (i = 0; i < value_count; i++) { value = rand() % 20000; hdr_record_value(expected_histogram, value); hdr_record_corrected_value(expected_corrected_histogram, value, 1000); hdr_interval_recorder_record_value_atomic(&recorder, value); hdr_interval_recorder_record_corrected_value_atomic(&recorder_corrected, value, 1000); } recorder_histogram = hdr_interval_recorder_sample(&recorder); result = compare_histograms(expected_histogram, recorder_histogram); if (result) { return result; } recorder_corrected_histogram = hdr_interval_recorder_sample(&recorder_corrected); result = compare_histograms(expected_corrected_histogram, recorder_corrected_histogram); if (result) { return result; } return 0; } static struct mu_result all_tests(void) { mu_run_test(test_create); mu_run_test(test_invalid_init); mu_run_test(test_create_with_large_values); mu_run_test(test_invalid_significant_figures); mu_run_test(test_total_count); mu_run_test(test_get_min_value); mu_run_test(test_get_max_value); mu_run_test(test_percentiles); mu_run_test(test_recorded_values); mu_run_test(test_linear_values); mu_run_test(test_logarithmic_values); mu_run_test(test_reset); mu_run_test(test_scaling_equivalence); mu_run_test(test_out_of_range_values); mu_run_test(test_linear_iter_buckets_correctly); mu_run_test(test_interval_recording); mu_ok; } static int hdr_histogram_run_tests(void) { struct mu_result result = all_tests(); if (result.message != 0) { printf("hdr_histogram_test.%s(): %s\n", result.test, result.message); } else { printf("ALL TESTS PASSED\n"); } printf("Tests run: %d\n", tests_run); return result.message == NULL ? 0 : -1; } int main(void) { return hdr_histogram_run_tests(); } HdrHistogram_c-0.11.8/test/hdr_histogram_benchmark.cpp000066400000000000000000000123321442262567300230410ustar00rootroot00000000000000#include #include #include #include #ifdef _WIN32 #pragma comment(lib, "Shlwapi.lib") #ifdef _DEBUG #pragma comment(lib, "benchmarkd.lib") #else #pragma comment(lib, "benchmark.lib") #endif #endif int64_t min_value = 1; int64_t min_precision = 3; int64_t max_precision = 4; int64_t min_time_unit = 1000; int64_t max_time_unit = 1000000; int64_t step_time_unit = 1000; int64_t generated_datapoints = 10000000; static void generate_arguments_pairs(benchmark::internal::Benchmark *b) { for (int64_t precision = min_precision; precision <= max_precision; precision++) { for (int64_t time_unit = min_time_unit; time_unit <= max_time_unit; time_unit *= step_time_unit) { b = b->ArgPair(precision, INT64_C(24) * 60 * 60 * time_unit); } } } static void BM_hdr_init(benchmark::State &state) { const int64_t precision = state.range(0); const int64_t max_value = state.range(1); for (auto _ : state) { struct hdr_histogram *histogram; benchmark::DoNotOptimize( hdr_init(min_value, max_value, precision, &histogram)); // read/write barrier benchmark::ClobberMemory(); } } static void BM_hdr_record_values(benchmark::State &state) { const int64_t precision = state.range(0); const int64_t max_value = state.range(1); struct hdr_histogram *histogram; hdr_init(min_value, max_value, precision, &histogram); benchmark::DoNotOptimize(histogram->counts); for (auto _ : state) { benchmark::DoNotOptimize(hdr_record_values(histogram, 1000000, 1)); // read/write barrier benchmark::ClobberMemory(); } } static void BM_hdr_value_at_percentile(benchmark::State &state) { srand(12345); const int64_t precision = state.range(0); const int64_t max_value = state.range(1); std::random_device rd; std::mt19937 e2(rd()); std::uniform_real_distribution<> dist(0, 100); std::default_random_engine generator; // gama distribution shape 1 scale 100000 std::gamma_distribution latency_gamma_dist(1.0, 100000); struct hdr_histogram *histogram; hdr_init(min_value, max_value, precision, &histogram); for (int64_t i = 1; i < generated_datapoints; i++) { int64_t number = int64_t(latency_gamma_dist(generator)) + 1; number = number > max_value ? max_value : number; hdr_record_value(histogram, number); } benchmark::DoNotOptimize(histogram->counts); for (auto _ : state) { state.PauseTiming(); const double percentile = dist(e2); state.ResumeTiming(); benchmark::DoNotOptimize(hdr_value_at_percentile(histogram, percentile)); // read/write barrier benchmark::ClobberMemory(); } } static void BM_hdr_value_at_percentile_given_array(benchmark::State &state) { srand(12345); const int64_t precision = state.range(0); const int64_t max_value = state.range(1); const double percentile_list[4] = {50.0, 95.0, 99.0, 99.9}; std::default_random_engine generator; // gama distribution shape 1 scale 100000 std::gamma_distribution latency_gamma_dist(1.0, 100000); struct hdr_histogram *histogram; hdr_init(min_value, max_value, precision, &histogram); for (int64_t i = 1; i < generated_datapoints; i++) { int64_t number = int64_t(latency_gamma_dist(generator)) + 1; number = number > max_value ? max_value : number; hdr_record_value(histogram, number); } benchmark::DoNotOptimize(histogram->counts); int64_t items_processed = 0; for (auto _ : state) { for (auto percentile : percentile_list) { benchmark::DoNotOptimize(hdr_value_at_percentile(histogram, percentile)); // read/write barrier benchmark::ClobberMemory(); } items_processed += 4; } state.SetItemsProcessed(items_processed); } static void BM_hdr_value_at_percentiles_given_array(benchmark::State &state) { srand(12345); const int64_t precision = state.range(0); const int64_t max_value = state.range(1); const double percentile_list[4] = {50.0, 95.0, 99.0, 99.9}; std::default_random_engine generator; // gama distribution shape 1 scale 100000 std::gamma_distribution latency_gamma_dist(1.0, 100000); struct hdr_histogram *histogram; hdr_init(min_value, max_value, precision, &histogram); for (int64_t i = 1; i < generated_datapoints; i++) { int64_t number = int64_t(latency_gamma_dist(generator)) + 1; number = number > max_value ? max_value : number; hdr_record_value(histogram, number); } benchmark::DoNotOptimize(histogram->counts); int64_t *values = (int64_t*) malloc(4 * sizeof(int64_t)); benchmark::DoNotOptimize(values); int64_t items_processed = 0; for (auto _ : state) { benchmark::DoNotOptimize( hdr_value_at_percentiles(histogram, percentile_list, values, 4)); // read/write barrier benchmark::ClobberMemory(); items_processed += 4; } state.SetItemsProcessed(items_processed); } // Register the functions as a benchmark BENCHMARK(BM_hdr_init)->Apply(generate_arguments_pairs); BENCHMARK(BM_hdr_record_values)->Apply(generate_arguments_pairs); BENCHMARK(BM_hdr_value_at_percentile)->Apply(generate_arguments_pairs); BENCHMARK(BM_hdr_value_at_percentile_given_array) ->Apply(generate_arguments_pairs); BENCHMARK(BM_hdr_value_at_percentiles_given_array) ->Apply(generate_arguments_pairs); BENCHMARK_MAIN();HdrHistogram_c-0.11.8/test/hdr_histogram_log_test.c000066400000000000000000000705351442262567300224000ustar00rootroot00000000000000/** * hdr_histogram_log_test.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include #include #include #include #include #include "hdr_encoding.h" #include "minunit.h" #if defined(_MSC_VER) #pragma warning(push) #pragma warning(disable: 4996) #endif int tests_run = 0; static bool compare_int(int a, int b) { if (a == b) { return true; } printf("%d != %d\n", a, b); return false; } static long ns_to_ms(long ns) { return (ns / 1000000) * 1000000; } static bool compare_timespec(hdr_timespec* a, hdr_timespec* b) { char a_str[128]; char b_str[128]; long a_tv_msec = ns_to_ms(a->tv_nsec); long b_tv_msec = ns_to_ms(b->tv_nsec); /* Allow off by 1 millisecond due to parsing and rounding. */ if (a->tv_sec == b->tv_sec && labs(a_tv_msec - b_tv_msec) <= 1000000) { return true; } if (a->tv_sec != b->tv_sec) { #if defined(_MSC_VER) _ctime32_s(a_str, sizeof(a_str), &a->tv_sec); _ctime32_s(b_str, sizeof(b_str), &b->tv_sec); printf("tv_sec: %s != %s\n", a_str, b_str); #else printf( "tv_sec: %s != %s\n", ctime_r(&a->tv_sec, a_str), ctime_r(&b->tv_sec, b_str)); #endif } if (a_tv_msec == b_tv_msec) { printf("%ld != %ld\n", a->tv_nsec, b->tv_nsec); } return false; } static bool compare_string(const char* a, const char* b, size_t len) { if (strncmp(a, b, len) == 0) { return true; } printf("%s != %s\n", a, b); return false; } static bool compare_histogram(struct hdr_histogram* a, struct hdr_histogram* b) { int64_t a_max, b_max, a_min, b_min; size_t a_size, b_size, counts_size; struct hdr_iter iter_a, iter_b; if (a->counts_len != b->counts_len) { printf( "a.counts_len = %"PRIu32", b.counts_len = %"PRIu32"\n", a->counts_len, b->counts_len); return false; } a_max = hdr_max(a); b_max = hdr_max(b); if (a_max != b_max) { printf("a.max = %"PRIu64", b.max = %"PRIu64"\n", a_max, b_max); } a_min = hdr_min(a); b_min = hdr_min(b); if (a_min != b_min) { printf("a.min = %"PRIu64", b.min = %"PRIu64"\n", a_min, b_min); } a_size = hdr_get_memory_size(a); b_size = hdr_get_memory_size(b); if (a_size != b_size) { printf("a.size: %u, b.size: %u\n", (unsigned) a_size, (unsigned) b_size); return false; } counts_size = a->counts_len * sizeof(int64_t); if (memcmp(a->counts, b->counts, counts_size) == 0) { return true; } printf("%s\n", "Counts incorrect"); hdr_iter_init(&iter_a, a); hdr_iter_init(&iter_b, b); while (hdr_iter_next(&iter_a) && hdr_iter_next(&iter_b)) { if (iter_a.count != iter_b.count || iter_a.value != iter_b.value) { printf( "A - value: %"PRIu64", count: %"PRIu64", B - value: %"PRIu64", count: %"PRIu64"\n", iter_a.value, iter_a.count, iter_b.value, iter_b.count); } } return false; } static struct hdr_histogram* raw_histogram = NULL; static struct hdr_histogram* cor_histogram = NULL; static void load_histograms(void) { int i; free(raw_histogram); free(cor_histogram); hdr_alloc(INT64_C(3600) * 1000 * 1000, 3, &raw_histogram); hdr_alloc(INT64_C(3600) * 1000 * 1000, 3, &cor_histogram); for (i = 0; i < 10000; i++) { hdr_record_value(raw_histogram, 1000); hdr_record_corrected_value(cor_histogram, 1000, 10000); } hdr_record_value(raw_histogram, 100000000); hdr_record_corrected_value(cor_histogram, 100000000, 10000); } static bool validate_return_code(int rc) { if (rc == 0) { return true; } printf("%s\n", hdr_strerror(rc)); return false; } /* Prototypes to avoid exporting in header file. */ void hdr_base64_encode_block(const uint8_t* input, char* output); void hdr_base64_decode_block(const char* input, uint8_t* output); int hdr_encode_compressed(struct hdr_histogram* h, uint8_t** buffer, size_t* length); int hdr_decode_compressed( uint8_t* buffer, size_t length, struct hdr_histogram** histogram); void hex_dump (char *desc, void *addr, int len); static char* test_encode_and_decode_compressed(void) { uint8_t* buffer = NULL; size_t len = 0; int rc = 0; struct hdr_histogram* actual = NULL; struct hdr_histogram* expected; load_histograms(); expected = raw_histogram; rc = hdr_encode_compressed(expected, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); rc = hdr_decode_compressed(buffer, len, &actual); mu_assert("Did not decode", validate_return_code(rc)); mu_assert("Loaded histogram is null", actual != NULL); mu_assert( "Comparison did not match", compare_histogram(expected, actual)); free(actual); return 0; } static char* test_encode_and_decode_compressed2(void) { uint8_t* buffer = NULL; size_t len = 0; int rc = 0; struct hdr_histogram* actual = NULL; struct hdr_histogram* expected; load_histograms(); expected = cor_histogram; rc = hdr_encode_compressed(expected, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); rc = hdr_decode_compressed(buffer, len, &actual); mu_assert("Did not decode", validate_return_code(rc)); mu_assert("Loaded histogram is null", actual != NULL); mu_assert( "Comparison did not match", compare_histogram(expected, actual)); free(actual); return 0; } static char* test_bounds_check_on_decode(void) { uint8_t* buffer = NULL; size_t len = 0; int rc = 0; struct hdr_histogram* actual = NULL; struct hdr_histogram* expected; load_histograms(); expected = cor_histogram; rc = hdr_encode_compressed(expected, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); rc = hdr_decode_compressed(buffer, len - 1, &actual); mu_assert("Should have be invalid", compare_int64(EINVAL, rc)); mu_assert("Should not have built histogram", NULL == actual); return 0; } static char* test_encode_and_decode_base64(void) { uint8_t* buffer = NULL; uint8_t* decoded = NULL; char* encoded = NULL; size_t encoded_len, decoded_len; size_t len = 0; int rc = 0; load_histograms(); rc = hdr_encode_compressed(cor_histogram, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); encoded_len = hdr_base64_encoded_len(len); decoded_len = hdr_base64_decoded_len(encoded_len); encoded = calloc(encoded_len + 1, sizeof(char)); decoded = calloc(decoded_len, sizeof(uint8_t)); hdr_base64_encode(buffer, len, encoded, encoded_len); hdr_base64_decode(encoded, encoded_len, decoded, decoded_len); mu_assert("Should be same", memcmp(buffer, decoded, len) == 0); return 0; } static char* test_encode_and_decode_empty(void) { uint8_t* buffer; uint8_t* decoded; char* encoded; size_t len = 0; int rc = 0; size_t encoded_len; size_t decoded_len; free(raw_histogram); mu_assert("allocation should be valid", 0 == hdr_init(1, 1000000, 1, &raw_histogram)); rc = hdr_encode_compressed(raw_histogram, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); encoded_len = hdr_base64_encoded_len(len); decoded_len = hdr_base64_decoded_len(encoded_len); encoded = calloc(encoded_len + 1, sizeof(char)); decoded = calloc(decoded_len, sizeof(uint8_t)); hdr_base64_encode(buffer, len, encoded, encoded_len); hdr_base64_decode(encoded, encoded_len, decoded, decoded_len); mu_assert("Should be same", memcmp(buffer, decoded, len) == 0); return 0; } static char* test_encode_and_decode_compressed_large(void) { const int64_t limit = INT64_C(3600) * 1000 * 1000; struct hdr_histogram* actual = NULL; struct hdr_histogram* expected = NULL; uint8_t* buffer = NULL; size_t len = 0; int i; int rc = 0; hdr_init(1, limit, 4, &expected); srand(5); for (i = 0; i < 8070; i++) { hdr_record_value(expected, rand() % limit); } rc = hdr_encode_compressed(expected, &buffer, &len); mu_assert("Did not encode", validate_return_code(rc)); rc = hdr_decode_compressed(buffer, len, &actual); mu_assert("Did not decode", validate_return_code(rc)); mu_assert("Loaded histogram is null", actual != NULL); mu_assert( "Comparison did not match", compare_histogram(expected, actual)); free(expected); free(actual); return 0; } static bool assert_base64_encode(const char* input, const char* expected) { size_t input_len = strlen(input); int output_len = (int) (ceil(input_len / 3.0) * 4.0); char* output = calloc(sizeof(char), output_len); int r = hdr_base64_encode((uint8_t*)input, input_len, output, output_len); bool result = r == 0 && compare_string(expected, output, output_len); free(output); return result; } static char* base64_encode_encodes_without_padding(void) { mu_assert( "Encoding without padding", assert_base64_encode( "any carnal pleasur", "YW55IGNhcm5hbCBwbGVhc3Vy")); return 0; } static char* base64_encode_encodes_with_padding(void) { mu_assert( "Encoding with padding '='", assert_base64_encode( "any carnal pleasure.", "YW55IGNhcm5hbCBwbGVhc3VyZS4=")); mu_assert( "Encoding with padding '=='", assert_base64_encode( "any carnal pleasure", "YW55IGNhcm5hbCBwbGVhc3VyZQ==")); return 0; } static char* base64_encode_fails_with_invalid_lengths(void) { mu_assert( "Output length not 4/3 of input length", hdr_base64_encode(NULL, 9, NULL, 11)); return 0; } static char* base64_encode_block_encodes_3_bytes(void) { char output[5] = { 0 }; hdr_base64_encode_block((uint8_t*)"Man", output); mu_assert("Encoding", compare_string("TWFu", output, 4)); return 0; } static char* base64_decode_block_decodes_4_chars(void) { uint8_t output[4] = { 0 }; hdr_base64_decode_block("TWFu", output); mu_assert("Decoding", compare_string("Man", (char*) output, 3)); return 0; } static bool assert_base64_decode(const char* base64_encoded, const char* expected) { size_t encoded_len = strlen(base64_encoded); size_t output_len = (encoded_len / 4) * 3; uint8_t* output = calloc(sizeof(uint8_t), output_len); int result = hdr_base64_decode(base64_encoded, encoded_len, output, output_len); return result == 0 && compare_string(expected, (char*)output, output_len); } static char* base64_decode_decodes_strings_without_padding(void) { mu_assert( "Encoding without padding", assert_base64_decode( "YW55IGNhcm5hbCBwbGVhc3Vy", "any carnal pleasur")); return 0; } static char* base64_decode_decodes_strings_with_padding(void) { mu_assert( "Encoding with padding '='", assert_base64_decode( "YW55IGNhcm5hbCBwbGVhc3VyZS4=", "any carnal pleasure.")); mu_assert( "Encoding with padding '=='", assert_base64_decode( "YW55IGNhcm5hbCBwbGVhc3VyZQ==", "any carnal pleasure")); return 0; } static char* base64_decode_fails_with_invalid_lengths(void) { mu_assert("Input length % 4 != 0", hdr_base64_decode(NULL, 5, NULL, 3) != 0); mu_assert("Input length < 4", hdr_base64_decode(NULL, 3, NULL, 3) != 0); mu_assert( "Output length not 3/4 of input length", hdr_base64_decode(NULL, 8, NULL, 7) != 0); return 0; } static char* writes_and_reads_log(void) { struct hdr_log_writer writer; struct hdr_log_reader reader; struct hdr_histogram* read_cor_histogram; struct hdr_histogram* read_raw_histogram; const char* file_name = "histogram.log"; int rc = 0; FILE* log_file; const char* tag = "tag_value"; char read_tag[32]; struct hdr_log_entry write_entry; struct hdr_log_entry read_entry; hdr_gettime(&write_entry.start_timestamp); write_entry.interval.tv_sec = 5; write_entry.interval.tv_nsec = 2000000; hdr_log_writer_init(&writer); hdr_log_reader_init(&reader); log_file = fopen(file_name, "w+"); rc = hdr_log_write_header(&writer, log_file, "Test log", &write_entry.start_timestamp); mu_assert("Failed header write", validate_return_code(rc)); write_entry.tag = (char *) tag; write_entry.tag_len = strlen(tag); hdr_log_write_entry(&writer, log_file, &write_entry, cor_histogram); mu_assert("Failed corrected write", validate_return_code(rc)); write_entry.tag = NULL; hdr_log_write_entry(&writer, log_file, &write_entry, raw_histogram); mu_assert("Failed raw write", validate_return_code(rc)); fprintf(log_file, "\n"); fflush(log_file); fclose(log_file); log_file = fopen(file_name, "r"); read_cor_histogram = NULL; read_raw_histogram = NULL; rc = hdr_log_read_header(&reader, log_file); mu_assert("Failed header read", validate_return_code(rc)); mu_assert("Incorrect major version", compare_int(reader.major_version, 1)); mu_assert("Incorrect minor version", compare_int(reader.minor_version, 2)); mu_assert( "Incorrect start timestamp", compare_timespec(&reader.start_timestamp, &write_entry.start_timestamp)); read_entry.tag = read_tag; read_entry.tag_len = sizeof(read_tag); read_entry.tag[0] = '\0'; read_entry.tag[read_entry.tag_len - 1] = '\0'; rc = hdr_log_read_entry(&reader, log_file, &read_entry, &read_cor_histogram); mu_assert("Failed corrected read", validate_return_code(rc)); mu_assert( "Incorrect first timestamp", compare_timespec(&read_entry.start_timestamp, &write_entry.start_timestamp)); mu_assert( "Incorrect first interval", compare_timespec(&read_entry.interval, &write_entry.interval)); mu_assert("Incorrect tag", compare_string(read_entry.tag, tag, strlen(tag))); read_entry.tag[0] = '\0'; read_entry.tag[read_entry.tag_len - 1] = '\0'; rc = hdr_log_read_entry(&reader, log_file, &read_entry, &read_raw_histogram); mu_assert("Should not find tag", read_entry.tag[0] == '\0'); mu_assert("Failed raw read", validate_return_code(rc)); mu_assert( "Histograms do not match", compare_histogram(cor_histogram, read_cor_histogram)); mu_assert( "Histograms do not match", compare_histogram(raw_histogram, read_raw_histogram)); rc = hdr_log_read(&reader, log_file, &read_cor_histogram, NULL, NULL); mu_assert("No EOF at end of file", rc == EOF); fclose(log_file); remove(file_name); return 0; } static char* log_reader_aggregates_into_single_histogram(void) { const char* file_name = "histogram.log"; hdr_timespec timestamp; hdr_timespec interval; struct hdr_log_writer writer; struct hdr_log_reader reader; int rc = 0; FILE* log_file; struct hdr_histogram* histogram; struct hdr_iter iter; int64_t expected_total_count; hdr_gettime(×tamp); interval.tv_sec = 5; interval.tv_nsec = 2000000; hdr_log_writer_init(&writer); hdr_log_reader_init(&reader); log_file = fopen(file_name, "w+"); hdr_log_write_header(&writer, log_file, "Test log", ×tamp); hdr_log_write(&writer, log_file, ×tamp, &interval, cor_histogram); hdr_log_write(&writer, log_file, ×tamp, &interval, raw_histogram); fflush(log_file); fclose(log_file); log_file = fopen(file_name, "r"); hdr_alloc(INT64_C(3600) * 1000 * 1000, 3, &histogram); rc = hdr_log_read_header(&reader, log_file); mu_assert("Failed header read", validate_return_code(rc)); rc = hdr_log_read(&reader, log_file, &histogram, NULL, NULL); mu_assert("Failed corrected read", validate_return_code(rc)); rc = hdr_log_read(&reader, log_file, &histogram, NULL, NULL); mu_assert("Failed raw read", validate_return_code(rc)); hdr_iter_recorded_init(&iter, histogram); expected_total_count = raw_histogram->total_count + cor_histogram->total_count; mu_assert( "Total counts incorrect", compare_int64(histogram->total_count, expected_total_count)); while (hdr_iter_next(&iter)) { int64_t count = iter.count; int64_t value = iter.value; int64_t expected_count = hdr_count_at_value(raw_histogram, value) + hdr_count_at_value(cor_histogram, value); mu_assert("Incorrect count", compare_int64(count, expected_count)); } fclose(log_file); remove(file_name); free(histogram); return 0; } static char* log_reader_fails_with_incorrect_version(void) { const char* log_with_invalid_version = "#[Test log]\n" "#[Histogram log format version 1.04]\n" "#[StartTime: 1404700005.222 (seconds since epoch), Mon Jul 02:26:45 GMT 2014]\n" "StartTimestamp\",\"EndTimestamp\",\"Interval_Max\",\"Interval_Compressed_Histogram\"\n"; const char* file_name = "histogram_with_invalid_version.log"; struct hdr_log_reader reader; FILE* log_file; int r; log_file = fopen(file_name, "w+"); fprintf(log_file, "%s", log_with_invalid_version); fflush(log_file); fclose(log_file); log_file = fopen(file_name, "r"); hdr_log_reader_init(&reader); r = hdr_log_read_header(&reader, log_file); mu_assert("Should error with incorrect version", r == HDR_LOG_INVALID_VERSION); fclose(log_file); remove(file_name); return 0; } static char* test_encode_decode_empty(void) { char *data; struct hdr_histogram *histogram, *hdr_new = NULL; hdr_alloc(INT64_C(3600) * 1000 * 1000, 3, &histogram); mu_assert("Failed to encode histogram data", hdr_log_encode(histogram, &data) == 0); mu_assert("Failed to decode histogram data", hdr_log_decode(&hdr_new, data, strlen(data)) == 0); mu_assert("Histograms should be the same", compare_histogram(histogram, hdr_new)); free(histogram); free(hdr_new); free(data); return 0; } static char* test_string_encode_decode(void) { int i; char *data; struct hdr_histogram *histogram, *hdr_new = NULL; hdr_alloc(INT64_C(3600) * 1000 * 1000, 3, &histogram); for (i = 1; i < 100; i++) { hdr_record_value(histogram, i*i); } mu_assert("Failed to encode histogram data", hdr_log_encode(histogram, &data) == 0); mu_assert("Failed to decode histogram data", hdr_log_decode(&hdr_new, data, strlen(data)) == 0); mu_assert("Histograms should be the same", compare_histogram(histogram, hdr_new)); mu_assert("Mean different after encode/decode", compare_double(hdr_mean(histogram), hdr_mean(hdr_new), 0.001)); return 0; } static char* test_string_encode_decode_2(void) { int i; char *data; struct hdr_histogram *histogram, *hdr_new = NULL; hdr_alloc(1000, 3, &histogram); for (i = 1; i < histogram->highest_trackable_value; i++) { hdr_record_value(histogram, i); } mu_assert( "Failed to encode histogram data", validate_return_code(hdr_log_encode(histogram, &data))); mu_assert( "Failed to decode histogram data", validate_return_code(hdr_log_decode(&hdr_new, data, strlen(data)))); mu_assert("Histograms should be the same", compare_histogram(histogram, hdr_new)); mu_assert("Mean different after encode/decode", compare_double(hdr_mean(histogram), hdr_mean(hdr_new), 0.001)); return 0; } static char* decode_v1_log(void) { const char* v1_log = "jHiccup-2.0.6.logV1.hlog"; struct hdr_histogram* accum; struct hdr_histogram* h = NULL; struct hdr_log_reader reader; hdr_timespec timestamp, interval; int rc; int64_t total_count = 0; int histogram_count = 0; FILE* f = fopen(v1_log, "r"); mu_assert("Can not open v1 log file", f != NULL); hdr_init(1, INT64_C(3600000000000), 3, &accum); hdr_log_reader_init(&reader); rc = hdr_log_read_header(&reader, f); mu_assert("Failed to read header", rc == 0); while ((rc = hdr_log_read(&reader, f, &h, ×tamp, &interval)) != EOF) { int64_t dropped; mu_assert("Failed to read histogram", rc == 0); histogram_count++; total_count += h->total_count; dropped = hdr_add(accum, h); mu_assert("Dropped events", compare_int64(dropped, 0)); free(h); h = NULL; } mu_assert("Wrong number of histograms", compare_int(histogram_count, 88)); mu_assert("Wrong total count", compare_int64(total_count, 65964)); mu_assert("99.9 percentile wrong", compare_int64(1829765119, hdr_value_at_percentile(accum, 99.9))); mu_assert("max value wrong", compare_int64(1888485375, hdr_max(accum))); mu_assert("Seconds wrong", compare_int64(1438867590, reader.start_timestamp.tv_sec)); mu_assert("Nanoseconds wrong", compare_int64(285000000, reader.start_timestamp.tv_nsec)); return 0; } static char* decode_v2_log(void) { struct hdr_histogram* accum; struct hdr_histogram* h = NULL; struct hdr_log_reader reader; hdr_timespec timestamp, interval; int histogram_count = 0; int64_t total_count = 0; int rc; const char* v2_log = "jHiccup-2.0.7S.logV2.hlog"; FILE* f = fopen(v2_log, "r"); mu_assert("Can not open v2 log file", f != NULL); hdr_init(1, INT64_C(3600000000000), 3, &accum); hdr_log_reader_init(&reader); rc = hdr_log_read_header(&reader, f); mu_assert("Failed to read header", validate_return_code(rc)); while ((rc = hdr_log_read(&reader, f, &h, ×tamp, &interval)) != EOF) { int64_t dropped; mu_assert("Failed to read histogram", validate_return_code(rc)); histogram_count++; total_count += h->total_count; dropped = hdr_add(accum, h); mu_assert("Dropped events", compare_int64(dropped, 0)); free(h); h = NULL; } mu_assert("Wrong number of histograms", compare_int(histogram_count, 62)); mu_assert("Wrong total count", compare_int64(total_count, 48761)); mu_assert("99.9 percentile wrong", compare_int64(1745879039, hdr_value_at_percentile(accum, 99.9))); mu_assert("max value wrong", compare_int64(1796210687, hdr_max(accum))); mu_assert("Seconds wrong", compare_int64(1441812279, reader.start_timestamp.tv_sec)); mu_assert("Nanoseconds wrong", compare_int64(474000000, reader.start_timestamp.tv_nsec)); return 0; } static char* decode_v3_log(void) { struct hdr_histogram* accum; struct hdr_histogram* h = NULL; struct hdr_log_reader reader; hdr_timespec timestamp; hdr_timespec interval; int rc; int histogram_count = 0; int64_t total_count = 0; const char* v3_log = "jHiccup-2.0.7S.logV3.hlog"; FILE* f = fopen(v3_log, "r"); if (NULL == f) { fprintf(stderr, "Open file: [%d] %s", errno, strerror(errno)); } mu_assert("Can not open v3 log file", f != NULL); hdr_init(1, INT64_C(3600000000000), 3, &accum); hdr_log_reader_init(&reader); rc = hdr_log_read_header(&reader, f); mu_assert("Failed to read header", validate_return_code(rc)); while ((rc = hdr_log_read(&reader, f, &h, ×tamp, &interval)) != EOF) { int64_t dropped; mu_assert("Failed to read histogram", validate_return_code(rc)); histogram_count++; total_count += h->total_count; dropped = hdr_add(accum, h); mu_assert("Dropped events", compare_int64(dropped, 0)); free(h); h = NULL; } mu_assert("Wrong number of histograms", compare_int(histogram_count, 62)); mu_assert("Wrong total count", compare_int64(total_count, 48761)); mu_assert("99.9 percentile wrong", compare_int64(1745879039, hdr_value_at_percentile(accum, 99.9))); mu_assert("max value wrong", compare_int64(1796210687, hdr_max(accum))); mu_assert("Seconds wrong", compare_int64(1441812279, reader.start_timestamp.tv_sec)); mu_assert("Nanoseconds wrong", compare_int64(474000000, reader.start_timestamp.tv_nsec)); return 0; } static int parse_line_from_file(const char* filename) { struct hdr_histogram *h = NULL; hdr_timespec timestamp; hdr_timespec interval; int result; FILE* f = fopen(filename, "r"); if (NULL == f) { fprintf(stderr, "Open file: [%d] %s", errno, strerror(errno)); return -EIO; } result = hdr_log_read(NULL, f, &h, ×tamp, &interval); fclose(f); return result; } static char* handle_invalid_log_lines(void) { mu_assert("Should have invalid histogram", -EINVAL == parse_line_from_file("test_tagged_invalid_histogram.txt")); mu_assert("Should have invalid tag key", -EINVAL == parse_line_from_file("test_tagged_invalid_tag_key.txt")); mu_assert("Should have invalid timestamp", -EINVAL == parse_line_from_file("test_tagged_invalid_timestamp.txt")); mu_assert("Should have missing histogram", -EINVAL == parse_line_from_file("test_tagged_missing_histogram.txt")); return 0; } static char* decode_v0_log(void) { struct hdr_histogram* accum; const char* v1_log = "jHiccup-2.0.1.logV0.hlog"; struct hdr_histogram* h = NULL; struct hdr_log_reader reader; hdr_timespec timestamp; hdr_timespec interval; int rc; int histogram_count = 0; int64_t total_count = 0; FILE* f = fopen(v1_log, "r"); mu_assert("Can not open v1 log file", f != NULL); hdr_init(1, INT64_C(3600000000000), 3, &accum); hdr_log_reader_init(&reader); rc = hdr_log_read_header(&reader, f); mu_assert("Failed to read header", rc == 0); while ((rc = hdr_log_read(&reader, f, &h, ×tamp, &interval)) != EOF) { int64_t dropped; mu_assert("Failed to read histogram", rc == 0); histogram_count++; total_count += h->total_count; dropped = hdr_add(accum, h); mu_assert("Dropped events", compare_int64(dropped, 0)); free(h); h = NULL; } mu_assert("Wrong number of histograms", compare_int(histogram_count, 81)); mu_assert("Wrong total count", compare_int64(total_count, 61256)); mu_assert("99.9 percentile wrong", compare_int64(1510998015, hdr_value_at_percentile(accum, 99.9))); mu_assert("max value wrong", compare_int64(1569718271, hdr_max(accum))); mu_assert("Seconds wrong", compare_int64(1438869961, reader.start_timestamp.tv_sec)); mu_assert("Nanoseconds wrong", compare_int64(225000000, reader.start_timestamp.tv_nsec)); return 0; } static struct mu_result all_tests(void) { tests_run = 0; mu_run_test(test_encode_decode_empty); mu_run_test(test_encode_and_decode_compressed); mu_run_test(test_encode_and_decode_compressed2); mu_run_test(test_encode_and_decode_compressed_large); mu_run_test(test_encode_and_decode_base64); mu_run_test(test_bounds_check_on_decode); mu_run_test(base64_decode_block_decodes_4_chars); mu_run_test(base64_decode_fails_with_invalid_lengths); mu_run_test(base64_decode_decodes_strings_without_padding); mu_run_test(base64_decode_decodes_strings_with_padding); mu_run_test(base64_encode_block_encodes_3_bytes); mu_run_test(base64_encode_fails_with_invalid_lengths); mu_run_test(base64_encode_encodes_without_padding); mu_run_test(base64_encode_encodes_with_padding); mu_run_test(writes_and_reads_log); mu_run_test(log_reader_aggregates_into_single_histogram); mu_run_test(log_reader_fails_with_incorrect_version); mu_run_test(test_string_encode_decode); mu_run_test(test_string_encode_decode_2); mu_run_test(decode_v3_log); mu_run_test(decode_v2_log); mu_run_test(decode_v1_log); mu_run_test(decode_v0_log); mu_run_test(handle_invalid_log_lines); mu_run_test(test_encode_and_decode_empty); free(raw_histogram); free(cor_histogram); mu_ok; } static int hdr_histogram_log_run_tests(void) { struct mu_result result = all_tests(); if (result.message != 0) { printf("hdr_histogram_log_test.%s(): %s\n", result.test, result.message); } else { printf("ALL TESTS PASSED\n"); } printf("Tests run: %d\n", tests_run); return result.message == NULL ? 0 : -1; } int main(void) { return hdr_histogram_log_run_tests(); } #if defined(_MSC_VER) #pragma warning(pop) #endif HdrHistogram_c-0.11.8/test/hdr_histogram_perf.c000066400000000000000000000043411442262567300215040ustar00rootroot00000000000000/** * hdr_histogram_perf.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #if defined(_WIN32) || defined(_WIN64) || defined(__CYGWIN__) #if !defined(WIN32_LEAN_AND_MEAN) #define WIN32_LEAN_AND_MEAN #endif #include #define snprintf sprintf_s #endif static hdr_timespec diff(hdr_timespec start, hdr_timespec end) { hdr_timespec temp; if ((end.tv_nsec-start.tv_nsec) < 0) { temp.tv_sec = end.tv_sec - start.tv_sec - 1; temp.tv_nsec = 1000000000 + end.tv_nsec-start.tv_nsec; } else { temp.tv_sec = end.tv_sec - start.tv_sec; temp.tv_nsec = end.tv_nsec - start.tv_nsec; } return temp; } /* Formats the given double with 2 dps, and , thousand separators */ static char *format_double(double d) { int p; static char buffer[30]; snprintf(buffer, sizeof(buffer), "%0.2f", d); p = (int) strlen(buffer) - 6; while (p > 0) { memmove(&buffer[p + 1], &buffer[p], strlen(buffer) - p + 1); buffer[p] = ','; p = p - 3; } return buffer; } int main(void) { struct hdr_histogram* histogram; hdr_timespec t0, t1; int result, i; int64_t iterations; int64_t max_value = INT64_C(24) * 60 * 60 * 1000000; int64_t min_value = 1; result = hdr_init(min_value, max_value, 4, &histogram); if (result != 0) { fprintf(stderr, "Failed to allocate histogram: %d\n", result); return -1; } iterations = 400000000; for (i = 0; i < 100; i++) { int64_t j; hdr_timespec taken; double time_taken, ops_sec; hdr_gettime(&t0); for (j = 1; j < iterations; j++) { hdr_record_value(histogram, j); } hdr_gettime(&t1); taken = diff(t0, t1); time_taken = (double)taken.tv_sec + (double)taken.tv_nsec / 1000000000.0; ops_sec = (double)(iterations - 1) / time_taken; printf("%s - %d, ops/sec: %s\n", "Iteration", i + 1, format_double(ops_sec)); } return 0; } HdrHistogram_c-0.11.8/test/hdr_histogram_test.c000066400000000000000000000443571442262567300215420ustar00rootroot00000000000000/** * hdr_histogram_test.c * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #include #include #include #include #include #include #include #include "minunit.h" #include "hdr_test_util.h" static bool compare_values(double a, double b, double variation) { return compare_double(a, b, b * variation); } static bool compare_percentile(int64_t a, double b, double variation) { return compare_values((double) a, b, variation); } int tests_run = 0; static struct hdr_histogram* raw_histogram = NULL; static struct hdr_histogram* cor_histogram = NULL; static struct hdr_histogram* scaled_raw_histogram = NULL; static struct hdr_histogram* scaled_cor_histogram = NULL; static void load_histograms(void) { const int64_t highest_trackable_value = INT64_C(3600) * 1000 * 1000; const int32_t significant_figures = 3; const int64_t interval = INT64_C(10000); const int64_t scale = 512; const int64_t scaled_interval = interval * scale; int i; if (raw_histogram) { free(raw_histogram); } hdr_init(1, highest_trackable_value, significant_figures, &raw_histogram); if (cor_histogram) { free(cor_histogram); } hdr_init(1, highest_trackable_value, significant_figures, &cor_histogram); if (scaled_raw_histogram) { free(scaled_raw_histogram); } hdr_init(1000, highest_trackable_value * 512, significant_figures, &scaled_raw_histogram); if (scaled_cor_histogram) { free(scaled_cor_histogram); } hdr_init(1000, highest_trackable_value * 512, significant_figures, &scaled_cor_histogram); for (i = 0; i < 10000; i++) { hdr_record_value(raw_histogram, 1000); hdr_record_corrected_value(cor_histogram, 1000, interval); hdr_record_value(scaled_raw_histogram, 1000 * scale); hdr_record_corrected_value(scaled_cor_histogram, 1000 * scale, scaled_interval); } hdr_record_value(raw_histogram, 100000000); hdr_record_corrected_value(cor_histogram, 100000000, 10000L); hdr_record_value(scaled_raw_histogram, 100000000 * scale); hdr_record_corrected_value(scaled_cor_histogram, 100000000 * scale, scaled_interval); } static char* test_create(void) { struct hdr_histogram* h = NULL; int r = hdr_init(1, INT64_C(3600000000), 3, &h); mu_assert("Failed to allocate hdr_histogram", r == 0); mu_assert("Failed to allocate hdr_histogram", h != NULL); mu_assert("Incorrect array length", compare_int64(h->counts_len, 23552)); free(h); return 0; } static char* test_create_with_large_values(void) { struct hdr_histogram* h = NULL; int r = hdr_init(20000000, 100000000, 5, &h); mu_assert("Didn't create", r == 0); hdr_record_value(h, 100000000); hdr_record_value(h, 20000000); hdr_record_value(h, 30000000); mu_assert( "50.0% Percentile", hdr_values_are_equivalent(h, 20000000, hdr_value_at_percentile(h, 50.0))); mu_assert( "83.33% Percentile", hdr_values_are_equivalent(h, 30000000, hdr_value_at_percentile(h, 83.33))); mu_assert( "83.34% Percentile", hdr_values_are_equivalent(h, 100000000, hdr_value_at_percentile(h, 83.34))); mu_assert( "99.0% Percentile", hdr_values_are_equivalent(h, 100000000, hdr_value_at_percentile(h, 99.0))); return 0; } static char* test_invalid_significant_figures(void) { struct hdr_histogram* h = NULL; int r = hdr_alloc(36000000, -1, &h); mu_assert("Result was not EINVAL", r == EINVAL); mu_assert("Histogram was not null", h == 0); r = hdr_alloc(36000000, 6, &h); mu_assert("Result was not EINVAL", r == EINVAL); mu_assert("Histogram was not null", h == 0); return 0; } static char* test_invalid_init(void) { struct hdr_histogram* h = NULL; mu_assert("Should not allow 0 as lowest trackable value", EINVAL == hdr_init(0, 64*1024, 2, &h)); mu_assert("Should have lowest < 2 * highest", EINVAL == hdr_init(80, 110, 5, &h)); return 0; } static char* test_total_count(void) { load_histograms(); mu_assert("Total raw count != 10001", raw_histogram->total_count == 10001); mu_assert("Total corrected count != 20000", cor_histogram->total_count == 20000); return 0; } static char* test_get_max_value(void) { int64_t actual_raw_max, actual_cor_max; load_histograms(); actual_raw_max = hdr_max(raw_histogram); mu_assert("hdr_max(raw_histogram) != 100000000L", hdr_values_are_equivalent(raw_histogram, actual_raw_max, 100000000)); actual_cor_max = hdr_max(cor_histogram); mu_assert("hdr_max(cor_histogram) != 100000000L", hdr_values_are_equivalent(cor_histogram, actual_cor_max, 100000000)); return 0; } static char* test_get_min_value(void) { load_histograms(); mu_assert("hdr_min(raw_histogram) != 1000", hdr_min(raw_histogram) == 1000); mu_assert("hdr_min(cor_histogram) != 1000", hdr_min(cor_histogram) == 1000); return 0; } static char* test_percentiles(void) { load_histograms(); mu_assert("Value at 30% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 30.0), 1000.0, 0.001)); mu_assert("Value at 99% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.0), 1000.0, 0.001)); mu_assert("Value at 99.99% not 1000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.99), 1000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 99.999), 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(hdr_value_at_percentile(raw_histogram, 100.0), 100000000.0, 0.001)); mu_assert("Value at 30% not 1000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 30.0), 1000.0, 0.001)); mu_assert("Value at 50% not 1000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 50.0), 1000.0, 0.001)); mu_assert("Value at 75% not 50000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 75.0), 50000000.0, 0.001)); mu_assert("Value at 90% not 80000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 90.0), 80000000.0, 0.001)); mu_assert("Value at 99% not 98000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 99.0), 98000000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 99.999), 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(hdr_value_at_percentile(cor_histogram, 100.0), 100000000.0, 0.001)); return 0; } static char* test_percentiles_by_value_at_percentiles(void) { load_histograms(); int64_t values[5] = { 0 }; double percentiles[5] = { 30.0, 99.0, 99.99, 99.999, 100.0 }; mu_assert( "value_at_percentiles return should be 0", hdr_value_at_percentiles(raw_histogram, percentiles, values, 5) == 0); mu_assert("Value at 30% not 1000.0", compare_percentile(values[0], 1000.0, 0.001)); mu_assert("Value at 99% not 1000.0", compare_percentile(values[1], 1000.0, 0.001)); mu_assert("Value at 99.99% not 1000.0", compare_percentile(values[2], 1000.0, 0.001)); mu_assert("Value at 99.999% not 100000000.0", compare_percentile(values[3], 100000000.0, 0.001)); mu_assert("Value at 100% not 100000000.0", compare_percentile(values[4], 100000000.0, 0.001)); return 0; } static char* test_recorded_values(void) { struct hdr_iter iter; int index; int64_t total_added_count = 0; load_histograms(); /* Raw Histogram */ hdr_iter_recorded_init(&iter, raw_histogram); index = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.recorded.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Value at 0 is not 10000", count_added_in_this_bucket == 10000); } else { mu_assert("Value at 1 is not 1", count_added_in_this_bucket == 1); } index++; } mu_assert("Should have encountered 2 values", index == 2); /* Corrected Histogram */ hdr_iter_recorded_init(&iter, cor_histogram); index = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.recorded.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10000", count_added_in_this_bucket == 10000); } mu_assert("Count should not be 0", iter.count != 0); mu_assert("Count at value iterated to should be count added in this step", iter.count == count_added_in_this_bucket); total_added_count += count_added_in_this_bucket; index++; } mu_assert("Total counts should be 20000", total_added_count == 20000); return 0; } static char* test_linear_values(void) { struct hdr_iter iter; int index; int64_t total_added_count; load_histograms(); /* Raw Histogram */ hdr_iter_linear_init(&iter, raw_histogram, 100000); index = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.linear.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10000", count_added_in_this_bucket == 10000); } else if (index == 999) { mu_assert("Count at 999 is not 1", count_added_in_this_bucket == 1); } else { mu_assert("Count should be 0", count_added_in_this_bucket == 0); } index++; } mu_assert("Should of met 1000 values", compare_int64(index, 1000)); /* Corrected Histogram */ hdr_iter_linear_init(&iter, cor_histogram, 10000); index = 0; total_added_count = 0; while (hdr_iter_next(&iter)) { int64_t count_added_in_this_bucket = iter.specifics.linear.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Count at 0 is not 10001", count_added_in_this_bucket == 10001); } total_added_count += count_added_in_this_bucket; index++; } mu_assert("Should of met 10001 values", index == 10000); mu_assert("Should of met 20000 counts", total_added_count == 20000); return 0; } static char* test_logarithmic_values(void) { struct hdr_iter iter; int index; uint64_t total_added_count; load_histograms(); hdr_iter_log_init(&iter, raw_histogram, 10000, 2.0); index = 0; while(hdr_iter_next(&iter)) { uint64_t count_added_in_this_bucket = iter.specifics.log.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Raw Logarithmic 10 msec bucket # 0 added a count of 10000", 10000 == count_added_in_this_bucket); } else if (index == 14) { mu_assert("Raw Logarithmic 10 msec bucket # 14 added a count of 1", 1 == count_added_in_this_bucket); } else { mu_assert("Raw Logarithmic 10 msec bucket added a count of 0", 0 == count_added_in_this_bucket); } index++; } mu_assert("Should of seen 14 values", index - 1 == 14); hdr_iter_log_init(&iter, cor_histogram, 10000, 2.0); index = 0; total_added_count = 0; while (hdr_iter_next(&iter)) { uint64_t count_added_in_this_bucket = iter.specifics.log.count_added_in_this_iteration_step; if (index == 0) { mu_assert("Corrected Logarithmic 10 msec bucket # 0 added a count of 10001", 10001 == count_added_in_this_bucket); } total_added_count += count_added_in_this_bucket; index++; } mu_assert("Should of seen 14 values", index - 1 == 14); mu_assert("Should of seen count of 20000", total_added_count == 20000); return 0; } static char* test_reset(void) { load_histograms(); mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(raw_histogram, 99.0) != 0); mu_assert("Value at 99% == 0.0", hdr_value_at_percentile(cor_histogram, 99.0) != 0); hdr_reset(raw_histogram); hdr_reset(cor_histogram); mu_assert("Total raw count != 0", raw_histogram->total_count == 0); mu_assert("Total corrected count != 0", cor_histogram->total_count == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(raw_histogram, 99.0) == 0); mu_assert("Value at 99% not 0.0", hdr_value_at_percentile(cor_histogram, 99.0) == 0); return 0; } static char* test_scaling_equivalence(void) { int64_t expected_99th, scaled_99th; load_histograms(); mu_assert( "Averages should be equivalent", compare_values( hdr_mean(cor_histogram) * 512, hdr_mean(scaled_cor_histogram), 0.000001)); mu_assert( "Total count should be equivalent", compare_int64( cor_histogram->total_count, scaled_cor_histogram->total_count)); expected_99th = hdr_value_at_percentile(cor_histogram, 99.0) * 512; scaled_99th = hdr_value_at_percentile(scaled_cor_histogram, 99.0); mu_assert( "99%'iles should be equivalent", compare_int64( hdr_lowest_equivalent_value(cor_histogram, expected_99th), hdr_lowest_equivalent_value(scaled_cor_histogram, scaled_99th))); return 0; } static char* test_out_of_range_values(void) { struct hdr_histogram *h; hdr_init(1, 1000, 4, &h); mu_assert("Should successfully record value", hdr_record_value(h, 32767)); mu_assert("Should not record value", !hdr_record_value(h, 32768)); return 0; } static char* test_linear_iter_buckets_correctly(void) { int step_count = 0; int64_t total_count = 0; struct hdr_histogram *h; struct hdr_iter iter; hdr_init(1, 255, 2, &h); hdr_record_value(h, 193); hdr_record_value(h, 255); hdr_record_value(h, 0); hdr_record_value(h, 1); hdr_record_value(h, 64); hdr_record_value(h, 128); hdr_iter_linear_init(&iter, h, 64); while (hdr_iter_next(&iter)) { total_count += iter.specifics.linear.count_added_in_this_iteration_step; /* start - changes to reproduce issue */ if (step_count == 0) { hdr_record_value(h, 2); } /* end - changes to reproduce issue */ step_count++; } mu_assert("Number of steps", compare_int64(4, step_count)); mu_assert("Total count", compare_int64(6, total_count)); return 0; } static char* test_interval_recording(void) { int value_count, i, value; char* result; struct hdr_histogram* expected_histogram; struct hdr_histogram* expected_corrected_histogram; struct hdr_interval_recorder recorder; struct hdr_interval_recorder recorder_corrected; struct hdr_histogram* recorder_histogram; struct hdr_histogram* recorder_corrected_histogram; value_count = 1000000; hdr_interval_recorder_init_all(&recorder, 1, INT64_C(24) * 60 * 60 * 1000000, 3); hdr_interval_recorder_init_all(&recorder_corrected, 1, INT64_C(24) * 60 * 60 * 1000000, 3); hdr_init(1, INT64_C(24) * 60 * 60 * 1000000, 3, &expected_histogram); hdr_init(1, INT64_C(24) * 60 * 60 * 1000000, 3, &expected_corrected_histogram); for (i = 0; i < value_count; i++) { value = rand() % 20000; hdr_record_value(expected_histogram, value); hdr_record_corrected_value(expected_corrected_histogram, value, 1000); hdr_interval_recorder_record_value(&recorder, value); hdr_interval_recorder_record_corrected_value(&recorder_corrected, value, 1000); } recorder_histogram = hdr_interval_recorder_sample(&recorder); result = compare_histograms(expected_histogram, recorder_histogram); if (result) { return result; } recorder_corrected_histogram = hdr_interval_recorder_sample(&recorder_corrected); result = compare_histograms(expected_corrected_histogram, recorder_corrected_histogram); if (result) { return result; } return 0; } static char* reset_histogram_on_sample_and_recycle(void) { struct hdr_interval_recorder recorder; struct hdr_histogram* inactive1; struct hdr_histogram* sample1; struct hdr_histogram* sample2; inactive1 = NULL; hdr_interval_recorder_init_all(&recorder, 1, INT64_C(24) * 60 * 60 * 1000000, 3); hdr_interval_recorder_record_value(&recorder, 1234); sample1 = hdr_interval_recorder_sample_and_recycle(&recorder, inactive1); mu_assert("Should have at least one value", compare_int64(1, sample1->total_count)); sample2 = hdr_interval_recorder_sample_and_recycle(&recorder, sample1); sample1 = hdr_interval_recorder_sample_and_recycle(&recorder, sample2); mu_assert("Should have been reset", compare_int64(0, sample1->total_count)); return 0; } static struct mu_result all_tests(void) { mu_run_test(test_create); mu_run_test(test_invalid_init); mu_run_test(test_create_with_large_values); mu_run_test(test_invalid_significant_figures); mu_run_test(test_total_count); mu_run_test(test_get_min_value); mu_run_test(test_get_max_value); mu_run_test(test_percentiles); mu_run_test(test_percentiles_by_value_at_percentiles); mu_run_test(test_recorded_values); mu_run_test(test_linear_values); mu_run_test(test_logarithmic_values); mu_run_test(test_reset); mu_run_test(test_scaling_equivalence); mu_run_test(test_out_of_range_values); mu_run_test(test_linear_iter_buckets_correctly); mu_run_test(test_interval_recording); mu_run_test(reset_histogram_on_sample_and_recycle); mu_ok; } static int hdr_histogram_run_tests(void) { struct mu_result result = all_tests(); if (result.message != 0) { printf("hdr_histogram_test.%s(): %s\n", result.test, result.message); } else { printf("ALL TESTS PASSED\n"); } printf("Tests run: %d\n", tests_run); return result.message == NULL ? 0 : -1; } int main(void) { return hdr_histogram_run_tests(); } HdrHistogram_c-0.11.8/test/hdr_test_util.h000066400000000000000000000017441442262567300205200ustar00rootroot00000000000000/** * hdr_test_util.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef HDR_HISTOGRAM_HDR_TEST_UTIL_H #define HDR_HISTOGRAM_HDR_TEST_UTIL_H static char* compare_histograms(struct hdr_histogram* expected, struct hdr_histogram* actual) { struct hdr_iter expected_iter; struct hdr_iter actual_iter; hdr_iter_init(&expected_iter, expected); hdr_iter_init(&actual_iter, actual); while (hdr_iter_next(&expected_iter)) { mu_assert("Should have next", hdr_iter_next(&actual_iter)); mu_assert("counts mismatch", compare_int64(expected_iter.count, actual_iter.count)); } mu_assert("Min mismatch", compare_int64(expected->min_value, actual->min_value)); mu_assert("Max mismatch", compare_int64(expected->max_value, actual->max_value)); mu_assert("Total mismatch", compare_int64(expected->total_count, actual->total_count)); return 0; } #endif HdrHistogram_c-0.11.8/test/hiccup.140623.1028.10646.hlog000066400000000000000000000031371442262567300214300ustar00rootroot00000000000000#[Logged with jHiccup version 2.0.3-SNAPSHOT] #[Histogram log format version 1.01] #[StartTime: 1403476110.183 (seconds since epoch), Mon Jun 23 10:28:30 NZST 2014] "StartTimestamp","EndTimestamp","Interval_Max","Interval_Compressed_Histogram" 0.042,5.004,0.115,HISTiQAAAEV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQt4QmrkKQvNugkq8g9KKUJoHSjMzoAJGhlEwCkbBKBgFo2AUDDkAANEpBrU= 5.046,5.000,1.294,HISTiQAAAEh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQm5QBhuEYraF0LyuEJoxFypvA6UFoTQzwygYBZQDxtEgGAWjYBSMgoEBAItJBaw= 10.046,5.000,3.113,HISTiQAAAEZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQlFQBiMqzX8RQjNJQMVDobQwlGZCo0fB8ASMo0EwGs+jYDS+R8HwBAC+mAXU 15.046,5.005,0.131,HISTiQAAAEd42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQhlQBiOU5oBQAuxQ4a9QcW8oLQKlmRlQASPDKBgFo2AUjIJRMAqGDAAAoysF8A== 20.051,4.995,0.147,HISTiQAAAEp42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQglQBlSegRlCCXhAaMbtUHE3KM0PpVmhNCMDKkDnj4JRMApGwSgYBaNgEAIAJgsF4A== 25.046,5.000,0.115,HISTiQAAAEZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQilQBiOUZoNQAnJQ4bNQ8UgoLQylWaA01NxRMApGwSgYBaNgFAwlAABjqwXo 30.046,5.000,0.131,HISTiQAAAEJ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQqkMqIARQgl4Q7n7oOJeUJoPSjNh1zcKRsEoGAWjYBSMgqEAAHWdBeo= 35.046,5.000,0.115,HISTiQAAAEV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQqlQBlSegRlCCWhDaMYzUPFgKC0CpRnR6FEwCkbBKBgFo2AUDCEAAHRlBeo= 40.046,5.000,0.131,HISTiQAAAER42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQikMqIAZQgloQWjGy1DxACjNi6oOTjMyjIJRMApGwSgYBaNgyAAAZDsF6A== 45.046,5.000,0.131,HISTiQAAAEl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQvFQBlSegQNC8W2BCp+Bis+H0hpQmgtKM0NpRoZRMApGwSgYBaNgFAwZAADuSAbd 50.046,5.000,0.246,HISTiQAAAEt42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMQvFQBlSegQ1CMd6G0PxuUPFbUNoJSotDaUY0mlRArr5RMApGwSgYBaNgFFAAAOooBt0= HdrHistogram_c-0.11.8/test/jHiccup-2.0.1.logV0.hlog000066400000000000000000000335271442262567300213640ustar00rootroot00000000000000#[Logged with jHiccup version 2.0.1] #[Histogram log format version 1.01] #[StartTime: 1438869961.225 (seconds since epoch), Thu Aug 06 07:06:01 PDT 2015] "StartTimestamp","EndTimestamp","Interval_Max","Interval_Compressed_Histogram" 0.116,1.005,3.031,HISTiQAAAG542pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI+gDFYozQmlOaA0M5Rmg9LsUJoFjc+GZg4rmjkwdUxofG4obQeldaG0LJTmR1PvCKXVIRQjzL2BUFoYTT0jwyjABkbDZTSeR8FofI+CEQ4AUBEGxA== 1.121,1.000,0.442,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA+hDEY0mhVKc0BpdijNAqW50NSx4dDPhqafDYf5OlDaGEpLQmleNPs8oLQy1LoYVD5cPcydUH+PglEwCkbBKBgFowAZAABAZwbC 2.121,0.999,0.459,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcYsANmNJoNB82Jpo4Fjc8NpVlhFkJpLijNDqV1obQGlFZEMx+mLghKK0AoxigoXxVKi0NpRjT/MDKMglEwCkbBKBgFowAOAAw5Brw= 3.120,1.002,0.442,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPehDEYozYxGs0BpVjQ+F5o+dhz6OWAWoZkDU88GpXWhtCqU1kDTD9MXAqXVodb7QvlmUJoXzZ0w942CUTAKRsEoGAWjAAkAABrTBr4= 4.122,1.000,0.475,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcYsAOoegY2ND6MZoHSXFCaHU09jM+Kpp4NB60DpfWhtByU5kYzLxBK60EoRncoXwNKS0BpZhz+YmQYBaNgFIyCUTAKRgEDAArJBrw= 5.122,1.000,0.442,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHcZUAEjTAJKs0BpNjRxGJ8dSnOgibPioFlw8JWhtBqUloXSPFCaC0qHQWltqHPDoXwtKC2MZj4jwygYBaNgFIyCUTAKMAAA+GAGug== 6.122,1.001,0.459,HISTiQAAAGd42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHcZsANGmAIozQKlWaE0M5RmQxOHqeNAU8eOpp4Lja8JpbWhtC6U5kQzPwRKa0CdaQPlm0JpYTRzGdHoUTAKRsEoGAWjYBQAAQD4sAa6 7.123,0.997,0.541,HISTiQAAAGt42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI+gDBYozYhGs6HJw/isaOpY0dTBaA4ozQmlmdHkeaG0HZR2gdKKUJodzV5VKO0Kpe9D6UooLQaludDcRywgVf0oGAWjYBSMglEwJAEAhtAHww== 8.120,1.001,0.459,HISTiQAAAGJ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHcZsANGKM0MUwilWXHQMHXsaHwWNBomzonGl4PSulBaEUoLoZkrD6XdofQbKL0CSsuiqUf3zygYBaNgFIyCUTAKgAAAJX4HuQ== 9.121,0.999,0.442,HISTiQAAAGJ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI+hDBY0mhWNhomzodEweSYc5jDjMIcTjTaC0i5QWhVK86Cpk4DSDlD6NZSuh9KSUJoDSjMyjIJRMApGwSgYBaMAAwAAlsoHxQ== 10.120,1.001,0.459,HISTiQAAAGB42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8ZUAETGs0KpZmhNDsazYKmDpd+GM2NQ582lFZDoznR7FeE0iEQilEKyi+E0vxo+mCAkWEUjIJRMApGwSgYBXAAADJXBsI= 11.121,1.000,0.442,HISTiQAAAGh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPegDEYozQyTgNLsaOLMaOpZ0NSzQmkuHPIw8zjRzFOB0jpQWhFK80NpHigtDaVdoPR3KD0dSkug2Q9z5ygYBaNgFIyCUTAKkAAAOxAHuw== 12.121,2.238,1568.670,HISTiQAAAOl42u2aMQ7CMAxFnZaqILEhISQYOAIjJ2Bk40YM7FyAMzBxPCRwhkYqlUpTTPL+8uXEdv6312zO14uIFPLCcStSHnaP2zuU6VyacAF7VMraRyZBXAfnZcBVy71/Z6m8Vl55gUG+17tXviuflBct+sAwcIyAPQP2DNgz/vGNX3wb1OUy3QPzxreF/r+qz+1ddDOvGHWu572L1DdVXcyTPVvS5TrqrMTozEMn8xtHpzUujOtDJ3NMSV/Rk8sv6/+tH77pl6JO/18m/KfTxtbzUvPDfPAdM8//s5t1xGPloWeY+loA+IAnHpcMHQ== 14.359,0.761,0.459,HISTiQAAAGp42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTFZQBhuUZsHBZ4bSHFCaFY2Gms/AjqafFYe5MPP4oLQWlLaB0mJQWhhKc0FpfihtBKX7oHQilBZAswfmLkaGUTAKRsEoGAWjYBTAAQCDmgZz 15.120,1.000,0.442,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcZUAEjGs2GRnOi8VmgNDManxtNnBlNH9Q9DOxQWhBK60FpeTRxDijNC6XDofRpKH0JSguj2c/IMApGwSgYBaNgFIwCDAAAR8IHvQ== 16.120,1.002,0.475,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPehDEY0mhmNZoHS7Gg0CxoNU8+GQx4mzoTGl4PSulBaA0qLQGluKM0Ppb2g9EYofRdKi6Kph9nLgOa/UTAKRsEoGAWjYEQDAEgCB70= 17.122,1.001,0.475,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTE8ZUAEjlGaFKUCj2aA0N5RmgdLsaPIsOPgcaHyYuTZQ2hBKq0BpUSjNCaWFobQvlD4IpVdCaXEozYXmH3R6FIyCUTAKRsEoGNEAAK+GB8k= 18.123,1.001,0.426,HISTiQAAAGJ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8ZsAOoegYWHDQblGZFo7mhNCeU5sKhnx2NlofSZlBaEUqLQmkOKC0EpcOg9H4ovQVKy6G5ZxSMglEwCkbBKBgFWAAAjYoHxQ== 19.124,0.996,0.426,HISTiQAAAGN42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTE9gDCjNBqVZ0GhmKM2KQx2MzwmleaA0OxrNhGYeTL0hlHaC0gY4zOOH0ilQeh2U7oHSMlCai2EUjIJRMApGwSgYBTgBAKssB8c= 20.120,1.003,0.459,HISTiQAAAGh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8ZUAFUHQMjlGZBo1mhNDsOPgeaek4ozQyluaA0N5p+ESitC6W10NTB3CUMpUOh9EYofQFKy6PZw4zmn1EwCkbBKBgFo2AUAAEAiFIHxQ== 21.123,0.997,0.442,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHdhDCjNiMaH0cxQmgNNnAuNzwalWdHMY0ETR1cnAaUdoLQylBZGswfG94bSZ6H0DigtCqV50OwfBaNgFIyCUTAKRgESAAArzge5 22.120,1.000,0.475,HISTiQAAAGh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTO+gDBYozQylWaE0B5o8D5RmQ6PZoTQnmn6YODcanw3NvEQo7QGlZaA0L5r9YlDaHEp3Q+kVaPLo+mCAkWEUjIJRMApGwSgYBQwAU9cH2w== 23.120,1.002,0.442,HISTiQAAAGd42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8ZUAFUHQMLGs0OpdmgNCuaOIzPCaWZ0fSzotFsaPaJQWkdKC0BpXnQaFEoHQulL0DpTVBaBkoLobljFIyCUTAKRsEoGAVIAABnpgfB 24.122,1.001,0.475,HISTiQAAAGh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTM9gDDSahQEVsKGJc0JpdhzizFCaFUrzQGkONH1cUNoISjtDaTUoLYCmng9Ku0Dp+VD6KJQWgtL8DNgBI8MoGAWjYBSMglEwChgAxMAHyw== 25.123,0.997,0.459,HISTiQAAAGt42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8ZsANmKM0CpbmgNCeUZofSrGh8DijNhmYejM+NZh7MfBkobQyllaE0H5q9wlDaD0qfh9KroLQ4mvlQfzMwMoyCUTAKRsEoGAWjAA4AcjYHwQ== 26.120,1.003,0.426,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTE8ZUAEjlGZFo5mhNBuU5oTSLGg0O5o+FjQ+OxoNk1eF0gZQ2gRK86GpF4LSPlB6I5Q+BaVFoTQvwygYBaNgFIyCUTAKcAIArGYHyQ== 27.123,0.997,0.475,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcZUAEzGs0KpVmgNBuaOBcanxNNHQuaPIxmh9KMUFoMSutBaWUoLYLmHgkoHQ2l70DpJWjqOdHMR6dHwSgYBaNgFIyCEQ0ATtIHvQ== 28.120,1.004,0.623,HISTiQAAAG142pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8ZUAEzlGaDKYDSrGjyXFCaHU2eA43PiKaPBc1cmD2SUNoUSqtDaX40+0SgdCCU3g+lT0JpYSjNg2Y/Aw4+uYBa5oyCUTAKRsEoGAUDAgCJQgfF 29.124,0.997,0.459,HISTiQAAAGd42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTM+gDGYozYJGc+CQZ4XS3FCaHUpzouljQ1PPhibPB6UNobQmlDZBM48LSotBaTcovQFKb4fSPGg0DDAyjIJRMApGwSgYBaMADgDKMAfL 30.121,0.999,0.475,HISTiQAAAG542pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8YUAELlGZG48NoqDkMvFCaE0qz46A5oDQblOZCMx+mTgpKG0FpTSgtAKUFobQYlHaC0jCPHIfSslCaD0ozormbkWEUjIJRMApGwSgYBQwAgpgHww== 31.120,1.000,0.475,HISTiQAAAGp42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8YUAEzlGaEKUATZ4PS7FCaBU0dB5RmRaNZ0PSxoYnLQmlrKK0GpfnQzJeG0o5Qei+UvgClJaE0J5q7GdD8NQpGwSgYBaNgFIxoAABYbAe/ 32.120,1.004,0.459,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8ZUAEjlGaB0qxoNNQcBnY0deji6Hx0c2D6mKG0JJRWh9JKUFoQSnNCaSEonQil10HpJ1BaHIc7GBlGwSgYBaNgFIyCUQAHAGMmB8E= 33.124,0.996,0.492,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA+gDEY0mgVKM0NpNhw0K5Rmh9KcUJoDTR07DhomrwSlbaC0Mpo5MPVCUNoPSh+H0mugtCiU5oF5kAE7YGQYBaNgFIyCUTAKRjAAAGPcB78= 34.120,1.003,0.442,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTG+gDGYozYJGw8Q5oDQnlGZDk0cXZ0cT50QzlxVKc0NpHSjtAqWNobQgmj5xKG0NpTdD6RVQWhhK88E8yDAKRsEoGAWjYBSMAgwAACgzB9c= 35.123,0.998,0.475,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPdhDCjNiEazQGkOKM2KRjOj0Rxo5rGjqUc3ByYvC6X1obQulBaG0mxQWhRKu0LpLVD6MpQWgdJcaO5iQPPXKBgFo2AUjIJRMKIBAEwqB70= 36.121,1.003,0.475,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTE8ZUAELGg3Vx8CBJs4NpdmhNCuUZkZTx4qmDibOiWauHJQ2htLqUFoYSnNBaSEoHQylD0DpVWjmwNzHiIMeBaNgFIyCUTAKRjQAAK6eB8k= 37.124,0.998,0.442,HISTiQAAAGp42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8YUAEHlGaB0sxQmg2NZofSrGg0Gxofpo4LzVwONFoBShtCaTUozQulOaG0EJQOgNI7oPRuKC0CpflgHmQYBaNgFIyCUTAKRgEGAACDQAfD 38.122,1.001,0.524,HISTiQAAAGt42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI+hDEYozQKl2dDE2dBomDpWKM2MQ54dSnOgyTOh8SWhtD6UVoPSvGjmSEDpFCj9GUo3Q2lhKM2D5i6YP3ABQvKjYBSMglEwCkbBsAIAi7IHxQ== 39.123,1.001,0.475,HISTiQAAAG542pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTO8YUAELlGaD0pxQmhtK80JpDjR1glCaC0ozo5nHgWYeE5q4LpQOhdLKUFoYSvNAaQko7QylJ0LpZWjqYe5kRPMfOn8UjIJRMApGwSgYkQAAVCcH2w== 40.124,1.000,0.442,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTC+hDEY0mhWN5ofSXFCaDUpzQGl2KM2MQ5wDh7kwcxSgtBmUNobSslBaCEpLQukgKL0FSvdCaREozQmlWRhGwSgYBaNgFIyCUYABAPuGB9E= 41.124,0.996,0.475,HISTiQAAAGd42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI+hDGaYAJRmgdJsUJoDjWZB08eFJs+OJg8TZ8WhThNKG0FpPSjNj0ZLQGlvKL0ISm+D0mJQmhPNP4xo9CgYBaNgFIyCUTCiAQCYogfF 42.120,1.004,0.475,HISTiQAAAGp42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTC9hDCjNCqXZ0PgsOMRhfHYozYEmzwyledDkWdDUKUBpWyhtCqXFoDQXlBaC0m5QeiGU3gmlRdHUwfwFA4wMo2AUjIJRMApGwShgAADzjgfR 43.124,0.996,0.442,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcYUAFUHQMzlGZHE2dCE4fRLDhoDjQ+Nw5xGSitDaVVobQwlGaF0uJQOgVKL4bSu6C0CpQWgNKMDKNgFIyCUTAKRsEowAAAPDAHuw== 44.120,1.004,0.459,HISTiQAAAGN42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8YUAEjDj4rTAManwVKs6PxOdDUM6OpY0WjRaC0NZRWhtICUJobTV0wlL4IpTdAaSUozYVmL7q/RsEoGAWjYBSMghENAFMcB78= 45.124,0.999,0.459,HISTiQAAAGN42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTDcZsANGmAI0mhlNnhVKs0FpFjT1rDhoFjS+GJTWgdKKUJofzXwYPwJK74fSl6G0KpTmQbOHkWEUjIJRMApGwSgYBXAAAN73B7E= 46.123,1.001,0.442,HISTiQAAAGh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMzGxQBlSegQNKs0JpdijNB6W5oDQbGs2Bph5Gs8AsQqNZUNUxhkH5hVBaFs0cJjT75KG0C5S2Q3MHzHxGhlEwCkbBKBgFo2AUYAAAlrEGDQ== 47.124,1.409,1233.125,HISTiQAAAMt42u2asQ3CMBREzzZG0DEABSMwBSU1FdNQ0LMAYzAeEpiCL1kCR8YmeddcfvL/9925zfp0OUvyemC/kcJue7s+S8VjepgldnqHN6xMX8jsCWbezsXEh8SrTJ+tQV2QN/cMuGfAPZMHfvGN33/Q5/DNufhudo5r7A/d6Cav4fOucE+r7+giT3QP19VrjU7yQ2c9nb2w71QXOslxzPr8lxwK5369d2r78M2+En79txNNneOp9eGbvjH7WSZeGP70fa2+uQAA1XAH+BcJvg== 48.533,0.591,0.311,HISTiQAAAFR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMjNegDKg8AxeUZkGjWdFoTijNjqaODY2GqWdEU8eMqo5RHMpPRnMHTN8oGAWjYBSMglEwCqgIAEz/Bas= 49.124,1.000,0.442,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTH+hDHYozQGlWaA0M5RmhdJsaDQ7Gp8Djc+Iwzw09YzcUH41lJZBs5cXzXxlKO0DpdOgNDeau6D+HgWjYBSMglEwCkYBMgAA774G+g== 50.124,1.000,0.442,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTLcZUAETGp8ZSjNCaRYozYomz46mH5c+dhzmy0JpbSitBqX5oTQHlOaD0n5QeibUGph75ND0oftnFIyCUTAKRsEoGAVAAADL1Aa2 51.124,1.000,0.442,HISTiQAAAGN42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHcZsANWKM2CxofR7FCaEYc6qH0MbGg0TJwTzRwY3xJKi0FpPijNgcaPhdIbofQjKK0EpbnQ3DcKRsEoGAWjYBSMAiQAACOuB7k= 52.124,1.000,0.475,HISTiQAAAGd42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8YUAFUHQMrlGZD46PTHFCaB0ozo+lDp5nQ1PFDaVEobYDGh5nLAqUFoXQalJ4DpZ9DaXEozYlmDyMaPQpGwSgYBaNgFIxoAAB6gAfD 53.124,0.999,0.442,HISTiQAAAF542pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTO+gDHY0mhNK8+AQZ0UTZ8GhjhOH+TD9vFDaEUp7QGllKM2BZr4Mmrq5UHohmnkwfcwMo2AUjIJRMApGwSjAAABYjwfb 54.123,1.001,0.442,HISTiQAAAGt42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTJ+gDGYozQuluaE0B5RmgdJcUJodSvOgibOg0cxo6tnRxIWgtCuUjoTS0lCaD0pzoqk3h9IdUHorlBZHczcjwygYBaNgFIyCUTAKMAAAl8cH4w== 55.124,0.999,0.442,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI+gDEYozQylWaA0K5o41BwGNjRxbjQ+Kw5z0M3jhdJqUNocSkui0TB1IlDaD0pvhdLHobQglOZC89coGAWjYBSMglEwCpAAAH2wB8M= 56.123,1.001,0.442,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTB9hDCjNCaU5oDQXDj4blObFoY4VBw2TZ4fSQlDaF0qbQGllKM2P5i5JKO0KpSdA6eVo5sHUMzKMglEwCkbBKBgFowADAACIDQfh 57.124,0.999,0.459,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTA8YUAEblGaE0swwhVCaA0qzQGl2KM2Kpg5dPTsazYKmThFKm0JpFSjNi2aOIJQOhdLLofQlKC2Npo4RjR4Fo2AUjIJRMApGARAAAFlsB78= 58.123,1.000,0.442,HISTiQAAAGB42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHcZsAMmHDQLlGaE0hxQmg1Ks6PxWXHoZ0FTJwWlTaC0OpTmQzMHZl8glF4OpX+jqRdAc+coGAWjYBSMglEwCpAAACNmB7k= 59.123,1.001,0.442,HISTiQAAAF942pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTE9gDCjNgkZzoMmzQml2NHVsaHxmKM2Ipp4Zhz5dKO2KxudDs18QSjtD6alQ+gGUFsOhbxSMglEwCkbBKBgFSAAAnxwHxw== 60.124,0.999,0.492,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTLcZUAEjGs0GpVnQ+MxoNEyeFUqzo5nDiaafDU2dBJRWhdLSUJoDTT8flPaB0rOh9A8orQSlZXD4Cxd/FIyCUTAKRsEoGFEAAAFqB7U= 61.123,0.999,0.442,HISTiQAAAGB42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTDcYUAFUHQMjGh+XODMazQKl2QioY0VTLwqlDaG0MJTmRzNPEEqHQeldUPoLlJaF0lxo9o2CUTAKRsEoGAWjAAkAAMvVB68= 62.122,1.000,18.481,HISTiQAAAIp42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTI8ZsAMmHDQrlOaC0mxQmhlKc6Cpg9EsaOpg4pxQWgpKW0FpSSgthKZOFEo7Q2mYR95CaQEozYPDP4wMo2Akg9H4H43nUTAaz6NgNF5G/Tvq71H/Di5/jto76u9Rewev/YxDPBxGwSgYBUgAAP6WB8U= 63.122,1.001,0.459,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTM8ZUAErTAJKs0Fpdhx8VjQ+TB8LGp8Vhz6YeQlQ2hxKS0BpHijNBaX5obQ7lF4GpbdBaRk0cxnR6FEwCkbBKBgFo2AUAAEA1joHzQ== 64.123,1.000,0.442,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPehDEaYAAMqYEGTZ4fSHGjqOdDUw2hWND4zGs0GpWWhtBEaXwBK80FpISgdA6VXQ+mLaPp40OwdBaNgFIyCUTAKRgESAABF0ge9 65.123,0.999,0.442,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcYUAEjlGaB0swE+Gxo4mxo8qxofA40cRgtC6UtoLQ8lOaF0lxQmhtKu0PpxVD6C5SWhNL8aP4ZBaNgFIyCUTAKRgESAAA10Ae7 66.122,1.001,0.459,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTM+hDFYozYxGw8TZoDQHmjg3mjyMZoTSLGjqYXx2NPNUoLQrlNaA0nxQmhNKC0Fpfyi9BErvgdLiaPoY0ehRMApGwSgYBaNgFAABANPaB80= 67.123,0.999,0.442,HISTiQAAAGF42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPdhDDSaHUqzoPFZoTQnlGaD0hw4zGFG04euHsaXg9KaUJoPSvOgqReF0hFQej2UfoBmDrp7RsEoGAWjYBSMglGABABLoge9 68.122,1.001,0.475,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHcZsANGNBqqn4ENSrNCaWY0cRYCfG4ozQGl2aG0IJTWgdJiaPKcUJoPSsdC6R1Q+g2UlkWzDx0wMYyCUTAKRsEoGAWjgAEAIHYHuQ== 69.123,0.999,0.459,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTLcYiAOMUJoNSjOj8dnQ1LNCaXYozYmmjwVKc0BpAShtC6WFoDQ3mnoYPwFK74LSd6C0LJQWhHkQzf2jYBSMglEwCkbBKAACAO+JB7M= 70.122,1.001,0.442,HISTiQAAAGN42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTDcZsANGKM0CpZnRaFY0PhManw1NnAnNPFY0cUUobQSleaA0N5p7OKG0PZTuhkrbQvnSUFoEzfxRMApGwSgYBaNgFCABAKc4BrI= 71.123,0.999,0.426,HISTiQAAAFh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTHehDBaYAAGaBQfNjEazofFZcfBhtDqUtofSEmjmwOwXgdKBULofQjGiy8PoUTAKRsEoGAWjYBRgAQDzCAa6 72.122,1.001,0.442,HISTiQAAAF142pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTNcZsANGHHwWKM2MRrPgoJnQaBYc+vigtAaUFoDSgmjqeKB0IpReBHWeDJQPo3lx+GMUjIJRMApGwSgYBUAAAIOkBq4= 73.123,1.001,0.475,HISTiQAAAGB42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTNcYsAOoegZGND4LGp8BTR0zGs2Kph6XuSJQ2hBKC0FpPjRzeKC0D5RuhhpnD+XLoulnweHOUTAKRsEoGAWjYEQDAHGaBqw= 74.124,0.999,0.442,HISTiQAAAGJ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTLcYsANGKM0MU4hGs0BpVjQ+G5o6mH52NHlWNHl5KG0JpYWgNBeaOhg/HErPgtJ/obQMmn4OhlEwCkbBKBgFo2AUYAAA7wEHsw== 75.123,1.000,0.459,HISTiQAAAGh42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTLehDGaYAJRmZEAFTGjq0NXDaBY0GqaOC0rzoIlzQGk1KK0DpQWgNBuUZkfTHwylm6HOlYPypdH0M6K5bxSMglEwCkbBKBgFQAAAzUwGtg== 76.123,1.000,0.475,HISTiQAAAGR42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTDcZUAFUHQMjGp8FBw1Tx4YmzoYmz4zDPJi8GJQ2htLCUFoQzTwRKO0BpeugxuhC+bJQWgjNPgY0+0bBKBgFo2AUjIIRDQCpiAay 77.123,1.001,0.459,HISTiQAAAGZ42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPcZsAOoegZmNBpdnBVKc0FpFjR5DjR9LGg0TFwbSptCaRkoLYBmviCUDobSG6D0BSitAKW50cxnZBgFo2AUjIJRMApGARwAAET6B70= 78.124,0.999,0.475,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTFcZsANGNBqqn4EFSrOh8WHqWNHUw2hmHPIwfZxQWgdK80FpDjSaF0p7Q+lpUGPsoXxRKC2Mw32MDKNgFIyCUTAKRsEoYAAAYlAGqg== 79.123,0.999,0.459,HISTiQAAAGV42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTPdgDCjNAqUZ0WiYPDOUZkMTZ8VhDisOdTB5TiitB6U9obQIlOZC0ycApV2gdC/UmTB3SqPpY0bzxygYBaNgFIyCUTAKgAAABCkGvA== 80.122,1.001,0.459,HISTiQAAAGN42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTNcY8ANGKM2Mxoeax8ACpVlxqGNDE0enYeaIQ2lVKC2Aph9Gc0DpWCg9HWqdDpQvCaVF0cxnZBgFo2AUjIJRMApGARwAAHIqBqw= 81.123,0.999,0.557,HISTiQAAAGl42pNpmdzBwMDAxAAGfgoMDMxuBjsWQLgMTFcZiANQ/QxsUJoRSrNAaWY0PjsaH109K5q5glBaHUrzQ2leNPUcUNobSndDjXeG8sWhtDCafQxo7iAEiFU3CkbBKBgFo2AUDEkAAGNwBqo= HdrHistogram_c-0.11.8/test/jHiccup-2.0.6.logV1.hlog000066400000000000000000000302671442262567300213700ustar00rootroot00000000000000#[Logged with jHiccup version 2.0.6] #[Histogram log format version 1.1] #[StartTime: 1438867590.285 (seconds since epoch), Thu Aug 06 06:26:30 PDT 2015] "StartTimestamp","Interval_Length","Interval_Max","Interval_Compressed_Histogram" 0.133,1.005,2.802,HISTIgAAAFd42pNpmazIwMAYxgABTBDKT4GBgdnNYMcCBvsPUBkeBkYGZqA8MwMbAzsDC5DFBCTZgJCDQY1BjkGLQZRBlUEPCB8zWDCYMxgDZZkZhgJgHDibAY8JB/A= 1.138,0.998,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDDDACMQsQJKRgYOBlYEZCFmAkB3IB/HkGJQYJBi4gXIyDPGMTAxzGKQZ2EC6AJ7YBtg= 2.136,1.001,0.475,HISTIgAAAEt42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDDDACIfMYMjCwArEzEA9TEBSgkGJQZCBn4GLQYDBh+ESw2cGYSBkYWAEAKZvB9Q= 3.137,1.001,0.492,HISTIgAAAE542pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPUBlGsCwTkGYFYg4GFgZmIIsFDNmBcrIMGgz8DDxAMTGGNIZHDPsZpIFskHlMALndB9o= 4.138,0.999,0.492,HISTIgAAAE142pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPUBkWBjY4BpGsQMwOFGcG6mEBQl8GOwZRBj6gGBtDBMMOhpUMUgxcQDkmBkYAwSAH4w== 5.137,1.003,0.459,HISTIgAAAEx42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPcBmQHBuYZmZgZWABYnYgZmNgBLI5GXQYrBj4wSKiDB4MexgeMwgw8DKwAgCbcgfb 6.140,0.998,0.492,HISTIgAAAE542pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDMiAGaiClYGRgR3MYmdgA5JsQDYLgxKDBgM/kGYBkq4MFxg+MEgyCAFVAs0EALiCB9c= 7.138,1.001,0.475,HISTIgAAAE942pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDDDACMQsDMxAyAaE7ECaFcxnAdLMDMoMagxCDBxAcTGGIIZbDBcZRBm4geYxAQCqKAfZ 8.139,0.997,0.459,HISTIgAAAFB42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDDDACMTMQBXsDCxANguQzcLABoQsQMjKIMegzsADFGNmkGBIYGRmWMIgw8DLwAQAj9EG1Q== 9.136,1.004,0.475,HISTIgAAAEx42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDMiACYyZGRiBEESzACEzkMXCoMmgzCDAwM/AysDH4MXwhOE5gwiDIFA1IwCmuAfX 10.140,0.996,0.459,HISTIgAAAE142pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPUBk2IGYBQiYGZgZWIGQBk0wM7AyMQDYbgy6DOQMHAzeQJcTgzHAFCMWBfGYAm8UH2A== 11.136,1.233,1035.993,HISTIgAAAJx42pNpmazIwMD5jgECmCCUnwIDA7ObwY4FDPYfGFABRAUjGDNCWcxgzMnAChZjYeBn0GbQY2ADsoYCYBy1eRCYyjiA/mGkqnpGiuxiHBI2MxLQy0g12cFiMyNJNP1V0d5MRhTMiCGCC1Nb5cDYjB0y4ZShvUr6msgEhsxQGhUyU1lsIHXjMpEFClmxsLCLks4aHOawMDACAO56ClU= 12.369,0.771,0.459,HISTIgAAAEx42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPSDJMDCxAyMTADMSMQMwGJFmBIiC2NIM8gxADO1BMjMGdYT5DL4M4Ax8DEwCR7Acv 13.140,0.996,0.459,HISTIgAAAEp42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDAjACJRnYmBmYAHTrEAWI5hkAdKSDKoMXEDIxiDI4MlwnJGDQQLIYgIAjsYG0A== 14.136,1.001,0.459,HISTIgAAAE142pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDAjAyMACxMxAVSxAyAqk2YAYJMLAIMmgwSDIwAkUFWXwYzjL8JNBnEGAgREAlsUH1A== 15.137,1.002,0.459,HISTIgAAAEx42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPcBlGBmYGViCEkExAmomBBYp5GYwYdBkkGfgY2BiEGFwZLjJcYBBm4GJgBACcBQfc 16.139,0.998,0.475,HISTIgAAAEt42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDMiAEQiZGViBkAUIWcE62IEsZgYpBm0GHiCbk0GQwYfhAcMjBjEgC6geAKdjB9Q= 17.137,1.003,0.475,HISTIgAAAEl42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDMiACQxZGRgZ2ME0M5BkBrNUGLQZBICizAzcDL4M1xneMEgz8AFlGAGnqwfY 18.140,0.998,0.442,HISTIgAAAE142pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPDAxIcswMjAwsYMjAwAaErEBRFqAYI4MDgzKDKAMfgziDHIM5w0WGkwxiDLwAiiQH1Q== 19.138,1.000,0.459,HISTIgAAAE542pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDAjABITMDIwMXECanYGVgYWBDcxiBpKKDCoMQgzcQBEBBh+GjwynGCQZOBiYAJl6B9c= 20.138,1.002,0.557,HISTIgAAAFF42pNpmazIwMDgwgABTBDKT4GBgdnNYMcCBvsPUBlWBhagLAiyACEzWC0jkMUBxIwMbAyaDJYMfAzsQB4/gxvDM4ZTDNIMPEAZBGAEAP1VB+Y= 21.140,0.998,0.459,HISTIgAAAEt42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDDDACIRAYTBkY2AFqmVjYAFiBiCbmUGQQROIuYGiggwejLwMuxhkgCxGAI58BtQ= 22.138,1.000,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDDDACJRlZGBlYIaqYmdgA0IWoBgjUEyGQZlBCMhnYhBlCGOUYFjLIMnACdIBAJ0WBtg= 23.138,0.998,0.492,HISTIgAAAEx42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDDDADJYFkSxADKLZgJgJyldmUGEQYOBhYGXgYwhlZGTYxyDMwM/ACNTBCACrbwbX 24.136,1.003,0.573,HISTIgAAAE942pNpmazIwMDgxgABTBDKT4GBgdnNYMcCBvsPDDDACITMQBXMDBxAkgUIQWxmMIuFQYFBkYGPgQ0oJsUQwsjMsJ1BkkEAZh7MBAD0rQbn 25.139,1.000,0.459,HISTIgAAAEx42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDDDACCbZGFiBkAOokpGBBchiY2AGQxkGTQZBoAgbAy+DKyM7wykgT4CBEQCPpwbX 26.139,0.997,0.475,HISTIgAAAEx42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPUBlGIGQFyjMDSVYGFjBkgoqyALEigzqDMAMnAy+DGIMfoyTDNAYhBh6QCgCfhQbZ 27.136,1.004,0.442,HISTIgAAAEp42pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPDDDAyMAMxixQdSxANgMDGxAyA6EigyoDJwM3AzsDH4M3w3eGGwyyDDwAhpMH1A== 28.140,0.996,0.459,HISTIgAAAEt42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPUBkWoBwIMgNZ7ECaHcxiYWAEk1wMBgxmDGIM3EC+IIMLw2eGTQz8QFEmAJxuB9k= 29.136,1.000,0.492,HISTIgAAAEp42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDKiAEQhZGNiAmBkIGRlYwXwWBmEGZQZ+MEuQIYWRi2EbgwoDB1AOqAMAqa0G1w== 30.136,1.003,0.459,HISTIgAAAE542pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDDDACIQgwMzAxsAChKxAmhlIMwJZzAxSDEoMvAzsQCjE4MPwnuE+gwQDPwMjAJclB9Y= 31.139,0.998,0.459,HISTIgAAAFF42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPUBkuBmagLBMDCwMbkGRkYAVCFiBmAGJmBj4GRQZdBlmgKjYg6cDwk2E+gwQDDwMzAJzYB9s= 32.137,0.999,0.459,HISTIgAAAEp42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPSDKMYMzCwM7AysAMFGEC0iAWCwM3gwyDBgM/mCfIEMfIzrAeSPMzMAIAj9AG1g== 33.136,1.004,0.459,HISTIgAAAE142pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDDDACJbnAGJWMGRiYAZCJgYWIGRmkGNQZRAAyjIzcDKEMrIy7GGQYRBkYAQAj3YG2g== 34.140,0.999,0.442,HISTIgAAAEl42pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPDDDACITMQMwGh6wMLEDIBBRjZZBiUGLgYeAAsngZ3BleMTxmkGHgBQCIIAfT 35.139,1.001,0.459,HISTIgAAAE142pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPcBkWIGZiYAZCCJuZgY2BFYhZgCQXgwmDNgM/AzuQJ8bgzHCX4TyDCAM3AyMAm0EH2g== 36.140,0.996,0.459,HISTIgAAAEp42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDMiAkYEFjNmAKpmhkBUImRjEGOQZ+BnYGTgYJBhCGD4zXGMQZeBhYAQAlpQH0Q== 37.136,1.004,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPUBlGIGRgYAWqYGZgA5IsQJoFzAPxmRkUGYwZhIAsVgYZBmeG3wwHGCQYOEC6AKnrB9w= 38.140,0.996,0.492,HISTIgAAAE542pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDAjAyMAMhEwM7EDMCoZsQDEOoBgLgzyDIgMPkM/KIMJgxfCI4SODOAMv2DxGALigB9c= 39.136,1.000,0.459,HISTIgAAAEt42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDAjAysAIVMECpFmANBsDB5AG8ZiAWI5BhUEKLCbBEMzIyTCPQYyBl4EJAJEUBtg= 40.136,1.000,0.492,HISTIgAAAE942pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPUBkWIGYGQkYgZgGqY2JgB9LMYMgGhIYMDgyyDBwMrAz8DCEMzxlmMkgDWSDACAC9Gwfg 41.136,1.002,0.492,HISTIgAAAE542pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPcBkWIMkMJFmBkJmBF4hBLBYGTqAcO4Migw+DAAMHUFSMwYjhHMNNII8frJMRAL4nB+I= 42.138,0.998,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDAjAyMAMxKxAyMTAAmSzAVnMQMgC5EszaDFwMXAAefwMngyvGZ4wiDIIgPQAAKfOB9U= 43.136,1.002,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDAxIciwMzAxsQAgimYA8RiDJAeSxMygwKDEIMHAC2YIMvgwvGC4zSDHwA+UZAalrB9o= 44.138,1.002,0.492,HISTIgAAAEx42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDAjACMTMQMgKhCCaBcxiYmADyigyKDFwM7AzcDGIMzgzCjBsBdICQFmgLgCrjQbb 45.140,0.996,0.459,HISTIgAAAEt42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPUBkWBkYwZGFgBaoCYTYgyQ7EbEAxNgZjBiMGfjBfjMGB4QPDLgYhII8JAJv1B9g= 46.136,1.003,0.492,HISTIgAAAFF42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPcBlGIGZhYGVgBtLsDBxAmh3MYwHKsDMYMOgySDBwAfmiQNOOMDxiEGIQBsowMDACALywB+E= 47.139,1.001,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDMiAkYGZgQWImYCYmYEViBmBJBNQTJxBg0GEgZOBjYGPIYjhGsNroIgwUIYRAKbXB9Y= 48.140,1.000,0.442,HISTIgAAAEt42pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPDAjAxMDIwAzG7AysDFxAkpmBBUwyMtgwGDIIM/AycDCIMpgz3GI4CaR5AItmB9k= 49.140,1.000,0.459,HISTIgAAAE142pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDMiAiYERCNkZmIGQlYENyGdmYAGKszCIMcgwcAMhFwM/QzjDK4anQBF+BkYAli4H0w== 50.140,2.452,1895.825,HISTIgAAAKx42pNpmazIwMB1hAECmCCUnwIDA7ObwY4FDPYfGGCAEYiZwWoYgZgZzGcCQwYGVgZhBhEGbgZ2BjYgW4+hjqGcgR/IYgSrohxQx5RRm+lpM+OA6aaXzYwDJDtQNjPiVUmKLC1V08pmRqJoRhqoHhw2E8aMA6aS9jYThkxEqSJe3eAykQkJMqPwSBMbSN2UmMjKwAKHrFRhDS1zOBk4gJATijmw8ge5GgDvng6P 52.592,0.546,0.442,HISTIgAAAEl42pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPUBlmoBwLEDMBWcxgkhEqxgpksTNIMQgxcDGwAfl8DDIM1Qy5DLwMrAB+SwaO 53.138,1.002,0.475,HISTIgAAAE142pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPcBlGBmYgZGRgAWImIMkMFmEDslgYOBnMGEwYJBjYGbgZeBkSGG4xrAXzgGoAq7YH3Q== 54.140,1.000,0.524,HISTIgAAAE942pNpmazIwMDgwAABTBDKT4GBgdnNYMcCBvsPDAjACIQgNWxAzMLACsTMQMwEZDEzKDLIMwgycANZ4gz+DI8Y7jBIM/AA5RghOgHYtgfd 55.140,0.996,0.475,HISTIgAAAEh42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDMiAGaiCBQwZwZgZCNnAumQY1Bh4gDwWBkEGZ4bLjMwMkgxCQBlGAJ0MBtI= 56.136,1.000,0.492,HISTIgAAAE942pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPUBkWoBwjEINIZgZWMIuVgQOIWRnYgLKaDPYMXGBRDgYvhhsMVxhkGASB+hgZGAG66gfd 57.136,1.003,0.492,HISTIgAAAFF42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDDDACIQMDCxAkomBFUizMLAxMANFmIF8NgZFBnUGYQYuoCgfgzfDR4brQB4/2DwmALhmB9s= 58.139,0.997,0.475,HISTIgAAAEt42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPUBlGqDwjAwsQsgFpNgZmKASJyDMoMAgx8AJV8DA4M9xheMsgziAClGMEAKc6B9M= 59.136,1.003,0.492,HISTIgAAAE542pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDAjACITMUMjIwAJUzczACsYsDHIMqgz8DNwM7AyCDN4MVxneM8gz8ABVAXUBALeqB9s= 60.139,0.999,0.459,HISTIgAAAE542pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPUBlmoBwLAyOQBrFAkBmMGYFyrAxcDGYMOgwiDAJANbwMrgznGB4ziDJwMjACAJn0B9c= 61.138,1.001,0.492,HISTIgAAAE942pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDDDACJRlYmBmYGVgY2AB8piBkAuIWYCiLAySDM4MQmAZMQZ/hg8MuxhEGHgg+gC7NQfe 62.139,0.999,0.475,HISTIgAAAEt42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDAgAkmUHklwMrAwsQMwMZINYTEAozaDEIAxkMzPIMKQy8jDMA/J4geKMAJ7UBto= 63.138,1.001,13.959,HISTIgAAAGJ42pNpmazIwMC8igECmCCUnwJQzM1gxwIG+w8MDHA5ZiBmZeBgYASS7AwsYD6IzQakVRjUGEQZuICyYgw2DDcY7gLZwkAVIMDIMNQA46jNA2YW45CwmZEikxhpJwsAR+UIUA== 64.139,0.997,0.492,HISTIgAAAE942pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDMiAhYGNgRUIWRiYGdiBmAUI2cGitgx6DJJAmp2BhyGU4SrDbgYBBg6gCkYGRgC9Qwfe 65.136,1.002,0.459,HISTIgAAAE142pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPcBkWBmYGNgZWMGQB8kFsJgZ2BkYg5mXQYNBnEGbgArL5GNwYXjAcANJ8DIwAnS0H3g== 66.138,0.998,0.459,HISTIgAAAEt42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDAjACIasDOxAkgWoloWBGQiZwGwFBjUGHgYOoBw3gx/DBYbfDMIMQgzMAJalB9I= 67.136,1.002,0.492,HISTIgAAAFF42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDDDAApRlYeBgYAOymYEkKxAyglnsQBjLYMEgwMDNwAkk7RiOMexi4GfgAsozMDACAMCHB+Y= 68.138,1.002,0.459,HISTIgAAAEp42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDDDAzMAKVgGiWYAQRHIAITOYJ89gySDMwAMUFWJwYtjD8JJBioGPgRkAmrYH2w== 69.140,1.212,763.363,HISTIgAAAKR42pNpmazIwMCZwwABTBDKT4GBgdnNYMcCBvsPDMiAEQiZgJgFiFnBqpmg+vgY+IEizGBxFYZshjQGbgZ2II8WgDamjtpMG5sZB8xu2tvMSJE87WRpYzYjSXxqqh4cNjOi0IxYRXHR9FdFfTMZoSQhTJyqgVVJqnnEQSYqq6OFSvJMZEKBzGh8XGLEq6SPieTrZgG2a1igED+LeJXYWYwAsfYJeg== 70.352,0.784,0.475,HISTIgAAAFJ42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPUBkuBm4GTgYWBl4gZmFgY+AAqmUEYhYGdiDNw2DGYAMk+YGQl0GLoZ6hDUizAfUxAgCtOgdN 71.136,1.001,0.492,HISTIgAAAEt42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDAjACMaMDKxAzMzADibZgCQLUESFQQ1I8gBFuBhCGLYzCjMIMYiAVTMBAKvBBtk= 72.137,1.003,0.475,HISTIgAAAEt42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDAjAyMAMxEApBhagSiYgyQjEELYsgzoDLwM7kMfFEMBwlpGLQYaBB6QHAJ0DBtc= 73.140,0.996,0.475,HISTIgAAAE942pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDDDACMTMQJKJgR1IsgLZIB4zAwsQszKIMWgyiANpVgZehgiGMwz3GeQZRIEyTACm5QfS 74.136,1.004,0.459,HISTIgAAAEx42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDAjACJZnZmBlYAFCJiBmBLKZgSQLgyiDJgM3AzsQ8jEkMjxkeAYU4WdgAgCWiAfX 75.140,0.997,0.492,HISTIgAAAEx42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDDDACJZnBkIWMIsNiFmBoiARJgZJBmUGYSCfnYGXoYCRiWEngwiQDdLDCACq1wbX 76.137,1.000,0.442,HISTIgAAAE142pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPDDDACJZnYmBmYANiJiCfmYEFCFmBLE4GeQYFBn4gzcIgxuDNcIzhB4M0gwgAho8H0g== 77.137,1.003,0.459,HISTIgAAAE942pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPDMiAkYGZgRWoioWBE8hiZmADirABeawMUgxaDHwMHECeAIMfw2WGrwwiDFwMzACYHQfY 78.140,1.000,0.459,HISTIgAAAFB42pNpmazIwMBgwQABTBDKT4GBgdnNYMcCBvsPUBlmIGYEyjMDISsDCwMbkAbx2IBsRgYOBj8GDwZJBnYgX4TBlmEdw2kGUQZ+BkYAnacH3g== 79.140,0.998,0.475,HISTIgAAAE142pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDAjACJRnApLsDMxgkoGBBchiA2JmBhEGHQZBoBgbAz+DL8Npht8M4gwCINUApvkH1A== 80.138,1.002,0.508,HISTIgAAAE542pNpmazIwMBgxwABTBDKT4GBgdnNYMcCBvsPDDDACIQsDMxAzMTACqSZgBgE2RjYgaQUgxaDIFhMnCGY4Q7DXQYJBn4gD6wTAMlCB90= 81.140,0.997,0.557,HISTIgAAAFB42pNpmazIwMDgwgABTBDKT4GBgdnNYMcCBvsPUBlWoBwjAzOQZAFCZiCbhYENyGOFimkz2DPwM/AB+dwMTgzHGJ4zCDDwgNXBACMA/WwH4w== 82.137,0.999,0.475,HISTIgAAAE542pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDDDACMZMQMjCwArEzAxsDJxgEWYgKc+gzsDHwA0UF2AIYrjK8IJBnIEfKMcIAKfXB9Y= 83.136,1.003,0.475,HISTIgAAAEx42pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPDAxwOUYgycrADIQscMwGFAexpBgUGbgZuBg4GAQZYhluMTxhEGYQAupgBACn3gfZ 84.139,1.001,0.492,HISTIgAAAEx42pNpmazIwMBgwwABTBDKT4GBgdnNYMcCBvsPDDDACIWsDMwMbGCVzGAeA5DHzCDBoMsgzMAB5MszeDI8ZLjCIMfAC1bBCAC31AfZ 85.140,0.996,0.442,HISTIgAAAEt42pNpmazIwMBgxgABTBDKT4GBgdnNYMcCBvsPUBl2IGQByrMCSTYGDiBkBfNYwSK8DG0M7gzCDJxAOX4GC4ZFDLMZRBg4AZVqB+U= 86.136,1.001,0.557,HISTIgAAAFF42pNpmazIwMDgwgABTBDKT4GBgdnNYMcCBvsPDAjACISsDCxAVSCSDUiD2MxAUTYGcQZNBiEgn5VBgiGU4Q7DYwYxBm6gDAMYg3UDAPppB+I= 87.137,0.999,0.541,HISTIgAAAE142pNpmazIwMDgxAABTBDKT4GBgdnNYMcCBvsPDAjACITMQDUsQJIVTLIAaRDJwiDMoAnEnAwcDCIMVgxXGP4ySDHwwMwD6QUA6PAH3Q== 88.136,1.002,0.475,HISTIgAAAE142pNpmazIwMBgxQABTBDKT4GBgdnNYMcCBvsPUBlGIGQCYxYGVgZ2IMkGxIwMzEAaREowaDLwM3AAebYM6ozdDE4MIkBVQF0An+EG3w== HdrHistogram_c-0.11.8/test/jHiccup-2.0.7S.logV2.hlog000066400000000000000000000174741442262567300215220ustar00rootroot00000000000000#[Logged with jHiccup version 2.0.7-SNAPSHOT] #[Histogram log format version 1.2] #[StartTime: 1441812279.474 (seconds since epoch), Wed Sep 09 08:24:39 PDT 2015] "StartTimestamp","Interval_Length","Interval_Max","Interval_Compressed_Histogram" 0.127,1.007,2.769,HISTFAAAAEV42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEBEJISEuATEZMQ4uASkhIR4nrxg9v2lMaxhvMekILGZkKmcCAEf2CsI= 1.134,0.999,0.442,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWLj45FTExAT4pBSEBKa6UkAgBi1uM7xjfMMlwMDABAC0CCjM= 2.133,1.001,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBE+Ph4OLgk5OSkeIS4+LgEeswIDo1+MbmdYNASYAA51CSo= 3.134,1.001,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBExPiEpITEFGTkRKSEeOR6FkCg1hTeMXvNYlHhYABQ5CTo= 4.135,0.997,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBE2PiERBREpBREhER4+Hj4uvQAdrTlMBldYDDhYAAugCKk= 5.132,1.002,0.426,HISTFAAAAEF42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBEWPhElOR4pARUpKTkpGQkxq2mMegZnGI0+MZuIcAEAHo8Jvw== 6.134,0.999,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWIS4FITEhDiEJERE+GT6ZkhZGLbl7jEqrWHREmFgAIbAJMw== 7.133,0.999,0.459,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNEhEtMQEBBTk5MQERCRkBEQEWlh9FJbg9jE+MS5ig1LhYmADkkCcE= 8.132,1.000,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWIREgEOIQEuGT4xHg41Oo0pIqu8LYwVImwMfGBAAfkgkw 9.132,1.751,1551.892,HISTFAAAAJZ42pNpmSzMwMB0nQECmCCUnwIDA7ObwY4FDPYfYDJMXFxsbGwMbBwszDwsDDxsHFw6RWJMLJMZmcqBMJrJmskSiA2ZZJmkgRBCgmheIORGI1H5rEzMQAyDzFhY2EWRWUwMWCBxQtQQhAIWJiyAaEHyFbKwsLHAADYWAWmiFeKS5gACLsIEzdQICAgBIQShEfhFABXDF+M= 10.883,0.250,0.426,HISTFAAAAD142pNpmSzMwMAgxQABTBDKT4GBgdnNYMcCBvsPEBEeFi4mPg4WLhY2BjY2FhYOBSkpASEtoRA+NgDkCQZR 11.133,1.003,0.524,HISTFAAAAER42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPUBk2HgkZKREpEQUeGSEBAQ6xSYxhCnp7GJ02sWgJsbCwMgEAO0AJSQ== 12.136,0.997,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBk2AT4eCQURHgkuEREOHjERlSQhhWuMSV9Y7ERYWAAa4gko 13.133,0.998,0.459,HISTFAAAAD942pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBkRIR4RMRk5KQE+PgEhMRmzEjWZJ4whW1hMBNiYAB42CTA= 14.131,1.000,0.492,HISTFAAAAEN42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPUBkWFhE5GT4FKQkRCR4ZCREpqwmMBhpHGG16WHx42JgYmAA6swk+ 15.131,1.001,0.442,HISTFAAAAD542pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPMBkuMTEFHgklFRkRATkJERGdKgudfYwRTSwGalwAF2IJOw== 16.132,1.001,0.524,HISTFAAAAEZ42pNpmSzMwMCgxAABTBDKT4GBgdnNYMcCBvsPEBE2IQEFCQkpGREpHj4hKS6NU4z7GDMkuBoYDSYw2wiwMLEyAQBQ3wne 17.133,0.998,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBk2DjElIR4RHiExKQE5IT61iCodtXWMdn0sKVJMTAAekAk0 18.131,1.000,0.459,HISTFAAAAEF42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPUBkWISERJSUJESklHhEJEREhqwZGLakPjDZdLBYCHCwAKOkJPg== 19.131,1.000,0.475,HISTFAAAAEF42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPUAk2HjkJBSk+Pi4BMT4xIQE9pxIluTOMPhtYbITY2JgAKLoJOQ== 20.131,1.004,0.475,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBFmPhEJOSEhDi4+ETEeASEhswIVi1+MFjtYvCRYGJgAIP8JNw== 21.135,0.999,0.492,HISTFAAAAEB42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNMhk1AjINDRECAj4+Hi49LKS5CS2EGo1kXa4ANExMDEwAmOQil 22.134,0.997,0.459,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBFmHhE+MRExCTEZAS4RMQERvRI1hSuMTidY3KQ4mAAXhgks 23.131,1.004,0.508,HISTFAAAAEB42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNMhotHSEBASEyMg09MQUSIT6tKS2YKY8gfFj8tJmYmJgAsowkz 24.135,0.998,0.492,HISTFAAAAEJ42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBEBLjkhETEpET4BISEhCR6FsqAQFY1jjBoTWPQEOJiZAC2aCUY= 25.133,1.002,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBkuHh4BITEpMSEpLiE5AS6FoAgdpQuMJk9YzMRYmAAdngk2 26.135,0.998,0.508,HISTFAAAAER42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPUAkOKSEJKTUJOT4+IQkeIT69LYwVCnIbGI0eMZtJsTAxMwEAQvkJyg== 27.133,0.998,0.442,HISTFAAAAEN42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBE2CQUZFTkZOSURKQkRMT6NKYwhbYxaOocY/a4xSUmwAQA4pQpb 28.131,1.002,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBGtFDcHIy0jDQUdPjENFZUzjNNYHCT4uBQkzJiYADIGCcY= 29.133,1.460,968.884,HISTFAAAAJZ42pNpmSzMwMDUwgABTBDKT4GBgdnNYMcCBvsPEBE5AwMDJSUFISk2ETYuAS6PQ0xSXCzsTEw7GZnKgdCTyZLJGog1maSZZIFYGkpLMnEz8QIhOolgcTKxAiEzmGRFYxMShbEYUCAalzRBsjSjARYmTIBNjDKFSIIsIMDGAgPYWJRJE1DIxQEEaAQHF2GCNDVsAE2dFJE= 30.593,0.541,0.459,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBEFCxUNBRkFMTE+Pj4ZHgGHFYwGIkJcMiIpbEwMTAAdQQhJ 31.134,0.997,0.737,HISTFAAAAER42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEJGAHsYexqKaIAcPPRMVKTEhoR6mJUxqfBx8LFwCTOxM0kwAfR8KqA== 32.131,1.002,0.508,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNEJKCDMcHJw8jOTUfNSEZGQuUb4x9GHxkJDg2hMA4WViYmAHWrC2k= 33.133,1.000,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBGXGK8QHS09PRM9BRMxBa55jBOY03REhByE3DhYADicCkc= 34.133,0.998,0.442,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBE1NzsfJwMVEw0pFS0hOZm4FqYKPy2FAoUJjFIsTAA/mQql 35.131,1.000,0.459,HISTFAAAAEN42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBERMy0jPTk5LRUFJQk1GamYdUzHGO0UxIrUljBKsbEwAQBKXgqU 36.131,1.001,0.557,HISTFAAAAEd42pNpmSzMwMCgygABTBDKT4GBgdnNYMcCBvsPEBExJzcNMyU5PRUpLSkJKYWwHqYWRjslkTKNC4wKHGwMTExArUwAi/IKnA== 37.132,1.002,0.442,HISTFAAAAEJ42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBEFLRsVPQkTKTkhPT4ZBTm3V4yTGD20pFoYtZqYxESYAEjICok= 38.134,1.000,0.803,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNERM7Hwk3LRslMSkZMQExDLGQL0yTGIC2pKJ1VjCwcTJpMAFufCso= 39.134,0.997,0.492,HISTFAAAAEN42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEBE5Oz8DPRsFORM5FQkNKaGCA8wtjCoSfBYSTYxCLEBtTABiWgor 40.131,1.000,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBExJQUNFTElFRUZBRUZDTGfJqYKHzmhHka5ZUwSQmwANK0J+g== 41.131,1.002,0.475,HISTFAAAAEV42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEBE2Hj45PiEFGSU5EQkpKREJuVmMLYwaWk8YQyYwa3CxMTABAEOgCdQ= 42.133,1.000,0.459,HISTFAAAAD942pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBk+Lg4+ER4hMT4hIT4lLh69OAOZZ4wOr1hCpFiYABjUCSY= 43.133,1.002,0.442,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBFmLgEJMTERHjEuCRERBSERoww5rRuMendYPFRYAA3tCTM= 44.135,0.998,0.590,HISTFAAAAEJ42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPUBk+FT0lJTktJSUjOTE1OQGpmnOMdnorGF3WMemxCTIBAEAhCnU= 45.133,0.998,0.442,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWMS0DIyMFOSsNPTEFMSGNA4x+LxidfOp0VjBKcLAAAECLCv4= 46.131,1.004,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEuMS0VEyMlLSkzGQUJOSkJj6RnjE56WxjNWpik2JgAO34KfQ== 47.135,0.996,0.475,HISTFAAAAEF42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNUgk2GR0ZOQkSAR4aLS0KKTyNtDqOWxjVGu2fMGlJMTEwANsIJvA== 48.131,1.950,1803.551,HISTFAAAAKF42pNpmSzMwMD0mQECmCCUnwIDA7ObwY4FDPYfICKsTExMLCysLCxsbEwMTAIsDHIsWTwsbNsZmcqZKpncmayZLIFYnUmWSRoMIbQkEy8TNxQjkwgWJxMrGDJDaews/KIMKBCNSytBZCYqYGHCBNjEiBckoJAFBNhYYADBwipIhkIC0lwcQIBGcHARJqigBkwKCQgICSAIFA75IlwAeB8ZpQ== 50.081,0.050,0.393,HISTFAAAADl42pNpmSzMwMAgxgABTBDKT4GBgdnNYMcCBvsPEBE2BiYWNiYWZiYGJiZmJg4OLiYuFiYWAMWGBSM= 50.131,1.001,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBE2Lj4VAQkuJT45KTkOKSExI68eRgeDvB2MfcxxckwAJD8JyA== 51.132,0.999,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBk2NgUFGSkNAQEeJSkuKSmxhAojhZADjKuYiyS4WAAlWgm/ 52.131,1.002,0.557,HISTFAAAAER42pNpmSzMwMCgxAABTBDKT4GBgdnNYMcCBvsPUBkWPjEFGSMZKQMJJSEhPgkJiyodjZIHjB+YSvh4mBiYWJkAVc8KVw== 53.133,0.998,0.442,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBE2HjklJR0VPSUDHTUxJSkJs02MuxhtrLxKHjH6cbEAADjeCuw= 54.131,1.003,0.442,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBkNPzMLIw0NLQ0pFTERCTGLT4wpQSVbGFcwynExAQA/uwsC 55.134,0.997,0.426,HISTFAAAAD942pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPUBkWFTUjCy01BQ0VFRUJGSkJjRamiqA5jHmXGIV4ACoyCmo= 56.131,1.000,0.459,HISTFAAAAEF42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNUhk1FzsrAQElFQ0xCQkJOTEDnE6ObxwrGDsYuJjUODiYASN8KbA== 57.131,1.000,0.459,HISTFAAAAEF42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPMBk5FT0JAzUNKTklKQ0FMaGUJ4wJFjcYk+4wqnAwMAEAQooK6Q== 58.131,1.002,0.442,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBEuCRMNJwMlIzUtLR0ZMREZv6IHjFYGdUXLGE14WAA4OwsG 59.133,0.998,0.442,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBklExUdIwcdFRUlOTMZPhWXB4wBTssYsy4xKnGwAQA8bAry 60.131,1.000,0.524,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBFmIRcjPR0bFR0lDSk5KQkZpXlMXkF5qxh3MMqIcDIBADy8CoE= 61.131,1.000,26.083,HISTFAAAAF542pNpmSzMwMAQyAABTBDKT4GBgdnNYMcCBvsPMBkFHSMrCzEZLSUFCSkJOTmTf4xRQW2MYT8Y5diYdjIylTNVMrkzWTJZA7EmkzQYykJpSSZeJm4ghpAQFgATDg85 HdrHistogram_c-0.11.8/test/jHiccup-2.0.7S.logV3.hlog000066400000000000000000000175541442262567300215220ustar00rootroot00000000000000#[Logged with jHiccup version 2.0.7-SNAPSHOT] #[Histogram log format version 1.3] #[StartTime: 1441812279.474 (seconds since epoch), Wed Sep 09 08:24:39 PDT 2015] "StartTimestamp","Interval_Length","Interval_Max","Interval_Compressed_Histogram" 0.127,1.007,2.769,HISTFAAAAEV42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEBEJISEuATEZMQ4uASkhIR4nrxg9v2lMaxhvMekILGZkKmcCAEf2CsI= Tag=a1.134a,1.134,0.999,0.442,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWLj45FTExAT4pBSEBKa6UkAgBi1uM7xjfMMlwMDABAC0CCjM= 2.133,1.001,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBE+Ph4OLgk5OSkeIS4+LgEeswIDo1+MbmdYNASYAA51CSo= Tag=a3.134a,3.134,1.001,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBExPiEpITEFGTkRKSEeOR6FkCg1hTeMXvNYlHhYABQ5CTo= 4.135,0.997,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBE2PiERBREpBREhER4+Hj4uvQAdrTlMBldYDDhYAAugCKk= Tag=a5.132a,5.132,1.002,0.426,HISTFAAAAEF42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBEWPhElOR4pARUpKTkpGQkxq2mMegZnGI0+MZuIcAEAHo8Jvw== 6.134,0.999,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWIS4FITEhDiEJERE+GT6ZkhZGLbl7jEqrWHREmFgAIbAJMw== Tag=a7.133a,7.133,0.999,0.459,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNEhEtMQEBBTk5MQERCRkBEQEWlh9FJbg9jE+MS5ig1LhYmADkkCcE= 8.132,1.000,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWIREgEOIQEuGT4xHg41Oo0pIqu8LYwVImwMfGBAAfkgkw 9.132,1.751,1551.892,HISTFAAAAJZ42pNpmSzMwMB0nQECmCCUnwIDA7ObwY4FDPYfYDJMXFxsbGwMbBwszDwsDDxsHFw6RWJMLJMZmcqBMJrJmskSiA2ZZJmkgRBCgmheIORGI1H5rEzMQAyDzFhY2EWRWUwMWCBxQtQQhAIWJiyAaEHyFbKwsLHAADYWAWmiFeKS5gACLsIEzdQICAgBIQShEfhFABXDF+M= 10.883,0.250,0.426,HISTFAAAAD142pNpmSzMwMAgxQABTBDKT4GBgdnNYMcCBvsPEBEeFi4mPg4WLhY2BjY2FhYOBSkpASEtoRA+NgDkCQZR 11.133,1.003,0.524,HISTFAAAAER42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPUBk2HgkZKREpEQUeGSEBAQ6xSYxhCnp7GJ02sWgJsbCwMgEAO0AJSQ== 12.136,0.997,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBk2AT4eCQURHgkuEREOHjERlSQhhWuMSV9Y7ERYWAAa4gko 13.133,0.998,0.459,HISTFAAAAD942pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBkRIR4RMRk5KQE+PgEhMRmzEjWZJ4whW1hMBNiYAB42CTA= 14.131,1.000,0.492,HISTFAAAAEN42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPUBkWFhE5GT4FKQkRCR4ZCREpqwmMBhpHGG16WHx42JgYmAA6swk+ 15.131,1.001,0.442,HISTFAAAAD542pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPMBkuMTEFHgklFRkRATkJERGdKgudfYwRTSwGalwAF2IJOw== 16.132,1.001,0.524,HISTFAAAAEZ42pNpmSzMwMCgxAABTBDKT4GBgdnNYMcCBvsPEBE2IQEFCQkpGREpHj4hKS6NU4z7GDMkuBoYDSYw2wiwMLEyAQBQ3wne 17.133,0.998,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBk2DjElIR4RHiExKQE5IT61iCodtXWMdn0sKVJMTAAekAk0 18.131,1.000,0.459,HISTFAAAAEF42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPUBkWISERJSUJESklHhEJEREhqwZGLakPjDZdLBYCHCwAKOkJPg== 19.131,1.000,0.475,HISTFAAAAEF42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPUAk2HjkJBSk+Pi4BMT4xIQE9pxIluTOMPhtYbITY2JgAKLoJOQ== 20.131,1.004,0.475,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBFmPhEJOSEhDi4+ETEeASEhswIVi1+MFjtYvCRYGJgAIP8JNw== 21.135,0.999,0.492,HISTFAAAAEB42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNMhk1AjINDRECAj4+Hi49LKS5CS2EGo1kXa4ANExMDEwAmOQil 22.134,0.997,0.459,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBFmHhE+MRExCTEZAS4RMQERvRI1hSuMTidY3KQ4mAAXhgks 23.131,1.004,0.508,HISTFAAAAEB42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNMhotHSEBASEyMg09MQUSIT6tKS2YKY8gfFj8tJmYmJgAsowkz 24.135,0.998,0.492,HISTFAAAAEJ42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBEBLjkhETEpET4BISEhCR6FsqAQFY1jjBoTWPQEOJiZAC2aCUY= 25.133,1.002,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBkuHh4BITEpMSEpLiE5AS6FoAgdpQuMJk9YzMRYmAAdngk2 26.135,0.998,0.508,HISTFAAAAER42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPUAkOKSEJKTUJOT4+IQkeIT69LYwVCnIbGI0eMZtJsTAxMwEAQvkJyg== 27.133,0.998,0.442,HISTFAAAAEN42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBE2CQUZFTkZOSURKQkRMT6NKYwhbYxaOocY/a4xSUmwAQA4pQpb 28.131,1.002,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBGtFDcHIy0jDQUdPjENFZUzjNNYHCT4uBQkzJiYADIGCcY= 29.133,1.460,968.884,HISTFAAAAJZ42pNpmSzMwMDUwgABTBDKT4GBgdnNYMcCBvsPEBE5AwMDJSUFISk2ETYuAS6PQ0xSXCzsTEw7GZnKgdCTyZLJGog1maSZZIFYGkpLMnEz8QIhOolgcTKxAiEzmGRFYxMShbEYUCAalzRBsjSjARYmTIBNjDKFSIIsIMDGAgPYWJRJE1DIxQEEaAQHF2GCNDVsAE2dFJE= 30.593,0.541,0.459,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBEFCxUNBRkFMTE+Pj4ZHgGHFYwGIkJcMiIpbEwMTAAdQQhJ 31.134,0.997,0.737,HISTFAAAAER42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEJGAHsYexqKaIAcPPRMVKTEhoR6mJUxqfBx8LFwCTOxM0kwAfR8KqA== 32.131,1.002,0.508,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNEJKCDMcHJw8jOTUfNSEZGQuUb4x9GHxkJDg2hMA4WViYmAHWrC2k= 33.133,1.000,0.426,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBGXGK8QHS09PRM9BRMxBa55jBOY03REhByE3DhYADicCkc= 34.133,0.998,0.442,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBE1NzsfJwMVEw0pFS0hOZm4FqYKPy2FAoUJjFIsTAA/mQql 35.131,1.000,0.459,HISTFAAAAEN42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBERMy0jPTk5LRUFJQk1GamYdUzHGO0UxIrUljBKsbEwAQBKXgqU 36.131,1.001,0.557,HISTFAAAAEd42pNpmSzMwMCgygABTBDKT4GBgdnNYMcCBvsPEBExJzcNMyU5PRUpLSkJKYWwHqYWRjslkTKNC4wKHGwMTExArUwAi/IKnA== 37.132,1.002,0.442,HISTFAAAAEJ42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPEBEFLRsVPQkTKTkhPT4ZBTm3V4yTGD20pFoYtZqYxESYAEjICok= 38.134,1.000,0.803,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNERM7Hwk3LRslMSkZMQExDLGQL0yTGIC2pKJ1VjCwcTJpMAFufCso= 39.134,0.997,0.492,HISTFAAAAEN42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEBE5Oz8DPRsFORM5FQkNKaGCA8wtjCoSfBYSTYxCLEBtTABiWgor 40.131,1.000,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBExJQUNFTElFRUZBRUZDTGfJqYKHzmhHka5ZUwSQmwANK0J+g== 41.131,1.002,0.475,HISTFAAAAEV42pNpmSzMwMCgyAABTBDKT4GBgdnNYMcCBvsPEBE2Hj45PiEFGSU5EQkpKREJuVmMLYwaWk8YQyYwa3CxMTABAEOgCdQ= 42.133,1.000,0.459,HISTFAAAAD942pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBk+Lg4+ER4hMT4hIT4lLh69OAOZZ4wOr1hCpFiYABjUCSY= 43.133,1.002,0.442,HISTFAAAAD942pNpmSzMwMAgwwABTBDKT4GBgdnNYMcCBvsPEBFmLgEJMTERHjEuCRERBSERoww5rRuMendYPFRYAA3tCTM= 44.135,0.998,0.590,HISTFAAAAEJ42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPUBk+FT0lJTktJSUjOTE1OQGpmnOMdnorGF3WMemxCTIBAEAhCnU= 45.133,0.998,0.442,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEWMS0DIyMFOSsNPTEFMSGNA4x+LxidfOp0VjBKcLAAAECLCv4= 46.131,1.004,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBEuMS0VEyMlLSkzGQUJOSkJj6RnjE56WxjNWpik2JgAO34KfQ== 47.135,0.996,0.475,HISTFAAAAEF42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNUgk2GR0ZOQkSAR4aLS0KKTyNtDqOWxjVGu2fMGlJMTEwANsIJvA== 48.131,1.950,1803.551,HISTFAAAAKF42pNpmSzMwMD0mQECmCCUnwIDA7ObwY4FDPYfICKsTExMLCysLCxsbEwMTAIsDHIsWTwsbNsZmcqZKpncmayZLIFYnUmWSRoMIbQkEy8TNxQjkwgWJxMrGDJDaews/KIMKBCNSytBZCYqYGHCBNjEiBckoJAFBNhYYADBwipIhkIC0lwcQIBGcHARJqigBkwKCQgICSAIFA75IlwAeB8ZpQ== 50.081,0.050,0.393,HISTFAAAADl42pNpmSzMwMAgxgABTBDKT4GBgdnNYMcCBvsPEBE2BiYWNiYWZiYGJiZmJg4OLiYuFiYWAMWGBSM= 50.131,1.001,0.442,HISTFAAAAEF42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBE2Lj4VAQkuJT45KTkOKSExI68eRgeDvB2MfcxxckwAJD8JyA== 51.132,0.999,0.459,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPUBk2NgUFGSkNAQEeJSkuKSmxhAojhZADjKuYiyS4WAAlWgm/ 52.131,1.002,0.557,HISTFAAAAER42pNpmSzMwMCgxAABTBDKT4GBgdnNYMcCBvsPUBkWPjEFGSMZKQMJJSEhPgkJiyodjZIHjB+YSvh4mBiYWJkAVc8KVw== 53.133,0.998,0.442,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBE2HjklJR0VPSUDHTUxJSkJs02MuxhtrLxKHjH6cbEAADjeCuw= 54.131,1.003,0.442,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBkNPzMLIw0NLQ0pFTERCTGLT4wpQSVbGFcwynExAQA/uwsC 55.134,0.997,0.426,HISTFAAAAD942pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPUBkWFTUjCy01BQ0VFRUJGSkJjRamiqA5jHmXGIV4ACoyCmo= 56.131,1.000,0.459,HISTFAAAAEF42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNUhk1FzsrAQElFQ0xCQkJOTEDnE6ObxwrGDsYuJjUODiYASN8KbA== 57.131,1.000,0.459,HISTFAAAAEF42pNpmSzMwMAgzwABTBDKT4GBgdnNYMcCBvsPMBk5FT0JAzUNKTklKQ0FMaGUJ4wJFjcYk+4wqnAwMAEAQooK6Q== 58.131,1.002,0.442,HISTFAAAAEB42pNpmSzMwMAgywABTBDKT4GBgdnNYMcCBvsPEBEuCRMNJwMlIzUtLR0ZMREZv6IHjFYGdUXLGE14WAA4OwsG 59.133,0.998,0.442,HISTFAAAAEB42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPMBklExUdIwcdFRUlOTMZPhWXB4wBTssYsy4xKnGwAQA8bAry 60.131,1.000,0.524,HISTFAAAAEJ42pNpmSzMwMAgxwABTBDKT4GBgdnNYMcCBvsPEBFmIRcjPR0bFR0lDSk5KQkZpXlMXkF5qxh3MMqIcDIBADy8CoE= 61.131,1.000,26.083,HISTFAAAAF542pNpmSzMwMAQyAABTBDKT4GBgdnNYMcCBvsPMBkFHSMrCzEZLSUFCSkJOTmTf4xRQW2MYT8Y5diYdjIylTNVMrkzWTJZA7EmkzQYykJpSSZeJm4ghpAQFgATDg85 HdrHistogram_c-0.11.8/test/minunit.c000066400000000000000000000007041442262567300173200ustar00rootroot00000000000000#include #include "minunit.h" bool compare_double(double a, double b, double delta) { if (fabs(a - b) < delta) { return true; } printf("[compare_double] fabs(%f, %f) < %f == false\n", a, b, delta); return false; } bool compare_int64(int64_t a, int64_t b) { if (a == b) { return true; } printf("[compare_int64] %" PRIu64 " == %" PRIu64 " == false\n", a, b); return false; } HdrHistogram_c-0.11.8/test/minunit.h000066400000000000000000000022121442262567300173210ustar00rootroot00000000000000/** * minunit.h * Written by Michael Barker and released to the public domain, * as explained at http://creativecommons.org/publicdomain/zero/1.0/ */ #ifndef MINUNIT_H #define MINUNIT_H #include #include #include struct mu_result { char* test; char* message; }; #define mu_assert(message, test) \ do { \ if (!(test)) \ return message; \ } while (0) #define mu_run_test(name) \ do { \ char *message = name(); \ tests_run++; \ if (message) { \ struct mu_result r; \ r.test = #name; \ r.message = message; \ return r; \ } \ } while (0) #define mu_ok \ do { \ struct mu_result r; \ r.test = 0; \ r.message = 0; \ return r; \ } while (0) extern int tests_run; bool compare_double(double a, double b, double delta); bool compare_int64(int64_t a, int64_t b); #endif HdrHistogram_c-0.11.8/test/test_tagged_invalid_histogram.txt000066400000000000000000000000731442262567300243060ustar00rootroot00000000000000Tag=a7.133a,7.133,0.999,0.459,HISTFAAAAEJ42pNpmSzMwMCgwAABTHdrHistogram_c-0.11.8/test/test_tagged_invalid_tag_key.txt000066400000000000000000000002011442262567300237250ustar00rootroot00000000000000Ta=a7.133a,7.133,0.999,0.459,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNEhEtMQEBBTk5MQERCRkBEQEWlh9FJbg9jE+MS5ig1LhYmADkkCcE=HdrHistogram_c-0.11.8/test/test_tagged_invalid_timestamp.txt000066400000000000000000000002031442262567300243070ustar00rootroot00000000000000Tag=a7.133a,7.1a33,0.999,0.459,HISTFAAAAEJ42pNpmSzMwMCgwAABTBDKD8hndjPYsYDB/gNEhEtMQEBBTk5MQERCRkBEQEWlh9FJbg9jE+MS5ig1LhYmADkkCcE=HdrHistogram_c-0.11.8/test/test_tagged_missing_histogram.txt000066400000000000000000000000351442262567300243270ustar00rootroot00000000000000Tag=a7.133a,7.133,0.999,0.459HdrHistogram_c-0.11.8/test/vendor/000077500000000000000000000000001442262567300167655ustar00rootroot00000000000000HdrHistogram_c-0.11.8/test/vendor/google/000077500000000000000000000000001442262567300202415ustar00rootroot00000000000000HdrHistogram_c-0.11.8/test/vendor/google/benchmark/000077500000000000000000000000001442262567300221735ustar00rootroot00000000000000