diff --git a/BUILD.bazel b/BUILD.bazel index d2b3d946ee..dd31d65241 100644 --- a/BUILD.bazel +++ b/BUILD.bazel @@ -123,9 +123,6 @@ BUTIL_SRCS = [ "src/butil/third_party/modp_b64/modp_b64.cc", "src/butil/third_party/symbolize/demangle.cc", "src/butil/third_party/symbolize/symbolize.cc", - "src/butil/third_party/snappy/snappy-sinksource.cc", - "src/butil/third_party/snappy/snappy-stubs-internal.cc", - "src/butil/third_party/snappy/snappy.cc", "src/butil/third_party/murmurhash3/murmurhash3.cpp", "src/butil/arena.cpp", "src/butil/at_exit.cc", @@ -342,6 +339,7 @@ cc_library( "@com_github_gflags_gflags//:gflags", "@com_github_madler_zlib//:zlib", "@com_google_protobuf//:protobuf", + "@snappy" ] + select({ "//bazel/config:brpc_with_glog": ["@com_github_google_glog//:glog"], "//conditions:default": [], diff --git a/CMakeLists.txt b/CMakeLists.txt index bcffdb9b4d..8d716c90f1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -372,9 +372,6 @@ set(BUTIL_SOURCES ${PROJECT_SOURCE_DIR}/src/butil/third_party/modp_b64/modp_b64.cc ${PROJECT_SOURCE_DIR}/src/butil/third_party/symbolize/demangle.cc ${PROJECT_SOURCE_DIR}/src/butil/third_party/symbolize/symbolize.cc - ${PROJECT_SOURCE_DIR}/src/butil/third_party/snappy/snappy-sinksource.cc - ${PROJECT_SOURCE_DIR}/src/butil/third_party/snappy/snappy-stubs-internal.cc - ${PROJECT_SOURCE_DIR}/src/butil/third_party/snappy/snappy.cc ${PROJECT_SOURCE_DIR}/src/butil/third_party/murmurhash3/murmurhash3.cpp ${PROJECT_SOURCE_DIR}/src/butil/arena.cpp ${PROJECT_SOURCE_DIR}/src/butil/at_exit.cc diff --git a/MODULE.bazel b/MODULE.bazel index 2439a8815f..2aec554aca 100644 --- a/MODULE.bazel +++ b/MODULE.bazel @@ -17,6 +17,7 @@ bazel_dep(name = 'rules_cc', version = '0.0.1') bazel_dep(name = 'rules_proto', version = '4.0.0') bazel_dep(name = 'zlib', version = '1.3.1.bcr.5', repo_name = 'com_github_madler_zlib') bazel_dep(name = 'libunwind', version = '1.8.1', repo_name = 'com_github_libunwind_libunwind') +bazel_dep(name = "snappy", version = "1.2.2") # --registry=https://baidu.github.io/babylon/registry bazel_dep(name = 'leveldb', version = '1.23', repo_name = 'com_github_google_leveldb') diff --git a/MODULE.bazel.lock b/MODULE.bazel.lock new file mode 100644 index 0000000000..589fa5a79b --- /dev/null +++ b/MODULE.bazel.lock @@ -0,0 +1,994 @@ +{ + "lockFileVersion": 11, + "registryFileHashes": { + "https://baidu.github.io/babylon/registry/bazel_registry.json": "not found", + "https://baidu.github.io/babylon/registry/modules/libevent/2.1.12/MODULE.bazel": "1ba8ed9390cd17472cd0495f0bdfdc4d2de62781fd6ef157b32682f07033bd4d", + "https://baidu.github.io/babylon/registry/modules/libevent/2.1.12/source.json": "97292d6719ae1313ace6f2f049aea985a9bd34570583bba96fe72e3fe722aaa1", + "https://baidu.github.io/babylon/registry/modules/thrift/0.21.0/MODULE.bazel": "8d28c0adba6b3010c8f4e8297039f890286fe3429584559d4332bfbb105a9bb0", + "https://baidu.github.io/babylon/registry/modules/thrift/0.21.0/source.json": "9b0a0c088bad57ec8bdef2e4d1c33cc541d7005dfb6387c03bc64b42a0d6f4cc", + "https://bcr.bazel.build/bazel_registry.json": "8a28e4aff06ee60aed2a8c281907fb8bcbf3b753c91fb5a5c57da3215d5b3497", + "https://bcr.bazel.build/modules/abseil-cpp/20210324.2/MODULE.bazel": "7cd0312e064fde87c8d1cd79ba06c876bd23630c83466e9500321be55c96ace2", + "https://bcr.bazel.build/modules/abseil-cpp/20211102.0/MODULE.bazel": "70390338f7a5106231d20620712f7cccb659cd0e9d073d1991c038eb9fc57589", + "https://bcr.bazel.build/modules/abseil-cpp/20230125.1/MODULE.bazel": "89047429cb0207707b2dface14ba7f8df85273d484c2572755be4bab7ce9c3a0", + "https://bcr.bazel.build/modules/abseil-cpp/20230802.0.bcr.1/MODULE.bazel": "1c8cec495288dccd14fdae6e3f95f772c1c91857047a098fad772034264cc8cb", + "https://bcr.bazel.build/modules/abseil-cpp/20230802.0.bcr.1/source.json": "14892cc698e02ffedf4967546e6bedb7245015906888d3465fcf27c90a26da10", + "https://bcr.bazel.build/modules/abseil-cpp/20230802.0/MODULE.bazel": "d253ae36a8bd9ee3c5955384096ccb6baf16a1b1e93e858370da0a3b94f77c16", + "https://bcr.bazel.build/modules/apple_support/1.17.1/MODULE.bazel": "655c922ab1209978a94ef6ca7d9d43e940cd97d9c172fb55f94d91ac53f8610b", + "https://bcr.bazel.build/modules/apple_support/1.17.1/source.json": "6b2b8c74d14e8d485528a938e44bdb72a5ba17632b9e14ef6e68a5ee96c8347f", + "https://bcr.bazel.build/modules/apple_support/1.5.0/MODULE.bazel": "50341a62efbc483e8a2a6aec30994a58749bd7b885e18dd96aa8c33031e558ef", + "https://bcr.bazel.build/modules/bazel_features/1.10.0/MODULE.bazel": "f75e8807570484a99be90abcd52b5e1f390362c258bcb73106f4544957a48101", + "https://bcr.bazel.build/modules/bazel_features/1.11.0/MODULE.bazel": "f9382337dd5a474c3b7d334c2f83e50b6eaedc284253334cf823044a26de03e8", + "https://bcr.bazel.build/modules/bazel_features/1.15.0/MODULE.bazel": "d38ff6e517149dc509406aca0db3ad1efdd890a85e049585b7234d04238e2a4d", + "https://bcr.bazel.build/modules/bazel_features/1.19.0/MODULE.bazel": "59adcdf28230d220f0067b1f435b8537dd033bfff8db21335ef9217919c7fb58", + "https://bcr.bazel.build/modules/bazel_features/1.19.0/source.json": "d7bf14517c1b25b9d9c580b0f8795fceeae08a7590f507b76aace528e941375d", + "https://bcr.bazel.build/modules/bazel_skylib/1.0.3/MODULE.bazel": "bcb0fd896384802d1ad283b4e4eb4d718eebd8cb820b0a2c3a347fb971afd9d8", + "https://bcr.bazel.build/modules/bazel_skylib/1.1.1/MODULE.bazel": "1add3e7d93ff2e6998f9e118022c84d163917d912f5afafb3058e3d2f1545b5e", + "https://bcr.bazel.build/modules/bazel_skylib/1.2.0/MODULE.bazel": "44fe84260e454ed94ad326352a698422dbe372b21a1ac9f3eab76eb531223686", + "https://bcr.bazel.build/modules/bazel_skylib/1.2.1/MODULE.bazel": "f35baf9da0efe45fa3da1696ae906eea3d615ad41e2e3def4aeb4e8bc0ef9a7a", + "https://bcr.bazel.build/modules/bazel_skylib/1.3.0/MODULE.bazel": "20228b92868bf5cfc41bda7afc8a8ba2a543201851de39d990ec957b513579c5", + "https://bcr.bazel.build/modules/bazel_skylib/1.4.1/MODULE.bazel": "a0dcb779424be33100dcae821e9e27e4f2901d9dfd5333efe5ac6a8d7ab75e1d", + "https://bcr.bazel.build/modules/bazel_skylib/1.5.0/MODULE.bazel": "32880f5e2945ce6a03d1fbd588e9198c0a959bb42297b2cfaf1685b7bc32e138", + "https://bcr.bazel.build/modules/bazel_skylib/1.6.1/MODULE.bazel": "8fdee2dbaace6c252131c00e1de4b165dc65af02ea278476187765e1a617b917", + "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/MODULE.bazel": "3120d80c5861aa616222ec015332e5f8d3171e062e3e804a2a0253e1be26e59b", + "https://bcr.bazel.build/modules/bazel_skylib/1.7.1/source.json": "f121b43eeefc7c29efbd51b83d08631e2347297c95aac9764a701f2a6a2bb953", + "https://bcr.bazel.build/modules/boost.algorithm/1.83.0/MODULE.bazel": "f5afbca8fe26f73016c040ae2525c8cfdfb7c7f8a0b2aa7412e08447a8bf76b4", + "https://bcr.bazel.build/modules/boost.algorithm/1.83.0/source.json": "cbc02be90eedd45da42f55b7e352a3aeac56ae72f62237308b5e6e1733b2f2c5", + "https://bcr.bazel.build/modules/boost.array/1.83.0.bcr.1/MODULE.bazel": "ffe2956a8f5d90839e710cb298f0a342acc5a1d8fdfeee9578cae9657df87e38", + "https://bcr.bazel.build/modules/boost.array/1.83.0.bcr.1/source.json": "6d3925fef402c04bd7ea463203c1892c6ab96351c2264566e4bc9e6543fc777f", + "https://bcr.bazel.build/modules/boost.array/1.83.0/MODULE.bazel": "76bc954c31d8c840d89f347ec3d8f4542fc74229e9ab9d74b7e21342a8becd39", + "https://bcr.bazel.build/modules/boost.assert/1.83.0.bcr.1/MODULE.bazel": "abc07418c37c6e1876f56d959ff1b7cdcac70c8b7236bbacc69ab66686968910", + "https://bcr.bazel.build/modules/boost.assert/1.83.0.bcr.1/source.json": "05d5c7ef77352f32264b9ca625df8ca742b78a94d4b057347a54204d6cd9ded6", + "https://bcr.bazel.build/modules/boost.assert/1.83.0/MODULE.bazel": "7b132fe0760e15733253280bd4b9e0c8867b6a8e27322d3def361cab7a729ac7", + "https://bcr.bazel.build/modules/boost.bind/1.83.0.bcr.1/MODULE.bazel": "c226a7152112ec5329aa831fd7daab296db2e8bf1a427e05c33bb770c885e044", + "https://bcr.bazel.build/modules/boost.bind/1.83.0.bcr.1/source.json": "1ad06dbc6d538e539abaeb58d647d787b63c2b0eb54f61168c8501d420cdd691", + "https://bcr.bazel.build/modules/boost.bind/1.83.0/MODULE.bazel": "11e5db47f917eb4a0238e89bc0eda2b41a979682c679cc21209dbd347c3f4723", + "https://bcr.bazel.build/modules/boost.concept_check/1.83.0.bcr.1/MODULE.bazel": "987ddeeca7c552f7c15557ed9f1e1de26e976d1380002cd41e56ea0ef7e1d25e", + "https://bcr.bazel.build/modules/boost.concept_check/1.83.0.bcr.1/source.json": "0a5cb9c8a8b424c04a717b2cbf483f1ee576611b3370550369671ea4f5852e3c", + "https://bcr.bazel.build/modules/boost.concept_check/1.83.0/MODULE.bazel": "a783fc53e77b42e8baa39a4e8f031d0dc2c87f2da386569bb9d46bc12a652c66", + "https://bcr.bazel.build/modules/boost.config/1.83.0.bcr.1/MODULE.bazel": "a9049b46df8ba7d4a895122cfbda4cf71ad01f441fad62117931cfafecba35d1", + "https://bcr.bazel.build/modules/boost.config/1.83.0.bcr.1/source.json": "4810a18d8d9827bf2822ca8e3e1491cfb882657224bc2def70b334120415ccc2", + "https://bcr.bazel.build/modules/boost.config/1.83.0/MODULE.bazel": "beb2e8899be8dc7e3fc2d5b6d5302e665f42be85046e60a955bcbd7ba8174bf8", + "https://bcr.bazel.build/modules/boost.container_hash/1.83.0.bcr.1/MODULE.bazel": "baf420d50979d18d247681bb4f3e097c054f314c2a3c98c14f1b750871329ad7", + "https://bcr.bazel.build/modules/boost.container_hash/1.83.0.bcr.1/source.json": "f3248fbd4a2cd88333343bd78f317e3f7b085b6a2a31adab26f402083bdbdb26", + "https://bcr.bazel.build/modules/boost.container_hash/1.83.0/MODULE.bazel": "be8328ca4dcbe7832438eedf35607f277dd7b4372d75996f5287f40867d1cd2e", + "https://bcr.bazel.build/modules/boost.conversion/1.83.0.bcr.1/MODULE.bazel": "d05ea5d39c0399ddd0331922e64a6bb8bdfe40b83cb6d4ecee62d7cb68f6c36b", + "https://bcr.bazel.build/modules/boost.conversion/1.83.0.bcr.1/source.json": "7b91cda19dcf46d35b47fd30ea9a6226c880d27f6abd51f8107c5015fec9bd46", + "https://bcr.bazel.build/modules/boost.conversion/1.83.0/MODULE.bazel": "d7c3ae92bb0e806da3174eeba584a66aa02a6677a3768eec62f89c7159b48723", + "https://bcr.bazel.build/modules/boost.core/1.83.0.bcr.1/MODULE.bazel": "6aa5d86d84dbeefeda0f5e3ac596db7426ecb6f6ebdf69383c2963292ee568cf", + "https://bcr.bazel.build/modules/boost.core/1.83.0.bcr.1/source.json": "62f0884fe4d287b72146c3355df6d737b016f312bb3bf9c1bbf41fd84400b046", + "https://bcr.bazel.build/modules/boost.core/1.83.0/MODULE.bazel": "769d1faa7dc89832c1a435110a0b447b2e280b3da740ca1811711418fc2e476e", + "https://bcr.bazel.build/modules/boost.describe/1.83.0.bcr.1/MODULE.bazel": "04f902525e3f53a7eec9e10bb58623d5b249afaa4f245917cc827f63933351ba", + "https://bcr.bazel.build/modules/boost.describe/1.83.0.bcr.1/source.json": "b3201219ad62723a684c98d1f13448346774d5979adf99d88583765150a9095c", + "https://bcr.bazel.build/modules/boost.describe/1.83.0/MODULE.bazel": "63ca2aa1c8f62e8a187767d294529f1a762d0f6a4bc1b6081c3e1af63458bac4", + "https://bcr.bazel.build/modules/boost.detail/1.83.0.bcr.2/MODULE.bazel": "0016cbb9f265ebd4efcbb5f1aff14ccce5754bd98c3d9ff375d3a39f4173f8de", + "https://bcr.bazel.build/modules/boost.detail/1.83.0.bcr.2/source.json": "0044cf130a00ccde75322449d2a525e1ca95af2bd61b49873125943c4d3ff7ad", + "https://bcr.bazel.build/modules/boost.detail/1.83.0/MODULE.bazel": "9bbd10b5c30d0c17908fd0c94e9a26f4899540d1c1a97088911d1195feb98da9", + "https://bcr.bazel.build/modules/boost.dynamic_bitset/1.83.0.bcr.1/MODULE.bazel": "2093a9d09159b97ada67ed370492f61c775ae7df5018c8ba9c69053ed7813dab", + "https://bcr.bazel.build/modules/boost.dynamic_bitset/1.83.0.bcr.1/source.json": "c8470feff0d94ef0c950dfa6b214cc119bbaae95355e27838b9d295c7b222b21", + "https://bcr.bazel.build/modules/boost.exception/1.83.0/MODULE.bazel": "3cc2e06995cb92e329449793e389051035ec3516180aaec0bbfd36efc6c90d7b", + "https://bcr.bazel.build/modules/boost.exception/1.83.0/source.json": "09d071c13a55cd740d2354729eb02cc716a2673c6e6030725690af16f32ad6fa", + "https://bcr.bazel.build/modules/boost.function/1.83.0.bcr.1/MODULE.bazel": "b555cccb955cc4bd8d548f81ec29fdd33284ae04afd9ed92b254abe6357a5ed7", + "https://bcr.bazel.build/modules/boost.function/1.83.0.bcr.1/source.json": "a85e42738a1fd7eb3df45ca31fe213ca23832adb0032a7bcf9cd8dac42445f86", + "https://bcr.bazel.build/modules/boost.function/1.83.0/MODULE.bazel": "fa8cf838f76289180210f17e5f5effb51b91ce0be0a2cc72a2b134e53006bbd6", + "https://bcr.bazel.build/modules/boost.function_types/1.83.0.bcr.1/MODULE.bazel": "266d931a312bafb39053b6a0260e59882c1389e8126f9dc5b3f37a1c2b66a152", + "https://bcr.bazel.build/modules/boost.function_types/1.83.0.bcr.1/source.json": "c421295de00ee97f4d605d8a873ce002b64d9e4226f61db710ceaaf2ff1c581a", + "https://bcr.bazel.build/modules/boost.function_types/1.83.0/MODULE.bazel": "8974442d5a0929ef7df5f63fa5d49221b2274cd19f2be0ca91b99d2538b74d64", + "https://bcr.bazel.build/modules/boost.functional/1.83.0.bcr.1/MODULE.bazel": "8e0f52ea1e5f1d34442347c1ddcb202ce2cc610175226df58770c69d7267b4a8", + "https://bcr.bazel.build/modules/boost.functional/1.83.0.bcr.1/source.json": "6a3c58ca81f5226221ac1565aa3a7c93e5d04b27d2f9bd71e1b113ff19f5a658", + "https://bcr.bazel.build/modules/boost.functional/1.83.0/MODULE.bazel": "f6c5ec6684a05d5c235a9141a417c1c18eee1af1783a30f7f3f19bd3020f128b", + "https://bcr.bazel.build/modules/boost.fusion/1.83.0.bcr.1/MODULE.bazel": "1a651840d5710e5f2b882535f9fd7a18d6932c24559185362a3dfe0ca3702ee4", + "https://bcr.bazel.build/modules/boost.fusion/1.83.0.bcr.1/source.json": "8977203271c1f1db3f329e5cdd4960d26060ef13bdc7e47820b77f61d2369909", + "https://bcr.bazel.build/modules/boost.fusion/1.83.0/MODULE.bazel": "394a7dd5bb57baad66c30db1cf871c2b7d05129637945c04c3b26e11bd0cb4de", + "https://bcr.bazel.build/modules/boost.integer/1.83.0.bcr.1/MODULE.bazel": "29655d7e043ba79065ed8fb8b8b99133470ff240f4606bebb6085d2c856578df", + "https://bcr.bazel.build/modules/boost.integer/1.83.0.bcr.1/source.json": "92d1105b5e005c47b10c09b42dfbc86374a069b62055c7471eb8546545ee534b", + "https://bcr.bazel.build/modules/boost.integer/1.83.0/MODULE.bazel": "2bbbc2e0e01f901ce84ef66859635e3ad0b645eeb3a133e243af8e750f4db54d", + "https://bcr.bazel.build/modules/boost.io/1.83.0.bcr.1/MODULE.bazel": "ce3b42ee33880f7250263a158c51b6c33c38ccbff754b78703c8af3f842e1cb1", + "https://bcr.bazel.build/modules/boost.io/1.83.0.bcr.1/source.json": "94e74cc68d9ba9821aa35c207a943c8140856fbc494b3524d3729f0caa9e97db", + "https://bcr.bazel.build/modules/boost.io/1.83.0/MODULE.bazel": "47457a879a81af920b096b76affd242f898fdf406aec12c62c6772a84aa0e0a0", + "https://bcr.bazel.build/modules/boost.iterator/1.83.0.bcr.1/MODULE.bazel": "6ac7783146113154a83e841bfa4449105718006378edff7fbfc53aeddf00812b", + "https://bcr.bazel.build/modules/boost.iterator/1.83.0.bcr.1/source.json": "16e10bfe39dd3096147160668219e7a9bb8a42bbce5bd6a8a9bfcb9c428f7912", + "https://bcr.bazel.build/modules/boost.iterator/1.83.0/MODULE.bazel": "a526477248e085c73e8059708b61b9238536f923ede8c310e979aec4672f2e5d", + "https://bcr.bazel.build/modules/boost.move/1.83.0.bcr.1/MODULE.bazel": "e901ceb363762eb989a7a53418fe7ce2acf8f542a413109105184a4e22e38096", + "https://bcr.bazel.build/modules/boost.move/1.83.0.bcr.1/source.json": "978a8ff249833ab0764a7c2a83a9bda299960112613f22c1ee3bb3ec97fbddbf", + "https://bcr.bazel.build/modules/boost.move/1.83.0/MODULE.bazel": "9294f124718b42857e0eabde467fd78b2b9f8844529749fc1ffe27bc44d23940", + "https://bcr.bazel.build/modules/boost.mp11/1.83.0.bcr.1/MODULE.bazel": "cf0d62cfca8865a1e1672953bd5b08cf5cb95e3aae819427565606305dd29165", + "https://bcr.bazel.build/modules/boost.mp11/1.83.0.bcr.1/source.json": "554cee46c279651fc3ffca71d947e8b99cb26bd87661debe7946eb21b61031f7", + "https://bcr.bazel.build/modules/boost.mp11/1.83.0/MODULE.bazel": "5b47c08596fd8b0f1cf5e183b22012a8380bacbdf68535de0a469a26bcb32f47", + "https://bcr.bazel.build/modules/boost.mpl/1.83.0.bcr.1/MODULE.bazel": "9cd97b224f9c1d8ffefdf48a7163767ca3968fbdfbc76f057caefbb4054be33e", + "https://bcr.bazel.build/modules/boost.mpl/1.83.0.bcr.1/source.json": "2ad7f4a254613fe2c0722d6127d9b366dbd19dcd8e44ad23f3ff66bf48163019", + "https://bcr.bazel.build/modules/boost.mpl/1.83.0/MODULE.bazel": "3110db5c9c5000140076797d61592f8abffd50e91e04a153ee24bf47d30e38ec", + "https://bcr.bazel.build/modules/boost.numeric_conversion/1.83.0.bcr.1/MODULE.bazel": "1920d71f656a0433947579a86c22e0dd897816eadee3ae20d5c51dab9505deb3", + "https://bcr.bazel.build/modules/boost.numeric_conversion/1.83.0.bcr.1/source.json": "fc35a1dbb8810812f05fa54667f0edeac142f5fc144f9426236694a1d01e875c", + "https://bcr.bazel.build/modules/boost.numeric_conversion/1.83.0/MODULE.bazel": "34fbcfe4eab607de5285b543f63142042f98c0895d765476f251c7bb45acf33d", + "https://bcr.bazel.build/modules/boost.optional/1.83.0.bcr.1/MODULE.bazel": "971e786a19e31dfbd8d311dff3bbffc7c1e16f348e019dfca50620fd9c475092", + "https://bcr.bazel.build/modules/boost.optional/1.83.0.bcr.1/source.json": "486e1173f8b24120078f072f434a79fb3aa8c6b0dafbc19c56b7780ea2336595", + "https://bcr.bazel.build/modules/boost.optional/1.83.0/MODULE.bazel": "d2d9c9afa139aa075212e451570aee269d73d5ccda31ab0ab33a9a4b406c0cf7", + "https://bcr.bazel.build/modules/boost.predef/1.83.0.bcr.1/MODULE.bazel": "0dd34241f892423a9dcd20e1256b6a1c787d60849e9576c724a71607ad8a1955", + "https://bcr.bazel.build/modules/boost.predef/1.83.0.bcr.1/source.json": "deb64fec0911e7a5d38d8517ecdd470b0b3983506662e01f63f8925688c05c01", + "https://bcr.bazel.build/modules/boost.predef/1.83.0/MODULE.bazel": "7bfd5416496b14c32e0684e57e47b8452fc5fe0e4afad294b31c2140b1d73dc8", + "https://bcr.bazel.build/modules/boost.preprocessor/1.83.0.bcr.1/MODULE.bazel": "edb9fb7900ea7002cbefffd97302b071d7cbd8f948b51c7b1a75043bd2985eba", + "https://bcr.bazel.build/modules/boost.preprocessor/1.83.0.bcr.1/source.json": "69dc4f6fc76305c21c4a651c94ccfdc8a76d8fbae1151e7c1d1a4599dffc0f03", + "https://bcr.bazel.build/modules/boost.preprocessor/1.83.0/MODULE.bazel": "5d1096729ebd16d2679c798110c0896720be23959c59afa36547d04815e255c8", + "https://bcr.bazel.build/modules/boost.random/1.83.0.bcr.1/MODULE.bazel": "cabe3ba820c9588a9ca22548b88ad8c4b307be085691b286ff0dae8a46b25fa0", + "https://bcr.bazel.build/modules/boost.random/1.83.0.bcr.1/source.json": "5cc5c8c13e525c5b1c12ea5b31359a16bfaf25b750c0601c0624b9342872e05d", + "https://bcr.bazel.build/modules/boost.range/1.83.0.bcr.1/MODULE.bazel": "136d623462d1d5c7cf79df83b5ce17a8582a92abb116da9d88c5e5594e5a7d92", + "https://bcr.bazel.build/modules/boost.range/1.83.0.bcr.1/source.json": "f99062101034f19d9bf2bef3e07cc99bf192640b72560663227e5375efd1e144", + "https://bcr.bazel.build/modules/boost.range/1.83.0/MODULE.bazel": "ceba0feb376949eecb77944bc37ac434261dede457fc449958164fca5d1430db", + "https://bcr.bazel.build/modules/boost.regex/1.83.0.bcr.1/MODULE.bazel": "5e2c235ea0bdbd8fa942f429ed8aefa1ad3e1471993a17a7b82c1f127dbcb3a2", + "https://bcr.bazel.build/modules/boost.regex/1.83.0.bcr.1/source.json": "1d5fda14ae73d5f12ced3c8731006f28b54bdaf75da35f6cc06c2b57b724d011", + "https://bcr.bazel.build/modules/boost.regex/1.83.0/MODULE.bazel": "75a260515a22080dc48aa02fd6dc1aa6bc42695dd7c6a449f37343cd0ea9b018", + "https://bcr.bazel.build/modules/boost.smart_ptr/1.83.0.bcr.1/MODULE.bazel": "5652293a4b393e5a56ef4113e0f41b6121d22a0d8f7ccd3e27c4042b947683e3", + "https://bcr.bazel.build/modules/boost.smart_ptr/1.83.0.bcr.1/source.json": "1b1b6b549073ef6b1bdbd9898490f73ddb6324774d441cd24d6d1181d4bc75f4", + "https://bcr.bazel.build/modules/boost.smart_ptr/1.83.0/MODULE.bazel": "67537f1bcdf50ab51ad79d9ac4e089018a7ebad1a2d362efcc54f5fc5ba45bd4", + "https://bcr.bazel.build/modules/boost.static_assert/1.83.0.bcr.1/MODULE.bazel": "2b605adc483c6241865f1e862437331bc6f56c0d376769908b70ba18d3da1f07", + "https://bcr.bazel.build/modules/boost.static_assert/1.83.0.bcr.1/source.json": "a0eac8de976fff7efdf498933d7494df30eff471c51c1edfc822007069697ed7", + "https://bcr.bazel.build/modules/boost.static_assert/1.83.0/MODULE.bazel": "680325e3252ae8306555bcf0539d16dcf9ccf9656d8781dfa3449a554d8da016", + "https://bcr.bazel.build/modules/boost.system/1.83.0.bcr.1/MODULE.bazel": "5f905d0fbb1ce99231f3fa278b2e5999aa7395c6393ac42d479ae21824adf03f", + "https://bcr.bazel.build/modules/boost.system/1.83.0.bcr.1/source.json": "0676ab63c01c5ddf731a5cf54667ffc6560e9fb52401a2a9ac6a10c5a9909019", + "https://bcr.bazel.build/modules/boost.throw_exception/1.83.0.bcr.1/MODULE.bazel": "b757c832f5f5f818d87c9eaa993d3eb211554197321c3edf641e2c8821cf19c2", + "https://bcr.bazel.build/modules/boost.throw_exception/1.83.0.bcr.1/source.json": "c752d584840e9183141f9d53f07f2051016c16771a973cdd1487f9585980c2e5", + "https://bcr.bazel.build/modules/boost.throw_exception/1.83.0/MODULE.bazel": "5df92502378293277ca48837e41f33805ede9e6165acefbf83d96b861919e56e", + "https://bcr.bazel.build/modules/boost.tokenizer/1.83.0/MODULE.bazel": "6501c3df8303a842740307b7c4443bb5d01d1ce10abf88d497d9607790bf1d23", + "https://bcr.bazel.build/modules/boost.tokenizer/1.83.0/source.json": "57aa54da8b6ca096ed45a05c752cf68a343567b03e3c069a4f77f485e9389cb9", + "https://bcr.bazel.build/modules/boost.tti/1.83.0.bcr.1/MODULE.bazel": "86dd0d443379e67bb41e9b8c9097d652699ddfc0986bd2fb0462f6f5294ee84d", + "https://bcr.bazel.build/modules/boost.tti/1.83.0.bcr.1/source.json": "660900b6e3615af5b222cf699ff220787d0550e380e28408e475a6a0d354d794", + "https://bcr.bazel.build/modules/boost.tuple/1.83.0.bcr.1/MODULE.bazel": "1d540b5efd3b65eeabd3621e5187a799e21bfa9ffc6afd7d4ad307cc4a27a6d4", + "https://bcr.bazel.build/modules/boost.tuple/1.83.0.bcr.1/source.json": "7aa33ec2aaae45605049ea0ec1c1de9517a1e1278a22d0a521521d4023f9ad87", + "https://bcr.bazel.build/modules/boost.tuple/1.83.0/MODULE.bazel": "96640d5e7abec507a5dd63a9f8a6f90e45bc02d7fed6a0fb51e5e869bba9fecd", + "https://bcr.bazel.build/modules/boost.type_traits/1.83.0.bcr.1/MODULE.bazel": "89bbca2de42dc79ffcabb3625103771e4b04566eee6b8cfe7fa807d133d053f7", + "https://bcr.bazel.build/modules/boost.type_traits/1.83.0.bcr.1/source.json": "051e4969558e4a356c5059f4a4f41335b3968b91fa8ae1772898676ec95ded56", + "https://bcr.bazel.build/modules/boost.type_traits/1.83.0/MODULE.bazel": "4a094b5ecac0d41b0c071455ec0b7384e74b54118b4861bd054d5d9ff521d748", + "https://bcr.bazel.build/modules/boost.typeof/1.83.0.bcr.1/MODULE.bazel": "6b3dd6cfe993a8ccf98bce79506be41ec893c65013d7a5be9177c8a185e86d87", + "https://bcr.bazel.build/modules/boost.typeof/1.83.0.bcr.1/source.json": "0ec40beca58de1b17c1ddb18c357ef525977e4312540122b3b91cbe485556f17", + "https://bcr.bazel.build/modules/boost.typeof/1.83.0/MODULE.bazel": "da614fe02971fa4d77c33e94274d1d72ca7fae6ef3e94288f90064b1c8bb6278", + "https://bcr.bazel.build/modules/boost.unordered/1.83.0/MODULE.bazel": "2fffc6c8bbb119a59561d40dc8add727636b778adb4b1df2a523cd1b1b2393ac", + "https://bcr.bazel.build/modules/boost.unordered/1.83.0/source.json": "c1488a104633d662cd782a7afcd7278f55384eada175a1154c237fd70dbb175c", + "https://bcr.bazel.build/modules/boost.utility/1.83.0.bcr.1/MODULE.bazel": "1346dc27d6c8b7ced10896224ed3e406adac3fd79c8450d78c291228f1b9075d", + "https://bcr.bazel.build/modules/boost.utility/1.83.0.bcr.1/source.json": "15636369b5452784e7bd04f7ae52c751e591dd4ebb852688fccc66234d452929", + "https://bcr.bazel.build/modules/boost.utility/1.83.0/MODULE.bazel": "e122ee2a63d4e76dec8d2f81b13f95b7638fcbcd15f752610a3343f13bdb97fd", + "https://bcr.bazel.build/modules/boost.uuid/1.83.0.bcr.1/MODULE.bazel": "0ec51572f062cfb4795cf57c84a16b1b61890954dead42dd55e8616e09159c37", + "https://bcr.bazel.build/modules/boost.uuid/1.83.0.bcr.1/source.json": "d53f1653d8c2062f42884311de23220573e287b1eb224c465845357ded8c5a89", + "https://bcr.bazel.build/modules/boost.variant2/1.83.0.bcr.1/MODULE.bazel": "c60baa3b8923712a156197ffaf5cf9972bf35e44d00a90f7019a06761f391d3e", + "https://bcr.bazel.build/modules/boost.variant2/1.83.0.bcr.1/source.json": "041f94707bd509bc1f93782ccb6c38d491ac0dca25d26011f2047639d3a2bcd1", + "https://bcr.bazel.build/modules/boost.winapi/1.83.0.bcr.1/MODULE.bazel": "faf78b50dae672a38b77db545a460428cfe47a8d79466455ef397d76037e9e40", + "https://bcr.bazel.build/modules/boost.winapi/1.83.0.bcr.1/source.json": "0957b4dabe425e7f9d8d02db63969b808a280c11388ad7814e50b0779ae592cc", + "https://bcr.bazel.build/modules/boringssl/0.0.0-20211025-d4f1ab9/MODULE.bazel": "6ee6353f8b1a701fe2178e1d925034294971350b6d3ac37e67e5a7d463267834", + "https://bcr.bazel.build/modules/boringssl/0.0.0-20211025-d4f1ab9/source.json": "323bafff99739f6aba35b69a84f0bc04ddb4540a46c1694355f60f073dff3001", + "https://bcr.bazel.build/modules/buildozer/7.1.2/MODULE.bazel": "2e8dd40ede9c454042645fd8d8d0cd1527966aa5c919de86661e62953cd73d84", + "https://bcr.bazel.build/modules/buildozer/7.1.2/source.json": "c9028a501d2db85793a6996205c8de120944f50a0d570438fcae0457a5f9d1f8", + "https://bcr.bazel.build/modules/gflags/2.2.2/MODULE.bazel": "ba6502c3fee189734f359454db8a49b7c08afd7271b32e7c6fc38c2d2e1edbeb", + "https://bcr.bazel.build/modules/gflags/2.2.2/source.json": "b06d93702e18b5d75a69d53464c37ef5c2a9b4e237a8d4f2bf0217b3b0af2bee", + "https://bcr.bazel.build/modules/glog/0.5.0/MODULE.bazel": "f5e4f5ae1c0642c84a06a68c5428a576b28bac2cd1dfa3faf5b6d683c69007a4", + "https://bcr.bazel.build/modules/glog/0.5.0/source.json": "241565699f6a5428189e090297f6f9742259e791908cbace6e9f0eeb8104bd9e", + "https://bcr.bazel.build/modules/google_benchmark/1.8.2/MODULE.bazel": "a70cf1bba851000ba93b58ae2f6d76490a9feb74192e57ab8e8ff13c34ec50cb", + "https://bcr.bazel.build/modules/googletest/1.11.0/MODULE.bazel": "3a83f095183f66345ca86aa13c58b59f9f94a2f81999c093d4eeaa2d262d12f4", + "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/MODULE.bazel": "22c31a561553727960057361aa33bf20fb2e98584bc4fec007906e27053f80c6", + "https://bcr.bazel.build/modules/googletest/1.14.0.bcr.1/source.json": "41e9e129f80d8c8bf103a7acc337b76e54fad1214ac0a7084bf24f4cd924b8b4", + "https://bcr.bazel.build/modules/googletest/1.14.0/MODULE.bazel": "cfbcbf3e6eac06ef9d85900f64424708cc08687d1b527f0ef65aa7517af8118f", + "https://bcr.bazel.build/modules/jsoncpp/1.9.5/MODULE.bazel": "31271aedc59e815656f5736f282bb7509a97c7ecb43e927ac1a37966e0578075", + "https://bcr.bazel.build/modules/jsoncpp/1.9.5/source.json": "4108ee5085dd2885a341c7fab149429db457b3169b86eb081fa245eadf69169d", + "https://bcr.bazel.build/modules/libevent/2.1.12/MODULE.bazel": "not found", + "https://bcr.bazel.build/modules/libpfm/4.11.0/MODULE.bazel": "45061ff025b301940f1e30d2c16bea596c25b176c8b6b3087e92615adbd52902", + "https://bcr.bazel.build/modules/libunwind/1.8.1/MODULE.bazel": "d9b947b15135786aed51671c22872a93e2637c74caa20e94f2061fd3b1efd6c3", + "https://bcr.bazel.build/modules/libunwind/1.8.1/source.json": "2b4e58e2fa6ed7204862ab1a4e5978e4107340884c3217596ff7910b8dfae919", + "https://bcr.bazel.build/modules/platforms/0.0.10/MODULE.bazel": "8cb8efaf200bdeb2150d93e162c40f388529a25852b332cec879373771e48ed5", + "https://bcr.bazel.build/modules/platforms/0.0.11/MODULE.bazel": "0daefc49732e227caa8bfa834d65dc52e8cc18a2faf80df25e8caea151a9413f", + "https://bcr.bazel.build/modules/platforms/0.0.11/source.json": "f7e188b79ebedebfe75e9e1d098b8845226c7992b307e28e1496f23112e8fc29", + "https://bcr.bazel.build/modules/platforms/0.0.4/MODULE.bazel": "9b328e31ee156f53f3c416a64f8491f7eb731742655a47c9eec4703a71644aee", + "https://bcr.bazel.build/modules/platforms/0.0.5/MODULE.bazel": "5733b54ea419d5eaf7997054bb55f6a1d0b5ff8aedf0176fef9eea44f3acda37", + "https://bcr.bazel.build/modules/platforms/0.0.6/MODULE.bazel": "ad6eeef431dc52aefd2d77ed20a4b353f8ebf0f4ecdd26a807d2da5aa8cd0615", + "https://bcr.bazel.build/modules/platforms/0.0.7/MODULE.bazel": "72fd4a0ede9ee5c021f6a8dd92b503e089f46c227ba2813ff183b71616034814", + "https://bcr.bazel.build/modules/platforms/0.0.8/MODULE.bazel": "9f142c03e348f6d263719f5074b21ef3adf0b139ee4c5133e2aa35664da9eb2d", + "https://bcr.bazel.build/modules/platforms/0.0.9/MODULE.bazel": "4a87a60c927b56ddd67db50c89acaa62f4ce2a1d2149ccb63ffd871d5ce29ebc", + "https://bcr.bazel.build/modules/protobuf/21.7/MODULE.bazel": "a5a29bb89544f9b97edce05642fac225a808b5b7be74038ea3640fae2f8e66a7", + "https://bcr.bazel.build/modules/protobuf/27.0/MODULE.bazel": "7873b60be88844a0a1d8f80b9d5d20cfbd8495a689b8763e76c6372998d3f64c", + "https://bcr.bazel.build/modules/protobuf/27.3/MODULE.bazel": "d94898cbf9d6d25c0edca2521211413506b68a109a6b01776832ed25154d23d7", + "https://bcr.bazel.build/modules/protobuf/27.3/source.json": "d6fdc641a99c600df6eb0fa5b99879ca497dbcf6fd1287372576a83f82dd93b6", + "https://bcr.bazel.build/modules/protobuf/3.19.0/MODULE.bazel": "6b5fbb433f760a99a22b18b6850ed5784ef0e9928a72668b66e4d7ccd47db9b0", + "https://bcr.bazel.build/modules/protobuf/3.19.6/MODULE.bazel": "9233edc5e1f2ee276a60de3eaa47ac4132302ef9643238f23128fea53ea12858", + "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/MODULE.bazel": "88af1c246226d87e65be78ed49ecd1e6f5e98648558c14ce99176da041dc378e", + "https://bcr.bazel.build/modules/pybind11_bazel/2.11.1/source.json": "be4789e951dd5301282729fe3d4938995dc4c1a81c2ff150afc9f1b0504c6022", + "https://bcr.bazel.build/modules/re2/2023-09-01/MODULE.bazel": "cb3d511531b16cfc78a225a9e2136007a48cf8a677e4264baeab57fe78a80206", + "https://bcr.bazel.build/modules/re2/2023-09-01/source.json": "e044ce89c2883cd957a2969a43e79f7752f9656f6b20050b62f90ede21ec6eb4", + "https://bcr.bazel.build/modules/rules_cc/0.0.1/MODULE.bazel": "cb2aa0747f84c6c3a78dad4e2049c154f08ab9d166b1273835a8174940365647", + "https://bcr.bazel.build/modules/rules_cc/0.0.12/MODULE.bazel": "28259f5cb8dd72d7503eb4fd1f9c89ab13759a438b1b78cb9655568d8566d7f9", + "https://bcr.bazel.build/modules/rules_cc/0.0.13/MODULE.bazel": "0e8529ed7b323dad0775ff924d2ae5af7640b23553dfcd4d34344c7e7a867191", + "https://bcr.bazel.build/modules/rules_cc/0.0.2/MODULE.bazel": "6915987c90970493ab97393024c156ea8fb9f3bea953b2f3ec05c34f19b5695c", + "https://bcr.bazel.build/modules/rules_cc/0.0.6/MODULE.bazel": "abf360251023dfe3efcef65ab9d56beefa8394d4176dd29529750e1c57eaa33f", + "https://bcr.bazel.build/modules/rules_cc/0.0.8/MODULE.bazel": "964c85c82cfeb6f3855e6a07054fdb159aced38e99a5eecf7bce9d53990afa3e", + "https://bcr.bazel.build/modules/rules_cc/0.0.9/MODULE.bazel": "836e76439f354b89afe6a911a7adf59a6b2518fafb174483ad78a2a2fde7b1c5", + "https://bcr.bazel.build/modules/rules_cc/0.1.1/MODULE.bazel": "2f0222a6f229f0bf44cd711dc13c858dad98c62d52bd51d8fc3a764a83125513", + "https://bcr.bazel.build/modules/rules_cc/0.1.1/source.json": "d61627377bd7dd1da4652063e368d9366fc9a73920bfa396798ad92172cf645c", + "https://bcr.bazel.build/modules/rules_foreign_cc/0.12.0/MODULE.bazel": "d850fab025ce79a845077035861034393f1cc1efc1d9d58d766272a26ba67def", + "https://bcr.bazel.build/modules/rules_foreign_cc/0.12.0/source.json": "c97ddc022179fe30d1a9b94425d1e56d0a633f72332c55463e584a52ce1b38ac", + "https://bcr.bazel.build/modules/rules_foreign_cc/0.8.0/MODULE.bazel": "e9b4fe0b66c8a7e57bd385a304ea812dcaac3b69b762e2346c808cde26b8cb8d", + "https://bcr.bazel.build/modules/rules_foreign_cc/0.9.0/MODULE.bazel": "c9e8c682bf75b0e7c704166d79b599f93b72cfca5ad7477df596947891feeef6", + "https://bcr.bazel.build/modules/rules_java/4.0.0/MODULE.bazel": "5a78a7ae82cd1a33cef56dc578c7d2a46ed0dca12643ee45edbb8417899e6f74", + "https://bcr.bazel.build/modules/rules_java/5.3.5/MODULE.bazel": "a4ec4f2db570171e3e5eb753276ee4b389bae16b96207e9d3230895c99644b86", + "https://bcr.bazel.build/modules/rules_java/7.6.1/MODULE.bazel": "2f14b7e8a1aa2f67ae92bc69d1ec0fa8d9f827c4e17ff5e5f02e91caa3b2d0fe", + "https://bcr.bazel.build/modules/rules_java/7.6.1/source.json": "8f3f3076554e1558e8e468b2232991c510ecbcbed9e6f8c06ac31c93bcf38362", + "https://bcr.bazel.build/modules/rules_jvm_external/4.4.2/MODULE.bazel": "a56b85e418c83eb1839819f0b515c431010160383306d13ec21959ac412d2fe7", + "https://bcr.bazel.build/modules/rules_jvm_external/5.1/MODULE.bazel": "33f6f999e03183f7d088c9be518a63467dfd0be94a11d0055fe2d210f89aa909", + "https://bcr.bazel.build/modules/rules_jvm_external/5.1/source.json": "5abb45cc9beb27b77aec6a65a11855ef2b55d95dfdc358e9f312b78ae0ba32d5", + "https://bcr.bazel.build/modules/rules_license/0.0.3/MODULE.bazel": "627e9ab0247f7d1e05736b59dbb1b6871373de5ad31c3011880b4133cafd4bd0", + "https://bcr.bazel.build/modules/rules_license/0.0.7/MODULE.bazel": "088fbeb0b6a419005b89cf93fe62d9517c0a2b8bb56af3244af65ecfe37e7d5d", + "https://bcr.bazel.build/modules/rules_license/1.0.0/MODULE.bazel": "a7fda60eefdf3d8c827262ba499957e4df06f659330bbe6cdbdb975b768bb65c", + "https://bcr.bazel.build/modules/rules_license/1.0.0/source.json": "a52c89e54cc311196e478f8382df91c15f7a2bfdf4c6cd0e2675cc2ff0b56efb", + "https://bcr.bazel.build/modules/rules_pkg/0.7.0/MODULE.bazel": "df99f03fc7934a4737122518bb87e667e62d780b610910f0447665a7e2be62dc", + "https://bcr.bazel.build/modules/rules_pkg/0.7.0/source.json": "c2557066e0c0342223ba592510ad3d812d4963b9024831f7f66fd0584dd8c66c", + "https://bcr.bazel.build/modules/rules_proto/4.0.0/MODULE.bazel": "a7a7b6ce9bee418c1a760b3d84f83a299ad6952f9903c67f19e4edd964894e06", + "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/MODULE.bazel": "e8dff86b0971688790ae75528fe1813f71809b5afd57facb44dad9e8eca631b7", + "https://bcr.bazel.build/modules/rules_proto/5.3.0-21.7/source.json": "d57902c052424dfda0e71646cb12668d39c4620ee0544294d9d941e7d12bc3a9", + "https://bcr.bazel.build/modules/rules_python/0.10.2/MODULE.bazel": "cc82bc96f2997baa545ab3ce73f196d040ffb8756fd2d66125a530031cd90e5f", + "https://bcr.bazel.build/modules/rules_python/0.22.1/MODULE.bazel": "26114f0c0b5e93018c0c066d6673f1a2c3737c7e90af95eff30cfee38d0bbac7", + "https://bcr.bazel.build/modules/rules_python/0.23.1/MODULE.bazel": "49ffccf0511cb8414de28321f5fcf2a31312b47c40cc21577144b7447f2bf300", + "https://bcr.bazel.build/modules/rules_python/0.25.0/MODULE.bazel": "72f1506841c920a1afec76975b35312410eea3aa7b63267436bfb1dd91d2d382", + "https://bcr.bazel.build/modules/rules_python/0.25.0/source.json": "c45006984eeaa18ad14c006091b264bff620c41952e9184edfe225ea95c3f986", + "https://bcr.bazel.build/modules/rules_python/0.4.0/MODULE.bazel": "9208ee05fd48bf09ac60ed269791cf17fb343db56c8226a720fbb1cdf467166c", + "https://bcr.bazel.build/modules/snappy/1.2.2/MODULE.bazel": "f8d3ddaad8d45d504dd537b2a3205ebcb1c4f3ae88d81b225681e4b88faead7c", + "https://bcr.bazel.build/modules/snappy/1.2.2/source.json": "790f71ab14c7cb97f39a9678e5bbbc5164822ea0115bbfa606d80b884b0da38c", + "https://bcr.bazel.build/modules/stardoc/0.5.1/MODULE.bazel": "1a05d92974d0c122f5ccf09291442580317cdd859f07a8655f1db9a60374f9f8", + "https://bcr.bazel.build/modules/stardoc/0.5.3/MODULE.bazel": "c7f6948dae6999bf0db32c1858ae345f112cacf98f174c7a8bb707e41b974f1c", + "https://bcr.bazel.build/modules/stardoc/0.5.3/source.json": "cd53fe968dc8cd98197c052db3db6d82562960c87b61e7a90ee96f8e4e0dda97", + "https://bcr.bazel.build/modules/thrift/0.21.0/MODULE.bazel": "not found", + "https://bcr.bazel.build/modules/upb/0.0.0-20220923-a547704/MODULE.bazel": "7298990c00040a0e2f121f6c32544bab27d4452f80d9ce51349b1a28f3005c43", + "https://bcr.bazel.build/modules/xz/5.4.5.bcr.5/MODULE.bazel": "b93d7035ac14c900dfdf7624e42cfcbfc34415aa8d3c83a6f225867c48d28dad", + "https://bcr.bazel.build/modules/xz/5.4.5.bcr.5/source.json": "30c4e5c856087a60d92e2522eafd316c0661671f4478ca94c6b7bd877010210a", + "https://bcr.bazel.build/modules/zlib/1.2.11/MODULE.bazel": "07b389abc85fdbca459b69e2ec656ae5622873af3f845e1c9d80fe179f3effa0", + "https://bcr.bazel.build/modules/zlib/1.2.12/MODULE.bazel": "3b1a8834ada2a883674be8cbd36ede1b6ec481477ada359cd2d3ddc562340b27", + "https://bcr.bazel.build/modules/zlib/1.2.13/MODULE.bazel": "aa6deb1b83c18ffecd940c4119aff9567cd0a671d7bba756741cb2ef043a29d5", + "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.5/MODULE.bazel": "eec517b5bbe5492629466e11dae908d043364302283de25581e3eb944326c4ca", + "https://bcr.bazel.build/modules/zlib/1.3.1.bcr.5/source.json": "22bc55c47af97246cfc093d0acf683a7869377de362b5d1c552c2c2e16b7a806", + "https://bcr.bazel.build/modules/zlib/1.3/MODULE.bazel": "6a9c02f19a24dcedb05572b2381446e27c272cd383aed11d41d99da9e3167a72", + "https://raw.githubusercontent.com/secretflow/bazel-registry/main/bazel_registry.json": "8a28e4aff06ee60aed2a8c281907fb8bcbf3b753c91fb5a5c57da3215d5b3497", + "https://raw.githubusercontent.com/secretflow/bazel-registry/main/modules/leveldb/1.23/MODULE.bazel": "450b5dafff03fd68d2c57544e0cdca1411e9cf42ae599e31fbbbfdf1ddea92b3", + "https://raw.githubusercontent.com/secretflow/bazel-registry/main/modules/leveldb/1.23/source.json": "82a078a44ec4a6c299fe108e87b6d7a0ce56dd46206bfc69495001087d7e2dfb", + "https://raw.githubusercontent.com/secretflow/bazel-registry/main/modules/openssl/3.3.2.bcr.1/MODULE.bazel": "e26204291f98123dd57567b1b558518777787b488d946fbabe181249e1336029", + "https://raw.githubusercontent.com/secretflow/bazel-registry/main/modules/openssl/3.3.2.bcr.1/source.json": "ae3d5c57f40316cdd5d017a5fdc280d5980119556ec61000c0d7d9276b1d8610" + }, + "selectedYankedVersions": {}, + "moduleExtensions": { + "@@apple_support~//crosstool:setup.bzl%apple_cc_configure_extension": { + "general": { + "bzlTransitiveDigest": "7ii+gFxWSxHhQPrBxfMEHhtrGvHmBTvsh+KOyGunP/s=", + "usagesDigest": "lTon/N84OKzwOBzHgfdF8vJqtH0gCUX9FqtuRj2zj44=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "local_config_apple_cc": { + "bzlFile": "@@apple_support~//crosstool:setup.bzl", + "ruleClassName": "_apple_cc_autoconf", + "attributes": {} + }, + "local_config_apple_cc_toolchains": { + "bzlFile": "@@apple_support~//crosstool:setup.bzl", + "ruleClassName": "_apple_cc_autoconf_toolchains", + "attributes": {} + } + }, + "recordedRepoMappingEntries": [ + [ + "apple_support~", + "bazel_tools", + "bazel_tools" + ] + ] + } + }, + "@@rules_foreign_cc~//foreign_cc:extensions.bzl%tools": { + "general": { + "bzlTransitiveDigest": "f6RBwbUKS3C3FNQJAYhIWLiHaTLQDr1nKJidK7iQTBg=", + "usagesDigest": "rcono0M8vAWDAJxsr93rRa5vX8s73ZexMVAKXNZRFTg=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "cmake-3.23.2-linux-aarch64": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/Kitware/CMake/releases/download/v3.23.2/cmake-3.23.2-linux-aarch64.tar.gz" + ], + "sha256": "f2654bf780b53f170bbbec44d8ac67d401d24788e590faa53036a89476efa91e", + "strip_prefix": "cmake-3.23.2-linux-aarch64", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"cmake_bin\",\n srcs = [\"bin/cmake\"],\n)\n\nfilegroup(\n name = \"cmake_data\",\n srcs = glob(\n [\n \"**\",\n ],\n exclude = [\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"**/* *\",\n ],\n ),\n)\n\nnative_tool_toolchain(\n name = \"cmake_tool\",\n path = \"bin/cmake\",\n target = \":cmake_data\",\n env = {\"CMAKE\": \"$(execpath :cmake_bin)\"},\n tools = [\":cmake_bin\"],\n)\n" + } + }, + "rules_foreign_cc_framework_toolchain_macos": { + "bzlFile": "@@rules_foreign_cc~//foreign_cc/private/framework:toolchain.bzl", + "ruleClassName": "framework_toolchain_repository", + "attributes": { + "commands_src": "@rules_foreign_cc//foreign_cc/private/framework/toolchains:macos_commands.bzl", + "exec_compatible_with": [ + "@platforms//os:macos" + ] + } + }, + "ninja_1.12.1_win": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-win.zip" + ], + "sha256": "f550fec705b6d6ff58f2db3c374c2277a37691678d6aba463adcbb129108467a", + "strip_prefix": "", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"ninja_bin\",\n srcs = [\"ninja.exe\"],\n)\n\nnative_tool_toolchain(\n name = \"ninja_tool\",\n env = {\"NINJA\": \"$(execpath :ninja_bin)\"},\n path = \"$(execpath :ninja_bin)\",\n target = \":ninja_bin\",\n)\n" + } + }, + "gnumake_src": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "filegroup(\n name = \"all_srcs\",\n srcs = glob([\"**\"]),\n visibility = [\"//visibility:public\"],\n)\n", + "sha256": "dd16fb1d67bfab79a72f5e8390735c49e3e8e70b4945a15ab1f81ddb78658fb3", + "strip_prefix": "make-4.4.1", + "urls": [ + "https://mirror.bazel.build/ftpmirror.gnu.org/gnu/make/make-4.4.1.tar.gz", + "http://ftpmirror.gnu.org/gnu/make/make-4.4.1.tar.gz" + ] + } + }, + "gettext_runtime": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "\ncc_import(\n name = \"gettext_runtime\",\n shared_library = \"bin/libintl-8.dll\",\n visibility = [\"//visibility:public\"],\n)\n ", + "sha256": "1f4269c0e021076d60a54e98da6f978a3195013f6de21674ba0edbc339c5b079", + "urls": [ + "https://mirror.bazel.build/download.gnome.org/binaries/win64/dependencies/gettext-runtime_0.18.1.1-2_win64.zip", + "https://download.gnome.org/binaries/win64/dependencies/gettext-runtime_0.18.1.1-2_win64.zip" + ] + } + }, + "cmake_src": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "filegroup(\n name = \"all_srcs\",\n srcs = glob([\"**\"]),\n visibility = [\"//visibility:public\"],\n)\n", + "sha256": "f316b40053466f9a416adf981efda41b160ca859e97f6a484b447ea299ff26aa", + "strip_prefix": "cmake-3.23.2", + "urls": [ + "https://github.com/Kitware/CMake/releases/download/v3.23.2/cmake-3.23.2.tar.gz" + ], + "patches": [ + "@@rules_foreign_cc~//toolchains:cmake-c++11.patch" + ] + } + }, + "bazel_skylib": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://mirror.bazel.build/github.com/bazelbuild/bazel-skylib/releases/download/1.2.1/bazel-skylib-1.2.1.tar.gz", + "https://github.com/bazelbuild/bazel-skylib/releases/download/1.2.1/bazel-skylib-1.2.1.tar.gz" + ], + "sha256": "f7be3474d42aae265405a592bb7da8e171919d74c16f082a5457840f06054728" + } + }, + "cmake-3.23.2-macos-universal": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/Kitware/CMake/releases/download/v3.23.2/cmake-3.23.2-macos-universal.tar.gz" + ], + "sha256": "853a0f9af148c5ef47282ffffee06c4c9f257be2635936755f39ca13c3286c88", + "strip_prefix": "cmake-3.23.2-macos-universal/CMake.app/Contents", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"cmake_bin\",\n srcs = [\"bin/cmake\"],\n)\n\nfilegroup(\n name = \"cmake_data\",\n srcs = glob(\n [\n \"**\",\n ],\n exclude = [\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"**/* *\",\n ],\n ),\n)\n\nnative_tool_toolchain(\n name = \"cmake_tool\",\n path = \"bin/cmake\",\n target = \":cmake_data\",\n env = {\"CMAKE\": \"$(execpath :cmake_bin)\"},\n tools = [\":cmake_bin\"],\n)\n" + } + }, + "ninja_1.12.1_linux-aarch64": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-linux-aarch64.zip" + ], + "sha256": "5c25c6570b0155e95fce5918cb95f1ad9870df5768653afe128db822301a05a1", + "strip_prefix": "", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"ninja_bin\",\n srcs = [\"ninja\"],\n)\n\nnative_tool_toolchain(\n name = \"ninja_tool\",\n env = {\"NINJA\": \"$(execpath :ninja_bin)\"},\n path = \"$(execpath :ninja_bin)\",\n target = \":ninja_bin\",\n)\n" + } + }, + "meson_src": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "exports_files([\"meson.py\"])\n\nfilegroup(\n name = \"runtime\",\n srcs = glob([\"mesonbuild/**\"]),\n visibility = [\"//visibility:public\"],\n)\n", + "sha256": "567e533adf255de73a2de35049b99923caf872a455af9ce03e01077e0d384bed", + "strip_prefix": "meson-1.5.1", + "urls": [ + "https://mirror.bazel.build/github.com/mesonbuild/meson/releases/download/1.5.1/meson-1.5.1.tar.gz", + "https://github.com/mesonbuild/meson/releases/download/1.5.1/meson-1.5.1.tar.gz" + ] + } + }, + "rules_foreign_cc_framework_toolchain_freebsd": { + "bzlFile": "@@rules_foreign_cc~//foreign_cc/private/framework:toolchain.bzl", + "ruleClassName": "framework_toolchain_repository", + "attributes": { + "commands_src": "@rules_foreign_cc//foreign_cc/private/framework/toolchains:freebsd_commands.bzl", + "exec_compatible_with": [ + "@platforms//os:freebsd" + ] + } + }, + "rules_foreign_cc_framework_toolchain_linux": { + "bzlFile": "@@rules_foreign_cc~//foreign_cc/private/framework:toolchain.bzl", + "ruleClassName": "framework_toolchain_repository", + "attributes": { + "commands_src": "@rules_foreign_cc//foreign_cc/private/framework/toolchains:linux_commands.bzl", + "exec_compatible_with": [ + "@platforms//os:linux" + ] + } + }, + "rules_python": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "sha256": "84aec9e21cc56fbc7f1335035a71c850d1b9b5cc6ff497306f84cced9a769841", + "strip_prefix": "rules_python-0.23.1", + "url": "https://github.com/bazelbuild/rules_python/archive/refs/tags/0.23.1.tar.gz" + } + }, + "ninja_1.12.1_mac": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-mac.zip" + ], + "sha256": "89a287444b5b3e98f88a945afa50ce937b8ffd1dcc59c555ad9b1baf855298c9", + "strip_prefix": "", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"ninja_bin\",\n srcs = [\"ninja\"],\n)\n\nnative_tool_toolchain(\n name = \"ninja_tool\",\n env = {\"NINJA\": \"$(execpath :ninja_bin)\"},\n path = \"$(execpath :ninja_bin)\",\n target = \":ninja_bin\",\n)\n" + } + }, + "pkgconfig_src": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "filegroup(\n name = \"all_srcs\",\n srcs = glob([\"**\"]),\n visibility = [\"//visibility:public\"],\n)\n", + "sha256": "6fc69c01688c9458a57eb9a1664c9aba372ccda420a02bf4429fe610e7e7d591", + "strip_prefix": "pkg-config-0.29.2", + "patches": [ + "@@rules_foreign_cc~//toolchains:pkgconfig-detectenv.patch", + "@@rules_foreign_cc~//toolchains:pkgconfig-makefile-vc.patch", + "@@rules_foreign_cc~//toolchains:pkgconfig-builtin-glib-int-conversion.patch" + ], + "urls": [ + "https://pkgconfig.freedesktop.org/releases/pkg-config-0.29.2.tar.gz", + "https://mirror.bazel.build/pkgconfig.freedesktop.org/releases/pkg-config-0.29.2.tar.gz" + ] + } + }, + "ninja_build_src": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "filegroup(\n name = \"all_srcs\",\n srcs = glob([\"**\"]),\n visibility = [\"//visibility:public\"],\n)\n", + "integrity": "sha256-ghvf9Io/aDvEuztvC1/nstZHz2XVKutjMoyRpsbfKFo=", + "strip_prefix": "ninja-1.12.1", + "urls": [ + "https://mirror.bazel.build/github.com/ninja-build/ninja/archive/v1.12.1.tar.gz", + "https://github.com/ninja-build/ninja/archive/v1.12.1.tar.gz" + ] + } + }, + "glib_src": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "\ncc_import(\n name = \"msvc_hdr\",\n hdrs = [\"msvc_recommended_pragmas.h\"],\n visibility = [\"//visibility:public\"],\n)\n ", + "sha256": "bc96f63112823b7d6c9f06572d2ad626ddac7eb452c04d762592197f6e07898e", + "strip_prefix": "glib-2.26.1", + "urls": [ + "https://mirror.bazel.build/download.gnome.org/sources/glib/2.26/glib-2.26.1.tar.gz", + "https://download.gnome.org/sources/glib/2.26/glib-2.26.1.tar.gz" + ] + } + }, + "ninja_1.12.1_linux": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-linux.zip" + ], + "sha256": "6f98805688d19672bd699fbbfa2c2cf0fc054ac3df1f0e6a47664d963d530255", + "strip_prefix": "", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"ninja_bin\",\n srcs = [\"ninja\"],\n)\n\nnative_tool_toolchain(\n name = \"ninja_tool\",\n env = {\"NINJA\": \"$(execpath :ninja_bin)\"},\n path = \"$(execpath :ninja_bin)\",\n target = \":ninja_bin\",\n)\n" + } + }, + "cmake-3.23.2-windows-x86_64": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/Kitware/CMake/releases/download/v3.23.2/cmake-3.23.2-windows-x86_64.zip" + ], + "sha256": "2329387f3166b84c25091c86389fb891193967740c9bcf01e7f6d3306f7ffda0", + "strip_prefix": "cmake-3.23.2-windows-x86_64", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"cmake_bin\",\n srcs = [\"bin/cmake.exe\"],\n)\n\nfilegroup(\n name = \"cmake_data\",\n srcs = glob(\n [\n \"**\",\n ],\n exclude = [\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"**/* *\",\n ],\n ),\n)\n\nnative_tool_toolchain(\n name = \"cmake_tool\",\n path = \"bin/cmake.exe\",\n target = \":cmake_data\",\n env = {\"CMAKE\": \"$(execpath :cmake_bin)\"},\n tools = [\":cmake_bin\"],\n)\n" + } + }, + "glib_runtime": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "\nexports_files(\n [\n \"bin/libgio-2.0-0.dll\",\n \"bin/libglib-2.0-0.dll\",\n \"bin/libgmodule-2.0-0.dll\",\n \"bin/libgobject-2.0-0.dll\",\n \"bin/libgthread-2.0-0.dll\",\n ],\n visibility = [\"//visibility:public\"],\n)\n ", + "sha256": "88d857087e86f16a9be651ee7021880b3f7ba050d34a1ed9f06113b8799cb973", + "urls": [ + "https://mirror.bazel.build/download.gnome.org/binaries/win64/glib/2.26/glib_2.26.1-1_win64.zip", + "https://download.gnome.org/binaries/win64/glib/2.26/glib_2.26.1-1_win64.zip" + ] + } + }, + "rules_foreign_cc_framework_toolchains": { + "bzlFile": "@@rules_foreign_cc~//foreign_cc/private/framework:toolchain.bzl", + "ruleClassName": "framework_toolchain_repository_hub", + "attributes": {} + }, + "bazel_features": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "sha256": "ba1282c1aa1d1fffdcf994ab32131d7c7551a9bc960fbf05f42d55a1b930cbfb", + "strip_prefix": "bazel_features-1.15.0", + "url": "https://github.com/bazel-contrib/bazel_features/releases/download/v1.15.0/bazel_features-v1.15.0.tar.gz" + } + }, + "ninja_1.12.1_toolchains": { + "bzlFile": "@@rules_foreign_cc~//toolchains:prebuilt_toolchains_repository.bzl", + "ruleClassName": "prebuilt_toolchains_repository", + "attributes": { + "repos": { + "ninja_1.12.1_linux": [ + "@platforms//cpu:x86_64", + "@platforms//os:linux" + ], + "ninja_1.12.1_linux-aarch64": [ + "@platforms//cpu:aarch64", + "@platforms//os:linux" + ], + "ninja_1.12.1_mac": [ + "@platforms//cpu:x86_64", + "@platforms//os:macos" + ], + "ninja_1.12.1_mac_aarch64": [ + "@platforms//cpu:aarch64", + "@platforms//os:macos" + ], + "ninja_1.12.1_win": [ + "@platforms//cpu:x86_64", + "@platforms//os:windows" + ] + }, + "tool": "ninja" + } + }, + "glib_dev": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "build_file_content": "\nload(\"@rules_cc//cc:defs.bzl\", \"cc_library\")\n\ncc_import(\n name = \"glib_dev\",\n hdrs = glob([\"include/**\"]),\n shared_library = \"@glib_runtime//:bin/libglib-2.0-0.dll\",\n visibility = [\"//visibility:public\"],\n)\n ", + "sha256": "bdf18506df304d38be98a4b3f18055b8b8cca81beabecad0eece6ce95319c369", + "urls": [ + "https://mirror.bazel.build/download.gnome.org/binaries/win64/glib/2.26/glib-dev_2.26.1-1_win64.zip", + "https://download.gnome.org/binaries/win64/glib/2.26/glib-dev_2.26.1-1_win64.zip" + ] + } + }, + "cmake_3.23.2_toolchains": { + "bzlFile": "@@rules_foreign_cc~//toolchains:prebuilt_toolchains_repository.bzl", + "ruleClassName": "prebuilt_toolchains_repository", + "attributes": { + "repos": { + "cmake-3.23.2-linux-aarch64": [ + "@platforms//cpu:aarch64", + "@platforms//os:linux" + ], + "cmake-3.23.2-linux-x86_64": [ + "@platforms//cpu:x86_64", + "@platforms//os:linux" + ], + "cmake-3.23.2-macos-universal": [ + "@platforms//os:macos" + ], + "cmake-3.23.2-windows-i386": [ + "@platforms//cpu:x86_32", + "@platforms//os:windows" + ], + "cmake-3.23.2-windows-x86_64": [ + "@platforms//cpu:x86_64", + "@platforms//os:windows" + ] + }, + "tool": "cmake" + } + }, + "cmake-3.23.2-windows-i386": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/Kitware/CMake/releases/download/v3.23.2/cmake-3.23.2-windows-i386.zip" + ], + "sha256": "6a4fcd6a2315b93cb23c93507efccacc30c449c2bf98f14d6032bb226c582e07", + "strip_prefix": "cmake-3.23.2-windows-i386", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"cmake_bin\",\n srcs = [\"bin/cmake.exe\"],\n)\n\nfilegroup(\n name = \"cmake_data\",\n srcs = glob(\n [\n \"**\",\n ],\n exclude = [\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"**/* *\",\n ],\n ),\n)\n\nnative_tool_toolchain(\n name = \"cmake_tool\",\n path = \"bin/cmake.exe\",\n target = \":cmake_data\",\n env = {\"CMAKE\": \"$(execpath :cmake_bin)\"},\n tools = [\":cmake_bin\"],\n)\n" + } + }, + "cmake-3.23.2-linux-x86_64": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/Kitware/CMake/releases/download/v3.23.2/cmake-3.23.2-linux-x86_64.tar.gz" + ], + "sha256": "aaced6f745b86ce853661a595bdac6c5314a60f8181b6912a0a4920acfa32708", + "strip_prefix": "cmake-3.23.2-linux-x86_64", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"cmake_bin\",\n srcs = [\"bin/cmake\"],\n)\n\nfilegroup(\n name = \"cmake_data\",\n srcs = glob(\n [\n \"**\",\n ],\n exclude = [\n \"WORKSPACE\",\n \"WORKSPACE.bazel\",\n \"BUILD\",\n \"BUILD.bazel\",\n \"**/* *\",\n ],\n ),\n)\n\nnative_tool_toolchain(\n name = \"cmake_tool\",\n path = \"bin/cmake\",\n target = \":cmake_data\",\n env = {\"CMAKE\": \"$(execpath :cmake_bin)\"},\n tools = [\":cmake_bin\"],\n)\n" + } + }, + "ninja_1.12.1_mac_aarch64": { + "bzlFile": "@@bazel_tools//tools/build_defs/repo:http.bzl", + "ruleClassName": "http_archive", + "attributes": { + "urls": [ + "https://github.com/ninja-build/ninja/releases/download/v1.12.1/ninja-mac.zip" + ], + "sha256": "89a287444b5b3e98f88a945afa50ce937b8ffd1dcc59c555ad9b1baf855298c9", + "strip_prefix": "", + "build_file_content": "load(\"@rules_foreign_cc//toolchains/native_tools:native_tools_toolchain.bzl\", \"native_tool_toolchain\")\n\npackage(default_visibility = [\"//visibility:public\"])\n\nfilegroup(\n name = \"ninja_bin\",\n srcs = [\"ninja\"],\n)\n\nnative_tool_toolchain(\n name = \"ninja_tool\",\n env = {\"NINJA\": \"$(execpath :ninja_bin)\"},\n path = \"$(execpath :ninja_bin)\",\n target = \":ninja_bin\",\n)\n" + } + }, + "rules_foreign_cc_framework_toolchain_windows": { + "bzlFile": "@@rules_foreign_cc~//foreign_cc/private/framework:toolchain.bzl", + "ruleClassName": "framework_toolchain_repository", + "attributes": { + "commands_src": "@rules_foreign_cc//foreign_cc/private/framework/toolchains:windows_commands.bzl", + "exec_compatible_with": [ + "@platforms//os:windows" + ] + } + } + }, + "recordedRepoMappingEntries": [ + [ + "rules_foreign_cc~", + "bazel_tools", + "bazel_tools" + ], + [ + "rules_foreign_cc~", + "rules_foreign_cc", + "rules_foreign_cc~" + ] + ] + } + }, + "@@rules_python~//python/extensions:python.bzl%python": { + "general": { + "bzlTransitiveDigest": "Kf/7zZzswWR1HLTsIkowkR+hnYBf2occRd9uW0D1KME=", + "usagesDigest": "M8/NqQuC9d+paxu5fLyiB29Pv9UCmhBJfvdJsaVw824=", + "recordedFileInputs": {}, + "recordedDirentsInputs": {}, + "envVariables": {}, + "generatedRepoSpecs": { + "python_3_11_s390x-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "e477f0749161f9aa7887964f089d9460a539f6b4a8fdab5166f898210e1a87a4", + "patches": [], + "platform": "s390x-unknown-linux-gnu", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-s390x-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-s390x-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_11_aarch64-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "2e84fc53f4e90e11963281c5c871f593abcb24fc796a50337fa516be99af02fb", + "patches": [], + "platform": "aarch64-unknown-linux-gnu", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-aarch64-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-aarch64-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_11_aarch64-apple-darwin": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "cb6d2948384a857321f2aa40fa67744cd9676a330f08b6dad7070bda0b6120a4", + "patches": [], + "platform": "aarch64-apple-darwin", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-aarch64-apple-darwin-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-aarch64-apple-darwin-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9": { + "bzlFile": "@@rules_python~//python/private:toolchains_repo.bzl", + "ruleClassName": "toolchain_aliases", + "attributes": { + "python_version": "3.9.17", + "user_repository_name": "python_3_9" + } + }, + "pythons_hub": { + "bzlFile": "@@rules_python~//python/extensions/private:pythons_hub.bzl", + "ruleClassName": "hub_repo", + "attributes": { + "default_python_version": "3.11", + "toolchain_prefixes": [ + "_0000_python_3_9_", + "_0001_python_3_11_" + ], + "toolchain_python_versions": [ + "3.9", + "3.11" + ], + "toolchain_set_python_version_constraints": [ + "True", + "False" + ], + "toolchain_user_repository_names": [ + "python_3_9", + "python_3_11" + ] + } + }, + "python_3_11_x86_64-pc-windows-msvc": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "878614c03ea38538ae2f758e36c85d2c0eb1eaaca86cd400ff8c76693ee0b3e1", + "patches": [], + "platform": "x86_64-pc-windows-msvc", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-x86_64-pc-windows-msvc-shared-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-x86_64-pc-windows-msvc-shared-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9_aarch64-apple-darwin": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "73dbe2d702210b566221da9265acc274ba15275c5d0d1fa327f44ad86cde9aa1", + "patches": [], + "platform": "aarch64-apple-darwin", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-aarch64-apple-darwin-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-aarch64-apple-darwin-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9_x86_64-pc-windows-msvc": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "9b9a1e21eff29dcf043cea38180cf8ca3604b90117d00062a7b31605d4157714", + "patches": [], + "platform": "x86_64-pc-windows-msvc", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-x86_64-pc-windows-msvc-shared-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-x86_64-pc-windows-msvc-shared-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9_ppc64le-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "c591a28d943dce5cf9833e916125fdfbeb3120270c4866ee214493ccb5b83c3c", + "patches": [], + "platform": "ppc64le-unknown-linux-gnu", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-ppc64le-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-ppc64le-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9_aarch64-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "b77012ddaf7e0673e4aa4b1c5085275a06eee2d66f33442b5c54a12b62b96cbe", + "patches": [], + "platform": "aarch64-unknown-linux-gnu", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-aarch64-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-aarch64-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_11": { + "bzlFile": "@@rules_python~//python/private:toolchains_repo.bzl", + "ruleClassName": "toolchain_aliases", + "attributes": { + "python_version": "3.11.4", + "user_repository_name": "python_3_11" + } + }, + "python_3_11_ppc64le-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "df7b92ed9cec96b3bb658fb586be947722ecd8e420fb23cee13d2e90abcfcf25", + "patches": [], + "platform": "ppc64le-unknown-linux-gnu", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-ppc64le-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-ppc64le-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_11_x86_64-apple-darwin": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "47e1557d93a42585972772e82661047ca5f608293158acb2778dccf120eabb00", + "patches": [], + "platform": "x86_64-apple-darwin", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-x86_64-apple-darwin-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-x86_64-apple-darwin-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_versions": { + "bzlFile": "@@rules_python~//python/private:toolchains_repo.bzl", + "ruleClassName": "multi_toolchain_aliases", + "attributes": { + "python_versions": { + "3.11": "python_3_11", + "3.9": "python_3_9" + } + } + }, + "python_3_9_x86_64-apple-darwin": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "dfe1bea92c94b9cb779288b0b06e39157c5ff7e465cdd24032ac147c2af485c0", + "patches": [], + "platform": "x86_64-apple-darwin", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-x86_64-apple-darwin-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-x86_64-apple-darwin-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9_x86_64-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "26c4a712b4b8e11ed5c027db5654eb12927c02da4857b777afb98f7a930ce637", + "patches": [], + "platform": "x86_64-unknown-linux-gnu", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-x86_64-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-x86_64-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_9_s390x-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "01454d7cc7c9c2fccde42ba868c4f372eaaafa48049d49dd94c9cf2875f497e6", + "patches": [], + "platform": "s390x-unknown-linux-gnu", + "python_version": "3.9.17", + "release_filename": "20230726/cpython-3.9.17+20230726-s390x-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.9.17+20230726-s390x-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + }, + "python_3_11_x86_64-unknown-linux-gnu": { + "bzlFile": "@@rules_python~//python:repositories.bzl", + "ruleClassName": "python_repository", + "attributes": { + "sha256": "e26247302bc8e9083a43ce9e8dd94905b40d464745b1603041f7bc9a93c65d05", + "patches": [], + "platform": "x86_64-unknown-linux-gnu", + "python_version": "3.11.4", + "release_filename": "20230726/cpython-3.11.4+20230726-x86_64-unknown-linux-gnu-install_only.tar.gz", + "urls": [ + "https://github.com/indygreg/python-build-standalone/releases/download/20230726/cpython-3.11.4+20230726-x86_64-unknown-linux-gnu-install_only.tar.gz" + ], + "distutils_content": "", + "strip_prefix": "python", + "coverage_tool": "", + "ignore_root_user_error": false + } + } + }, + "recordedRepoMappingEntries": [ + [ + "rules_python~", + "bazel_tools", + "bazel_tools" + ] + ] + } + } + } +} diff --git a/src/brpc/policy/public_pbrpc_protocol.cpp b/src/brpc/policy/public_pbrpc_protocol.cpp index 38a749dc72..1e30a846bb 100644 --- a/src/brpc/policy/public_pbrpc_protocol.cpp +++ b/src/brpc/policy/public_pbrpc_protocol.cpp @@ -19,7 +19,7 @@ #include // MethodDescriptor #include // Message #include -#include "butil/third_party/snappy/snappy.h" // snappy::Compress +#include "snappy.h" // snappy::Compress #include "butil/time.h" #include "brpc/controller.h" // Controller #include "brpc/socket.h" // Socket @@ -136,7 +136,7 @@ void PublicPbrpcServiceAdaptor::SerializeResponseToIOBuf( } if (cntl->response_compress_type() == COMPRESS_TYPE_SNAPPY) { std::string tmp; - butil::snappy::Compress(response_str->data(), response_str->size(), &tmp); + snappy::Compress(response_str->data(), response_str->size(), &tmp); response_str->swap(tmp); head->set_compress_type(COMPRESS_TYPE); } diff --git a/src/brpc/policy/snappy_compress.cpp b/src/brpc/policy/snappy_compress.cpp index 8019b97b3c..edfa58efae 100644 --- a/src/brpc/policy/snappy_compress.cpp +++ b/src/brpc/policy/snappy_compress.cpp @@ -17,7 +17,7 @@ #include "butil/logging.h" -#include "butil/third_party/snappy/snappy.h" +#include "snappy.h" #include "brpc/policy/snappy_compress.h" #include "brpc/protocol.h" #include "brpc/compress.h" @@ -72,13 +72,13 @@ bool SnappyDecompress(const butil::IOBuf& data, google::protobuf::Message* msg) bool SnappyCompress(const butil::IOBuf& in, butil::IOBuf* out) { butil::IOBufAsSnappySource source(in); butil::IOBufAsSnappySink sink(*out); - return butil::snappy::Compress(&source, &sink); + return snappy::Compress(&source, &sink); } bool SnappyDecompress(const butil::IOBuf& in, butil::IOBuf* out) { butil::IOBufAsSnappySource source(in); butil::IOBufAsSnappySink sink(*out); - return butil::snappy::Uncompress(&source, &sink); + return snappy::Uncompress(&source, &sink); } } // namespace policy diff --git a/src/butil/iobuf.h b/src/butil/iobuf.h index 3682f61ecc..fc2227959f 100644 --- a/src/butil/iobuf.h +++ b/src/butil/iobuf.h @@ -29,7 +29,7 @@ #include // std::ostream #include // ZeroCopyInputStream #include "butil/strings/string_piece.h" // butil::StringPiece -#include "butil/third_party/snappy/snappy-sinksource.h" +#include "snappy-sinksource.h" #include "butil/zero_copy_stream_as_streambuf.h" #include "butil/macros.h" #include "butil/reader_writer.h" @@ -605,7 +605,7 @@ class IOBufAsZeroCopyOutputStream }; // Wrap IOBuf into input of snappy compression. -class IOBufAsSnappySource : public butil::snappy::Source { +class IOBufAsSnappySource : public snappy::Source { public: explicit IOBufAsSnappySource(const butil::IOBuf& buf) : _buf(&buf), _stream(buf) {} @@ -627,7 +627,7 @@ class IOBufAsSnappySource : public butil::snappy::Source { }; // Wrap IOBuf into output of snappy compression. -class IOBufAsSnappySink : public butil::snappy::Sink { +class IOBufAsSnappySink : public snappy::Sink { public: explicit IOBufAsSnappySink(butil::IOBuf& buf); virtual ~IOBufAsSnappySink() {} diff --git a/src/butil/third_party/snappy/AUTHORS b/src/butil/third_party/snappy/AUTHORS deleted file mode 100644 index 4858b377c7..0000000000 --- a/src/butil/third_party/snappy/AUTHORS +++ /dev/null @@ -1 +0,0 @@ -opensource@google.com diff --git a/src/butil/third_party/snappy/COPYING b/src/butil/third_party/snappy/COPYING deleted file mode 100644 index bd0e5971db..0000000000 --- a/src/butil/third_party/snappy/COPYING +++ /dev/null @@ -1,54 +0,0 @@ -Copyright 2011, Google Inc. -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - * Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above -copyright notice, this list of conditions and the following disclaimer -in the documentation and/or other materials provided with the -distribution. - * Neither the name of Google Inc. nor the names of its -contributors may be used to endorse or promote products derived from -this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -=== - -Some of the benchmark data in testdata/ is licensed differently: - - - fireworks.jpeg is Copyright 2013 Steinar H. Gunderson, and - is licensed under the Creative Commons Attribution 3.0 license - (CC-BY-3.0). See https://creativecommons.org/licenses/by/3.0/ - for more information. - - - kppkn.gtb is taken from the Gaviota chess tablebase set, and - is licensed under the MIT License. See - https://sites.google.com/site/gaviotachessengine/Home/endgame-tablebases-1 - for more information. - - - paper-100k.pdf is an excerpt (bytes 92160 to 194560) from the paper - “Combinatorial Modeling of Chromatin Features Quantitatively Predicts DNA - Replication Timing in _Drosophila_” by Federico Comoglio and Renato Paro, - which is licensed under the CC-BY license. See - http://www.ploscompbiol.org/static/license for more ifnormation. - - - alice29.txt, asyoulik.txt, plrabn12.txt and lcet10.txt are from Project - Gutenberg. The first three have expired copyrights and are in the public - domain; the latter does not have expired copyright, but is still in the - public domain according to the license information - (http://www.gutenberg.org/ebooks/53). diff --git a/src/butil/third_party/snappy/ChangeLog b/src/butil/third_party/snappy/ChangeLog deleted file mode 100644 index 1478db5501..0000000000 --- a/src/butil/third_party/snappy/ChangeLog +++ /dev/null @@ -1,2468 +0,0 @@ -commit eb66d8176b3d1f560ee012e1b488cb1540c45f88 -Author: Steinar H. Gunderson -Date: Mon Jun 22 16:10:47 2015 +0200 - - Initialized members of SnappyArrayWriter and SnappyDecompressionValidator. - These members were almost surely initialized before use by other member - functions, but Coverity was warning about this. Eliminating these warnings - minimizes clutter in that report and the likelihood of overlooking a real bug. - - A=cmumford - R=jeff - -commit b2312c4c25883ab03b5110f1b006dce95f419a4f -Author: Steinar H. Gunderson -Date: Mon Jun 22 16:03:28 2015 +0200 - - Add support for Uncompress(source, sink). Various changes to allow - Uncompress(source, sink) to get the same performance as the different - variants of Uncompress to Cord/DataBuffer/String/FlatBuffer. - - Changes to efficiently support Uncompress(source, sink) - -------- - - a) For strings - we add support to StringByteSink to do GetAppendBuffer so we - can write to it without copying. - b) For flat array buffers, we do GetAppendBuffer and see if we can get a full buffer. - - With the above changes we get performance with ByteSource/ByteSink - that is very close to directly using flat arrays and strings. - - We add various benchmark cases to demonstrate that. - - Orthogonal change - ------------------ - - Add support for TryFastAppend() for SnappyScatteredWriter. - - Benchmark results are below - - CPU: Intel Core2 dL1:32KB dL2:4096KB - Benchmark Time(ns) CPU(ns) Iterations - ----------------------------------------------------- - BM_UFlat/0 109065 108996 6410 896.0MB/s html - BM_UFlat/1 1012175 1012343 691 661.4MB/s urls - BM_UFlat/2 26775 26771 26149 4.4GB/s jpg - BM_UFlat/3 48947 48940 14363 1.8GB/s pdf - BM_UFlat/4 441029 440835 1589 886.1MB/s html4 - BM_UFlat/5 39861 39880 17823 588.3MB/s cp - BM_UFlat/6 18315 18300 38126 581.1MB/s c - BM_UFlat/7 5254 5254 100000 675.4MB/s lsp - BM_UFlat/8 1568060 1567376 447 626.6MB/s xls - BM_UFlat/9 337512 337734 2073 429.5MB/s txt1 - BM_UFlat/10 287269 287054 2434 415.9MB/s txt2 - BM_UFlat/11 890098 890219 787 457.2MB/s txt3 - BM_UFlat/12 1186593 1186863 590 387.2MB/s txt4 - BM_UFlat/13 573927 573318 1000 853.7MB/s bin - BM_UFlat/14 64250 64294 10000 567.2MB/s sum - BM_UFlat/15 7301 7300 96153 552.2MB/s man - BM_UFlat/16 109617 109636 6375 1031.5MB/s pb - BM_UFlat/17 364438 364497 1921 482.3MB/s gaviota - BM_UFlatSink/0 108518 108465 6450 900.4MB/s html - BM_UFlatSink/1 991952 991997 705 675.0MB/s urls - BM_UFlatSink/2 26815 26798 26065 4.4GB/s jpg - BM_UFlatSink/3 49127 49122 14255 1.8GB/s pdf - BM_UFlatSink/4 436674 436731 1604 894.4MB/s html4 - BM_UFlatSink/5 39738 39733 17345 590.5MB/s cp - BM_UFlatSink/6 18413 18416 37962 577.4MB/s c - BM_UFlatSink/7 5677 5676 100000 625.2MB/s lsp - BM_UFlatSink/8 1552175 1551026 451 633.2MB/s xls - BM_UFlatSink/9 338526 338489 2065 428.5MB/s txt1 - BM_UFlatSink/10 289387 289307 2420 412.6MB/s txt2 - BM_UFlatSink/11 893803 893706 783 455.4MB/s txt3 - BM_UFlatSink/12 1195919 1195459 586 384.4MB/s txt4 - BM_UFlatSink/13 559637 559779 1000 874.3MB/s bin - BM_UFlatSink/14 65073 65094 10000 560.2MB/s sum - BM_UFlatSink/15 7618 7614 92823 529.5MB/s man - BM_UFlatSink/16 110085 110121 6352 1027.0MB/s pb - BM_UFlatSink/17 369196 368915 1896 476.5MB/s gaviota - BM_UValidate/0 46954 46957 14899 2.0GB/s html - BM_UValidate/1 500621 500868 1000 1.3GB/s urls - BM_UValidate/2 283 283 2481447 417.2GB/s jpg - BM_UValidate/3 16230 16228 43137 5.4GB/s pdf - BM_UValidate/4 189129 189193 3701 2.0GB/s html4 - - A=uday - R=sanjay - -commit b2ad96006741d40935db2f73194a3e489b467338 -Author: Steinar H. Gunderson -Date: Mon Jun 22 15:48:29 2015 +0200 - - Changes to eliminate compiler warnings on MSVC - - This code was not compiling under Visual Studio 2013 with warnings being treated - as errors. Specifically: - - 1. Changed int -> size_t to eliminate signed/unsigned mismatch warning. - 2. Added some missing return values to functions. - 3. Inserting character instead of integer literals into strings to avoid type - conversions. - - A=cmumford - R=jeff - -commit e7a897e187e90b33f87bd9e64872cf561de9ebca -Author: Steinar H. Gunderson -Date: Mon Jun 22 15:45:11 2015 +0200 - - Fixed unit tests to compile under MSVC. - - 1. Including config.h in test. - 2. Including windows.h before zippy-test.h. - 3. Removed definition of WIN32_LEAN_AND_MEAN. This caused problems in - build environments that define WIN32_LEAN_AND_MEAN as our - definition didn't check for prior existence. This constant is old - and no longer needed anyhow. - 4. Disable MSVC warning 4722 since ~LogMessageCrash() never returns. - - A=cmumford - R=jeff - -commit 86eb8b152bdb065ad11bf331a9f7d65b72616acf -Author: Steinar H. Gunderson -Date: Mon Jun 22 15:41:30 2015 +0200 - - Change a few branch annotations that profiling found to be wrong. - Overall performance is neutral or slightly positive. - - Westmere (64-bit, opt): - - Benchmark Base (ns) New (ns) Improvement - -------------------------------------------------------------------------------------- - BM_UFlat/0 73798 71464 1.3GB/s html +3.3% - BM_UFlat/1 715223 704318 953.5MB/s urls +1.5% - BM_UFlat/2 8137 8871 13.0GB/s jpg -8.3% - BM_UFlat/3 200 204 935.5MB/s jpg_200 -2.0% - BM_UFlat/4 21627 21281 4.5GB/s pdf +1.6% - BM_UFlat/5 302806 290350 1.3GB/s html4 +4.3% - BM_UFlat/6 218920 219017 664.1MB/s txt1 -0.0% - BM_UFlat/7 190437 191212 626.1MB/s txt2 -0.4% - BM_UFlat/8 584192 580484 703.4MB/s txt3 +0.6% - BM_UFlat/9 776537 779055 591.6MB/s txt4 -0.3% - BM_UFlat/10 76056 72606 1.5GB/s pb +4.8% - BM_UFlat/11 235962 239043 737.4MB/s gaviota -1.3% - BM_UFlat/12 28049 28000 840.1MB/s cp +0.2% - BM_UFlat/13 12225 12021 886.9MB/s c +1.7% - BM_UFlat/14 3362 3544 1004.0MB/s lsp -5.1% - BM_UFlat/15 937015 939206 1048.9MB/s xls -0.2% - BM_UFlat/16 236 233 823.1MB/s xls_200 +1.3% - BM_UFlat/17 373170 361947 1.3GB/s bin +3.1% - BM_UFlat/18 264 264 725.5MB/s bin_200 +0.0% - BM_UFlat/19 42834 43577 839.2MB/s sum -1.7% - BM_UFlat/20 4770 4736 853.6MB/s man +0.7% - BM_UValidate/0 39671 39944 2.4GB/s html -0.7% - BM_UValidate/1 443391 443391 1.5GB/s urls +0.0% - BM_UValidate/2 163 163 703.3GB/s jpg +0.0% - BM_UValidate/3 113 112 1.7GB/s jpg_200 +0.9% - BM_UValidate/4 7555 7608 12.6GB/s pdf -0.7% - BM_ZFlat/0 157616 157568 621.5MB/s html (22.31 %) +0.0% - BM_ZFlat/1 1997290 2014486 333.4MB/s urls (47.77 %) -0.9% - BM_ZFlat/2 23035 22237 5.2GB/s jpg (99.95 %) +3.6% - BM_ZFlat/3 539 540 354.5MB/s jpg_200 (73.00 %) -0.2% - BM_ZFlat/4 80709 81369 1.2GB/s pdf (81.85 %) -0.8% - BM_ZFlat/5 639059 639220 613.0MB/s html4 (22.51 %) -0.0% - BM_ZFlat/6 577203 583370 249.3MB/s txt1 (57.87 %) -1.1% - BM_ZFlat/7 510887 516094 232.0MB/s txt2 (61.93 %) -1.0% - BM_ZFlat/8 1535843 1556973 262.2MB/s txt3 (54.92 %) -1.4% - BM_ZFlat/9 2070068 2102380 219.3MB/s txt4 (66.22 %) -1.5% - BM_ZFlat/10 152396 152148 745.5MB/s pb (19.64 %) +0.2% - BM_ZFlat/11 447367 445859 395.4MB/s gaviota (37.72 %) +0.3% - BM_ZFlat/12 76375 76797 306.3MB/s cp (48.12 %) -0.5% - BM_ZFlat/13 31518 31987 333.3MB/s c (42.40 %) -1.5% - BM_ZFlat/14 10598 10827 328.6MB/s lsp (48.37 %) -2.1% - BM_ZFlat/15 1782243 1802728 546.5MB/s xls (41.23 %) -1.1% - BM_ZFlat/16 526 539 355.0MB/s xls_200 (78.00 %) -2.4% - BM_ZFlat/17 598141 597311 822.1MB/s bin (18.11 %) +0.1% - BM_ZFlat/18 121 120 1.6GB/s bin_200 (7.50 %) +0.8% - BM_ZFlat/19 109981 112173 326.0MB/s sum (48.96 %) -2.0% - BM_ZFlat/20 14355 14575 277.4MB/s man (59.36 %) -1.5% - Sum of all benchmarks 33882722 33879325 +0.0% - - Sandy Bridge (64-bit, opt): - - Benchmark Base (ns) New (ns) Improvement - -------------------------------------------------------------------------------------- - BM_UFlat/0 43764 41600 2.3GB/s html +5.2% - BM_UFlat/1 517990 507058 1.3GB/s urls +2.2% - BM_UFlat/2 6625 5529 20.8GB/s jpg +19.8% - BM_UFlat/3 154 155 1.2GB/s jpg_200 -0.6% - BM_UFlat/4 12795 11747 8.1GB/s pdf +8.9% - BM_UFlat/5 200335 193413 2.0GB/s html4 +3.6% - BM_UFlat/6 156574 156426 929.2MB/s txt1 +0.1% - BM_UFlat/7 137574 137464 870.4MB/s txt2 +0.1% - BM_UFlat/8 422551 421603 967.4MB/s txt3 +0.2% - BM_UFlat/9 577749 578985 795.6MB/s txt4 -0.2% - BM_UFlat/10 42329 39362 2.8GB/s pb +7.5% - BM_UFlat/11 170615 169751 1037.9MB/s gaviota +0.5% - BM_UFlat/12 12800 12719 1.8GB/s cp +0.6% - BM_UFlat/13 6585 6579 1.6GB/s c +0.1% - BM_UFlat/14 2066 2044 1.7GB/s lsp +1.1% - BM_UFlat/15 750861 746911 1.3GB/s xls +0.5% - BM_UFlat/16 188 192 996.0MB/s xls_200 -2.1% - BM_UFlat/17 271622 264333 1.8GB/s bin +2.8% - BM_UFlat/18 208 207 923.6MB/s bin_200 +0.5% - BM_UFlat/19 24667 24845 1.4GB/s sum -0.7% - BM_UFlat/20 2663 2662 1.5GB/s man +0.0% - BM_ZFlat/0 115173 115624 846.5MB/s html (22.31 %) -0.4% - BM_ZFlat/1 1530331 1537769 436.5MB/s urls (47.77 %) -0.5% - BM_ZFlat/2 17503 17013 6.8GB/s jpg (99.95 %) +2.9% - BM_ZFlat/3 385 385 496.3MB/s jpg_200 (73.00 %) +0.0% - BM_ZFlat/4 61753 61540 1.6GB/s pdf (81.85 %) +0.3% - BM_ZFlat/5 484806 483356 810.1MB/s html4 (22.51 %) +0.3% - BM_ZFlat/6 464143 467609 310.9MB/s txt1 (57.87 %) -0.7% - BM_ZFlat/7 410315 413319 289.5MB/s txt2 (61.93 %) -0.7% - BM_ZFlat/8 1244082 1249381 326.5MB/s txt3 (54.92 %) -0.4% - BM_ZFlat/9 1696914 1709685 269.4MB/s txt4 (66.22 %) -0.7% - BM_ZFlat/10 104148 103372 1096.7MB/s pb (19.64 %) +0.8% - BM_ZFlat/11 363522 359722 489.8MB/s gaviota (37.72 %) +1.1% - BM_ZFlat/12 47021 50095 469.3MB/s cp (48.12 %) -6.1% - BM_ZFlat/13 16888 16985 627.4MB/s c (42.40 %) -0.6% - BM_ZFlat/14 5496 5469 650.3MB/s lsp (48.37 %) +0.5% - BM_ZFlat/15 1460713 1448760 679.5MB/s xls (41.23 %) +0.8% - BM_ZFlat/16 387 393 486.8MB/s xls_200 (78.00 %) -1.5% - BM_ZFlat/17 457654 451462 1086.6MB/s bin (18.11 %) +1.4% - BM_ZFlat/18 97 87 2.1GB/s bin_200 (7.50 %) +11.5% - BM_ZFlat/19 77904 80924 451.7MB/s sum (48.96 %) -3.7% - BM_ZFlat/20 7648 7663 527.1MB/s man (59.36 %) -0.2% - Sum of all benchmarks 25493635 25482069 +0.0% - - A=dehao - R=sesse - -commit 11ccdfb868387e56d845766d89ddab9d489c4128 -Author: Steinar H. Gunderson -Date: Mon Jun 22 16:07:58 2015 +0200 - - Sync with various Google-internal changes. - - Should not mean much for the open-source version. - -commit 22acaf438ed93ab21a2ff1919d173206798b996e -Author: Steinar H. Gunderson -Date: Mon Jun 22 15:39:08 2015 +0200 - - Change some internal path names. - - This is mostly to sync up with some changes from Google's internal - repositories; it does not affect the open-source distribution in itself. - -commit 1ff9be9b8fafc8528ca9e055646f5932aa5db9c4 -Author: snappy.mirrorbot@gmail.com -Date: Fri Feb 28 11:18:07 2014 +0000 - - Release Snappy 1.1.2. - - R=jeff - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@84 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 19690d78e83f8963f497585031efa3d9ca66b807 -Author: snappy.mirrorbot@gmail.com -Date: Wed Feb 19 10:31:49 2014 +0000 - - Fix public issue 82: Stop distributing benchmark data files that have - unclear or unsuitable licensing. - - In general, we replace the files we can with liberally licensed data, - and remove all the others (in particular all the parts of the Canterbury - corpus that are not clearly in the public domain). The replacements - do not always have the exact same characteristics as the original ones, - but they are more than good enough to be useful for benchmarking. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@83 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f82bff66afe0de4c9ae22f8c4ef84e3c2233e799 -Author: snappy.mirrorbot@gmail.com -Date: Fri Oct 25 13:31:27 2013 +0000 - - Add support for padding in the Snappy framed format. - - This is specifically motivated by DICOM's demands that embedded data - must be of an even number of bytes, but could in principle be used for - any sort of padding/alignment needed. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@82 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit eeead8dc38ea359f027fb6e89f345448e8e9d723 -Author: snappy.mirrorbot@gmail.com -Date: Tue Oct 15 15:21:31 2013 +0000 - - Release Snappy 1.1.1. - - R=jeff - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@81 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 6bc39e24c76adbbff26ae629fafbf7dfc795f554 -Author: snappy.mirrorbot@gmail.com -Date: Tue Aug 13 12:55:00 2013 +0000 - - Add autoconf tests for size_t and ssize_t. Sort-of resolves public issue 79; - it would solve the problem if MSVC typically used autoconf. However, it gives - a natural place (config.h) to put the typedef even for MSVC. - - R=jsbell - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@80 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 7c3c01df77e191ad1f8377448961fe88db2802e9 -Author: snappy.mirrorbot@gmail.com -Date: Mon Jul 29 11:06:44 2013 +0000 - - When we compare the number of bytes produced with the offset for a - backreference, make the signedness of the bytes produced clear, - by sticking it into a size_t. This avoids a signed/unsigned compare - warning from MSVC (public issue 71), and also is slightly clearer. - - Since the line is now so long the explanatory comment about the -1u - trick has to go somewhere else anyway, I used the opportunity to - explain it in slightly more detail. - - This is a purely stylistic change; the emitted assembler from GCC - is identical. - - R=jeff - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@79 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 2f0aaf8631d8fb2475ca1a6687c181efb14ed286 -Author: snappy.mirrorbot@gmail.com -Date: Sun Jun 30 19:24:03 2013 +0000 - - In the fast path for decompressing literals, instead of checking - whether there's 16 bytes free and then checking right afterwards - (when having subtracted the literal size) that there are now - 5 bytes free, just check once for 21 bytes. This skips a compare - and a branch; although it is easily predictable, it is still - a few cycles on a fast path that we would like to get rid of. - - Benchmarking this yields very confusing results. On open-source - GCC 4.8.1 on Haswell, we get exactly the expected results; the - benchmarks where we hit the fast path for literals (in particular - the two HTML benchmarks and the protobuf benchmark) give very nice - speedups, and the others are not really affected. - - However, benchmarks with Google's GCC branch on other hardware - is much less clear. It seems that we have a weak loss in some cases - (and the win for the “typical” win cases are not nearly as clear), - but that it depends on microarchitecture and plain luck in how we run - the benchmark. Looking at the generated assembler, it seems that - the removal of the if causes other large-scale changes in how the - function is laid out, which makes it likely that this is just bad luck. - - Thus, we should keep this change, even though its exact current impact is - unclear; it's a sensible change per se, and dropping it on the basis of - microoptimization for a given compiler (or even branch of a compiler) - would seem like a bad strategy in the long run. - - Microbenchmark results (all in 64-bit, opt mode): - - Nehalem, Google GCC: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------ - BM_UFlat/0 76747 75591 1.3GB/s html +1.5% - BM_UFlat/1 765756 757040 886.3MB/s urls +1.2% - BM_UFlat/2 10867 10893 10.9GB/s jpg -0.2% - BM_UFlat/3 124 131 1.4GB/s jpg_200 -5.3% - BM_UFlat/4 31663 31596 2.8GB/s pdf +0.2% - BM_UFlat/5 314162 308176 1.2GB/s html4 +1.9% - BM_UFlat/6 29668 29746 790.6MB/s cp -0.3% - BM_UFlat/7 12958 13386 796.4MB/s c -3.2% - BM_UFlat/8 3596 3682 966.0MB/s lsp -2.3% - BM_UFlat/9 1019193 1033493 953.3MB/s xls -1.4% - BM_UFlat/10 239 247 775.3MB/s xls_200 -3.2% - BM_UFlat/11 236411 240271 606.9MB/s txt1 -1.6% - BM_UFlat/12 206639 209768 571.2MB/s txt2 -1.5% - BM_UFlat/13 627803 635722 641.4MB/s txt3 -1.2% - BM_UFlat/14 845932 857816 538.2MB/s txt4 -1.4% - BM_UFlat/15 402107 391670 1.2GB/s bin +2.7% - BM_UFlat/16 283 279 683.6MB/s bin_200 +1.4% - BM_UFlat/17 46070 46815 781.5MB/s sum -1.6% - BM_UFlat/18 5053 5163 782.0MB/s man -2.1% - BM_UFlat/19 79721 76581 1.4GB/s pb +4.1% - BM_UFlat/20 251158 252330 697.5MB/s gaviota -0.5% - Sum of all benchmarks 4966150 4980396 -0.3% - - - Sandy Bridge, Google GCC: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------ - BM_UFlat/0 42850 42182 2.3GB/s html +1.6% - BM_UFlat/1 525660 515816 1.3GB/s urls +1.9% - BM_UFlat/2 7173 7283 16.3GB/s jpg -1.5% - BM_UFlat/3 92 91 2.1GB/s jpg_200 +1.1% - BM_UFlat/4 15147 14872 5.9GB/s pdf +1.8% - BM_UFlat/5 199936 192116 2.0GB/s html4 +4.1% - BM_UFlat/6 12796 12443 1.8GB/s cp +2.8% - BM_UFlat/7 6588 6400 1.6GB/s c +2.9% - BM_UFlat/8 2010 1951 1.8GB/s lsp +3.0% - BM_UFlat/9 761124 763049 1.3GB/s xls -0.3% - BM_UFlat/10 186 189 1016.1MB/s xls_200 -1.6% - BM_UFlat/11 159354 158460 918.6MB/s txt1 +0.6% - BM_UFlat/12 139732 139950 856.1MB/s txt2 -0.2% - BM_UFlat/13 429917 425027 961.7MB/s txt3 +1.2% - BM_UFlat/14 585255 587324 785.8MB/s txt4 -0.4% - BM_UFlat/15 276186 266173 1.8GB/s bin +3.8% - BM_UFlat/16 205 207 925.5MB/s bin_200 -1.0% - BM_UFlat/17 24925 24935 1.4GB/s sum -0.0% - BM_UFlat/18 2632 2576 1.5GB/s man +2.2% - BM_UFlat/19 40546 39108 2.8GB/s pb +3.7% - BM_UFlat/20 175803 168209 1048.9MB/s gaviota +4.5% - Sum of all benchmarks 3408117 3368361 +1.2% - - - Haswell, upstream GCC 4.8.1: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------ - BM_UFlat/0 46308 40641 2.3GB/s html +13.9% - BM_UFlat/1 513385 514706 1.3GB/s urls -0.3% - BM_UFlat/2 6197 6151 19.2GB/s jpg +0.7% - BM_UFlat/3 61 61 3.0GB/s jpg_200 +0.0% - BM_UFlat/4 13551 13429 6.5GB/s pdf +0.9% - BM_UFlat/5 198317 190243 2.0GB/s html4 +4.2% - BM_UFlat/6 14768 12560 1.8GB/s cp +17.6% - BM_UFlat/7 6453 6447 1.6GB/s c +0.1% - BM_UFlat/8 1991 1980 1.8GB/s lsp +0.6% - BM_UFlat/9 766947 770424 1.2GB/s xls -0.5% - BM_UFlat/10 170 169 1.1GB/s xls_200 +0.6% - BM_UFlat/11 164350 163554 888.7MB/s txt1 +0.5% - BM_UFlat/12 145444 143830 832.1MB/s txt2 +1.1% - BM_UFlat/13 437849 438413 929.2MB/s txt3 -0.1% - BM_UFlat/14 603587 605309 759.8MB/s txt4 -0.3% - BM_UFlat/15 249799 248067 1.9GB/s bin +0.7% - BM_UFlat/16 191 188 1011.4MB/s bin_200 +1.6% - BM_UFlat/17 26064 24778 1.4GB/s sum +5.2% - BM_UFlat/18 2620 2601 1.5GB/s man +0.7% - BM_UFlat/19 44551 37373 3.0GB/s pb +19.2% - BM_UFlat/20 165408 164584 1.0GB/s gaviota +0.5% - Sum of all benchmarks 3408011 3385508 +0.7% - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@78 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 062bf544a61107db730b6d08cb0b159c4dd9b24c -Author: snappy.mirrorbot@gmail.com -Date: Fri Jun 14 21:42:26 2013 +0000 - - Make the two IncrementalCopy* functions take in an ssize_t instead of a len, - in order to avoid having to do 32-to-64-bit signed conversions on a hot path - during decompression. (Also fixes some MSVC warnings, mentioned in public - issue 75, but more of those remain.) They cannot be size_t because we expect - them to go negative and test for that. - - This saves a few movzwl instructions, yielding ~2% speedup in decompression. - - - Sandy Bridge: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------------------------- - BM_UFlat/0 48009 41283 2.3GB/s html +16.3% - BM_UFlat/1 531274 513419 1.3GB/s urls +3.5% - BM_UFlat/2 7378 7062 16.8GB/s jpg +4.5% - BM_UFlat/3 92 92 2.0GB/s jpg_200 +0.0% - BM_UFlat/4 15057 14974 5.9GB/s pdf +0.6% - BM_UFlat/5 204323 193140 2.0GB/s html4 +5.8% - BM_UFlat/6 13282 12611 1.8GB/s cp +5.3% - BM_UFlat/7 6511 6504 1.6GB/s c +0.1% - BM_UFlat/8 2014 2030 1.7GB/s lsp -0.8% - BM_UFlat/9 775909 768336 1.3GB/s xls +1.0% - BM_UFlat/10 182 184 1043.2MB/s xls_200 -1.1% - BM_UFlat/11 167352 161630 901.2MB/s txt1 +3.5% - BM_UFlat/12 147393 142246 842.8MB/s txt2 +3.6% - BM_UFlat/13 449960 432853 944.4MB/s txt3 +4.0% - BM_UFlat/14 620497 594845 775.9MB/s txt4 +4.3% - BM_UFlat/15 265610 267356 1.8GB/s bin -0.7% - BM_UFlat/16 206 205 932.7MB/s bin_200 +0.5% - BM_UFlat/17 25561 24730 1.4GB/s sum +3.4% - BM_UFlat/18 2620 2644 1.5GB/s man -0.9% - BM_UFlat/19 45766 38589 2.9GB/s pb +18.6% - BM_UFlat/20 171107 169832 1039.5MB/s gaviota +0.8% - Sum of all benchmarks 3500103 3394565 +3.1% - - - Westmere: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------------------------- - BM_UFlat/0 72624 71526 1.3GB/s html +1.5% - BM_UFlat/1 735821 722917 930.8MB/s urls +1.8% - BM_UFlat/2 10450 10172 11.7GB/s jpg +2.7% - BM_UFlat/3 117 117 1.6GB/s jpg_200 +0.0% - BM_UFlat/4 29817 29648 3.0GB/s pdf +0.6% - BM_UFlat/5 297126 293073 1.3GB/s html4 +1.4% - BM_UFlat/6 28252 27994 842.0MB/s cp +0.9% - BM_UFlat/7 12672 12391 862.1MB/s c +2.3% - BM_UFlat/8 3507 3425 1040.9MB/s lsp +2.4% - BM_UFlat/9 1004268 969395 1018.0MB/s xls +3.6% - BM_UFlat/10 233 227 844.8MB/s xls_200 +2.6% - BM_UFlat/11 230054 224981 647.8MB/s txt1 +2.3% - BM_UFlat/12 201229 196447 610.5MB/s txt2 +2.4% - BM_UFlat/13 609547 596761 685.3MB/s txt3 +2.1% - BM_UFlat/14 824362 804821 573.8MB/s txt4 +2.4% - BM_UFlat/15 371095 374899 1.3GB/s bin -1.0% - BM_UFlat/16 267 267 717.8MB/s bin_200 +0.0% - BM_UFlat/17 44623 43828 835.9MB/s sum +1.8% - BM_UFlat/18 5077 4815 841.0MB/s man +5.4% - BM_UFlat/19 74964 73210 1.5GB/s pb +2.4% - BM_UFlat/20 237987 236745 746.0MB/s gaviota +0.5% - Sum of all benchmarks 4794092 4697659 +2.1% - - - Istanbul: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------------------------- - BM_UFlat/0 98614 96376 1020.4MB/s html +2.3% - BM_UFlat/1 963740 953241 707.2MB/s urls +1.1% - BM_UFlat/2 25042 24769 4.8GB/s jpg +1.1% - BM_UFlat/3 180 180 1065.6MB/s jpg_200 +0.0% - BM_UFlat/4 45942 45403 1.9GB/s pdf +1.2% - BM_UFlat/5 400135 390226 1008.2MB/s html4 +2.5% - BM_UFlat/6 37768 37392 631.9MB/s cp +1.0% - BM_UFlat/7 18585 18200 588.2MB/s c +2.1% - BM_UFlat/8 5751 5690 627.7MB/s lsp +1.1% - BM_UFlat/9 1543154 1542209 641.4MB/s xls +0.1% - BM_UFlat/10 381 388 494.6MB/s xls_200 -1.8% - BM_UFlat/11 339715 331973 440.1MB/s txt1 +2.3% - BM_UFlat/12 294807 289418 415.4MB/s txt2 +1.9% - BM_UFlat/13 906160 884094 463.3MB/s txt3 +2.5% - BM_UFlat/14 1224221 1198435 386.1MB/s txt4 +2.2% - BM_UFlat/15 516277 502923 979.5MB/s bin +2.7% - BM_UFlat/16 405 402 477.2MB/s bin_200 +0.7% - BM_UFlat/17 61640 60621 605.6MB/s sum +1.7% - BM_UFlat/18 7326 7383 549.5MB/s man -0.8% - BM_UFlat/19 94720 92653 1.2GB/s pb +2.2% - BM_UFlat/20 360435 346687 510.6MB/s gaviota +4.0% - Sum of all benchmarks 6944998 6828663 +1.7% - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@77 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 328aafa1980824a9afdcd50edc30d9d5157e417f -Author: snappy.mirrorbot@gmail.com -Date: Thu Jun 13 16:19:52 2013 +0000 - - Add support for uncompressing to iovecs (scatter I/O). - Windows does not have struct iovec defined anywhere, - so we define our own version that's equal to what UNIX - typically has. - - The bulk of this patch was contributed by Mohit Aron. - - R=jeff - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@76 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit cd92eb0852e2339187b693eef3595a07d2276c1d -Author: snappy.mirrorbot@gmail.com -Date: Wed Jun 12 19:51:15 2013 +0000 - - Some code reorganization needed for an internal change. - - R=fikes - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@75 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit a3e928d62bbd61b523b988c07b560253950cf73b -Author: snappy.mirrorbot@gmail.com -Date: Tue Apr 9 15:33:30 2013 +0000 - - Supports truncated test data in zippy benchmark. - - R=sesse - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@74 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit bde324c0169763688f35ee44630a26ad1f49eec3 -Author: snappy.mirrorbot@gmail.com -Date: Tue Feb 5 14:36:15 2013 +0000 - - Release Snappy 1.1.0. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@73 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 8168446c7eaaa0594e1f4ca923376dcf3a2846fa -Author: snappy.mirrorbot@gmail.com -Date: Tue Feb 5 14:30:05 2013 +0000 - - Make ./snappy_unittest pass without "srcdir" being defined. - - Previously, snappy_unittests would read from an absolute path /testdata/..; - convert it to use a relative path instead. - - Patch from Marc-Antonie Ruel. - - R=maruel - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@72 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 27a0cc394950ebdad2e8d67322f0862835b10bd9 -Author: snappy.mirrorbot@gmail.com -Date: Fri Jan 18 12:16:36 2013 +0000 - - Increase the Zippy block size from 32 kB to 64 kB, winning ~3% density - while being effectively performance neutral. - - The longer story about density is that we win 3-6% density on the benchmarks - where this has any effect at all; many of the benchmarks (cp, c, lsp, man) - are smaller than 32 kB and thus will have no effect. Binary data also seems - to win little or nothing; of course, the already-compressed data wins nothing. - The protobuf benchmark wins as much as ~18% depending on architecture, - but I wouldn't be too sure that this is representative of protobuf data in - general. - - As of performance, we lose a tiny amount since we get more tags (e.g., a long - literal might be broken up into literal-copy-literal), but we win it back with - less clearing of the hash table, and more opportunities to skip incompressible - data (e.g. in the jpg benchmark). Decompression seems to get ever so slightly - slower, again due to more tags. The total net change is about as close to zero - as we can get, so the end effect seems to be simply more density and no - real performance change. - - The comment about not changing kBlockSize, scary as it is, is not really - relevant, since we're never going to have a block-level decompressor without - explicitly marked blocks. Replace it with something more appropriate. - - This affects the framing format, but it's okay to change it since it basically - has no users yet. - - - Density (note that cp, c, lsp and man are all smaller than 32 kB): - - Benchmark Description Base (%) New (%) Improvement - -------------------------------------------------------------- - ZFlat/0 html 22.57 22.31 +5.6% - ZFlat/1 urls 50.89 47.77 +6.5% - ZFlat/2 jpg 99.88 99.87 +0.0% - ZFlat/3 pdf 82.13 82.07 +0.1% - ZFlat/4 html4 23.55 22.51 +4.6% - ZFlat/5 cp 48.12 48.12 +0.0% - ZFlat/6 c 42.40 42.40 +0.0% - ZFlat/7 lsp 48.37 48.37 +0.0% - ZFlat/8 xls 41.34 41.23 +0.3% - ZFlat/9 txt1 59.81 57.87 +3.4% - ZFlat/10 txt2 64.07 61.93 +3.5% - ZFlat/11 txt3 57.11 54.92 +4.0% - ZFlat/12 txt4 68.35 66.22 +3.2% - ZFlat/13 bin 18.21 18.11 +0.6% - ZFlat/14 sum 51.88 48.96 +6.0% - ZFlat/15 man 59.36 59.36 +0.0% - ZFlat/16 pb 23.15 19.64 +17.9% - ZFlat/17 gaviota 38.27 37.72 +1.5% - Geometric mean 45.51 44.15 +3.1% - - - Microbenchmarks (64-bit, opt): - - Westmere 2.8 GHz: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------------------------- - BM_UFlat/0 75342 75027 1.3GB/s html +0.4% - BM_UFlat/1 723767 744269 899.6MB/s urls -2.8% - BM_UFlat/2 10072 10072 11.7GB/s jpg +0.0% - BM_UFlat/3 30747 30388 2.9GB/s pdf +1.2% - BM_UFlat/4 307353 306063 1.2GB/s html4 +0.4% - BM_UFlat/5 28593 28743 816.3MB/s cp -0.5% - BM_UFlat/6 12958 12998 818.1MB/s c -0.3% - BM_UFlat/7 3700 3792 935.8MB/s lsp -2.4% - BM_UFlat/8 999685 999905 982.1MB/s xls -0.0% - BM_UFlat/9 232954 230079 630.4MB/s txt1 +1.2% - BM_UFlat/10 200785 201468 592.6MB/s txt2 -0.3% - BM_UFlat/11 617267 610968 666.1MB/s txt3 +1.0% - BM_UFlat/12 821595 822475 558.7MB/s txt4 -0.1% - BM_UFlat/13 377097 377632 1.3GB/s bin -0.1% - BM_UFlat/14 45476 45260 805.8MB/s sum +0.5% - BM_UFlat/15 4985 5003 805.7MB/s man -0.4% - BM_UFlat/16 80813 77494 1.4GB/s pb +4.3% - BM_UFlat/17 251792 241553 727.7MB/s gaviota +4.2% - BM_UValidate/0 40343 40354 2.4GB/s html -0.0% - BM_UValidate/1 426890 451574 1.4GB/s urls -5.5% - BM_UValidate/2 187 179 661.9GB/s jpg +4.5% - BM_UValidate/3 13783 13827 6.4GB/s pdf -0.3% - BM_UValidate/4 162393 163335 2.3GB/s html4 -0.6% - BM_UDataBuffer/0 93756 93302 1046.7MB/s html +0.5% - BM_UDataBuffer/1 886714 916292 730.7MB/s urls -3.2% - BM_UDataBuffer/2 15861 16401 7.2GB/s jpg -3.3% - BM_UDataBuffer/3 38934 39224 2.2GB/s pdf -0.7% - BM_UDataBuffer/4 381008 379428 1029.5MB/s html4 +0.4% - BM_UCord/0 92528 91098 1072.0MB/s html +1.6% - BM_UCord/1 858421 885287 756.3MB/s urls -3.0% - BM_UCord/2 13140 13464 8.8GB/s jpg -2.4% - BM_UCord/3 39012 37773 2.3GB/s pdf +3.3% - BM_UCord/4 376869 371267 1052.1MB/s html4 +1.5% - BM_UCordString/0 75810 75303 1.3GB/s html +0.7% - BM_UCordString/1 735290 753841 888.2MB/s urls -2.5% - BM_UCordString/2 11945 13113 9.0GB/s jpg -8.9% - BM_UCordString/3 33901 32562 2.7GB/s pdf +4.1% - BM_UCordString/4 310985 309390 1.2GB/s html4 +0.5% - BM_UCordValidate/0 40952 40450 2.4GB/s html +1.2% - BM_UCordValidate/1 433842 456531 1.4GB/s urls -5.0% - BM_UCordValidate/2 1179 1173 100.8GB/s jpg +0.5% - BM_UCordValidate/3 14481 14392 6.1GB/s pdf +0.6% - BM_UCordValidate/4 164364 164151 2.3GB/s html4 +0.1% - BM_ZFlat/0 160610 156601 623.6MB/s html (22.31 %) +2.6% - BM_ZFlat/1 1995238 1993582 335.9MB/s urls (47.77 %) +0.1% - BM_ZFlat/2 30133 24983 4.7GB/s jpg (99.87 %) +20.6% - BM_ZFlat/3 74453 73128 1.2GB/s pdf (82.07 %) +1.8% - BM_ZFlat/4 647674 633729 616.4MB/s html4 (22.51 %) +2.2% - BM_ZFlat/5 76259 76090 308.4MB/s cp (48.12 %) +0.2% - BM_ZFlat/6 31106 31084 342.1MB/s c (42.40 %) +0.1% - BM_ZFlat/7 10507 10443 339.8MB/s lsp (48.37 %) +0.6% - BM_ZFlat/8 1811047 1793325 547.6MB/s xls (41.23 %) +1.0% - BM_ZFlat/9 597903 581793 249.3MB/s txt1 (57.87 %) +2.8% - BM_ZFlat/10 525320 514522 232.0MB/s txt2 (61.93 %) +2.1% - BM_ZFlat/11 1596591 1551636 262.3MB/s txt3 (54.92 %) +2.9% - BM_ZFlat/12 2134523 2094033 219.5MB/s txt4 (66.22 %) +1.9% - BM_ZFlat/13 593024 587869 832.6MB/s bin (18.11 %) +0.9% - BM_ZFlat/14 114746 110666 329.5MB/s sum (48.96 %) +3.7% - BM_ZFlat/15 14376 14485 278.3MB/s man (59.36 %) -0.8% - BM_ZFlat/16 167908 150070 753.6MB/s pb (19.64 %) +11.9% - BM_ZFlat/17 460228 442253 397.5MB/s gaviota (37.72 %) +4.1% - BM_ZCord/0 164896 160241 609.4MB/s html +2.9% - BM_ZCord/1 2070239 2043492 327.7MB/s urls +1.3% - BM_ZCord/2 54402 47002 2.5GB/s jpg +15.7% - BM_ZCord/3 85871 83832 1073.1MB/s pdf +2.4% - BM_ZCord/4 664078 648825 602.0MB/s html4 +2.4% - BM_ZDataBuffer/0 174874 172549 566.0MB/s html +1.3% - BM_ZDataBuffer/1 2134410 2139173 313.0MB/s urls -0.2% - BM_ZDataBuffer/2 71911 69551 1.7GB/s jpg +3.4% - BM_ZDataBuffer/3 98236 99727 902.1MB/s pdf -1.5% - BM_ZDataBuffer/4 710776 699104 558.8MB/s html4 +1.7% - Sum of all benchmarks 27358908 27200688 +0.6% - - - Sandy Bridge 2.6 GHz: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------------------------- - BM_UFlat/0 49356 49018 1.9GB/s html +0.7% - BM_UFlat/1 516764 531955 1.2GB/s urls -2.9% - BM_UFlat/2 6982 7304 16.2GB/s jpg -4.4% - BM_UFlat/3 15285 15598 5.6GB/s pdf -2.0% - BM_UFlat/4 206557 206669 1.8GB/s html4 -0.1% - BM_UFlat/5 13681 13567 1.7GB/s cp +0.8% - BM_UFlat/6 6571 6592 1.6GB/s c -0.3% - BM_UFlat/7 2008 1994 1.7GB/s lsp +0.7% - BM_UFlat/8 775700 773286 1.2GB/s xls +0.3% - BM_UFlat/9 165578 164480 881.8MB/s txt1 +0.7% - BM_UFlat/10 143707 144139 828.2MB/s txt2 -0.3% - BM_UFlat/11 443026 436281 932.8MB/s txt3 +1.5% - BM_UFlat/12 603129 595856 771.2MB/s txt4 +1.2% - BM_UFlat/13 271682 270450 1.8GB/s bin +0.5% - BM_UFlat/14 26200 25666 1.4GB/s sum +2.1% - BM_UFlat/15 2620 2608 1.5GB/s man +0.5% - BM_UFlat/16 48908 47756 2.3GB/s pb +2.4% - BM_UFlat/17 174638 170346 1031.9MB/s gaviota +2.5% - BM_UValidate/0 31922 31898 3.0GB/s html +0.1% - BM_UValidate/1 341265 363554 1.8GB/s urls -6.1% - BM_UValidate/2 160 151 782.8GB/s jpg +6.0% - BM_UValidate/3 10402 10380 8.5GB/s pdf +0.2% - BM_UValidate/4 129490 130587 2.9GB/s html4 -0.8% - BM_UDataBuffer/0 59383 58736 1.6GB/s html +1.1% - BM_UDataBuffer/1 619222 637786 1049.8MB/s urls -2.9% - BM_UDataBuffer/2 10775 11941 9.9GB/s jpg -9.8% - BM_UDataBuffer/3 18002 17930 4.9GB/s pdf +0.4% - BM_UDataBuffer/4 259182 259306 1.5GB/s html4 -0.0% - BM_UCord/0 59379 57814 1.6GB/s html +2.7% - BM_UCord/1 598456 615162 1088.4MB/s urls -2.7% - BM_UCord/2 8519 8628 13.7GB/s jpg -1.3% - BM_UCord/3 18123 17537 5.0GB/s pdf +3.3% - BM_UCord/4 252375 252331 1.5GB/s html4 +0.0% - BM_UCordString/0 49494 49790 1.9GB/s html -0.6% - BM_UCordString/1 524659 541803 1.2GB/s urls -3.2% - BM_UCordString/2 8206 8354 14.2GB/s jpg -1.8% - BM_UCordString/3 17235 16537 5.3GB/s pdf +4.2% - BM_UCordString/4 210188 211072 1.8GB/s html4 -0.4% - BM_UCordValidate/0 31956 31587 3.0GB/s html +1.2% - BM_UCordValidate/1 340828 362141 1.8GB/s urls -5.9% - BM_UCordValidate/2 783 744 158.9GB/s jpg +5.2% - BM_UCordValidate/3 10543 10462 8.4GB/s pdf +0.8% - BM_UCordValidate/4 130150 129789 2.9GB/s html4 +0.3% - BM_ZFlat/0 113873 111200 878.2MB/s html (22.31 %) +2.4% - BM_ZFlat/1 1473023 1489858 449.4MB/s urls (47.77 %) -1.1% - BM_ZFlat/2 23569 19486 6.1GB/s jpg (99.87 %) +21.0% - BM_ZFlat/3 49178 48046 1.8GB/s pdf (82.07 %) +2.4% - BM_ZFlat/4 475063 469394 832.2MB/s html4 (22.51 %) +1.2% - BM_ZFlat/5 46910 46816 501.2MB/s cp (48.12 %) +0.2% - BM_ZFlat/6 16883 16916 628.6MB/s c (42.40 %) -0.2% - BM_ZFlat/7 5381 5447 651.5MB/s lsp (48.37 %) -1.2% - BM_ZFlat/8 1466870 1473861 666.3MB/s xls (41.23 %) -0.5% - BM_ZFlat/9 468006 464101 312.5MB/s txt1 (57.87 %) +0.8% - BM_ZFlat/10 408157 408957 291.9MB/s txt2 (61.93 %) -0.2% - BM_ZFlat/11 1253348 1232910 330.1MB/s txt3 (54.92 %) +1.7% - BM_ZFlat/12 1702373 1702977 269.8MB/s txt4 (66.22 %) -0.0% - BM_ZFlat/13 439792 438557 1116.0MB/s bin (18.11 %) +0.3% - BM_ZFlat/14 80766 78851 462.5MB/s sum (48.96 %) +2.4% - BM_ZFlat/15 7420 7542 534.5MB/s man (59.36 %) -1.6% - BM_ZFlat/16 112043 100126 1.1GB/s pb (19.64 %) +11.9% - BM_ZFlat/17 368877 357703 491.4MB/s gaviota (37.72 %) +3.1% - BM_ZCord/0 116402 113564 859.9MB/s html +2.5% - BM_ZCord/1 1507156 1519911 440.5MB/s urls -0.8% - BM_ZCord/2 39860 33686 3.5GB/s jpg +18.3% - BM_ZCord/3 56211 54694 1.6GB/s pdf +2.8% - BM_ZCord/4 485594 479212 815.1MB/s html4 +1.3% - BM_ZDataBuffer/0 123185 121572 803.3MB/s html +1.3% - BM_ZDataBuffer/1 1569111 1589380 421.3MB/s urls -1.3% - BM_ZDataBuffer/2 53143 49556 2.4GB/s jpg +7.2% - BM_ZDataBuffer/3 65725 66826 1.3GB/s pdf -1.6% - BM_ZDataBuffer/4 517871 514750 758.9MB/s html4 +0.6% - Sum of all benchmarks 20258879 20315484 -0.3% - - - AMD Instanbul 2.4 GHz: - - Benchmark Base (ns) New (ns) Improvement - ------------------------------------------------------------------------------------------------- - BM_UFlat/0 97120 96585 1011.1MB/s html +0.6% - BM_UFlat/1 917473 948016 706.3MB/s urls -3.2% - BM_UFlat/2 21496 23938 4.9GB/s jpg -10.2% - BM_UFlat/3 44751 45639 1.9GB/s pdf -1.9% - BM_UFlat/4 391950 391413 998.0MB/s html4 +0.1% - BM_UFlat/5 37366 37201 630.7MB/s cp +0.4% - BM_UFlat/6 18350 18318 580.5MB/s c +0.2% - BM_UFlat/7 5672 5661 626.9MB/s lsp +0.2% - BM_UFlat/8 1533390 1529441 642.1MB/s xls +0.3% - BM_UFlat/9 335477 336553 431.0MB/s txt1 -0.3% - BM_UFlat/10 285140 292080 408.7MB/s txt2 -2.4% - BM_UFlat/11 888507 894758 454.9MB/s txt3 -0.7% - BM_UFlat/12 1187643 1210928 379.5MB/s txt4 -1.9% - BM_UFlat/13 493717 507447 964.5MB/s bin -2.7% - BM_UFlat/14 61740 60870 599.1MB/s sum +1.4% - BM_UFlat/15 7211 7187 560.9MB/s man +0.3% - BM_UFlat/16 97435 93100 1.2GB/s pb +4.7% - BM_UFlat/17 362662 356395 493.2MB/s gaviota +1.8% - BM_UValidate/0 47475 47118 2.0GB/s html +0.8% - BM_UValidate/1 501304 529741 1.2GB/s urls -5.4% - BM_UValidate/2 276 243 486.2GB/s jpg +13.6% - BM_UValidate/3 16361 16261 5.4GB/s pdf +0.6% - BM_UValidate/4 190741 190353 2.0GB/s html4 +0.2% - BM_UDataBuffer/0 111080 109771 889.6MB/s html +1.2% - BM_UDataBuffer/1 1051035 1085999 616.5MB/s urls -3.2% - BM_UDataBuffer/2 25801 25463 4.6GB/s jpg +1.3% - BM_UDataBuffer/3 50493 49946 1.8GB/s pdf +1.1% - BM_UDataBuffer/4 447258 444138 879.5MB/s html4 +0.7% - BM_UCord/0 109350 107909 905.0MB/s html +1.3% - BM_UCord/1 1023396 1054964 634.7MB/s urls -3.0% - BM_UCord/2 25292 24371 4.9GB/s jpg +3.8% - BM_UCord/3 48955 49736 1.8GB/s pdf -1.6% - BM_UCord/4 440452 437331 893.2MB/s html4 +0.7% - BM_UCordString/0 98511 98031 996.2MB/s html +0.5% - BM_UCordString/1 933230 963495 694.9MB/s urls -3.1% - BM_UCordString/2 23311 24076 4.9GB/s jpg -3.2% - BM_UCordString/3 45568 46196 1.9GB/s pdf -1.4% - BM_UCordString/4 397791 396934 984.1MB/s html4 +0.2% - BM_UCordValidate/0 47537 46921 2.0GB/s html +1.3% - BM_UCordValidate/1 505071 532716 1.2GB/s urls -5.2% - BM_UCordValidate/2 1663 1621 72.9GB/s jpg +2.6% - BM_UCordValidate/3 16890 16926 5.2GB/s pdf -0.2% - BM_UCordValidate/4 192365 191984 2.0GB/s html4 +0.2% - BM_ZFlat/0 184708 179103 545.3MB/s html (22.31 %) +3.1% - BM_ZFlat/1 2293864 2302950 290.7MB/s urls (47.77 %) -0.4% - BM_ZFlat/2 52852 47618 2.5GB/s jpg (99.87 %) +11.0% - BM_ZFlat/3 100766 96179 935.3MB/s pdf (82.07 %) +4.8% - BM_ZFlat/4 741220 727977 536.6MB/s html4 (22.51 %) +1.8% - BM_ZFlat/5 85402 85418 274.7MB/s cp (48.12 %) -0.0% - BM_ZFlat/6 36558 36494 291.4MB/s c (42.40 %) +0.2% - BM_ZFlat/7 12706 12507 283.7MB/s lsp (48.37 %) +1.6% - BM_ZFlat/8 2336823 2335688 420.5MB/s xls (41.23 %) +0.0% - BM_ZFlat/9 701804 681153 212.9MB/s txt1 (57.87 %) +3.0% - BM_ZFlat/10 606700 597194 199.9MB/s txt2 (61.93 %) +1.6% - BM_ZFlat/11 1852283 1803238 225.7MB/s txt3 (54.92 %) +2.7% - BM_ZFlat/12 2475527 2443354 188.1MB/s txt4 (66.22 %) +1.3% - BM_ZFlat/13 694497 696654 702.6MB/s bin (18.11 %) -0.3% - BM_ZFlat/14 136929 129855 280.8MB/s sum (48.96 %) +5.4% - BM_ZFlat/15 17172 17124 235.4MB/s man (59.36 %) +0.3% - BM_ZFlat/16 190364 171763 658.4MB/s pb (19.64 %) +10.8% - BM_ZFlat/17 567285 555190 316.6MB/s gaviota (37.72 %) +2.2% - BM_ZCord/0 193490 187031 522.1MB/s html +3.5% - BM_ZCord/1 2427537 2415315 277.2MB/s urls +0.5% - BM_ZCord/2 85378 81412 1.5GB/s jpg +4.9% - BM_ZCord/3 121898 119419 753.3MB/s pdf +2.1% - BM_ZCord/4 779564 762961 512.0MB/s html4 +2.2% - BM_ZDataBuffer/0 213820 207272 471.1MB/s html +3.2% - BM_ZDataBuffer/1 2589010 2586495 258.9MB/s urls +0.1% - BM_ZDataBuffer/2 121871 118885 1018.4MB/s jpg +2.5% - BM_ZDataBuffer/3 145382 145986 616.2MB/s pdf -0.4% - BM_ZDataBuffer/4 868117 852754 458.1MB/s html4 +1.8% - Sum of all benchmarks 33771833 33744763 +0.1% - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@71 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 81f34784b7b812dcda956ee489dfdc74ec2da990 -Author: snappy.mirrorbot@gmail.com -Date: Sun Jan 6 19:21:26 2013 +0000 - - Adjust the Snappy open-source distribution for the changes in Google's - internal file API. - - R=sanjay - - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@70 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 698af469b47fe809905e2ed173ad84241de5800f -Author: snappy.mirrorbot@gmail.com -Date: Fri Jan 4 11:54:20 2013 +0000 - - Change a few ORs to additions where they don't matter. This helps the compiler - use the LEA instruction more efficiently, since e.g. a + (b << 2) can be encoded - as one instruction. Even more importantly, it can constant-fold the - COPY_* enums together with the shifted negative constants, which also saves - some instructions. (We don't need it for LITERAL, since it happens to be 0.) - - I am unsure why the compiler couldn't do this itself, but the theory is that - it cannot prove that len-1 and len-4 cannot underflow/wrap, and thus can't - do the optimization safely. - - The gains are small but measurable; 0.5-1.0% over the BM_Z* benchmarks - (measured on Westmere, Sandy Bridge and Istanbul). - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@69 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 55209f9b92efd97e0a61be28ed94210de04c3bfc -Author: snappy.mirrorbot@gmail.com -Date: Mon Oct 8 11:37:16 2012 +0000 - - Stop giving -Werror to automake, due to an incompatibility between current - versions of libtool and automake on non-GNU platforms (e.g. Mac OS X). - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@68 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit b86e81c8b3426a62d8ab3a7674c2506e9e678740 -Author: snappy.mirrorbot@gmail.com -Date: Fri Aug 17 13:54:47 2012 +0000 - - Fix public issue 66: Document GetUncompressedLength better, in particular that - it leaves the source in a state that's not appropriate for RawUncompress. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@67 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 2e225ba821b420ae28e1d427075d5589c1e892d9 -Author: snappy.mirrorbot@gmail.com -Date: Tue Jul 31 11:44:44 2012 +0000 - - Fix public issue 64: Check for at configure time, - since MSVC seemingly does not have it. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@66 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit e89f20ab46ee11050760c6d57f05c2a3825a911c -Author: snappy.mirrorbot@gmail.com -Date: Wed Jul 4 09:34:48 2012 +0000 - - Handle the case where gettimeofday() goes backwards or returns the same value - twice; it could cause division by zero in the unit test framework. - (We already had one fix for this in place, but it was incomplete.) - - This could in theory happen on any system, since there are few guarantees - about gettimeofday(), but seems to only happen in practice on GNU/Hurd, where - gettimeofday() is cached and only updated ever so often. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@65 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 3ec60ac9878de5d0317ad38fc545080a4bfaa74f -Author: snappy.mirrorbot@gmail.com -Date: Wed Jul 4 09:28:33 2012 +0000 - - Mark ARMv4 as not supporting unaligned accesses (not just ARMv5 and ARMv6); - apparently Debian still targets these by default, giving us segfaults on - armel. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@64 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit be80d6f74f9d82220e952a54f3f129aae1f13f95 -Author: snappy.mirrorbot@gmail.com -Date: Tue May 22 09:46:05 2012 +0000 - - Fix public bug #62: Remove an extraneous comma at the end of an enum list, - causing compile errors when embedded in Mozilla on OpenBSD. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@63 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 8b95464146dddab1c7068f879162db9a885cdafe -Author: snappy.mirrorbot@gmail.com -Date: Tue May 22 09:32:50 2012 +0000 - - Snappy library no longer depends on iostream. - - Achieved by moving logging macro definitions to a test-only - header file, and by changing non-test code to use assert, - fprintf, and abort instead of LOG/CHECK macros. - - R=sesse - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@62 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit fc723b212d6972af7051261754770b3f70a7dc03 -Author: snappy.mirrorbot@gmail.com -Date: Fri Feb 24 15:46:37 2012 +0000 - - Release Snappy 1.0.5. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@61 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit dc63e0ad9693e13390ba31b00d92ecccaf7605c3 -Author: snappy.mirrorbot@gmail.com -Date: Thu Feb 23 17:00:36 2012 +0000 - - For 32-bit platforms, do not try to accelerate multiple neighboring - 32-bit loads with a 64-bit load during compression (it's not a win). - - The main target for this optimization is ARM, but 32-bit x86 gets - a small gain, too, although there is noise in the microbenchmarks. - It's a no-op for 64-bit x86. It does not affect decompression. - - Microbenchmark results on a Cortex-A9 1GHz, using g++ 4.6.2 (from - Ubuntu/Linaro), -O2 -DNDEBUG -Wa,-march=armv7a -mtune=cortex-a9 - -mthumb-interwork, minimum 1000 iterations: - - Benchmark Time(ns) CPU(ns) Iterations - --------------------------------------------------- - BM_ZFlat/0 1158277 1160000 1000 84.2MB/s html (23.57 %) [ +4.3%] - BM_ZFlat/1 14861782 14860000 1000 45.1MB/s urls (50.89 %) [ +1.1%] - BM_ZFlat/2 393595 390000 1000 310.5MB/s jpg (99.88 %) [ +0.0%] - BM_ZFlat/3 650583 650000 1000 138.4MB/s pdf (82.13 %) [ +3.1%] - BM_ZFlat/4 4661480 4660000 1000 83.8MB/s html4 (23.55 %) [ +4.3%] - BM_ZFlat/5 491973 490000 1000 47.9MB/s cp (48.12 %) [ +2.0%] - BM_ZFlat/6 193575 192678 1038 55.2MB/s c (42.40 %) [ +9.0%] - BM_ZFlat/7 62343 62754 3187 56.5MB/s lsp (48.37 %) [ +2.6%] - BM_ZFlat/8 17708468 17710000 1000 55.5MB/s xls (41.34 %) [ -0.3%] - BM_ZFlat/9 3755345 3760000 1000 38.6MB/s txt1 (59.81 %) [ +8.2%] - BM_ZFlat/10 3324217 3320000 1000 36.0MB/s txt2 (64.07 %) [ +4.2%] - BM_ZFlat/11 10139932 10140000 1000 40.1MB/s txt3 (57.11 %) [ +6.4%] - BM_ZFlat/12 13532109 13530000 1000 34.0MB/s txt4 (68.35 %) [ +5.0%] - BM_ZFlat/13 4690847 4690000 1000 104.4MB/s bin (18.21 %) [ +4.1%] - BM_ZFlat/14 830682 830000 1000 43.9MB/s sum (51.88 %) [ +1.2%] - BM_ZFlat/15 84784 85011 2235 47.4MB/s man (59.36 %) [ +1.1%] - BM_ZFlat/16 1293254 1290000 1000 87.7MB/s pb (23.15 %) [ +2.3%] - BM_ZFlat/17 2775155 2780000 1000 63.2MB/s gaviota (38.27 %) [+12.2%] - - Core i7 in 32-bit mode (only one run and 100 iterations, though, so noisy): - - Benchmark Time(ns) CPU(ns) Iterations - --------------------------------------------------- - BM_ZFlat/0 227582 223464 3043 437.0MB/s html (23.57 %) [ +7.4%] - BM_ZFlat/1 2982430 2918455 233 229.4MB/s urls (50.89 %) [ +2.9%] - BM_ZFlat/2 46967 46658 15217 2.5GB/s jpg (99.88 %) [ +0.0%] - BM_ZFlat/3 115298 114864 5833 783.2MB/s pdf (82.13 %) [ +1.5%] - BM_ZFlat/4 913440 899743 778 434.2MB/s html4 (23.55 %) [ +0.3%] - BM_ZFlat/5 110302 108571 7000 216.1MB/s cp (48.12 %) [ +0.0%] - BM_ZFlat/6 44409 43372 15909 245.2MB/s c (42.40 %) [ +0.8%] - BM_ZFlat/7 15713 15643 46667 226.9MB/s lsp (48.37 %) [ +2.7%] - BM_ZFlat/8 2625539 2602230 269 377.4MB/s xls (41.34 %) [ +1.4%] - BM_ZFlat/9 808884 811429 875 178.8MB/s txt1 (59.81 %) [ -3.9%] - BM_ZFlat/10 709532 700000 1000 170.5MB/s txt2 (64.07 %) [ +0.0%] - BM_ZFlat/11 2177682 2162162 333 188.2MB/s txt3 (57.11 %) [ -1.4%] - BM_ZFlat/12 2849640 2840000 250 161.8MB/s txt4 (68.35 %) [ -1.4%] - BM_ZFlat/13 849760 835476 778 585.8MB/s bin (18.21 %) [ +1.2%] - BM_ZFlat/14 165940 164571 4375 221.6MB/s sum (51.88 %) [ +1.4%] - BM_ZFlat/15 20939 20571 35000 196.0MB/s man (59.36 %) [ +2.1%] - BM_ZFlat/16 239209 236544 2917 478.1MB/s pb (23.15 %) [ +4.2%] - BM_ZFlat/17 616206 610000 1000 288.2MB/s gaviota (38.27 %) [ -1.6%] - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@60 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f8829ea39d51432ba4e6a26ddaec57acea779f4c -Author: snappy.mirrorbot@gmail.com -Date: Tue Feb 21 17:02:17 2012 +0000 - - Enable the use of unaligned loads and stores for ARM-based architectures - where they are available (ARMv7 and higher). This gives a significant - speed boost on ARM, both for compression and decompression. - It should not affect x86 at all. - - There are more changes possible to speed up ARM, but it might not be - that easy to do without hurting x86 or making the code uglier. - Also, we de not try to use NEON yet. - - Microbenchmark results on a Cortex-A9 1GHz, using g++ 4.6.2 (from Ubuntu/Linaro), - -O2 -DNDEBUG -Wa,-march=armv7a -mtune=cortex-a9 -mthumb-interwork: - - Benchmark Time(ns) CPU(ns) Iterations - --------------------------------------------------- - BM_UFlat/0 524806 529100 378 184.6MB/s html [+33.6%] - BM_UFlat/1 5139790 5200000 100 128.8MB/s urls [+28.8%] - BM_UFlat/2 86540 84166 1901 1.4GB/s jpg [ +0.6%] - BM_UFlat/3 215351 210176 904 428.0MB/s pdf [+29.8%] - BM_UFlat/4 2144490 2100000 100 186.0MB/s html4 [+33.3%] - BM_UFlat/5 194482 190000 1000 123.5MB/s cp [+36.2%] - BM_UFlat/6 91843 90175 2107 117.9MB/s c [+38.6%] - BM_UFlat/7 28535 28426 6684 124.8MB/s lsp [+34.7%] - BM_UFlat/8 9206600 9200000 100 106.7MB/s xls [+42.4%] - BM_UFlat/9 1865273 1886792 106 76.9MB/s txt1 [+32.5%] - BM_UFlat/10 1576809 1587301 126 75.2MB/s txt2 [+32.3%] - BM_UFlat/11 4968450 4900000 100 83.1MB/s txt3 [+32.7%] - BM_UFlat/12 6673970 6700000 100 68.6MB/s txt4 [+32.8%] - BM_UFlat/13 2391470 2400000 100 203.9MB/s bin [+29.2%] - BM_UFlat/14 334601 344827 522 105.8MB/s sum [+30.6%] - BM_UFlat/15 37404 38080 5252 105.9MB/s man [+33.8%] - BM_UFlat/16 535470 540540 370 209.2MB/s pb [+31.2%] - BM_UFlat/17 1875245 1886792 106 93.2MB/s gaviota [+37.8%] - BM_UValidate/0 178425 179533 1114 543.9MB/s html [ +2.7%] - BM_UValidate/1 2100450 2000000 100 334.8MB/s urls [ +5.0%] - BM_UValidate/2 1039 1044 172413 113.3GB/s jpg [ +3.4%] - BM_UValidate/3 59423 59470 3363 1.5GB/s pdf [ +7.8%] - BM_UValidate/4 760716 766283 261 509.8MB/s html4 [ +6.5%] - BM_ZFlat/0 1204632 1204819 166 81.1MB/s html (23.57 %) [+32.8%] - BM_ZFlat/1 15656190 15600000 100 42.9MB/s urls (50.89 %) [+27.6%] - BM_ZFlat/2 403336 410677 487 294.8MB/s jpg (99.88 %) [+16.5%] - BM_ZFlat/3 664073 671140 298 134.0MB/s pdf (82.13 %) [+28.4%] - BM_ZFlat/4 4961940 4900000 100 79.7MB/s html4 (23.55 %) [+30.6%] - BM_ZFlat/5 500664 501253 399 46.8MB/s cp (48.12 %) [+33.4%] - BM_ZFlat/6 217276 215982 926 49.2MB/s c (42.40 %) [+25.0%] - BM_ZFlat/7 64122 65487 3054 54.2MB/s lsp (48.37 %) [+36.1%] - BM_ZFlat/8 18045730 18000000 100 54.6MB/s xls (41.34 %) [+34.4%] - BM_ZFlat/9 4051530 4000000 100 36.3MB/s txt1 (59.81 %) [+25.0%] - BM_ZFlat/10 3451800 3500000 100 34.1MB/s txt2 (64.07 %) [+25.7%] - BM_ZFlat/11 11052340 11100000 100 36.7MB/s txt3 (57.11 %) [+24.3%] - BM_ZFlat/12 14538690 14600000 100 31.5MB/s txt4 (68.35 %) [+24.7%] - BM_ZFlat/13 5041850 5000000 100 97.9MB/s bin (18.21 %) [+32.0%] - BM_ZFlat/14 908840 909090 220 40.1MB/s sum (51.88 %) [+22.2%] - BM_ZFlat/15 86921 86206 1972 46.8MB/s man (59.36 %) [+42.2%] - BM_ZFlat/16 1312315 1315789 152 86.0MB/s pb (23.15 %) [+34.5%] - BM_ZFlat/17 3173120 3200000 100 54.9MB/s gaviota (38.27%) [+28.1%] - - - The move from 64-bit to 32-bit operations for the copies also affected 32-bit x86; - positive on the decompression side, and slightly negative on the compression side - (unless that is noise; I only ran once): - - Benchmark Time(ns) CPU(ns) Iterations - ----------------------------------------------------- - BM_UFlat/0 86279 86140 7778 1.1GB/s html [ +7.5%] - BM_UFlat/1 839265 822622 778 813.9MB/s urls [ +9.4%] - BM_UFlat/2 9180 9143 87500 12.9GB/s jpg [ +1.2%] - BM_UFlat/3 35080 35000 20000 2.5GB/s pdf [+10.1%] - BM_UFlat/4 350318 345000 2000 1.1GB/s html4 [ +7.0%] - BM_UFlat/5 33808 33472 21212 701.0MB/s cp [ +9.0%] - BM_UFlat/6 15201 15214 46667 698.9MB/s c [+14.9%] - BM_UFlat/7 4652 4651 159091 762.9MB/s lsp [ +7.5%] - BM_UFlat/8 1285551 1282528 538 765.7MB/s xls [+10.7%] - BM_UFlat/9 282510 281690 2414 514.9MB/s txt1 [+13.6%] - BM_UFlat/10 243494 239286 2800 498.9MB/s txt2 [+14.4%] - BM_UFlat/11 743625 740000 1000 550.0MB/s txt3 [+14.3%] - BM_UFlat/12 999441 989717 778 464.3MB/s txt4 [+16.1%] - BM_UFlat/13 412402 410076 1707 1.2GB/s bin [ +7.3%] - BM_UFlat/14 54876 54000 10000 675.3MB/s sum [+13.0%] - BM_UFlat/15 6146 6100 100000 660.8MB/s man [+14.8%] - BM_UFlat/16 90496 90286 8750 1.2GB/s pb [ +4.0%] - BM_UFlat/17 292650 292000 2500 602.0MB/s gaviota [+18.1%] - BM_UValidate/0 49620 49699 14286 1.9GB/s html [ +0.0%] - BM_UValidate/1 501371 500000 1000 1.3GB/s urls [ +0.0%] - BM_UValidate/2 232 227 3043478 521.5GB/s jpg [ +1.3%] - BM_UValidate/3 17250 17143 43750 5.1GB/s pdf [ -1.3%] - BM_UValidate/4 198643 200000 3500 1.9GB/s html4 [ -0.9%] - BM_ZFlat/0 227128 229415 3182 425.7MB/s html (23.57 %) [ -1.4%] - BM_ZFlat/1 2970089 2960000 250 226.2MB/s urls (50.89 %) [ -1.9%] - BM_ZFlat/2 45683 44999 15556 2.6GB/s jpg (99.88 %) [ +2.2%] - BM_ZFlat/3 114661 113136 6364 795.1MB/s pdf (82.13 %) [ -1.5%] - BM_ZFlat/4 919702 914286 875 427.2MB/s html4 (23.55%) [ -1.3%] - BM_ZFlat/5 108189 108422 6364 216.4MB/s cp (48.12 %) [ -1.2%] - BM_ZFlat/6 44525 44000 15909 241.7MB/s c (42.40 %) [ -2.9%] - BM_ZFlat/7 15973 15857 46667 223.8MB/s lsp (48.37 %) [ +0.0%] - BM_ZFlat/8 2677888 2639405 269 372.1MB/s xls (41.34 %) [ -1.4%] - BM_ZFlat/9 800715 780000 1000 186.0MB/s txt1 (59.81 %) [ -0.4%] - BM_ZFlat/10 700089 700000 1000 170.5MB/s txt2 (64.07 %) [ -2.9%] - BM_ZFlat/11 2159356 2138365 318 190.3MB/s txt3 (57.11 %) [ -0.3%] - BM_ZFlat/12 2796143 2779923 259 165.3MB/s txt4 (68.35 %) [ -1.4%] - BM_ZFlat/13 856458 835476 778 585.8MB/s bin (18.21 %) [ -0.1%] - BM_ZFlat/14 166908 166857 4375 218.6MB/s sum (51.88 %) [ -1.4%] - BM_ZFlat/15 21181 20857 35000 193.3MB/s man (59.36 %) [ -0.8%] - BM_ZFlat/16 244009 239973 2917 471.3MB/s pb (23.15 %) [ -1.4%] - BM_ZFlat/17 596362 590000 1000 297.9MB/s gaviota (38.27%) [ +0.0%] - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@59 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f2e184f638bdc7905f26c24faaf10fc0f5d33403 -Author: snappy.mirrorbot@gmail.com -Date: Sat Feb 11 22:11:22 2012 +0000 - - Lower the size allocated in the "corrupted input" unit test from 256 MB - to 2 MB. This fixes issues with running the unit test on platforms with - little RAM (e.g. some ARM boards). - - Also, reactivate the 2 MB test for 64-bit platforms; there's no good - reason why it shouldn't be. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@58 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit e750dc0f054ba74b0ce76dd2013e6728cc7a41c5 -Author: snappy.mirrorbot@gmail.com -Date: Sun Jan 8 17:55:48 2012 +0000 - - Minor refactoring to accomodate changes in Google's internal code tree. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@57 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit d9068ee301bdf893a4d8cb7c6518eacc44c4c1f2 -Author: snappy.mirrorbot@gmail.com -Date: Wed Jan 4 13:10:46 2012 +0000 - - Fix public issue r57: Fix most warnings with -Wall, mostly signed/unsigned - warnings. There are still some in the unit test, but the main .cc file should - be clean. We haven't enabled -Wall for the default build, since the unit test - is still not clean. - - This also fixes a real bug in the open-source implementation of - ReadFileToStringOrDie(); it would not detect errors correctly. - - I had to go through some pains to avoid performance loss as the types - were changed; I think there might still be some with 32-bit if and only if LFS - is enabled (ie., size_t is 64-bit), but for regular 32-bit and 64-bit I can't - see any losses, and I've diffed the generated GCC assembler between the old and - new code without seeing any significant choices. If anything, it's ever so - slightly faster. - - This may or may not enable compression of very large blocks (>2^32 bytes) - when size_t is 64-bit, but I haven't checked, and it is still not a supported - case. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@56 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 0755c815197dacc77d8971ae917c86d7aa96bf8e -Author: snappy.mirrorbot@gmail.com -Date: Wed Jan 4 10:46:39 2012 +0000 - - Add a framing format description. We do not have any implementation of this at - the current point, but there seems to be enough of a general interest in the - topic (cf. public bug #34). - - R=csilvers,sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@55 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit d7eb2dc4133794b62cba691f9be40d1549bc32e2 -Author: snappy.mirrorbot@gmail.com -Date: Mon Dec 5 21:27:26 2011 +0000 - - Speed up decompression by moving the refill check to the end of the loop. - - This seems to work because in most of the branches, the compiler can evaluate - “ip_limit_ - ip” in a more efficient way than reloading ip_limit_ from memory - (either by already having the entire expression in a register, or reconstructing - it from “avail”, or something else). Memory loads, even from L1, are seemingly - costly in the big picture at the current decompression speeds. - - Microbenchmarks (64-bit, opt mode): - - Westmere (Intel Core i7): - - Benchmark Time(ns) CPU(ns) Iterations - -------------------------------------------- - BM_UFlat/0 74492 74491 187894 1.3GB/s html [ +5.9%] - BM_UFlat/1 712268 712263 19644 940.0MB/s urls [ +3.8%] - BM_UFlat/2 10591 10590 1000000 11.2GB/s jpg [ -6.8%] - BM_UFlat/3 29643 29643 469915 3.0GB/s pdf [ +7.9%] - BM_UFlat/4 304669 304667 45930 1.3GB/s html4 [ +4.8%] - BM_UFlat/5 28508 28507 490077 823.1MB/s cp [ +4.0%] - BM_UFlat/6 12415 12415 1000000 856.5MB/s c [ +8.6%] - BM_UFlat/7 3415 3415 4084723 1039.0MB/s lsp [+18.0%] - BM_UFlat/8 979569 979563 14261 1002.5MB/s xls [ +5.8%] - BM_UFlat/9 230150 230148 60934 630.2MB/s txt1 [ +5.2%] - BM_UFlat/10 197167 197166 71135 605.5MB/s txt2 [ +4.7%] - BM_UFlat/11 607394 607390 23041 670.1MB/s txt3 [ +5.6%] - BM_UFlat/12 808502 808496 17316 568.4MB/s txt4 [ +5.0%] - BM_UFlat/13 372791 372788 37564 1.3GB/s bin [ +3.3%] - BM_UFlat/14 44541 44541 313969 818.8MB/s sum [ +5.7%] - BM_UFlat/15 4833 4833 2898697 834.1MB/s man [ +4.8%] - BM_UFlat/16 79855 79855 175356 1.4GB/s pb [ +4.8%] - BM_UFlat/17 245845 245843 56838 715.0MB/s gaviota [ +5.8%] - - Clovertown (Intel Core 2): - - Benchmark Time(ns) CPU(ns) Iterations - -------------------------------------------- - BM_UFlat/0 107911 107890 100000 905.1MB/s html [ +2.2%] - BM_UFlat/1 1011237 1011041 10000 662.3MB/s urls [ +2.5%] - BM_UFlat/2 26775 26770 523089 4.4GB/s jpg [ +0.0%] - BM_UFlat/3 48103 48095 290618 1.8GB/s pdf [ +3.4%] - BM_UFlat/4 437724 437644 31937 892.6MB/s html4 [ +2.1%] - BM_UFlat/5 39607 39600 358284 592.5MB/s cp [ +2.4%] - BM_UFlat/6 18227 18224 768191 583.5MB/s c [ +2.7%] - BM_UFlat/7 5171 5170 2709437 686.4MB/s lsp [ +3.9%] - BM_UFlat/8 1560291 1559989 8970 629.5MB/s xls [ +3.6%] - BM_UFlat/9 335401 335343 41731 432.5MB/s txt1 [ +3.0%] - BM_UFlat/10 287014 286963 48758 416.0MB/s txt2 [ +2.8%] - BM_UFlat/11 888522 888356 15752 458.1MB/s txt3 [ +2.9%] - BM_UFlat/12 1186600 1186378 10000 387.3MB/s txt4 [ +3.1%] - BM_UFlat/13 572295 572188 24468 855.4MB/s bin [ +2.1%] - BM_UFlat/14 64060 64049 218401 569.4MB/s sum [ +4.1%] - BM_UFlat/15 7264 7263 1916168 555.0MB/s man [ +1.4%] - BM_UFlat/16 108853 108836 100000 1039.1MB/s pb [ +1.7%] - BM_UFlat/17 364289 364223 38419 482.6MB/s gaviota [ +4.9%] - - Barcelona (AMD Opteron): - - Benchmark Time(ns) CPU(ns) Iterations - -------------------------------------------- - BM_UFlat/0 103900 103871 100000 940.2MB/s html [ +8.3%] - BM_UFlat/1 1000435 1000107 10000 669.5MB/s urls [ +6.6%] - BM_UFlat/2 24659 24652 567362 4.8GB/s jpg [ +0.1%] - BM_UFlat/3 48206 48193 291121 1.8GB/s pdf [ +5.0%] - BM_UFlat/4 421980 421850 33174 926.0MB/s html4 [ +7.3%] - BM_UFlat/5 40368 40357 346994 581.4MB/s cp [ +8.7%] - BM_UFlat/6 19836 19830 708695 536.2MB/s c [ +8.0%] - BM_UFlat/7 6100 6098 2292774 581.9MB/s lsp [ +9.0%] - BM_UFlat/8 1693093 1692514 8261 580.2MB/s xls [ +8.0%] - BM_UFlat/9 365991 365886 38225 396.4MB/s txt1 [ +7.1%] - BM_UFlat/10 311330 311238 44950 383.6MB/s txt2 [ +7.6%] - BM_UFlat/11 975037 974737 14376 417.5MB/s txt3 [ +6.9%] - BM_UFlat/12 1303558 1303175 10000 352.6MB/s txt4 [ +7.3%] - BM_UFlat/13 517448 517290 27144 946.2MB/s bin [ +5.5%] - BM_UFlat/14 66537 66518 210352 548.3MB/s sum [ +7.5%] - BM_UFlat/15 7976 7974 1760383 505.6MB/s man [ +5.6%] - BM_UFlat/16 103121 103092 100000 1097.0MB/s pb [ +8.7%] - BM_UFlat/17 391431 391314 35733 449.2MB/s gaviota [ +6.5%] - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@54 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 5ed51ce15fc4ff8d2f7235704eb6b0c3f762fb88 -Author: snappy.mirrorbot@gmail.com -Date: Wed Nov 23 11:14:17 2011 +0000 - - Speed up decompression by making the fast path for literals faster. - - We do the fast-path step as soon as possible; in fact, as soon as we know the - literal length. Since we usually hit the fast path, we can then skip the checks - for long literals and available input space (beyond what the fast path check - already does). - - Note that this changes the decompression Writer API; however, it does not - change the ABI, since writers are always templatized and as such never - cross compilation units. The new API is slightly more general, in that it - doesn't hard-code the value 16. Note that we also take care to check - for len <= 16 first, since the other two checks almost always succeed - (so we don't want to waste time checking for them until we have to). - - The improvements are most marked on Nehalem, but are generally positive - on other platforms as well. All microbenchmarks are 64-bit, opt. - - Clovertown (Core 2): - - Benchmark Time(ns) CPU(ns) Iterations - -------------------------------------------- - BM_UFlat/0 110226 110224 100000 886.0MB/s html [ +1.5%] - BM_UFlat/1 1036523 1036508 10000 646.0MB/s urls [ -0.8%] - BM_UFlat/2 26775 26775 522570 4.4GB/s jpg [ +0.0%] - BM_UFlat/3 49738 49737 280974 1.8GB/s pdf [ +0.3%] - BM_UFlat/4 446790 446792 31334 874.3MB/s html4 [ +0.8%] - BM_UFlat/5 40561 40562 350424 578.5MB/s cp [ +1.3%] - BM_UFlat/6 18722 18722 746903 568.0MB/s c [ +1.4%] - BM_UFlat/7 5373 5373 2608632 660.5MB/s lsp [ +8.3%] - BM_UFlat/8 1615716 1615718 8670 607.8MB/s xls [ +2.0%] - BM_UFlat/9 345278 345281 40481 420.1MB/s txt1 [ +1.4%] - BM_UFlat/10 294855 294855 47452 404.9MB/s txt2 [ +1.6%] - BM_UFlat/11 914263 914263 15316 445.2MB/s txt3 [ +1.1%] - BM_UFlat/12 1222694 1222691 10000 375.8MB/s txt4 [ +1.4%] - BM_UFlat/13 584495 584489 23954 837.4MB/s bin [ -0.6%] - BM_UFlat/14 66662 66662 210123 547.1MB/s sum [ +1.2%] - BM_UFlat/15 7368 7368 1881856 547.1MB/s man [ +4.0%] - BM_UFlat/16 110727 110726 100000 1021.4MB/s pb [ +2.3%] - BM_UFlat/17 382138 382141 36616 460.0MB/s gaviota [ -0.7%] - - Westmere (Core i7): - - Benchmark Time(ns) CPU(ns) Iterations - -------------------------------------------- - BM_UFlat/0 78861 78853 177703 1.2GB/s html [ +2.1%] - BM_UFlat/1 739560 739491 18912 905.4MB/s urls [ +3.4%] - BM_UFlat/2 9867 9866 1419014 12.0GB/s jpg [ +3.4%] - BM_UFlat/3 31989 31986 438385 2.7GB/s pdf [ +0.2%] - BM_UFlat/4 319406 319380 43771 1.2GB/s html4 [ +1.9%] - BM_UFlat/5 29639 29636 472862 791.7MB/s cp [ +5.2%] - BM_UFlat/6 13478 13477 1000000 789.0MB/s c [ +2.3%] - BM_UFlat/7 4030 4029 3475364 880.7MB/s lsp [ +8.7%] - BM_UFlat/8 1036585 1036492 10000 947.5MB/s xls [ +6.9%] - BM_UFlat/9 242127 242105 57838 599.1MB/s txt1 [ +3.0%] - BM_UFlat/10 206499 206480 67595 578.2MB/s txt2 [ +3.4%] - BM_UFlat/11 641635 641570 21811 634.4MB/s txt3 [ +2.4%] - BM_UFlat/12 848847 848769 16443 541.4MB/s txt4 [ +3.1%] - BM_UFlat/13 384968 384938 36366 1.2GB/s bin [ +0.3%] - BM_UFlat/14 47106 47101 297770 774.3MB/s sum [ +4.4%] - BM_UFlat/15 5063 5063 2772202 796.2MB/s man [ +7.7%] - BM_UFlat/16 83663 83656 167697 1.3GB/s pb [ +1.8%] - BM_UFlat/17 260224 260198 53823 675.6MB/s gaviota [ -0.5%] - - Barcelona (Opteron): - - Benchmark Time(ns) CPU(ns) Iterations - -------------------------------------------- - BM_UFlat/0 112490 112457 100000 868.4MB/s html [ -0.4%] - BM_UFlat/1 1066719 1066339 10000 627.9MB/s urls [ +1.0%] - BM_UFlat/2 24679 24672 563802 4.8GB/s jpg [ +0.7%] - BM_UFlat/3 50603 50589 277285 1.7GB/s pdf [ +2.6%] - BM_UFlat/4 452982 452849 30900 862.6MB/s html4 [ -0.2%] - BM_UFlat/5 43860 43848 319554 535.1MB/s cp [ +1.2%] - BM_UFlat/6 21419 21413 653573 496.6MB/s c [ +1.0%] - BM_UFlat/7 6646 6645 2105405 534.1MB/s lsp [ +0.3%] - BM_UFlat/8 1828487 1827886 7658 537.3MB/s xls [ +2.6%] - BM_UFlat/9 391824 391714 35708 370.3MB/s txt1 [ +2.2%] - BM_UFlat/10 334913 334816 41885 356.6MB/s txt2 [ +1.7%] - BM_UFlat/11 1042062 1041674 10000 390.7MB/s txt3 [ +1.1%] - BM_UFlat/12 1398902 1398456 10000 328.6MB/s txt4 [ +1.7%] - BM_UFlat/13 545706 545530 25669 897.2MB/s bin [ -0.4%] - BM_UFlat/14 71512 71505 196035 510.0MB/s sum [ +1.4%] - BM_UFlat/15 8422 8421 1665036 478.7MB/s man [ +2.6%] - BM_UFlat/16 112053 112048 100000 1009.3MB/s pb [ -0.4%] - BM_UFlat/17 416723 416713 33612 421.8MB/s gaviota [ -2.0%] - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@53 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 0c1b9c3904430f5b399bd057d76de4bc36b7a123 -Author: snappy.mirrorbot@gmail.com -Date: Tue Nov 8 14:46:39 2011 +0000 - - Fix public issue #53: Update the README to the API we actually open-sourced - with. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@52 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit b61134bc0a6a904b41522b4e5c9e80874c730cef -Author: snappy.mirrorbot@gmail.com -Date: Wed Oct 5 12:27:12 2011 +0000 - - In the format description, use a clearer example to emphasize that varints are - stored in little-endian. Patch from Christian von Roques. - - R=csilvers - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@51 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 21a2e4f55758e759302cd84ad0f3580affcba7d9 -Author: snappy.mirrorbot@gmail.com -Date: Thu Sep 15 19:34:06 2011 +0000 - - Release Snappy 1.0.4. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@50 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit e2e303286813c759c5b1cdb46dad63c494f0a061 -Author: snappy.mirrorbot@gmail.com -Date: Thu Sep 15 09:50:05 2011 +0000 - - Fix public issue #50: Include generic byteswap macros. - Also include Solaris 10 and FreeBSD versions. - - R=csilvers - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@49 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 593002da3c051f4721312869f816b41485bad3b7 -Author: snappy.mirrorbot@gmail.com -Date: Wed Aug 10 18:57:27 2011 +0000 - - Partially fix public issue 50: Remove an extra comma from the end of some - enum declarations, as it seems the Sun compiler does not like it. - - Based on patch by Travis Vitek. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@48 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f1063a5dc43891eed37f0586bfea57b84dddd756 -Author: snappy.mirrorbot@gmail.com -Date: Wed Aug 10 18:44:16 2011 +0000 - - Use the right #ifdef test for sys/mman.h. - - Based on patch by Travis Vitek. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@47 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 41c827a2fa9ce048202d941187f211180feadde4 -Author: snappy.mirrorbot@gmail.com -Date: Wed Aug 10 01:22:09 2011 +0000 - - Fix public issue #47: Small comment cleanups in the unit test. - - Originally based on a patch by Patrick Pelletier. - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@46 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 59aeffa6049b5c2a3a467e7602c1f93630b870e7 -Author: snappy.mirrorbot@gmail.com -Date: Wed Aug 10 01:14:43 2011 +0000 - - Fix public issue #46: Format description said "3-byte offset" - instead of "4-byte offset" for the longest copies. - - Also fix an inconsistency in the heading for section 2.2.3. - Both patches by Patrick Pelletier. - - R=csilvers - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@45 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 57e7cd72559cb022ef32856f2252a4c4585e562e -Author: snappy.mirrorbot@gmail.com -Date: Tue Jun 28 11:40:25 2011 +0000 - - Fix public issue #44: Make the definition and declaration of CompressFragment - identical, even regarding cv-qualifiers. - - This is required to work around a bug in the Solaris Studio C++ compiler - (it does not properly disregard cv-qualifiers when doing name mangling). - - R=sanjay - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@44 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 13c4a449a8ea22139c9aa441e8024eebc9dbdf6e -Author: snappy.mirrorbot@gmail.com -Date: Sat Jun 4 10:19:05 2011 +0000 - - Correct an inaccuracy in the Snappy format description. - (I stumbled into this when changing the way we decompress literals.) - - R=csilvers - - Revision created by MOE tool push_codebase. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@43 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f5406737403119e1483a71d2084d17728663a114 -Author: snappy.mirrorbot@gmail.com -Date: Fri Jun 3 20:53:06 2011 +0000 - - Speed up decompression by removing a fast-path attempt. - - Whenever we try to enter a copy fast-path, there is a certain cost in checking - that all the preconditions are in place, but it's normally offset by the fact - that we can usually take the cheaper path. However, in a certain path we've - already established that "avail < literal_length", which usually means that - either the available space is small, or the literal is big. Both will disqualify - us from taking the fast path, and thus we take the hit from the precondition - checking without gaining much from having a fast path. Thus, simply don't try - the fast path in this situation -- we're already on a slow path anyway - (one where we need to refill more data from the reader). - - I'm a bit surprised at how much this gained; it could be that this path is - more common than I thought, or that the simpler structure somehow makes the - compiler happier. I haven't looked at the assembler, but it's a win across - the board on both Core 2, Core i7 and Opteron, at least for the cases we - typically care about. The gains seem to be the largest on Core i7, though. - Results from my Core i7 workstation: - - - Benchmark Time(ns) CPU(ns) Iterations - --------------------------------------------------- - BM_UFlat/0 73337 73091 190996 1.3GB/s html [ +1.7%] - BM_UFlat/1 696379 693501 20173 965.5MB/s urls [ +2.7%] - BM_UFlat/2 9765 9734 1472135 12.1GB/s jpg [ +0.7%] - BM_UFlat/3 29720 29621 472973 3.0GB/s pdf [ +1.8%] - BM_UFlat/4 294636 293834 47782 1.3GB/s html4 [ +2.3%] - BM_UFlat/5 28399 28320 494700 828.5MB/s cp [ +3.5%] - BM_UFlat/6 12795 12760 1000000 833.3MB/s c [ +1.2%] - BM_UFlat/7 3984 3973 3526448 893.2MB/s lsp [ +5.7%] - BM_UFlat/8 991996 989322 14141 992.6MB/s xls [ +3.3%] - BM_UFlat/9 228620 227835 61404 636.6MB/s txt1 [ +4.0%] - BM_UFlat/10 197114 196494 72165 607.5MB/s txt2 [ +3.5%] - BM_UFlat/11 605240 603437 23217 674.4MB/s txt3 [ +3.7%] - BM_UFlat/12 804157 802016 17456 573.0MB/s txt4 [ +3.9%] - BM_UFlat/13 347860 346998 40346 1.4GB/s bin [ +1.2%] - BM_UFlat/14 44684 44559 315315 818.4MB/s sum [ +2.3%] - BM_UFlat/15 5120 5106 2739726 789.4MB/s man [ +3.3%] - BM_UFlat/16 76591 76355 183486 1.4GB/s pb [ +2.8%] - BM_UFlat/17 238564 237828 58824 739.1MB/s gaviota [ +1.6%] - BM_UValidate/0 42194 42060 333333 2.3GB/s html [ -0.1%] - BM_UValidate/1 433182 432005 32407 1.5GB/s urls [ -0.1%] - BM_UValidate/2 197 196 71428571 603.3GB/s jpg [ +0.5%] - BM_UValidate/3 14494 14462 972222 6.1GB/s pdf [ +0.5%] - BM_UValidate/4 168444 167836 83832 2.3GB/s html4 [ +0.1%] - - R=jeff - - Revision created by MOE tool push_codebase. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@42 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 197f3ee9f9397e98c9abf07f9da875fbcb725dba -Author: snappy.mirrorbot@gmail.com -Date: Fri Jun 3 20:47:14 2011 +0000 - - Speed up decompression by not needing a lookup table for literal items. - - Looking up into and decoding the values from char_table has long shown up as a - hotspot in the decompressor. While it turns out that it's hard to make a more - efficient decoder for the copy ops, the literals are simple enough that we can - decode them without needing a table lookup. (This means that 1/4 of the table - is now unused, although that in itself doesn't buy us anything.) - - The gains are small, but definitely present; some tests win as much as 10%, - but 1-4% is more typical. These results are from Core i7, in 64-bit mode; - Core 2 and Opteron show similar results. (I've run with more iterations - than unusual to make sure the smaller gains don't drown entirely in noise.) - - Benchmark Time(ns) CPU(ns) Iterations - --------------------------------------------------- - BM_UFlat/0 74665 74428 182055 1.3GB/s html [ +3.1%] - BM_UFlat/1 714106 711997 19663 940.4MB/s urls [ +4.4%] - BM_UFlat/2 9820 9789 1427115 12.1GB/s jpg [ -1.2%] - BM_UFlat/3 30461 30380 465116 2.9GB/s pdf [ +0.8%] - BM_UFlat/4 301445 300568 46512 1.3GB/s html4 [ +2.2%] - BM_UFlat/5 29338 29263 479452 801.8MB/s cp [ +1.6%] - BM_UFlat/6 13004 12970 1000000 819.9MB/s c [ +2.1%] - BM_UFlat/7 4180 4168 3349282 851.4MB/s lsp [ +1.3%] - BM_UFlat/8 1026149 1024000 10000 959.0MB/s xls [+10.7%] - BM_UFlat/9 237441 236830 59072 612.4MB/s txt1 [ +0.3%] - BM_UFlat/10 203966 203298 69307 587.2MB/s txt2 [ +0.8%] - BM_UFlat/11 627230 625000 22400 651.2MB/s txt3 [ +0.7%] - BM_UFlat/12 836188 833979 16787 551.0MB/s txt4 [ +1.3%] - BM_UFlat/13 351904 350750 39886 1.4GB/s bin [ +3.8%] - BM_UFlat/14 45685 45562 308370 800.4MB/s sum [ +5.9%] - BM_UFlat/15 5286 5270 2656546 764.9MB/s man [ +1.5%] - BM_UFlat/16 78774 78544 178117 1.4GB/s pb [ +4.3%] - BM_UFlat/17 242270 241345 58091 728.3MB/s gaviota [ +1.2%] - BM_UValidate/0 42149 42000 333333 2.3GB/s html [ -3.0%] - BM_UValidate/1 432741 431303 32483 1.5GB/s urls [ +7.8%] - BM_UValidate/2 198 197 71428571 600.7GB/s jpg [+16.8%] - BM_UValidate/3 14560 14521 965517 6.1GB/s pdf [ -4.1%] - BM_UValidate/4 169065 168671 83832 2.3GB/s html4 [ -2.9%] - - R=jeff - - Revision created by MOE tool push_codebase. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@41 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 8efa2639e885ac467e7b11c662975c5844019fb9 -Author: snappy.mirrorbot@gmail.com -Date: Thu Jun 2 22:57:41 2011 +0000 - - Release Snappy 1.0.3. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@40 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 2e12124bd87f39296709decc65195fa5bfced538 -Author: snappy.mirrorbot@gmail.com -Date: Thu Jun 2 18:06:54 2011 +0000 - - Remove an unneeded goto in the decompressor; it turns out that the - state of ip_ after decompression (or attempted decompresion) is - completely irrelevant, so we don't need the trailer. - - Performance is, as expected, mostly flat -- there's a curious ~3-5% - loss in the "lsp" test, but that test case is so short it is hard to say - anything definitive about why (most likely, it's some sort of - unrelated effect). - - R=jeff - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@39 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit c266bbf32103f8ed4a83e2272ed3d8828d5b8b34 -Author: snappy.mirrorbot@gmail.com -Date: Thu Jun 2 17:59:40 2011 +0000 - - Speed up decompression by caching ip_. - - It is seemingly hard for the compiler to understand that ip_, the current input - pointer into the compressed data stream, can not alias on anything else, and - thus using it directly will incur memory traffic as it cannot be kept in a - register. The code already knew about this and cached it into a local - variable, but since Step() only decoded one tag, it had to move ip_ back into - place between every tag. This seems to have cost us a significant amount of - performance, so changing Step() into a function that decodes as much as it can - before it saves ip_ back and returns. (Note that Step() was already inlined, - so it is not the manual inlining that buys the performance here.) - - The wins are about 3-6% for Core 2, 6-13% on Core i7 and 5-12% on Opteron - (for plain array-to-array decompression, in 64-bit opt mode). - - There is a tiny difference in the behavior here; if an invalid literal is - encountered (ie., the writer refuses the Append() operation), ip_ will now - point to the byte past the tag byte, instead of where the literal was - originally thought to end. However, we don't use ip_ for anything after - DecompressAllTags() has returned, so this should not change external behavior - in any way. - - Microbenchmark results for Core i7, 64-bit (Opteron results are similar): - - Benchmark Time(ns) CPU(ns) Iterations - --------------------------------------------------- - BM_UFlat/0 79134 79110 8835 1.2GB/s html [ +6.2%] - BM_UFlat/1 786126 786096 891 851.8MB/s urls [+10.0%] - BM_UFlat/2 9948 9948 69125 11.9GB/s jpg [ -1.3%] - BM_UFlat/3 31999 31998 21898 2.7GB/s pdf [ +6.5%] - BM_UFlat/4 318909 318829 2204 1.2GB/s html4 [ +6.5%] - BM_UFlat/5 31384 31390 22363 747.5MB/s cp [ +9.2%] - BM_UFlat/6 14037 14034 49858 757.7MB/s c [+10.6%] - BM_UFlat/7 4612 4612 151395 769.5MB/s lsp [ +9.5%] - BM_UFlat/8 1203174 1203007 582 816.3MB/s xls [+19.3%] - BM_UFlat/9 253869 253955 2757 571.1MB/s txt1 [+11.4%] - BM_UFlat/10 219292 219290 3194 544.4MB/s txt2 [+12.1%] - BM_UFlat/11 672135 672131 1000 605.5MB/s txt3 [+11.2%] - BM_UFlat/12 902512 902492 776 509.2MB/s txt4 [+12.5%] - BM_UFlat/13 372110 371998 1881 1.3GB/s bin [ +5.8%] - BM_UFlat/14 50407 50407 10000 723.5MB/s sum [+13.5%] - BM_UFlat/15 5699 5701 100000 707.2MB/s man [+12.4%] - BM_UFlat/16 83448 83424 8383 1.3GB/s pb [ +5.7%] - BM_UFlat/17 256958 256963 2723 684.1MB/s gaviota [ +7.9%] - BM_UValidate/0 42795 42796 16351 2.2GB/s html [+25.8%] - BM_UValidate/1 490672 490622 1427 1.3GB/s urls [+22.7%] - BM_UValidate/2 237 237 2950297 499.0GB/s jpg [+24.9%] - BM_UValidate/3 14610 14611 47901 6.0GB/s pdf [+26.8%] - BM_UValidate/4 171973 171990 4071 2.2GB/s html4 [+25.7%] - - - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@38 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit d0ee043bc50c62c5b5ff3da044f0b5567257407d -Author: snappy.mirrorbot@gmail.com -Date: Tue May 17 08:48:25 2011 +0000 - - Fix the numbering of the headlines in the Snappy format description. - - R=csilvers - DELTA=4 (0 added, 0 deleted, 4 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1906 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@37 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 6c7053871fbdb459c9c14287a138d7f82d6d84a1 -Author: snappy.mirrorbot@gmail.com -Date: Mon May 16 08:59:18 2011 +0000 - - Fix public issue #32: Add compressed format documentation for Snappy. - This text is new, but an earlier version from Zeev Tarantov was used - as reference. - - R=csilvers - DELTA=112 (111 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1867 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@36 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit a1f9f9973d127992f341d442969c86fd9a0847c9 -Author: snappy.mirrorbot@gmail.com -Date: Mon May 9 21:29:02 2011 +0000 - - Fix public issue #39: Pick out the median runs based on CPU time, - not real time. Also, use nth_element instead of sort, since we - only need one element. - - R=csilvers - DELTA=5 (3 added, 0 deleted, 2 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1799 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@35 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f7b105683c074cdf233740089e245e43f63e7e55 -Author: snappy.mirrorbot@gmail.com -Date: Mon May 9 21:28:45 2011 +0000 - - Fix public issue #38: Make the microbenchmark framework handle - properly cases where gettimeofday() can stand return the same - result twice (as sometimes on GNU/Hurd) or go backwards - (as when the user adjusts the clock). We avoid a division-by-zero, - and put a lower bound on the number of iterations -- the same - amount as we use to calibrate. - - We should probably use CLOCK_MONOTONIC for platforms that support - it, to be robust against clock adjustments; we already use Windows' - monotonic timers. However, that's for a later changelist. - - R=csilvers - DELTA=7 (5 added, 0 deleted, 2 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1798 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@34 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit d8d481427a05b88cdb0810c29bf400153595c423 -Author: snappy.mirrorbot@gmail.com -Date: Tue May 3 23:22:52 2011 +0000 - - Fix public issue #37: Only link snappy_unittest against -lz and other autodetected - libraries, not libsnappy.so (which doesn't need any such dependency). - - R=csilvers - DELTA=20 (14 added, 0 deleted, 6 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1710 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@33 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit bcecf195c0aeb2c98144d3d54b4d8d228774f50d -Author: snappy.mirrorbot@gmail.com -Date: Tue May 3 23:22:33 2011 +0000 - - Release Snappy 1.0.2, to get the license change and various other fixes into - a release. - - R=csilvers - DELTA=239 (236 added, 0 deleted, 3 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1709 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@32 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 84d9f642025cda672dda0d94a8008f094500aaa6 -Author: snappy.mirrorbot@gmail.com -Date: Tue Apr 26 12:34:55 2011 +0000 - - Fix public issue #30: Stop using gettimeofday() altogether on Win32, - as MSVC doesn't include it. Replace with QueryPerformanceCounter(), - which is monotonic and probably reasonably high-resolution. - (Some machines have traditionally had bugs in QPC, but they should - be relatively rare these days, and there's really no much better - alternative that I know of.) - - R=csilvers - DELTA=74 (55 added, 19 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1556 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@31 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 3d8e71df8d30f980d71d4c784ebfc5ff62d5b0cb -Author: snappy.mirrorbot@gmail.com -Date: Tue Apr 26 12:34:37 2011 +0000 - - Fix public issue #31: Don't reset PATH in autogen.sh; instead, do the trickery - we need for our own build system internally. - - R=csilvers - DELTA=16 (13 added, 1 deleted, 2 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1555 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@30 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 73987351de54c88e2fc3f5dcdeceb47708df3585 -Author: snappy.mirrorbot@gmail.com -Date: Fri Apr 15 22:55:56 2011 +0000 - - When including , define WIN32_LEAN_AND_MEAN first, - so we won't pull in macro definitions of things like min() and max(), - which can conflict with . - - R=csilvers - DELTA=1 (1 added, 0 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1485 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@29 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit fb7e0eade471a20b009720a84fea0af1552791d5 -Author: snappy.mirrorbot@gmail.com -Date: Mon Apr 11 09:07:01 2011 +0000 - - Fix public issue #29: Write CPU timing code for Windows, based on GetProcessTimes() - instead of getursage(). - - I thought I'd already committed this patch, so that the 1.0.1 release already - would have a Windows-compatible snappy_unittest, but I'd seemingly deleted it - instead, so this is a reconstruction. - - R=csilvers - DELTA=43 (39 added, 3 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1295 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@28 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit c67fa0c755a329000da5546fff79089d62ac2f82 -Author: snappy.mirrorbot@gmail.com -Date: Fri Apr 8 09:51:53 2011 +0000 - - Include C bindings of Snappy, contributed by Martin Gieseking. - - I've made a few changes since Martin's version; mostly style nits, but also - a semantic change -- most functions that return bool in the C++ version now - return an enum, to better match typical C (and zlib) semantics. - - I've kept the copyright notice, since Martin is obviously the author here; - he has signed the contributor license agreement, though, so this should not - hinder Google's use in the future. - - We'll need to update the libtool version number to match the added interface, - but as of http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html - I'm going to wait until public release. - - R=csilvers - DELTA=238 (233 added, 0 deleted, 5 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1294 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@27 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 56be85cb9ae06f2e92180ae2575bdd10c012ab73 -Author: snappy.mirrorbot@gmail.com -Date: Thu Apr 7 16:36:43 2011 +0000 - - Replace geo.protodata with a newer version. - - The data compresses/decompresses slightly faster than the old data, and has - similar density. - - R=lookingbill - DELTA=1 (0 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1288 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@26 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 3dd93f3ec74df54a37f68bffabb058ac757bbe72 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 30 20:27:53 2011 +0000 - - Fix public issue #27: Add HAVE_CONFIG_H tests around the config.h - inclusion in snappy-stubs-internal.h, which eases compiling outside the - automake/autoconf framework. - - R=csilvers - DELTA=5 (4 added, 1 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1152 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@25 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f67bcaa61006da8b325a7ed9909a782590971815 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 30 20:27:39 2011 +0000 - - Fix public issue #26: Take memory allocation and reallocation entirely out of the - Measure() loop. This gives all algorithms a small speed boost, except Snappy which - already didn't do reallocation (so the measurements were slightly biased in its - favor). - - R=csilvers - DELTA=92 (69 added, 9 deleted, 14 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1151 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@24 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit cc333c1c5cc4eabceceb9848ff3cac6c604ecbc6 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 30 20:25:09 2011 +0000 - - Renamed "namespace zippy" to "namespace snappy" to reduce - the differences from the opensource code. Will make it easier - in the future to mix-and-match third-party code that uses - snappy with google code. - - Currently, csearch shows that the only external user of - "namespace zippy" is some bigtable code that accesses - a TEST variable, which is temporarily kept in the zippy - namespace. - - R=sesse - DELTA=123 (18 added, 3 deleted, 102 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1150 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@23 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit f19fb07e6dc79d6857e37df572dba25ff30fc8f3 -Author: snappy.mirrorbot@gmail.com -Date: Mon Mar 28 22:17:04 2011 +0000 - - Put back the final few lines of what was truncated during the - license header change. - - R=csilvers - DELTA=5 (4 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1094 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@22 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 7e8ca8f8315fc2ecb4eea19db695039ab2ca43a0 -Author: snappy.mirrorbot@gmail.com -Date: Sat Mar 26 02:34:34 2011 +0000 - - Change on 2011-03-25 19:18:00-07:00 by sesse - - Replace the Apache 2.0 license header by the BSD-type license header; - somehow a lot of the files were missed in the last round. - - R=dannyb,csilvers - DELTA=147 (74 added, 2 deleted, 71 changed) - - Change on 2011-03-25 19:25:07-07:00 by sesse - - Unbreak the build; the relicensing removed a bit too much (only comments - were intended, but I also accidentially removed some of the top lines of - the actual source). - - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1072 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@21 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit b4bbc1041b35d844ec26fbae25f2864995361fd8 -Author: snappy.mirrorbot@gmail.com -Date: Fri Mar 25 16:14:41 2011 +0000 - - Change Snappy from the Apache 2.0 to a BSD-type license. - - R=dannyb - DELTA=328 (80 added, 184 deleted, 64 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1061 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@20 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit c47640c510eb11cf8913edfa34f667bceb3a4401 -Author: snappy.mirrorbot@gmail.com -Date: Fri Mar 25 00:39:01 2011 +0000 - - Release Snappy 1.0.1, to soup up all the various small changes - that have been made since release. - - R=csilvers - DELTA=266 (260 added, 0 deleted, 6 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1057 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@19 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit b1dc1f643eaff897a5ce135f525799b99687b118 -Author: snappy.mirrorbot@gmail.com -Date: Thu Mar 24 19:15:54 2011 +0000 - - Fix a microbenchmark crash on mingw32; seemingly %lld is not universally - supported on Windows, and %I64d is recommended instead. - - R=csilvers - DELTA=6 (5 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1034 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@18 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 98004ca9afc62a3279dfe9d9a359083f61db437f -Author: snappy.mirrorbot@gmail.com -Date: Thu Mar 24 19:15:27 2011 +0000 - - Fix public issue #19: Fix unit test when Google Test is installed but the - gflags package isn't (Google Test is not properly initialized). - - Patch by Martin Gieseking. - - R=csilvers - DELTA=2 (1 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1033 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@17 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 444a6c5f72d6f8d8f7213a5bcc08b26606eb9934 -Author: snappy.mirrorbot@gmail.com -Date: Thu Mar 24 19:13:57 2011 +0000 - - Make the unit test work on systems without mmap(). This is required for, - among others, Windows support. For Windows in specific, we could have used - CreateFileMapping/MapViewOfFile, but this should at least get us a bit closer - to compiling, and is of course also relevant for embedded systems with no MMU. - - (Part 2/2) - - R=csilvers - DELTA=15 (12 added, 3 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1032 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@16 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 2e182e9bb840737f9cd8817e859dc17a82f2c16b -Author: snappy.mirrorbot@gmail.com -Date: Thu Mar 24 19:12:27 2011 +0000 - - Make the unit test work on systems without mmap(). This is required for, - among others, Windows support. For Windows in specific, we could have used - CreateFileMapping/MapViewOfFile, but this should at least get us a bit closer - to compiling, and is of course also relevant for embedded systems with no MMU. - - (Part 1/2) - - R=csilvers - DELTA=9 (8 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1031 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@15 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 48662cbb7f81533977334629790d346220084527 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 23:17:36 2011 +0000 - - Fix public issue #12: Don't keep autogenerated auto* files in Subversion; - it causes problems with others sending patches etc.. - - We can't get this 100% hermetic anyhow, due to files like lt~obsolete.m4, - so we can just as well go cleanly in the other direction. - - R=csilvers - DELTA=21038 (0 added, 21036 deleted, 2 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=1012 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@14 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 9e4717a586149c9538b353400312bab5ab5458c4 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 17:50:49 2011 +0000 - - Fix public issue tracker bug #3: Call AC_SUBST([LIBTOOL_DEPS]), or the rule - to rebuild libtool in Makefile.am won't work. - - R=csilvers - DELTA=1 (1 added, 0 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=997 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@13 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 519c822a34a91a0c0eb32d98e9686ee7d9cd6651 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:16:39 2011 +0000 - - Fix public issue #10: Don't add GTEST_CPPFLAGS to snappy_unittest_CXXFLAGS; - it's not needed (CPPFLAGS are always included when compiling). - - R=csilvers - DELTA=1 (0 added, 1 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=994 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@12 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit ea6b936378583cba730c33c8a53776edc1782208 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:16:18 2011 +0000 - - Fix public issue #9: Add -Wall -Werror to automake flags. - (This concerns automake itself, not the C++ compiler.) - - R=csilvers - DELTA=4 (3 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=993 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@11 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit e3ca06af253094b1c3a8eae508cd97accf077535 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:13:37 2011 +0000 - - Fix a typo in the Snappy README file. - - R=csilvers - DELTA=1 (0 added, 0 deleted, 1 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=992 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@10 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 39d27bea23873abaa663e884261386b17b058f20 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:13:13 2011 +0000 - - Fix public issue #6: Add a --with-gflags for disabling gflags autodetection - and using a manually given setting (use/don't use) instead. - - R=csilvers - DELTA=16 (13 added, 0 deleted, 3 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=991 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@9 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 60add43d99c1c31aeecd895cb555ad6f6520608e -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:12:44 2011 +0000 - - Fix public issue #5: Replace the EXTRA_LIBSNAPPY_LDFLAGS setup with something - slightly more standard, that also doesn't leak libtool command-line into - configure.ac. - - R=csilvers - DELTA=7 (0 added, 4 deleted, 3 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=990 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@8 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit a8dd1700879ad646106742aa0e9c3a48dc07b01d -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:12:22 2011 +0000 - - Fix public issue #4: Properly quote all macro arguments in configure.ac. - - R=csilvers - DELTA=16 (0 added, 0 deleted, 16 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=989 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@7 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 79752dd7033658e28dc894de55012bdf2c9afca3 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:11:54 2011 +0000 - - Fix public issue #7: Don't use internal variables named ac_*, as those belong - to autoconf's namespace. - - R=csilvers - DELTA=6 (0 added, 0 deleted, 6 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=988 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@6 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 46e39fb20c297129494b969ac4ea64fcd04b4fa0 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:11:09 2011 +0000 - - Add missing licensing headers to a few files. (Part 2/2.) - - R=csilvers - DELTA=12 (12 added, 0 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=987 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@5 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 3e764216fc8edaafca480443b90e55c14eaae2c2 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:10:39 2011 +0000 - - Add mising licensing headers to a few files. (Part 1/2.) - - R=csilvers - DELTA=24 (24 added, 0 deleted, 0 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=986 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@4 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 9a59f183c8ffec62dcdabd3499d0d515e44e4ef0 -Author: snappy.mirrorbot@gmail.com -Date: Wed Mar 23 11:10:04 2011 +0000 - - Use the correct license file for the Apache 2.0 license; - spotted by Florian Weimer. - - R=csilvers - DELTA=202 (174 added, 0 deleted, 28 changed) - - - Revision created by MOE tool push_codebase. - MOE_MIGRATION=985 - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@3 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 28a64402392c791905d6e1384ea1b48a5cb0b281 -Author: snappy.mirrorbot@gmail.com -Date: Fri Mar 18 17:14:15 2011 +0000 - - Revision created by MOE tool push_codebase. - MOE_MIGRATION= - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@2 03e5f5b5-db94-4691-08a0-1a8bf15f6143 - -commit 7c3c6077b72b4ae2237267a20f640b55e9a90569 -Author: sesse@google.com -Date: Fri Mar 18 17:13:52 2011 +0000 - - Create trunk directory. - - - git-svn-id: https://snappy.googlecode.com/svn/trunk@1 03e5f5b5-db94-4691-08a0-1a8bf15f6143 diff --git a/src/butil/third_party/snappy/NEWS b/src/butil/third_party/snappy/NEWS deleted file mode 100644 index 4eb7a1d1a9..0000000000 --- a/src/butil/third_party/snappy/NEWS +++ /dev/null @@ -1,140 +0,0 @@ -Snappy v1.1.3, July 6th 2015: - -This is the first release to be done from GitHub, which means that -some minor things like the ChangeLog format has changed (git log -format instead of svn log). - - * Add support for Uncompress() from a Source to a Sink. - - * Various minor changes to improve MSVC support; in particular, - the unit tests now compile and run under MSVC. - - -Snappy v1.1.2, February 28th 2014: - -This is a maintenance release with no changes to the actual library -source code. - - * Stop distributing benchmark data files that have unclear - or unsuitable licensing. - - * Add support for padding chunks in the framing format. - - -Snappy v1.1.1, October 15th 2013: - - * Add support for uncompressing to iovecs (scatter I/O). - The bulk of this patch was contributed by Mohit Aron. - - * Speed up decompression by ~2%; much more so (~13-20%) on - a few benchmarks on given compilers and CPUs. - - * Fix a few issues with MSVC compilation. - - * Support truncated test data in the benchmark. - - -Snappy v1.1.0, January 18th 2013: - - * Snappy now uses 64 kB block size instead of 32 kB. On average, - this means it compresses about 3% denser (more so for some - inputs), at the same or better speeds. - - * libsnappy no longer depends on iostream. - - * Some small performance improvements in compression on x86 - (0.5–1%). - - * Various portability fixes for ARM-based platforms, for MSVC, - and for GNU/Hurd. - - -Snappy v1.0.5, February 24th 2012: - - * More speed improvements. Exactly how big will depend on - the architecture: - - - 3–10% faster decompression for the base case (x86-64). - - - ARMv7 and higher can now use unaligned accesses, - and will see about 30% faster decompression and - 20–40% faster compression. - - - 32-bit platforms (ARM and 32-bit x86) will see 2–5% - faster compression. - - These are all cumulative (e.g., ARM gets all three speedups). - - * Fixed an issue where the unit test would crash on system - with less than 256 MB address space available, - e.g. some embedded platforms. - - * Added a framing format description, for use over e.g. HTTP, - or for a command-line compressor. We do not have any - implementations of this at the current point, but there seems - to be enough of a general interest in the topic. - Also make the format description slightly clearer. - - * Remove some compile-time warnings in -Wall - (mostly signed/unsigned comparisons), for easier embedding - into projects that use -Wall -Werror. - - -Snappy v1.0.4, September 15th 2011: - - * Speeded up the decompressor somewhat; typically about 2–8% - for Core i7, in 64-bit mode (comparable for Opteron). - Somewhat more for some tests, almost no gain for others. - - * Make Snappy compile on certain platforms it didn't before - (Solaris with SunPro C++, HP-UX, AIX). - - * Correct some minor errors in the format description. - - -Snappy v1.0.3, June 2nd 2011: - - * Speeded up the decompressor somewhat; about 3-6% for Core 2, - 6-13% for Core i7, and 5-12% for Opteron (all in 64-bit mode). - - * Added compressed format documentation. This text is new, - but an earlier version from Zeev Tarantov was used as reference. - - * Only link snappy_unittest against -lz and other autodetected - libraries, not libsnappy.so (which doesn't need any such dependency). - - * Fixed some display issues in the microbenchmarks, one of which would - frequently make the test crash on GNU/Hurd. - - -Snappy v1.0.2, April 29th 2011: - - * Relicense to a BSD-type license. - - * Added C bindings, contributed by Martin Gieseking. - - * More Win32 fixes, in particular for MSVC. - - * Replace geo.protodata with a newer version. - - * Fix timing inaccuracies in the unit test when comparing Snappy - to other algorithms. - - -Snappy v1.0.1, March 25th 2011: - -This is a maintenance release, mostly containing minor fixes. -There is no new functionality. The most important fixes include: - - * The COPYING file and all licensing headers now correctly state that - Snappy is licensed under the Apache 2.0 license. - - * snappy_unittest should now compile natively under Windows, - as well as on embedded systems with no mmap(). - - * Various autotools nits have been fixed. - - -Snappy v1.0, March 17th 2011: - - * Initial version. diff --git a/src/butil/third_party/snappy/README b/src/butil/third_party/snappy/README deleted file mode 100644 index 3bc8888f99..0000000000 --- a/src/butil/third_party/snappy/README +++ /dev/null @@ -1,135 +0,0 @@ -Snappy, a fast compressor/decompressor. - - -Introduction -============ - -Snappy is a compression/decompression library. It does not aim for maximum -compression, or compatibility with any other compression library; instead, -it aims for very high speeds and reasonable compression. For instance, -compared to the fastest mode of zlib, Snappy is an order of magnitude faster -for most inputs, but the resulting compressed files are anywhere from 20% to -100% bigger. (For more information, see "Performance", below.) - -Snappy has the following properties: - - * Fast: Compression speeds at 250 MB/sec and beyond, with no assembler code. - See "Performance" below. - * Stable: Over the last few years, Snappy has compressed and decompressed - petabytes of data in Google's production environment. The Snappy bitstream - format is stable and will not change between versions. - * Robust: The Snappy decompressor is designed not to crash in the face of - corrupted or malicious input. - * Free and open source software: Snappy is licensed under a BSD-type license. - For more information, see the included COPYING file. - -Snappy has previously been called "Zippy" in some Google presentations -and the like. - - -Performance -=========== - -Snappy is intended to be fast. On a single core of a Core i7 processor -in 64-bit mode, it compresses at about 250 MB/sec or more and decompresses at -about 500 MB/sec or more. (These numbers are for the slowest inputs in our -benchmark suite; others are much faster.) In our tests, Snappy usually -is faster than algorithms in the same class (e.g. LZO, LZF, FastLZ, QuickLZ, -etc.) while achieving comparable compression ratios. - -Typical compression ratios (based on the benchmark suite) are about 1.5-1.7x -for plain text, about 2-4x for HTML, and of course 1.0x for JPEGs, PNGs and -other already-compressed data. Similar numbers for zlib in its fastest mode -are 2.6-2.8x, 3-7x and 1.0x, respectively. More sophisticated algorithms are -capable of achieving yet higher compression rates, although usually at the -expense of speed. Of course, compression ratio will vary significantly with -the input. - -Although Snappy should be fairly portable, it is primarily optimized -for 64-bit x86-compatible processors, and may run slower in other environments. -In particular: - - - Snappy uses 64-bit operations in several places to process more data at - once than would otherwise be possible. - - Snappy assumes unaligned 32- and 64-bit loads and stores are cheap. - On some platforms, these must be emulated with single-byte loads - and stores, which is much slower. - - Snappy assumes little-endian throughout, and needs to byte-swap data in - several places if running on a big-endian platform. - -Experience has shown that even heavily tuned code can be improved. -Performance optimizations, whether for 64-bit x86 or other platforms, -are of course most welcome; see "Contact", below. - - -Usage -===== - -Note that Snappy, both the implementation and the main interface, -is written in C++. However, several third-party bindings to other languages -are available; see the Google Code page at http://code.google.com/p/snappy/ -for more information. Also, if you want to use Snappy from C code, you can -use the included C bindings in snappy-c.h. - -To use Snappy from your own C++ program, include the file "snappy.h" from -your calling file, and link against the compiled library. - -There are many ways to call Snappy, but the simplest possible is - - snappy::Compress(input.data(), input.size(), &output); - -and similarly - - snappy::Uncompress(input.data(), input.size(), &output); - -where "input" and "output" are both instances of std::string. - -There are other interfaces that are more flexible in various ways, including -support for custom (non-array) input sources. See the header file for more -information. - - -Tests and benchmarks -==================== - -When you compile Snappy, snappy_unittest is compiled in addition to the -library itself. You do not need it to use the compressor from your own library, -but it contains several useful components for Snappy development. - -First of all, it contains unit tests, verifying correctness on your machine in -various scenarios. If you want to change or optimize Snappy, please run the -tests to verify you have not broken anything. Note that if you have the -Google Test library installed, unit test behavior (especially failures) will be -significantly more user-friendly. You can find Google Test at - - http://code.google.com/p/googletest/ - -You probably also want the gflags library for handling of command-line flags; -you can find it at - - http://code.google.com/p/google-gflags/ - -In addition to the unit tests, snappy contains microbenchmarks used to -tune compression and decompression performance. These are automatically run -before the unit tests, but you can disable them using the flag ---run_microbenchmarks=false if you have gflags installed (otherwise you will -need to edit the source). - -Finally, snappy can benchmark Snappy against a few other compression libraries -(zlib, LZO, LZF, FastLZ and QuickLZ), if they were detected at configure time. -To benchmark using a given file, give the compression algorithm you want to test -Snappy against (e.g. --zlib) and then a list of one or more file names on the -command line. The testdata/ directory contains the files used by the -microbenchmark, which should provide a reasonably balanced starting point for -benchmarking. (Note that baddata[1-3].snappy are not intended as benchmarks; they -are used to verify correctness in the presence of corrupted data in the unit -test.) - - -Contact -======= - -Snappy is distributed through Google Code. For the latest version, a bug tracker, -and other information, see - - http://code.google.com/p/snappy/ diff --git a/src/butil/third_party/snappy/format_description.txt b/src/butil/third_party/snappy/format_description.txt deleted file mode 100644 index 20db66c1f2..0000000000 --- a/src/butil/third_party/snappy/format_description.txt +++ /dev/null @@ -1,110 +0,0 @@ -Snappy compressed format description -Last revised: 2011-10-05 - - -This is not a formal specification, but should suffice to explain most -relevant parts of how the Snappy format works. It is originally based on -text by Zeev Tarantov. - -Snappy is a LZ77-type compressor with a fixed, byte-oriented encoding. -There is no entropy encoder backend nor framing layer -- the latter is -assumed to be handled by other parts of the system. - -This document only describes the format, not how the Snappy compressor nor -decompressor actually works. The correctness of the decompressor should not -depend on implementation details of the compressor, and vice versa. - - -1. Preamble - -The stream starts with the uncompressed length (up to a maximum of 2^32 - 1), -stored as a little-endian varint. Varints consist of a series of bytes, -where the lower 7 bits are data and the upper bit is set iff there are -more bytes to be read. In other words, an uncompressed length of 64 would -be stored as 0x40, and an uncompressed length of 2097150 (0x1FFFFE) -would be stored as 0xFE 0xFF 0x7F. - - -2. The compressed stream itself - -There are two types of elements in a Snappy stream: Literals and -copies (backreferences). There is no restriction on the order of elements, -except that the stream naturally cannot start with a copy. (Having -two literals in a row is never optimal from a compression point of -view, but nevertheless fully permitted.) Each element starts with a tag byte, -and the lower two bits of this tag byte signal what type of element will -follow: - - 00: Literal - 01: Copy with 1-byte offset - 10: Copy with 2-byte offset - 11: Copy with 4-byte offset - -The interpretation of the upper six bits are element-dependent. - - -2.1. Literals (00) - -Literals are uncompressed data stored directly in the byte stream. -The literal length is stored differently depending on the length -of the literal: - - - For literals up to and including 60 bytes in length, the upper - six bits of the tag byte contain (len-1). The literal follows - immediately thereafter in the bytestream. - - For longer literals, the (len-1) value is stored after the tag byte, - little-endian. The upper six bits of the tag byte describe how - many bytes are used for the length; 60, 61, 62 or 63 for - 1-4 bytes, respectively. The literal itself follows after the - length. - - -2.2. Copies - -Copies are references back into previous decompressed data, telling -the decompressor to reuse data it has previously decoded. -They encode two values: The _offset_, saying how many bytes back -from the current position to read, and the _length_, how many bytes -to copy. Offsets of zero can be encoded, but are not legal; -similarly, it is possible to encode backreferences that would -go past the end of the block (offset > current decompressed position), -which is also nonsensical and thus not allowed. - -As in most LZ77-based compressors, the length can be larger than the offset, -yielding a form of run-length encoding (RLE). For instance, -"xababab" could be encoded as - - - -Note that since the current Snappy compressor works in 32 kB -blocks and does not do matching across blocks, it will never produce -a bitstream with offsets larger than about 32768. However, the -decompressor should not rely on this, as it may change in the future. - -There are several different kinds of copy elements, depending on -the amount of bytes to be copied (length), and how far back the -data to be copied is (offset). - - -2.2.1. Copy with 1-byte offset (01) - -These elements can encode lengths between [4..11] bytes and offsets -between [0..2047] bytes. (len-4) occupies three bits and is stored -in bits [2..4] of the tag byte. The offset occupies 11 bits, of which the -upper three are stored in the upper three bits ([5..7]) of the tag byte, -and the lower eight are stored in a byte following the tag byte. - - -2.2.2. Copy with 2-byte offset (10) - -These elements can encode lengths between [1..64] and offsets from -[0..65535]. (len-1) occupies six bits and is stored in the upper -six bits ([2..7]) of the tag byte. The offset is stored as a -little-endian 16-bit integer in the two bytes following the tag byte. - - -2.2.3. Copy with 4-byte offset (11) - -These are like the copies with 2-byte offsets (see previous subsection), -except that the offset is stored as a 32-bit integer instead of a -16-bit integer (and thus will occupy four bytes). diff --git a/src/butil/third_party/snappy/framing_format.txt b/src/butil/third_party/snappy/framing_format.txt deleted file mode 100644 index 9764e83de6..0000000000 --- a/src/butil/third_party/snappy/framing_format.txt +++ /dev/null @@ -1,135 +0,0 @@ -Snappy framing format description -Last revised: 2013-10-25 - -This format decribes a framing format for Snappy, allowing compressing to -files or streams that can then more easily be decompressed without having -to hold the entire stream in memory. It also provides data checksums to -help verify integrity. It does not provide metadata checksums, so it does -not protect against e.g. all forms of truncations. - -Implementation of the framing format is optional for Snappy compressors and -decompressor; it is not part of the Snappy core specification. - - -1. General structure - -The file consists solely of chunks, lying back-to-back with no padding -in between. Each chunk consists first a single byte of chunk identifier, -then a three-byte little-endian length of the chunk in bytes (from 0 to -16777215, inclusive), and then the data if any. The four bytes of chunk -header is not counted in the data length. - -The different chunk types are listed below. The first chunk must always -be the stream identifier chunk (see section 4.1, below). The stream -ends when the file ends -- there is no explicit end-of-file marker. - - -2. File type identification - -The following identifiers for this format are recommended where appropriate. -However, note that none have been registered officially, so this is only to -be taken as a guideline. We use "Snappy framed" to distinguish between this -format and raw Snappy data. - - File extension: .sz - MIME type: application/x-snappy-framed - HTTP Content-Encoding: x-snappy-framed - - -3. Checksum format - -Some chunks have data protected by a checksum (the ones that do will say so -explicitly). The checksums are always masked CRC-32Cs. - -A description of CRC-32C can be found in RFC 3720, section 12.1, with -examples in section B.4. - -Checksums are not stored directly, but masked, as checksumming data and -then its own checksum can be problematic. The masking is the same as used -in Apache Hadoop: Rotate the checksum by 15 bits, then add the constant -0xa282ead8 (using wraparound as normal for unsigned integers). This is -equivalent to the following C code: - - uint32_t mask_checksum(uint32_t x) { - return ((x >> 15) | (x << 17)) + 0xa282ead8; - } - -Note that the masking is reversible. - -The checksum is always stored as a four bytes long integer, in little-endian. - - -4. Chunk types - -The currently supported chunk types are described below. The list may -be extended in the future. - - -4.1. Stream identifier (chunk type 0xff) - -The stream identifier is always the first element in the stream. -It is exactly six bytes long and contains "sNaPpY" in ASCII. This means that -a valid Snappy framed stream always starts with the bytes - - 0xff 0x06 0x00 0x00 0x73 0x4e 0x61 0x50 0x70 0x59 - -The stream identifier chunk can come multiple times in the stream besides -the first; if such a chunk shows up, it should simply be ignored, assuming -it has the right length and contents. This allows for easy concatenation of -compressed files without the need for re-framing. - - -4.2. Compressed data (chunk type 0x00) - -Compressed data chunks contain a normal Snappy compressed bitstream; -see the compressed format specification. The compressed data is preceded by -the CRC-32C (see section 3) of the _uncompressed_ data. - -Note that the data portion of the chunk, i.e., the compressed contents, -can be at most 16777211 bytes (2^24 - 1, minus the checksum). -However, we place an additional restriction that the uncompressed data -in a chunk must be no longer than 65536 bytes. This allows consumers to -easily use small fixed-size buffers. - - -4.3. Uncompressed data (chunk type 0x01) - -Uncompressed data chunks allow a compressor to send uncompressed, -raw data; this is useful if, for instance, uncompressible or -near-incompressible data is detected, and faster decompression is desired. - -As in the compressed chunks, the data is preceded by its own masked -CRC-32C (see section 3). - -An uncompressed data chunk, like compressed data chunks, should contain -no more than 65536 data bytes, so the maximum legal chunk length with the -checksum is 65540. - - -4.4. Padding (chunk type 0xfe) - -Padding chunks allow a compressor to increase the size of the data stream -so that it complies with external demands, e.g. that the total number of -bytes is a multiple of some value. - -All bytes of the padding chunk, except the chunk byte itself and the length, -should be zero, but decompressors must not try to interpret or verify the -padding data in any way. - - -4.5. Reserved unskippable chunks (chunk types 0x02-0x7f) - -These are reserved for future expansion. A decoder that sees such a chunk -should immediately return an error, as it must assume it cannot decode the -stream correctly. - -Future versions of this specification may define meanings for these chunks. - - -4.6. Reserved skippable chunks (chunk types 0x80-0xfd) - -These are also reserved for future expansion, but unlike the chunks -described in 4.5, a decoder seeing these must skip them and continue -decoding. - -Future versions of this specification may define meanings for these chunks. diff --git a/src/butil/third_party/snappy/snappy-internal.h b/src/butil/third_party/snappy/snappy-internal.h deleted file mode 100644 index 3822a99b71..0000000000 --- a/src/butil/third_party/snappy/snappy-internal.h +++ /dev/null @@ -1,152 +0,0 @@ -// Copyright 2008 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Internals shared between the Snappy implementation and its unittest. - -#ifndef BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_ -#define BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_ - -#include "snappy-stubs-internal.h" - -namespace butil { -namespace snappy { -namespace internal { - -class WorkingMemory { -public: - WorkingMemory() : large_table_(NULL) { } - ~WorkingMemory() { delete[] large_table_; } - - // Allocates and clears a hash table using memory in "*this", - // stores the number of buckets in "*table_size" and returns a pointer to - // the base of the hash table. - uint16_t* GetHashTable(size_t input_size, int* table_size); - -private: - uint16_t small_table_[1<<10]; // 2KB - uint16_t* large_table_; // Allocated only when needed - - DISALLOW_COPY_AND_ASSIGN(WorkingMemory); -}; - -// Flat array compression that does not emit the "uncompressed length" -// prefix. Compresses "input" string to the "*op" buffer. -// -// REQUIRES: "input_length <= kBlockSize" -// REQUIRES: "op" points to an array of memory that is at least -// "MaxCompressedLength(input_length)" in size. -// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero. -// REQUIRES: "table_size" is a power of two -// -// Returns an "end" pointer into "op" buffer. -// "end - op" is the compressed size of "input". -char* CompressFragment(const char* input, - size_t input_length, - char* op, - uint16_t* table, - const int table_size); - -// Return the largest n such that -// -// s1[0,n-1] == s2[0,n-1] -// and n <= (s2_limit - s2). -// -// Does not read *s2_limit or beyond. -// Does not read *(s1 + (s2_limit - s2)) or beyond. -// Requires that s2_limit >= s2. -// -// Separate implementation for x86_64, for speed. Uses the fact that -// x86_64 is little endian. -#if defined(ARCH_K8) -static inline int FindMatchLength(const char* s1, - const char* s2, - const char* s2_limit) { - assert(s2_limit >= s2); - int matched = 0; - - // Find out how long the match is. We loop over the data 64 bits at a - // time until we find a 64-bit block that doesn't match; then we find - // the first non-matching bit and use that to calculate the total - // length of the match. - while (BAIDU_LIKELY(s2 <= s2_limit - 8)) { - if (UNALIGNED_LOAD64(s2) == UNALIGNED_LOAD64(s1 + matched)) { - s2 += 8; - matched += 8; - } else { - // On current (mid-2008) Opteron models there is a 3% more - // efficient code sequence to find the first non-matching byte. - // However, what follows is ~10% better on Intel Core 2 and newer, - // and we expect AMD's bsf instruction to improve. - uint64_t x = UNALIGNED_LOAD64(s2) ^ UNALIGNED_LOAD64(s1 + matched); - int matching_bits = Bits::FindLSBSetNonZero64(x); - matched += matching_bits >> 3; - return matched; - } - } - while (BAIDU_LIKELY(s2 < s2_limit)) { - if (s1[matched] == *s2) { - ++s2; - ++matched; - } else { - return matched; - } - } - return matched; -} -#else -static inline int FindMatchLength(const char* s1, - const char* s2, - const char* s2_limit) { - // Implementation based on the x86-64 version, above. - assert(s2_limit >= s2); - int matched = 0; - - while (s2 <= s2_limit - 4 && - UNALIGNED_LOAD32(s2) == UNALIGNED_LOAD32(s1 + matched)) { - s2 += 4; - matched += 4; - } - if (LittleEndian::IsLittleEndian() && s2 <= s2_limit - 4) { - uint32_t x = UNALIGNED_LOAD32(s2) ^ UNALIGNED_LOAD32(s1 + matched); - int matching_bits = Bits::FindLSBSetNonZero(x); - matched += matching_bits >> 3; - } else { - while ((s2 < s2_limit) && (s1[matched] == *s2)) { - ++s2; - ++matched; - } - } - return matched; -} -#endif - -} // end namespace internal -} // end namespace snappy -} // end namespace butil - -#endif // BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_INTERNAL_H_ diff --git a/src/butil/third_party/snappy/snappy-sinksource.cc b/src/butil/third_party/snappy/snappy-sinksource.cc deleted file mode 100644 index 58136b4837..0000000000 --- a/src/butil/third_party/snappy/snappy-sinksource.cc +++ /dev/null @@ -1,106 +0,0 @@ -// Copyright 2011 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include - -#include "butil/third_party/snappy/snappy-sinksource.h" - -namespace butil { -namespace snappy { - -Source::~Source() { } - -Sink::~Sink() { } - -char* Sink::GetAppendBuffer(size_t length, char* scratch) { - return scratch; -} - -char* Sink::GetAppendBufferVariable( - size_t min_size, size_t desired_size_hint, char* scratch, - size_t scratch_size, size_t* allocated_size) { - *allocated_size = scratch_size; - return scratch; -} - -void Sink::AppendAndTakeOwnership( - char* bytes, size_t n, - void (*deleter)(void*, const char*, size_t), - void *deleter_arg) { - Append(bytes, n); - (*deleter)(deleter_arg, bytes, n); -} - -ByteArraySource::~ByteArraySource() { } - -size_t ByteArraySource::Available() const { return left_; } - -const char* ByteArraySource::Peek(size_t* len) { - *len = left_; - return ptr_; -} - -void ByteArraySource::Skip(size_t n) { - left_ -= n; - ptr_ += n; -} - -UncheckedByteArraySink::~UncheckedByteArraySink() { } - -void UncheckedByteArraySink::Append(const char* data, size_t n) { - // Do no copying if the caller filled in the result of GetAppendBuffer() - if (data != dest_) { - memcpy(dest_, data, n); - } - dest_ += n; -} - -char* UncheckedByteArraySink::GetAppendBuffer(size_t len, char* scratch) { - return dest_; -} - -void UncheckedByteArraySink::AppendAndTakeOwnership( - char* data, size_t n, - void (*deleter)(void*, const char*, size_t), - void *deleter_arg) { - if (data != dest_) { - memcpy(dest_, data, n); - (*deleter)(deleter_arg, data, n); - } - dest_ += n; -} - -char* UncheckedByteArraySink::GetAppendBufferVariable( - size_t min_size, size_t desired_size_hint, char* scratch, - size_t scratch_size, size_t* allocated_size) { - *allocated_size = desired_size_hint; - return dest_; -} - -} // namespace snappy -} // namespace butil diff --git a/src/butil/third_party/snappy/snappy-sinksource.h b/src/butil/third_party/snappy/snappy-sinksource.h deleted file mode 100644 index b34fb4cdf5..0000000000 --- a/src/butil/third_party/snappy/snappy-sinksource.h +++ /dev/null @@ -1,184 +0,0 @@ -// Copyright 2011 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#ifndef BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_ -#define BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_ - -#include - -namespace butil { -namespace snappy { - -// A Sink is an interface that consumes a sequence of bytes. -class Sink { - public: - Sink() { } - virtual ~Sink(); - - // Append "bytes[0,n-1]" to this. - virtual void Append(const char* bytes, size_t n) = 0; - - // Returns a writable buffer of the specified length for appending. - // May return a pointer to the caller-owned scratch buffer which - // must have at least the indicated length. The returned buffer is - // only valid until the next operation on this Sink. - // - // After writing at most "length" bytes, call Append() with the - // pointer returned from this function and the number of bytes - // written. Many Append() implementations will avoid copying - // bytes if this function returned an internal buffer. - // - // If a non-scratch buffer is returned, the caller may only pass a - // prefix of it to Append(). That is, it is not correct to pass an - // interior pointer of the returned array to Append(). - // - // The default implementation always returns the scratch buffer. - virtual char* GetAppendBuffer(size_t length, char* scratch); - - // For higher performance, Sink implementations can provide custom - // AppendAndTakeOwnership() and GetAppendBufferVariable() methods. - // These methods can reduce the number of copies done during - // compression/decompression. - - // Append "bytes[0,n-1] to the sink. Takes ownership of "bytes" - // and calls the deleter function as (*deleter)(deleter_arg, bytes, n) - // to free the buffer. deleter function must be non NULL. - // - // The default implementation just calls Append and frees "bytes". - // Other implementations may avoid a copy while appending the buffer. - virtual void AppendAndTakeOwnership( - char* bytes, size_t n, void (*deleter)(void*, const char*, size_t), - void *deleter_arg); - - // Returns a writable buffer for appending and writes the buffer's capacity to - // *allocated_size. Guarantees *allocated_size >= min_size. - // May return a pointer to the caller-owned scratch buffer which must have - // scratch_size >= min_size. - // - // The returned buffer is only valid until the next operation - // on this ByteSink. - // - // After writing at most *allocated_size bytes, call Append() with the - // pointer returned from this function and the number of bytes written. - // Many Append() implementations will avoid copying bytes if this function - // returned an internal buffer. - // - // If the sink implementation allocates or reallocates an internal buffer, - // it should use the desired_size_hint if appropriate. If a caller cannot - // provide a reasonable guess at the desired capacity, it should set - // desired_size_hint = 0. - // - // If a non-scratch buffer is returned, the caller may only pass - // a prefix to it to Append(). That is, it is not correct to pass an - // interior pointer to Append(). - // - // The default implementation always returns the scratch buffer. - virtual char* GetAppendBufferVariable( - size_t min_size, size_t desired_size_hint, char* scratch, - size_t scratch_size, size_t* allocated_size); - - private: - // No copying - Sink(const Sink&); - void operator=(const Sink&); -}; - -// A Source is an interface that yields a sequence of bytes -class Source { - public: - Source() { } - virtual ~Source(); - - // Return the number of bytes left to read from the source - virtual size_t Available() const = 0; - - // Peek at the next flat region of the source. Does not reposition - // the source. The returned region is empty iff Available()==0. - // - // Returns a pointer to the beginning of the region and store its - // length in *len. - // - // The returned region is valid until the next call to Skip() or - // until this object is destroyed, whichever occurs first. - // - // The returned region may be larger than Available() (for example - // if this ByteSource is a view on a substring of a larger source). - // The caller is responsible for ensuring that it only reads the - // Available() bytes. - virtual const char* Peek(size_t* len) = 0; - - // Skip the next n bytes. Invalidates any buffer returned by - // a previous call to Peek(). - // REQUIRES: Available() >= n - virtual void Skip(size_t n) = 0; - - private: - // No copying - Source(const Source&); - void operator=(const Source&); -}; - -// A Source implementation that yields the contents of a flat array -class ByteArraySource : public Source { - public: - ByteArraySource(const char* p, size_t n) : ptr_(p), left_(n) { } - virtual ~ByteArraySource(); - size_t Available() const override; - const char* Peek(size_t* len) override; - void Skip(size_t n) override; - private: - const char* ptr_; - size_t left_; -}; - -// A Sink implementation that writes to a flat array without any bound checks. -class UncheckedByteArraySink : public Sink { - public: - explicit UncheckedByteArraySink(char* dest) : dest_(dest) { } - virtual ~UncheckedByteArraySink(); - void Append(const char* data, size_t n) override; - char* GetAppendBuffer(size_t len, char* scratch) override; - char* GetAppendBufferVariable( - size_t min_size, size_t desired_size_hint, char* scratch, - size_t scratch_size, size_t* allocated_size) override; - void AppendAndTakeOwnership( - char* bytes, size_t n, void (*deleter)(void*, const char*, size_t), - void *deleter_arg) override; - - // Return the current output pointer so that a caller can see how - // many bytes were produced. - // Note: this is not a Sink method. - char* CurrentDestination() const { return dest_; } - private: - char* dest_; -}; - -} // namespace snappy -} // namespace butil - -#endif // BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_SINKSOURCE_H_ diff --git a/src/butil/third_party/snappy/snappy-stubs-internal.cc b/src/butil/third_party/snappy/snappy-stubs-internal.cc deleted file mode 100644 index f3571320a0..0000000000 --- a/src/butil/third_party/snappy/snappy-stubs-internal.cc +++ /dev/null @@ -1,44 +0,0 @@ -// Copyright 2011 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include -#include - -#include "butil/third_party/snappy/snappy-stubs-internal.h" - -namespace butil { -namespace snappy { - -void Varint::Append32(std::string* s, uint32_t value) { - char buf[Varint::kMax32]; - const char* p = Varint::Encode32(buf, value); - s->append(buf, p - buf); -} - -} // namespace snappy -} // namespace butil diff --git a/src/butil/third_party/snappy/snappy-stubs-internal.h b/src/butil/third_party/snappy/snappy-stubs-internal.h deleted file mode 100644 index e94a9c73b6..0000000000 --- a/src/butil/third_party/snappy/snappy-stubs-internal.h +++ /dev/null @@ -1,402 +0,0 @@ -// Copyright 2011 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// Various stubs for the open-source version of Snappy. - -#ifndef BUTIL_THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_ -#define BUTIL_THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_ - -#include -#include -#include -#include -#include "butil/compiler_specific.h" -#include "butil/basictypes.h" -#include "butil/sys_byteorder.h" - -#define SNAPPY_MAJOR 1 -#define SNAPPY_MINOR 1 -#define SNAPPY_PATCHLEVEL 3 -#define SNAPPY_VERSION \ - ((SNAPPY_MAJOR << 16) | (SNAPPY_MINOR << 8) | SNAPPY_PATCHLEVEL) - -#if defined(__x86_64__) - -// Enable 64-bit optimized versions of some routines. -#define ARCH_K8 1 - -#endif - -// Needed by OS X, among others. -#ifndef MAP_ANONYMOUS -#define MAP_ANONYMOUS MAP_ANON -#endif - -// This is only used for recomputing the tag byte table used during -// decompression; for simplicity we just remove it from the open-source -// version (anyone who wants to regenerate it can just do the call -// themselves within main()). -#define DEFINE_bool(flag_name, default_value, description) \ - bool FLAGS_ ## flag_name = default_value -#define DECLARE_bool(flag_name) \ - extern bool FLAGS_ ## flag_name - -namespace butil { -namespace snappy { - -// x86 and PowerPC can simply do these loads and stores native. - -#if defined(__i386__) || defined(__x86_64__) || defined(__powerpc__) - -#define UNALIGNED_LOAD16(_p) (*reinterpret_cast(_p)) -#define UNALIGNED_LOAD32(_p) (*reinterpret_cast(_p)) -#define UNALIGNED_LOAD64(_p) (*reinterpret_cast(_p)) - -#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast(_p) = (_val)) -#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast(_p) = (_val)) -#define UNALIGNED_STORE64(_p, _val) (*reinterpret_cast(_p) = (_val)) - -// ARMv7 and newer support native unaligned accesses, but only of 16-bit -// and 32-bit values (not 64-bit); older versions either raise a fatal signal, -// do an unaligned read and rotate the words around a bit, or do the reads very -// slowly (trip through kernel mode). There's no simple #define that says just -// “ARMv7 or higher”, so we have to filter away all ARMv5 and ARMv6 -// sub-architectures. -// -// This is a mess, but there's not much we can do about it. - -#elif defined(__arm__) && \ - !defined(__ARM_ARCH_4__) && \ - !defined(__ARM_ARCH_4T__) && \ - !defined(__ARM_ARCH_5__) && \ - !defined(__ARM_ARCH_5T__) && \ - !defined(__ARM_ARCH_5TE__) && \ - !defined(__ARM_ARCH_5TEJ__) && \ - !defined(__ARM_ARCH_6__) && \ - !defined(__ARM_ARCH_6J__) && \ - !defined(__ARM_ARCH_6K__) && \ - !defined(__ARM_ARCH_6Z__) && \ - !defined(__ARM_ARCH_6ZK__) && \ - !defined(__ARM_ARCH_6T2__) - -#define UNALIGNED_LOAD16(_p) (*reinterpret_cast(_p)) -#define UNALIGNED_LOAD32(_p) (*reinterpret_cast(_p)) - -#define UNALIGNED_STORE16(_p, _val) (*reinterpret_cast(_p) = (_val)) -#define UNALIGNED_STORE32(_p, _val) (*reinterpret_cast(_p) = (_val)) - -// TODO(user): NEON supports unaligned 64-bit loads and stores. -// See if that would be more efficient on platforms supporting it, -// at least for copies. - -inline uint64_t UNALIGNED_LOAD64(const void *p) { - uint64_t t; - memcpy(&t, p, sizeof t); - return t; -} - -inline void UNALIGNED_STORE64(void *p, uint64_t v) { - memcpy(p, &v, sizeof v); -} - -#else - -// These functions are provided for architectures that don't support -// unaligned loads and stores. - -inline uint16_t UNALIGNED_LOAD16(const void *p) { - uint16_t t; - memcpy(&t, p, sizeof t); - return t; -} - -inline uint32_t UNALIGNED_LOAD32(const void *p) { - uint32_t t; - memcpy(&t, p, sizeof t); - return t; -} - -inline uint64_t UNALIGNED_LOAD64(const void *p) { - uint64_t t; - memcpy(&t, p, sizeof t); - return t; -} - -inline void UNALIGNED_STORE16(void *p, uint16_t v) { - memcpy(p, &v, sizeof v); -} - -inline void UNALIGNED_STORE32(void *p, uint32_t v) { - memcpy(p, &v, sizeof v); -} - -inline void UNALIGNED_STORE64(void *p, uint64_t v) { - memcpy(p, &v, sizeof v); -} - -#endif - -// This can be more efficient than UNALIGNED_LOAD64 + UNALIGNED_STORE64 -// on some platforms, in particular ARM. -inline void UnalignedCopy64(const void *src, void *dst) { - if (sizeof(void *) == 8) { - UNALIGNED_STORE64(dst, UNALIGNED_LOAD64(src)); - } else { - const char *src_char = reinterpret_cast(src); - char *dst_char = reinterpret_cast(dst); - - UNALIGNED_STORE32(dst_char, UNALIGNED_LOAD32(src_char)); - UNALIGNED_STORE32(dst_char + 4, UNALIGNED_LOAD32(src_char + 4)); - } -} - -// Convert to little-endian storage, opposite of network format. -// Convert x from host to little endian: x = LittleEndian.FromHost(x); -// convert x from little endian to host: x = LittleEndian.ToHost(x); -// -// Store values into unaligned memory converting to little endian order: -// LittleEndian.Store16(p, x); -// -// Load unaligned values stored in little endian converting to host order: -// x = LittleEndian.Load16(p); -class LittleEndian { -public: - // Conversion functions. -#if defined(ARCH_CPU_LITTLE_ENDIAN) - static uint16_t FromHost16(uint16_t x) { return x; } - static uint16_t ToHost16(uint16_t x) { return x; } - - static uint32_t FromHost32(uint32_t x) { return x; } - static uint32_t ToHost32(uint32_t x) { return x; } - - static bool IsLittleEndian() { return true; } - -#else // !defined(ARCH_CPU_LITTLE_ENDIAN) - static uint16_t FromHost16(uint16_t x) { return ByteSwap(x); } - static uint16_t ToHost16(uint16_t x) { return ByteSwap(x); } - - static uint32_t FromHost32(uint32_t x) { return ByteSwap(x); } - static uint32_t ToHost32(uint32_t x) { return ByteSwap(x); } - - static bool IsLittleEndian() { return false; } -#endif // !defined(ARCH_CPU_LITTLE_ENDIAN) - - // Functions to do unaligned loads and stores in little-endian order. - static uint16_t Load16(const void *p) { - return ToHost16(UNALIGNED_LOAD16(p)); - } - - static void Store16(void *p, uint16_t v) { - UNALIGNED_STORE16(p, FromHost16(v)); - } - - static uint32_t Load32(const void *p) { - return ToHost32(UNALIGNED_LOAD32(p)); - } - - static void Store32(void *p, uint32_t v) { - UNALIGNED_STORE32(p, FromHost32(v)); - } -}; - -// Some bit-manipulation functions. -class Bits { -public: - // Return floor(log2(n)) for positive integer n. Returns -1 iff n == 0. - static int Log2Floor(uint32_t n); - - // Return the first set least / most significant bit, 0-indexed. Returns an - // undefined value if n == 0. FindLSBSetNonZero() is similar to ffs() except - // that it's 0-indexed. - static int FindLSBSetNonZero(uint32_t n); - static int FindLSBSetNonZero64(uint64_t n); - -private: - DISALLOW_COPY_AND_ASSIGN(Bits); -}; - -#if defined(COMPILER_GCC) - -inline int Bits::Log2Floor(uint32_t n) { - return n == 0 ? -1 : 31 ^ __builtin_clz(n); -} - -inline int Bits::FindLSBSetNonZero(uint32_t n) { - return __builtin_ctz(n); -} - -inline int Bits::FindLSBSetNonZero64(uint64_t n) { - return __builtin_ctzll(n); -} - -#else // Portable versions. - -inline int Bits::Log2Floor(uint32_t n) { - if (n == 0) - return -1; - int log = 0; - uint32_t value = n; - for (int i = 4; i >= 0; --i) { - int shift = (1 << i); - uint32_t x = value >> shift; - if (x != 0) { - value = x; - log += shift; - } - } - assert(value == 1); - return log; -} - -inline int Bits::FindLSBSetNonZero(uint32_t n) { - int rc = 31; - for (int i = 4, shift = 1 << 4; i >= 0; --i) { - const uint32_t x = n << shift; - if (x != 0) { - n = x; - rc -= shift; - } - shift >>= 1; - } - return rc; -} - -// FindLSBSetNonZero64() is defined in terms of FindLSBSetNonZero(). -inline int Bits::FindLSBSetNonZero64(uint64_t n) { - const uint32_t bottombits = static_cast(n); - if (bottombits == 0) { - // Bottom bits are zero, so scan in top bits - return 32 + FindLSBSetNonZero(static_cast(n >> 32)); - } else { - return FindLSBSetNonZero(bottombits); - } -} - -#endif // End portable versions. - -// Variable-length integer encoding. -class Varint { -public: - // Maximum lengths of varint encoding of uint32. - static const int kMax32 = 5; - - // Attempts to parse a varint32 from a prefix of the bytes in [ptr,limit-1]. - // Never reads a character at or beyond limit. If a valid/terminated varint32 - // was found in the range, stores it in *OUTPUT and returns a pointer just - // past the last byte of the varint32. Else returns NULL. On success, - // "result <= limit". - static const char* Parse32WithLimit(const char* ptr, const char* limit, - uint32_t* OUTPUT); - - // REQUIRES "ptr" points to a buffer of length sufficient to hold "v". - // EFFECTS Encodes "v" into "ptr" and returns a pointer to the - // byte just past the last encoded byte. - static char* Encode32(char* ptr, uint32_t v); - - // EFFECTS Appends the varint representation of "value" to "*s". - static void Append32(std::string* s, uint32_t value); -}; - -inline const char* Varint::Parse32WithLimit(const char* p, - const char* l, - uint32_t* OUTPUT) { - const unsigned char* ptr = reinterpret_cast(p); - const unsigned char* limit = reinterpret_cast(l); - uint32_t b, result; - if (ptr >= limit) return NULL; - b = *(ptr++); result = b & 127; if (b < 128) goto done; - if (ptr >= limit) return NULL; - b = *(ptr++); result |= (b & 127) << 7; if (b < 128) goto done; - if (ptr >= limit) return NULL; - b = *(ptr++); result |= (b & 127) << 14; if (b < 128) goto done; - if (ptr >= limit) return NULL; - b = *(ptr++); result |= (b & 127) << 21; if (b < 128) goto done; - if (ptr >= limit) return NULL; - b = *(ptr++); result |= (b & 127) << 28; if (b < 16) goto done; - return NULL; // Value is too long to be a varint32 -done: - *OUTPUT = result; - return reinterpret_cast(ptr); -} - -inline char* Varint::Encode32(char* sptr, uint32_t v) { - // Operate on characters as unsigneds - unsigned char* ptr = reinterpret_cast(sptr); - static const int B = 128; - if (v < (1<<7)) { - *(ptr++) = v; - } else if (v < (1<<14)) { - *(ptr++) = v | B; - *(ptr++) = v>>7; - } else if (v < (1<<21)) { - *(ptr++) = v | B; - *(ptr++) = (v>>7) | B; - *(ptr++) = v>>14; - } else if (v < (1<<28)) { - *(ptr++) = v | B; - *(ptr++) = (v>>7) | B; - *(ptr++) = (v>>14) | B; - *(ptr++) = v>>21; - } else { - *(ptr++) = v | B; - *(ptr++) = (v>>7) | B; - *(ptr++) = (v>>14) | B; - *(ptr++) = (v>>21) | B; - *(ptr++) = v>>28; - } - return reinterpret_cast(ptr); -} - -// If you know the internal layout of the std::string in use, you can -// replace this function with one that resizes the string without -// filling the new space with zeros (if applicable) -- -// it will be non-portable but faster. -inline void STLStringResizeUninitialized(std::string* s, size_t new_size) { - s->resize(new_size); -} - -// Return a mutable char* pointing to a string's internal buffer, -// which may not be null-terminated. Writing through this pointer will -// modify the string. -// -// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the -// next call to a string method that invalidates iterators. -// -// As of 2006-04, there is no standard-blessed way of getting a -// mutable reference to a string's internal buffer. However, issue 530 -// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-defects.html#530) -// proposes this as the method. It will officially be part of the standard -// for C++0x. This should already work on all current implementations. -inline char* string_as_array(std::string* str) { - return str->empty() ? NULL : &*str->begin(); -} - -} // namespace snappy -} // namespace butil - -#endif // BUTIL_THIRD_PARTY_SNAPPY_OPENSOURCE_SNAPPY_STUBS_INTERNAL_H_ diff --git a/src/butil/third_party/snappy/snappy.cc b/src/butil/third_party/snappy/snappy.cc deleted file mode 100644 index c42889f857..0000000000 --- a/src/butil/third_party/snappy/snappy.cc +++ /dev/null @@ -1,1555 +0,0 @@ -// Copyright 2005 Google Inc. All Rights Reserved. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - -#include "butil/third_party/snappy/snappy.h" -#include "butil/third_party/snappy/snappy-internal.h" -#include "butil/third_party/snappy/snappy-sinksource.h" - -#include - -#include -#include -#include - -namespace butil { -namespace snappy { - -// Any hash function will produce a valid compressed bitstream, but a good -// hash function reduces the number of collisions and thus yields better -// compression for compressible input, and more speed for incompressible -// input. Of course, it doesn't hurt if the hash function is reasonably fast -// either, as it gets called a lot. -static inline uint32_t HashBytes(uint32_t bytes, int shift) { - uint32_t kMul = 0x1e35a7bd; - return (bytes * kMul) >> shift; -} -static inline uint32_t Hash(const char* p, int shift) { - return HashBytes(UNALIGNED_LOAD32(p), shift); -} - -size_t MaxCompressedLength(size_t source_len) { - // Compressed data can be defined as: - // compressed := item* literal* - // item := literal* copy - // - // The trailing literal sequence has a space blowup of at most 62/60 - // since a literal of length 60 needs one tag byte + one extra byte - // for length information. - // - // Item blowup is trickier to measure. Suppose the "copy" op copies - // 4 bytes of data. Because of a special check in the encoding code, - // we produce a 4-byte copy only if the offset is < 65536. Therefore - // the copy op takes 3 bytes to encode, and this type of item leads - // to at most the 62/60 blowup for representing literals. - // - // Suppose the "copy" op copies 5 bytes of data. If the offset is big - // enough, it will take 5 bytes to encode the copy op. Therefore the - // worst case here is a one-byte literal followed by a five-byte copy. - // I.e., 6 bytes of input turn into 7 bytes of "compressed" data. - // - // This last factor dominates the blowup, so the final estimate is: - return 32 + source_len + source_len/6; -} - -enum { - LITERAL = 0, - COPY_1_BYTE_OFFSET = 1, // 3 bit length + 3 bits of offset in opcode - COPY_2_BYTE_OFFSET = 2, - COPY_4_BYTE_OFFSET = 3 -}; -static const uint32_t kMaximumTagLength = 5; // COPY_4_BYTE_OFFSET plus the actual offset. - -// Copy "len" bytes from "src" to "op", one byte at a time. Used for -// handling COPY operations where the input and output regions may -// overlap. For example, suppose: -// src == "ab" -// op == src + 2 -// len == 20 -// After IncrementalCopy(src, op, len), the result will have -// eleven copies of "ab" -// ababababababababababab -// Note that this does not match the semantics of either memcpy() -// or memmove(). -static inline void IncrementalCopy(const char* src, char* op, ssize_t len) { - assert(len > 0); - do { - *op++ = *src++; - } while (--len > 0); -} - -// Equivalent to IncrementalCopy except that it can write up to ten extra -// bytes after the end of the copy, and that it is faster. -// -// The main part of this loop is a simple copy of eight bytes at a time until -// we've copied (at least) the requested amount of bytes. However, if op and -// src are less than eight bytes apart (indicating a repeating pattern of -// length < 8), we first need to expand the pattern in order to get the correct -// results. For instance, if the buffer looks like this, with the eight-byte -// and patterns marked as intervals: -// -// abxxxxxxxxxxxx -// [------] src -// [------] op -// -// a single eight-byte copy from to will repeat the pattern once, -// after which we can move two bytes without moving : -// -// ababxxxxxxxxxx -// [------] src -// [------] op -// -// and repeat the exercise until the two no longer overlap. -// -// This allows us to do very well in the special case of one single byte -// repeated many times, without taking a big hit for more general cases. -// -// The worst case of extra writing past the end of the match occurs when -// op - src == 1 and len == 1; the last copy will read from byte positions -// [0..7] and write to [4..11], whereas it was only supposed to write to -// position 1. Thus, ten excess bytes. - -namespace { - -const uint32_t kMaxIncrementCopyOverflow = 10; - -inline void IncrementalCopyFastPath(const char* src, char* op, ssize_t len) { - while (BAIDU_UNLIKELY(op - src < 8)) { - UnalignedCopy64(src, op); - len -= op - src; - op += op - src; - } - while (len > 0) { - UnalignedCopy64(src, op); - src += 8; - op += 8; - len -= 8; - } -} - -} // namespace - -static inline char* EmitLiteral(char* op, - const char* literal, - int len, - bool allow_fast_path) { - int n = len - 1; // Zero-length literals are disallowed - if (n < 60) { - // Fits in tag byte - *op++ = LITERAL | (n << 2); - - // The vast majority of copies are below 16 bytes, for which a - // call to memcpy is overkill. This fast path can sometimes - // copy up to 15 bytes too much, but that is okay in the - // main loop, since we have a bit to go on for both sides: - // - // - The input will always have kInputMarginBytes = 15 extra - // available bytes, as long as we're in the main loop, and - // if not, allow_fast_path = false. - // - The output will always have 32 spare bytes (see - // MaxCompressedLength). - if (allow_fast_path && len <= 16) { - UnalignedCopy64(literal, op); - UnalignedCopy64(literal + 8, op + 8); - return op + len; - } - } else { - // Encode in upcoming bytes - char* base = op; - int count = 0; - op++; - while (n > 0) { - *op++ = n & 0xff; - n >>= 8; - count++; - } - assert(count >= 1); - assert(count <= 4); - *base = LITERAL | ((59+count) << 2); - } - memcpy(op, literal, len); - return op + len; -} - -static inline char* EmitCopyLessThan64(char* op, size_t offset, int len) { - assert(len <= 64); - assert(len >= 4); - assert(offset < 65536); - - if ((len < 12) && (offset < 2048)) { - size_t len_minus_4 = len - 4; - assert(len_minus_4 < 8); // Must fit in 3 bits - *op++ = COPY_1_BYTE_OFFSET + ((len_minus_4) << 2) + ((offset >> 8) << 5); - *op++ = offset & 0xff; - } else { - *op++ = COPY_2_BYTE_OFFSET + ((len-1) << 2); - LittleEndian::Store16(op, offset); - op += 2; - } - return op; -} - -static inline char* EmitCopy(char* op, size_t offset, int len) { - // Emit 64 byte copies but make sure to keep at least four bytes reserved - while (BAIDU_UNLIKELY(len >= 68)) { - op = EmitCopyLessThan64(op, offset, 64); - len -= 64; - } - - // Emit an extra 60 byte copy if have too much data to fit in one copy - if (len > 64) { - op = EmitCopyLessThan64(op, offset, 60); - len -= 60; - } - - // Emit remainder - op = EmitCopyLessThan64(op, offset, len); - return op; -} - - -bool GetUncompressedLength(const char* start, size_t n, size_t* result) { - uint32_t v = 0; - const char* limit = start + n; - if (Varint::Parse32WithLimit(start, limit, &v) != NULL) { - *result = v; - return true; - } else { - return false; - } -} - -namespace internal { -uint16_t* WorkingMemory::GetHashTable(size_t input_size, int* table_size) { - // Use smaller hash table when input.size() is smaller, since we - // fill the table, incurring O(hash table size) overhead for - // compression, and if the input is short, we won't need that - // many hash table entries anyway. - assert(kMaxHashTableSize >= 256); - size_t htsize = 256; - while (htsize < kMaxHashTableSize && htsize < input_size) { - htsize <<= 1; - } - - uint16_t* table; - if (htsize <= arraysize(small_table_)) { - table = small_table_; - } else { - if (large_table_ == NULL) { - large_table_ = new uint16_t[kMaxHashTableSize]; - } - table = large_table_; - } - - *table_size = htsize; - memset(table, 0, htsize * sizeof(*table)); - return table; -} -} // end namespace internal - -// For 0 <= offset <= 4, GetUint32AtOffset(GetEightBytesAt(p), offset) will -// equal UNALIGNED_LOAD32(p + offset). Motivation: On x86-64 hardware we have -// empirically found that overlapping loads such as -// UNALIGNED_LOAD32(p) ... UNALIGNED_LOAD32(p+1) ... UNALIGNED_LOAD32(p+2) -// are slower than UNALIGNED_LOAD64(p) followed by shifts and casts to uint32. -// -// We have different versions for 64- and 32-bit; ideally we would avoid the -// two functions and just inline the UNALIGNED_LOAD64 call into -// GetUint32AtOffset, but GCC (at least not as of 4.6) is seemingly not clever -// enough to avoid loading the value multiple times then. For 64-bit, the load -// is done when GetEightBytesAt() is called, whereas for 32-bit, the load is -// done at GetUint32AtOffset() time. - -#ifdef ARCH_K8 - -typedef uint64_t EightBytesReference; - -static inline EightBytesReference GetEightBytesAt(const char* ptr) { - return UNALIGNED_LOAD64(ptr); -} - -static inline uint32_t GetUint32AtOffset(uint64_t v, int offset) { - assert(offset >= 0); - assert(offset <= 4); - return v >> (LittleEndian::IsLittleEndian() ? 8 * offset : 32 - 8 * offset); -} - -#else - -typedef const char* EightBytesReference; - -static inline EightBytesReference GetEightBytesAt(const char* ptr) { - return ptr; -} - -static inline uint32_t GetUint32AtOffset(const char* v, int offset) { - assert(offset >= 0); - assert(offset <= 4); - return UNALIGNED_LOAD32(v + offset); -} - -#endif - -// Flat array compression that does not emit the "uncompressed length" -// prefix. Compresses "input" string to the "*op" buffer. -// -// REQUIRES: "input" is at most "kBlockSize" bytes long. -// REQUIRES: "op" points to an array of memory that is at least -// "MaxCompressedLength(input.size())" in size. -// REQUIRES: All elements in "table[0..table_size-1]" are initialized to zero. -// REQUIRES: "table_size" is a power of two -// -// Returns an "end" pointer into "op" buffer. -// "end - op" is the compressed size of "input". -namespace internal { -char* CompressFragment(const char* input, - size_t input_size, - char* op, - uint16_t* table, - const int table_size) { - // "ip" is the input pointer, and "op" is the output pointer. - const char* ip = input; - assert(input_size <= kBlockSize); - assert((table_size & (table_size - 1)) == 0); // table must be power of two - const int shift = 32 - Bits::Log2Floor(table_size); - assert(static_cast(kuint32max >> shift) == table_size - 1); - const char* ip_end = input + input_size; - const char* base_ip = ip; - // Bytes in [next_emit, ip) will be emitted as literal bytes. Or - // [next_emit, ip_end) after the main loop. - const char* next_emit = ip; - - const size_t kInputMarginBytes = 15; - if (BAIDU_LIKELY(input_size >= kInputMarginBytes)) { - const char* ip_limit = input + input_size - kInputMarginBytes; - - for (uint32_t next_hash = Hash(++ip, shift); ; ) { - assert(next_emit < ip); - // The body of this loop calls EmitLiteral once and then EmitCopy one or - // more times. (The exception is that when we're close to exhausting - // the input we goto emit_remainder.) - // - // In the first iteration of this loop we're just starting, so - // there's nothing to copy, so calling EmitLiteral once is - // necessary. And we only start a new iteration when the - // current iteration has determined that a call to EmitLiteral will - // precede the next call to EmitCopy (if any). - // - // Step 1: Scan forward in the input looking for a 4-byte-long match. - // If we get close to exhausting the input then goto emit_remainder. - // - // Heuristic match skipping: If 32 bytes are scanned with no matches - // found, start looking only at every other byte. If 32 more bytes are - // scanned, look at every third byte, etc.. When a match is found, - // immediately go back to looking at every byte. This is a small loss - // (~5% performance, ~0.1% density) for compressible data due to more - // bookkeeping, but for non-compressible data (such as JPEG) it's a huge - // win since the compressor quickly "realizes" the data is incompressible - // and doesn't bother looking for matches everywhere. - // - // The "skip" variable keeps track of how many bytes there are since the - // last match; dividing it by 32 (ie. right-shifting by five) gives the - // number of bytes to move ahead for each iteration. - uint32_t skip = 32; - - const char* next_ip = ip; - const char* candidate; - do { - ip = next_ip; - uint32_t hash = next_hash; - assert(hash == Hash(ip, shift)); - uint32_t bytes_between_hash_lookups = skip++ >> 5; - next_ip = ip + bytes_between_hash_lookups; - if (BAIDU_UNLIKELY(next_ip > ip_limit)) { - goto emit_remainder; - } - next_hash = Hash(next_ip, shift); - candidate = base_ip + table[hash]; - assert(candidate >= base_ip); - assert(candidate < ip); - - table[hash] = ip - base_ip; - } while (BAIDU_LIKELY(UNALIGNED_LOAD32(ip) != - UNALIGNED_LOAD32(candidate))); - - // Step 2: A 4-byte match has been found. We'll later see if more - // than 4 bytes match. But, prior to the match, input - // bytes [next_emit, ip) are unmatched. Emit them as "literal bytes." - assert(next_emit + 16 <= ip_end); - op = EmitLiteral(op, next_emit, ip - next_emit, true); - - // Step 3: Call EmitCopy, and then see if another EmitCopy could - // be our next move. Repeat until we find no match for the - // input immediately after what was consumed by the last EmitCopy call. - // - // If we exit this loop normally then we need to call EmitLiteral next, - // though we don't yet know how big the literal will be. We handle that - // by proceeding to the next iteration of the main loop. We also can exit - // this loop via goto if we get close to exhausting the input. - EightBytesReference input_bytes; - uint32_t candidate_bytes = 0; - - do { - // We have a 4-byte match at ip, and no need to emit any - // "literal bytes" prior to ip. - const char* base = ip; - int matched = 4 + FindMatchLength(candidate + 4, ip + 4, ip_end); - ip += matched; - size_t offset = base - candidate; - assert(0 == memcmp(base, candidate, matched)); - op = EmitCopy(op, offset, matched); - // We could immediately start working at ip now, but to improve - // compression we first update table[Hash(ip - 1, ...)]. - const char* insert_tail = ip - 1; - next_emit = ip; - if (BAIDU_UNLIKELY(ip >= ip_limit)) { - goto emit_remainder; - } - input_bytes = GetEightBytesAt(insert_tail); - uint32_t prev_hash = HashBytes(GetUint32AtOffset(input_bytes, 0), shift); - table[prev_hash] = ip - base_ip - 1; - uint32_t cur_hash = HashBytes(GetUint32AtOffset(input_bytes, 1), shift); - candidate = base_ip + table[cur_hash]; - candidate_bytes = UNALIGNED_LOAD32(candidate); - table[cur_hash] = ip - base_ip; - } while (GetUint32AtOffset(input_bytes, 1) == candidate_bytes); - - next_hash = HashBytes(GetUint32AtOffset(input_bytes, 2), shift); - ++ip; - } - } - -emit_remainder: - // Emit the remaining bytes as a literal - if (next_emit < ip_end) { - op = EmitLiteral(op, next_emit, ip_end - next_emit, false); - } - - return op; -} -} // end namespace internal - -// Signature of output types needed by decompression code. -// The decompression code is templatized on a type that obeys this -// signature so that we do not pay virtual function call overhead in -// the middle of a tight decompression loop. -// -// class DecompressionWriter { -// public: -// // Called before decompression -// void SetExpectedLength(size_t length); -// -// // Called after decompression -// bool CheckLength() const; -// -// // Called repeatedly during decompression -// bool Append(const char* ip, size_t length); -// bool AppendFromSelf(uint32_t offset, size_t length); -// -// // The rules for how TryFastAppend differs from Append are somewhat -// // convoluted: -// // -// // - TryFastAppend is allowed to decline (return false) at any -// // time, for any reason -- just "return false" would be -// // a perfectly legal implementation of TryFastAppend. -// // The intention is for TryFastAppend to allow a fast path -// // in the common case of a small append. -// // - TryFastAppend is allowed to read up to bytes -// // from the input buffer, whereas Append is allowed to read -// // . However, if it returns true, it must leave -// // at least five (kMaximumTagLength) bytes in the input buffer -// // afterwards, so that there is always enough space to read the -// // next tag without checking for a refill. -// // - TryFastAppend must always return decline (return false) -// // if is 61 or more, as in this case the literal length is not -// // decoded fully. In practice, this should not be a big problem, -// // as it is unlikely that one would implement a fast path accepting -// // this much data. -// // -// bool TryFastAppend(const char* ip, size_t available, size_t length); -// }; - -// ----------------------------------------------------------------------- -// Lookup table for decompression code. Generated by ComputeTable() below. -// ----------------------------------------------------------------------- - -// Mapping from i in range [0,4] to a mask to extract the bottom 8*i bits -static const uint32_t wordmask[] = { - 0u, 0xffu, 0xffffu, 0xffffffu, 0xffffffffu -}; - -// Data stored per entry in lookup table: -// Range Bits-used Description -// ------------------------------------ -// 1..64 0..7 Literal/copy length encoded in opcode byte -// 0..7 8..10 Copy offset encoded in opcode byte / 256 -// 0..4 11..13 Extra bytes after opcode -// -// We use eight bits for the length even though 7 would have sufficed -// because of efficiency reasons: -// (1) Extracting a byte is faster than a bit-field -// (2) It properly aligns copy offset so we do not need a <<8 -static const uint16_t char_table[256] = { - 0x0001, 0x0804, 0x1001, 0x2001, 0x0002, 0x0805, 0x1002, 0x2002, - 0x0003, 0x0806, 0x1003, 0x2003, 0x0004, 0x0807, 0x1004, 0x2004, - 0x0005, 0x0808, 0x1005, 0x2005, 0x0006, 0x0809, 0x1006, 0x2006, - 0x0007, 0x080a, 0x1007, 0x2007, 0x0008, 0x080b, 0x1008, 0x2008, - 0x0009, 0x0904, 0x1009, 0x2009, 0x000a, 0x0905, 0x100a, 0x200a, - 0x000b, 0x0906, 0x100b, 0x200b, 0x000c, 0x0907, 0x100c, 0x200c, - 0x000d, 0x0908, 0x100d, 0x200d, 0x000e, 0x0909, 0x100e, 0x200e, - 0x000f, 0x090a, 0x100f, 0x200f, 0x0010, 0x090b, 0x1010, 0x2010, - 0x0011, 0x0a04, 0x1011, 0x2011, 0x0012, 0x0a05, 0x1012, 0x2012, - 0x0013, 0x0a06, 0x1013, 0x2013, 0x0014, 0x0a07, 0x1014, 0x2014, - 0x0015, 0x0a08, 0x1015, 0x2015, 0x0016, 0x0a09, 0x1016, 0x2016, - 0x0017, 0x0a0a, 0x1017, 0x2017, 0x0018, 0x0a0b, 0x1018, 0x2018, - 0x0019, 0x0b04, 0x1019, 0x2019, 0x001a, 0x0b05, 0x101a, 0x201a, - 0x001b, 0x0b06, 0x101b, 0x201b, 0x001c, 0x0b07, 0x101c, 0x201c, - 0x001d, 0x0b08, 0x101d, 0x201d, 0x001e, 0x0b09, 0x101e, 0x201e, - 0x001f, 0x0b0a, 0x101f, 0x201f, 0x0020, 0x0b0b, 0x1020, 0x2020, - 0x0021, 0x0c04, 0x1021, 0x2021, 0x0022, 0x0c05, 0x1022, 0x2022, - 0x0023, 0x0c06, 0x1023, 0x2023, 0x0024, 0x0c07, 0x1024, 0x2024, - 0x0025, 0x0c08, 0x1025, 0x2025, 0x0026, 0x0c09, 0x1026, 0x2026, - 0x0027, 0x0c0a, 0x1027, 0x2027, 0x0028, 0x0c0b, 0x1028, 0x2028, - 0x0029, 0x0d04, 0x1029, 0x2029, 0x002a, 0x0d05, 0x102a, 0x202a, - 0x002b, 0x0d06, 0x102b, 0x202b, 0x002c, 0x0d07, 0x102c, 0x202c, - 0x002d, 0x0d08, 0x102d, 0x202d, 0x002e, 0x0d09, 0x102e, 0x202e, - 0x002f, 0x0d0a, 0x102f, 0x202f, 0x0030, 0x0d0b, 0x1030, 0x2030, - 0x0031, 0x0e04, 0x1031, 0x2031, 0x0032, 0x0e05, 0x1032, 0x2032, - 0x0033, 0x0e06, 0x1033, 0x2033, 0x0034, 0x0e07, 0x1034, 0x2034, - 0x0035, 0x0e08, 0x1035, 0x2035, 0x0036, 0x0e09, 0x1036, 0x2036, - 0x0037, 0x0e0a, 0x1037, 0x2037, 0x0038, 0x0e0b, 0x1038, 0x2038, - 0x0039, 0x0f04, 0x1039, 0x2039, 0x003a, 0x0f05, 0x103a, 0x203a, - 0x003b, 0x0f06, 0x103b, 0x203b, 0x003c, 0x0f07, 0x103c, 0x203c, - 0x0801, 0x0f08, 0x103d, 0x203d, 0x1001, 0x0f09, 0x103e, 0x203e, - 0x1801, 0x0f0a, 0x103f, 0x203f, 0x2001, 0x0f0b, 0x1040, 0x2040 -}; - -// In debug mode, allow optional computation of the table at startup. -// Also, check that the decompression table is correct. -#if 0 -DEFINE_bool(snappy_dump_decompression_table, false, - "If true, we print the decompression table at startup."); - -static uint16_t MakeEntry(unsigned int extra, - unsigned int len, - unsigned int copy_offset) { - // Check that all of the fields fit within the allocated space - assert(extra == (extra & 0x7)); // At most 3 bits - assert(copy_offset == (copy_offset & 0x7)); // At most 3 bits - assert(len == (len & 0x7f)); // At most 7 bits - return len | (copy_offset << 8) | (extra << 11); -} - -static void ALLOW_UNUSED ComputeTable() { - uint16_t dst[256]; - - // Place invalid entries in all places to detect missing initialization - int assigned = 0; - for (int i = 0; i < 256; i++) { - dst[i] = 0xffff; - } - - // Small LITERAL entries. We store (len-1) in the top 6 bits. - for (unsigned int len = 1; len <= 60; len++) { - dst[LITERAL | ((len-1) << 2)] = MakeEntry(0, len, 0); - assigned++; - } - - // Large LITERAL entries. We use 60..63 in the high 6 bits to - // encode the number of bytes of length info that follow the opcode. - for (unsigned int extra_bytes = 1; extra_bytes <= 4; extra_bytes++) { - // We set the length field in the lookup table to 1 because extra - // bytes encode len-1. - dst[LITERAL | ((extra_bytes+59) << 2)] = MakeEntry(extra_bytes, 1, 0); - assigned++; - } - - // COPY_1_BYTE_OFFSET. - // - // The tag byte in the compressed data stores len-4 in 3 bits, and - // offset/256 in 5 bits. offset%256 is stored in the next byte. - // - // This format is used for length in range [4..11] and offset in - // range [0..2047] - for (unsigned int len = 4; len < 12; len++) { - for (unsigned int offset = 0; offset < 2048; offset += 256) { - dst[COPY_1_BYTE_OFFSET | ((len-4)<<2) | ((offset>>8)<<5)] = - MakeEntry(1, len, offset>>8); - assigned++; - } - } - - // COPY_2_BYTE_OFFSET. - // Tag contains len-1 in top 6 bits, and offset in next two bytes. - for (unsigned int len = 1; len <= 64; len++) { - dst[COPY_2_BYTE_OFFSET | ((len-1)<<2)] = MakeEntry(2, len, 0); - assigned++; - } - - // COPY_4_BYTE_OFFSET. - // Tag contents len-1 in top 6 bits, and offset in next four bytes. - for (unsigned int len = 1; len <= 64; len++) { - dst[COPY_4_BYTE_OFFSET | ((len-1)<<2)] = MakeEntry(4, len, 0); - assigned++; - } - - // Check that each entry was initialized exactly once. - if (assigned != 256) { - fprintf(stderr, "ComputeTable: assigned only %d of 256\n", assigned); - abort(); - } - for (int i = 0; i < 256; i++) { - if (dst[i] == 0xffff) { - fprintf(stderr, "ComputeTable: did not assign byte %d\n", i); - abort(); - } - } - - if (FLAGS_snappy_dump_decompression_table) { - printf("static const uint16_t char_table[256] = {\n "); - for (int i = 0; i < 256; i++) { - printf("0x%04x%s", - dst[i], - ((i == 255) ? "\n" : (((i%8) == 7) ? ",\n " : ", "))); - } - printf("};\n"); - } - - // Check that computed table matched recorded table - for (int i = 0; i < 256; i++) { - if (dst[i] != char_table[i]) { - fprintf(stderr, "ComputeTable: byte %d: computed (%x), expect (%x)\n", - i, static_cast(dst[i]), static_cast(char_table[i])); - abort(); - } - } -} -#endif //disabled - -// Helper class for decompression -class SnappyDecompressor { -private: - Source* reader_; // Underlying source of bytes to decompress - const char* ip_; // Points to next buffered byte - const char* ip_limit_; // Points just past buffered bytes - uint32_t peeked_; // Bytes peeked from reader (need to skip) - bool eof_; // Hit end of input without an error? - char scratch_[kMaximumTagLength]; // See RefillTag(). - - // Ensure that all of the tag metadata for the next tag is available - // in [ip_..ip_limit_-1]. Also ensures that [ip,ip+4] is readable even - // if (ip_limit_ - ip_ < 5). - // - // Returns true on success, false on error or end of input. - bool RefillTag(); - -public: - explicit SnappyDecompressor(Source* reader) - : reader_(reader), - ip_(NULL), - ip_limit_(NULL), - peeked_(0), - eof_(false) { - } - - ~SnappyDecompressor() { - // Advance past any bytes we peeked at from the reader - reader_->Skip(peeked_); - } - - // Returns true iff we have hit the end of the input without an error. - bool eof() const { - return eof_; - } - - // Read the uncompressed length stored at the start of the compressed data. - // On succcess, stores the length in *result and returns true. - // On failure, returns false. - bool ReadUncompressedLength(uint32_t* result) { - assert(ip_ == NULL); // Must not have read anything yet - // Length is encoded in 1..5 bytes - *result = 0; - uint32_t shift = 0; - while (true) { - if (shift >= 32) return false; - size_t n; - const char* ip = reader_->Peek(&n); - if (n == 0) return false; - const unsigned char c = *(reinterpret_cast(ip)); - reader_->Skip(1); - *result |= static_cast(c & 0x7f) << shift; - if (c < 128) { - break; - } - shift += 7; - } - return true; - } - - // Process the next item found in the input. - // Returns true if successful, false on error or end of input. - template - void DecompressAllTags(Writer* writer) { - const char* ip = ip_; - - // We could have put this refill fragment only at the beginning of the loop. - // However, duplicating it at the end of each branch gives the compiler more - // scope to optimize the expression based on the local - // context, which overall increases speed. -#define MAYBE_REFILL() \ - if (ip_limit_ - ip < kMaximumTagLength) { \ - ip_ = ip; \ - if (!RefillTag()) return; \ - ip = ip_; \ - } - - MAYBE_REFILL(); - for ( ;; ) { - const unsigned char c = *(reinterpret_cast(ip++)); - - if ((c & 0x3) == LITERAL) { - size_t literal_length = (c >> 2) + 1u; - if (writer->TryFastAppend(ip, ip_limit_ - ip, literal_length)) { - assert(literal_length < 61); - ip += literal_length; - // NOTE(user): There is no MAYBE_REFILL() here, as TryFastAppend() - // will not return true unless there's already at least five spare - // bytes in addition to the literal. - continue; - } - if (BAIDU_UNLIKELY(literal_length >= 61)) { - // Long literal. - const size_t literal_length_length = literal_length - 60; - literal_length = - (LittleEndian::Load32(ip) & wordmask[literal_length_length]) + 1; - ip += literal_length_length; - } - - size_t avail = ip_limit_ - ip; - while (avail < literal_length) { - if (!writer->Append(ip, avail)) return; - literal_length -= avail; - reader_->Skip(peeked_); - size_t n; - ip = reader_->Peek(&n); - avail = n; - peeked_ = avail; - if (avail == 0) return; // Premature end of input - ip_limit_ = ip + avail; - } - if (!writer->Append(ip, literal_length)) { - return; - } - ip += literal_length; - MAYBE_REFILL(); - } else { - const uint32_t entry = char_table[c]; - const uint32_t trailer = LittleEndian::Load32(ip) & wordmask[entry >> 11]; - const uint32_t length = entry & 0xff; - ip += entry >> 11; - - // copy_offset/256 is encoded in bits 8..10. By just fetching - // those bits, we get copy_offset (since the bit-field starts at - // bit 8). - const uint32_t copy_offset = entry & 0x700; - if (!writer->AppendFromSelf(copy_offset + trailer, length)) { - return; - } - MAYBE_REFILL(); - } - } - -#undef MAYBE_REFILL - } -}; - -bool SnappyDecompressor::RefillTag() { - const char* ip = ip_; - if (ip == ip_limit_) { - // Fetch a new fragment from the reader - reader_->Skip(peeked_); // All peeked bytes are used up - size_t n; - ip = reader_->Peek(&n); - peeked_ = n; - if (n == 0) { - eof_ = true; - return false; - } - ip_limit_ = ip + n; - } - - // Read the tag character - assert(ip < ip_limit_); - const unsigned char c = *(reinterpret_cast(ip)); - const uint32_t entry = char_table[c]; - const uint32_t needed = (entry >> 11) + 1; // +1 byte for 'c' - assert(needed <= sizeof(scratch_)); - - // Read more bytes from reader if needed - uint32_t nbuf = ip_limit_ - ip; - if (nbuf < needed) { - // Stitch together bytes from ip and reader to form the word - // contents. We store the needed bytes in "scratch_". They - // will be consumed immediately by the caller since we do not - // read more than we need. - memmove(scratch_, ip, nbuf); - reader_->Skip(peeked_); // All peeked bytes are used up - peeked_ = 0; - while (nbuf < needed) { - size_t length; - const char* src = reader_->Peek(&length); - if (length == 0) return false; - uint32_t to_add = std::min(needed - nbuf, length); - memcpy(scratch_ + nbuf, src, to_add); - nbuf += to_add; - reader_->Skip(to_add); - } - assert(nbuf == needed); - ip_ = scratch_; - ip_limit_ = scratch_ + needed; - } else if (nbuf < kMaximumTagLength) { - // Have enough bytes, but move into scratch_ so that we do not - // read past end of input - memmove(scratch_, ip, nbuf); - reader_->Skip(peeked_); // All peeked bytes are used up - peeked_ = 0; - ip_ = scratch_; - ip_limit_ = scratch_ + nbuf; - } else { - // Pass pointer to buffer returned by reader_. - ip_ = ip; - } - return true; -} - -template -static bool InternalUncompress(Source* r, Writer* writer) { - // Read the uncompressed length from the front of the compressed input - SnappyDecompressor decompressor(r); - uint32_t uncompressed_len = 0; - if (!decompressor.ReadUncompressedLength(&uncompressed_len)) return false; - return InternalUncompressAllTags(&decompressor, writer, uncompressed_len); -} - -template -static bool InternalUncompressAllTags(SnappyDecompressor* decompressor, - Writer* writer, - uint32_t uncompressed_len) { - writer->SetExpectedLength(uncompressed_len); - - // Process the entire input - decompressor->DecompressAllTags(writer); - writer->Flush(); - return (decompressor->eof() && writer->CheckLength()); -} - -bool GetUncompressedLength(Source* source, uint32_t* result) { - SnappyDecompressor decompressor(source); - return decompressor.ReadUncompressedLength(result); -} - -size_t Compress(Source* reader, Sink* writer) { - size_t written = 0; - size_t N = reader->Available(); - char ulength[Varint::kMax32]; - char* p = Varint::Encode32(ulength, N); - writer->Append(ulength, p-ulength); - written += (p - ulength); - - internal::WorkingMemory wmem; - char* scratch = NULL; - char* scratch_output = NULL; - - while (N > 0) { - // Get next block to compress (without copying if possible) - size_t fragment_size; - const char* fragment = reader->Peek(&fragment_size); - assert(fragment_size != 0); // premature end of input - const size_t num_to_read = std::min(N, kBlockSize); - size_t bytes_read = fragment_size; - - size_t pending_advance = 0; - if (bytes_read >= num_to_read) { - // Buffer returned by reader is large enough - pending_advance = num_to_read; - fragment_size = num_to_read; - } else { - // Read into scratch buffer - if (scratch == NULL) { - // If this is the last iteration, we want to allocate N bytes - // of space, otherwise the max possible kBlockSize space. - // num_to_read contains exactly the correct value - scratch = new char[num_to_read]; - } - memcpy(scratch, fragment, bytes_read); - reader->Skip(bytes_read); - - while (bytes_read < num_to_read) { - fragment = reader->Peek(&fragment_size); - size_t n = std::min(fragment_size, num_to_read - bytes_read); - memcpy(scratch + bytes_read, fragment, n); - bytes_read += n; - reader->Skip(n); - } - assert(bytes_read == num_to_read); - fragment = scratch; - fragment_size = num_to_read; - } - assert(fragment_size == num_to_read); - - // Get encoding table for compression - int table_size; - uint16_t* table = wmem.GetHashTable(num_to_read, &table_size); - - // Compress input_fragment and append to dest - const int max_output = MaxCompressedLength(num_to_read); - - // Need a scratch buffer for the output, in case the byte sink doesn't - // have room for us directly. - if (scratch_output == NULL) { - scratch_output = new char[max_output]; - } else { - // Since we encode kBlockSize regions followed by a region - // which is <= kBlockSize in length, a previously allocated - // scratch_output[] region is big enough for this iteration. - } - char* dest = writer->GetAppendBuffer(max_output, scratch_output); - char* end = internal::CompressFragment(fragment, fragment_size, - dest, table, table_size); - writer->Append(dest, end - dest); - written += (end - dest); - - N -= num_to_read; - reader->Skip(pending_advance); - } - - delete[] scratch; - delete[] scratch_output; - - return written; -} - -// ----------------------------------------------------------------------- -// IOVec interfaces -// ----------------------------------------------------------------------- - -// A type that writes to an iovec. -// Note that this is not a "ByteSink", but a type that matches the -// Writer template argument to SnappyDecompressor::DecompressAllTags(). -class SnappyIOVecWriter { -private: - const struct iovec* output_iov_; - const size_t output_iov_count_; - - // We are currently writing into output_iov_[curr_iov_index_]. - int curr_iov_index_; - - // Bytes written to output_iov_[curr_iov_index_] so far. - size_t curr_iov_written_; - - // Total bytes decompressed into output_iov_ so far. - size_t total_written_; - - // Maximum number of bytes that will be decompressed into output_iov_. - size_t output_limit_; - - inline char* GetIOVecPointer(int index, size_t offset) { - return reinterpret_cast(output_iov_[index].iov_base) + - offset; - } - -public: - // Does not take ownership of iov. iov must be valid during the - // entire lifetime of the SnappyIOVecWriter. - inline SnappyIOVecWriter(const struct iovec* iov, size_t iov_count) - : output_iov_(iov), - output_iov_count_(iov_count), - curr_iov_index_(0), - curr_iov_written_(0), - total_written_(0), - output_limit_((size_t)-1) { - } - - inline void SetExpectedLength(size_t len) { - output_limit_ = len; - } - - inline bool CheckLength() const { - return total_written_ == output_limit_; - } - - inline bool Append(const char* ip, size_t len) { - if (total_written_ + len > output_limit_) { - return false; - } - - while (len > 0) { - assert(curr_iov_written_ <= output_iov_[curr_iov_index_].iov_len); - if (curr_iov_written_ >= output_iov_[curr_iov_index_].iov_len) { - // This iovec is full. Go to the next one. - if ((size_t)(curr_iov_index_ + 1) >= output_iov_count_) { - return false; - } - curr_iov_written_ = 0; - ++curr_iov_index_; - } - - const size_t to_write = std::min( - len, output_iov_[curr_iov_index_].iov_len - curr_iov_written_); - memcpy(GetIOVecPointer(curr_iov_index_, curr_iov_written_), - ip, - to_write); - curr_iov_written_ += to_write; - total_written_ += to_write; - ip += to_write; - len -= to_write; - } - - return true; - } - - inline bool TryFastAppend(const char* ip, size_t available, size_t len) { - const size_t space_left = output_limit_ - total_written_; - if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16 && - output_iov_[curr_iov_index_].iov_len - curr_iov_written_ >= 16) { - // Fast path, used for the majority (about 95%) of invocations. - char* ptr = GetIOVecPointer(curr_iov_index_, curr_iov_written_); - UnalignedCopy64(ip, ptr); - UnalignedCopy64(ip + 8, ptr + 8); - curr_iov_written_ += len; - total_written_ += len; - return true; - } - - return false; - } - - inline bool AppendFromSelf(size_t offset, size_t len) { - if (offset > total_written_ || offset == 0) { - return false; - } - const size_t space_left = output_limit_ - total_written_; - if (len > space_left) { - return false; - } - - // Locate the iovec from which we need to start the copy. - int from_iov_index = curr_iov_index_; - size_t from_iov_offset = curr_iov_written_; - while (offset > 0) { - if (from_iov_offset >= offset) { - from_iov_offset -= offset; - break; - } - - offset -= from_iov_offset; - --from_iov_index; - assert(from_iov_index >= 0); - from_iov_offset = output_iov_[from_iov_index].iov_len; - } - - // Copy bytes starting from the iovec pointed to by from_iov_index to - // the current iovec. - while (len > 0) { - assert(from_iov_index <= curr_iov_index_); - if (from_iov_index != curr_iov_index_) { - const size_t to_copy = std::min( - output_iov_[from_iov_index].iov_len - from_iov_offset, - len); - Append(GetIOVecPointer(from_iov_index, from_iov_offset), to_copy); - len -= to_copy; - if (len > 0) { - ++from_iov_index; - from_iov_offset = 0; - } - } else { - assert(curr_iov_written_ <= output_iov_[curr_iov_index_].iov_len); - size_t to_copy = std::min(output_iov_[curr_iov_index_].iov_len - - curr_iov_written_, - len); - if (to_copy == 0) { - // This iovec is full. Go to the next one. - if ((size_t)(curr_iov_index_ + 1) >= output_iov_count_) { - return false; - } - ++curr_iov_index_; - curr_iov_written_ = 0; - continue; - } - if (to_copy > len) { - to_copy = len; - } - IncrementalCopy(GetIOVecPointer(from_iov_index, from_iov_offset), - GetIOVecPointer(curr_iov_index_, curr_iov_written_), - to_copy); - curr_iov_written_ += to_copy; - from_iov_offset += to_copy; - total_written_ += to_copy; - len -= to_copy; - } - } - - return true; - } - - inline void Flush() {} -}; - -bool RawUncompressToIOVec(const char* compressed, size_t compressed_length, - const struct iovec* iov, size_t iov_cnt) { - ByteArraySource reader(compressed, compressed_length); - return RawUncompressToIOVec(&reader, iov, iov_cnt); -} - -bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov, - size_t iov_cnt) { - SnappyIOVecWriter output(iov, iov_cnt); - return InternalUncompress(compressed, &output); -} - -// ----------------------------------------------------------------------- -// Flat array interfaces -// ----------------------------------------------------------------------- - -// A type that writes to a flat array. -// Note that this is not a "ByteSink", but a type that matches the -// Writer template argument to SnappyDecompressor::DecompressAllTags(). -class SnappyArrayWriter { -private: - char* base_; - char* op_; - char* op_limit_; - -public: - inline explicit SnappyArrayWriter(char* dst) - : base_(dst), - op_(dst), - op_limit_(dst) { - } - - inline void SetExpectedLength(size_t len) { - op_limit_ = op_ + len; - } - - inline bool CheckLength() const { - return op_ == op_limit_; - } - - inline bool Append(const char* ip, size_t len) { - char* op = op_; - const size_t space_left = op_limit_ - op; - if (space_left < len) { - return false; - } - memcpy(op, ip, len); - op_ = op + len; - return true; - } - - inline bool TryFastAppend(const char* ip, size_t available, size_t len) { - char* op = op_; - const size_t space_left = op_limit_ - op; - if (len <= 16 && available >= 16 + kMaximumTagLength && space_left >= 16) { - // Fast path, used for the majority (about 95%) of invocations. - UnalignedCopy64(ip, op); - UnalignedCopy64(ip + 8, op + 8); - op_ = op + len; - return true; - } else { - return false; - } - } - - inline bool AppendFromSelf(size_t offset, size_t len) { - char* op = op_; - const size_t space_left = op_limit_ - op; - - // Check if we try to append from before the start of the buffer. - // Normally this would just be a check for "produced < offset", - // but "produced <= offset - 1u" is equivalent for every case - // except the one where offset==0, where the right side will wrap around - // to a very big number. This is convenient, as offset==0 is another - // invalid case that we also want to catch, so that we do not go - // into an infinite loop. - assert(op >= base_); - size_t produced = op - base_; - if (produced <= offset - 1u) { - return false; - } - if (len <= 16 && offset >= 8 && space_left >= 16) { - // Fast path, used for the majority (70-80%) of dynamic invocations. - UnalignedCopy64(op - offset, op); - UnalignedCopy64(op - offset + 8, op + 8); - } else { - if (space_left >= len + kMaxIncrementCopyOverflow) { - IncrementalCopyFastPath(op - offset, op, len); - } else { - if (space_left < len) { - return false; - } - IncrementalCopy(op - offset, op, len); - } - } - - op_ = op + len; - return true; - } - inline size_t Produced() const { - return op_ - base_; - } - inline void Flush() {} -}; - -bool RawUncompress(const char* compressed, size_t n, char* uncompressed) { - ByteArraySource reader(compressed, n); - return RawUncompress(&reader, uncompressed); -} - -bool RawUncompress(Source* compressed, char* uncompressed) { - SnappyArrayWriter output(uncompressed); - return InternalUncompress(compressed, &output); -} - -bool Uncompress(const char* compressed, size_t n, std::string* uncompressed) { - size_t ulength; - if (!GetUncompressedLength(compressed, n, &ulength)) { - return false; - } - // On 32-bit builds: max_size() < kuint32max. Check for that instead - // of crashing (e.g., consider externally specified compressed data). - if (ulength > uncompressed->max_size()) { - return false; - } - STLStringResizeUninitialized(uncompressed, ulength); - return RawUncompress(compressed, n, string_as_array(uncompressed)); -} - -// A Writer that drops everything on the floor and just does validation -class SnappyDecompressionValidator { -private: - size_t expected_; - size_t produced_; - -public: - inline SnappyDecompressionValidator() : expected_(0), produced_(0) { } - inline void SetExpectedLength(size_t len) { - expected_ = len; - } - inline bool CheckLength() const { - return expected_ == produced_; - } - inline bool Append(const char* ip, size_t len) { - produced_ += len; - return produced_ <= expected_; - } - inline bool TryFastAppend(const char* ip, size_t available, size_t length) { - return false; - } - inline bool AppendFromSelf(size_t offset, size_t len) { - // See SnappyArrayWriter::AppendFromSelf for an explanation of - // the "offset - 1u" trick. - if (produced_ <= offset - 1u) return false; - produced_ += len; - return produced_ <= expected_; - } - inline void Flush() {} -}; - -bool IsValidCompressedBuffer(const char* compressed, size_t n) { - ByteArraySource reader(compressed, n); - SnappyDecompressionValidator writer; - return InternalUncompress(&reader, &writer); -} - -bool IsValidCompressed(Source* compressed) { - SnappyDecompressionValidator writer; - return InternalUncompress(compressed, &writer); -} - -void RawCompress(const char* input, - size_t input_length, - char* compressed, - size_t* compressed_length) { - ByteArraySource reader(input, input_length); - UncheckedByteArraySink writer(compressed); - Compress(&reader, &writer); - - // Compute how many bytes were added - *compressed_length = (writer.CurrentDestination() - compressed); -} - -size_t Compress(const char* input, size_t input_length, std::string* compressed) { - // Pre-grow the buffer to the max length of the compressed output - compressed->resize(MaxCompressedLength(input_length)); - - size_t compressed_length; - RawCompress(input, input_length, string_as_array(compressed), - &compressed_length); - compressed->resize(compressed_length); - return compressed_length; -} - -// ----------------------------------------------------------------------- -// Sink interface -// ----------------------------------------------------------------------- - -// A type that decompresses into a Sink. The template parameter -// Allocator must export one method "char* Allocate(int size);", which -// allocates a buffer of "size" and appends that to the destination. -template -class SnappyScatteredWriter { - Allocator allocator_; - - // We need random access into the data generated so far. Therefore - // we keep track of all of the generated data as an array of blocks. - // All of the blocks except the last have length kBlockSize. - std::vector blocks_; - size_t expected_; - - // Total size of all fully generated blocks so far - size_t full_size_; - - // Pointer into current output block - char* op_base_; // Base of output block - char* op_ptr_; // Pointer to next unfilled byte in block - char* op_limit_; // Pointer just past block - - inline size_t Size() const { - return full_size_ + (op_ptr_ - op_base_); - } - - bool SlowAppend(const char* ip, size_t len); - bool SlowAppendFromSelf(size_t offset, size_t len); - -public: - inline explicit SnappyScatteredWriter(const Allocator& allocator) - : allocator_(allocator), - full_size_(0), - op_base_(NULL), - op_ptr_(NULL), - op_limit_(NULL) { - } - - inline void SetExpectedLength(size_t len) { - assert(blocks_.empty()); - expected_ = len; - } - - inline bool CheckLength() const { - return Size() == expected_; - } - - // Return the number of bytes actually uncompressed so far - inline size_t Produced() const { - return Size(); - } - - inline bool Append(const char* ip, size_t len) { - size_t avail = op_limit_ - op_ptr_; - if (len <= avail) { - // Fast path - memcpy(op_ptr_, ip, len); - op_ptr_ += len; - return true; - } else { - return SlowAppend(ip, len); - } - } - - inline bool TryFastAppend(const char* ip, size_t available, size_t length) { - char* op = op_ptr_; - const int space_left = op_limit_ - op; - if (length <= 16 && available >= 16 + kMaximumTagLength && - space_left >= 16) { - // Fast path, used for the majority (about 95%) of invocations. - UNALIGNED_STORE64(op, UNALIGNED_LOAD64(ip)); - UNALIGNED_STORE64(op + 8, UNALIGNED_LOAD64(ip + 8)); - op_ptr_ = op + length; - return true; - } else { - return false; - } - } - - inline bool AppendFromSelf(size_t offset, size_t len) { - // See SnappyArrayWriter::AppendFromSelf for an explanation of - // the "offset - 1u" trick. - if (offset - 1u < (size_t)(op_ptr_ - op_base_)) { - // ^ Fix warning in gcc 3.4 - const size_t space_left = op_limit_ - op_ptr_; - if (space_left >= len + kMaxIncrementCopyOverflow) { - // Fast path: src and dst in current block. - IncrementalCopyFastPath(op_ptr_ - offset, op_ptr_, len); - op_ptr_ += len; - return true; - } - } - return SlowAppendFromSelf(offset, len); - } - - // Called at the end of the decompress. We ask the allocator - // write all blocks to the sink. - inline void Flush() { allocator_.Flush(Produced()); } -}; - -template -bool SnappyScatteredWriter::SlowAppend(const char* ip, size_t len) { - size_t avail = op_limit_ - op_ptr_; - while (len > avail) { - // Completely fill this block - memcpy(op_ptr_, ip, avail); - op_ptr_ += avail; - assert(op_limit_ - op_ptr_ == 0); - full_size_ += (op_ptr_ - op_base_); - len -= avail; - ip += avail; - - // Bounds check - if (full_size_ + len > expected_) { - return false; - } - - // Make new block - size_t bsize = std::min(kBlockSize, expected_ - full_size_); - op_base_ = allocator_.Allocate(bsize); - op_ptr_ = op_base_; - op_limit_ = op_base_ + bsize; - blocks_.push_back(op_base_); - avail = bsize; - } - - memcpy(op_ptr_, ip, len); - op_ptr_ += len; - return true; -} - -template -bool SnappyScatteredWriter::SlowAppendFromSelf(size_t offset, - size_t len) { - // Overflow check - // See SnappyArrayWriter::AppendFromSelf for an explanation of - // the "offset - 1u" trick. - const size_t cur = Size(); - if (offset - 1u >= cur) return false; - if (expected_ - cur < len) return false; - - // Currently we shouldn't ever hit this path because Compress() chops the - // input into blocks and does not create cross-block copies. However, it is - // nice if we do not rely on that, since we can get better compression if we - // allow cross-block copies and thus might want to change the compressor in - // the future. - size_t src = cur - offset; - while (len-- > 0) { - char c = blocks_[src >> kBlockLog][src & (kBlockSize-1)]; - Append(&c, 1); - src++; - } - return true; -} - -class SnappySinkAllocator { -public: - explicit SnappySinkAllocator(Sink* dest): dest_(dest) {} - ~SnappySinkAllocator() {} - - char* Allocate(int size) { - Datablock block(new char[size], size); - blocks_.push_back(block); - return block.data; - } - - // We flush only at the end, because the writer wants - // random access to the blocks and once we hand the - // block over to the sink, we can't access it anymore. - // Also we don't write more than has been actually written - // to the blocks. - void Flush(size_t size) { - size_t size_written = 0; - size_t block_size; - for (size_t i = 0; i < blocks_.size(); ++i) { - block_size = std::min(blocks_[i].size, size - size_written); - dest_->AppendAndTakeOwnership(blocks_[i].data, block_size, - &SnappySinkAllocator::Deleter, NULL); - size_written += block_size; - } - blocks_.clear(); - } - -private: - struct Datablock { - char* data; - size_t size; - Datablock(char* p, size_t s) : data(p), size(s) {} - }; - - static void Deleter(void* arg, const char* bytes, size_t size) { - delete[] bytes; - } - - Sink* dest_; - std::vector blocks_; - - // Note: copying this object is allowed -}; - -size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed) { - SnappySinkAllocator allocator(uncompressed); - SnappyScatteredWriter writer(allocator); - InternalUncompress(compressed, &writer); - return writer.Produced(); -} - -bool Uncompress(Source* compressed, Sink* uncompressed) { - // Read the uncompressed length from the front of the compressed input - SnappyDecompressor decompressor(compressed); - uint32_t uncompressed_len = 0; - if (!decompressor.ReadUncompressedLength(&uncompressed_len)) { - return false; - } - - char c; - size_t allocated_size; - char* buf = uncompressed->GetAppendBufferVariable( - 1, uncompressed_len, &c, 1, &allocated_size); - - // If we can get a flat buffer, then use it, otherwise do block by block - // uncompression - if (allocated_size >= uncompressed_len) { - SnappyArrayWriter writer(buf); - bool result = InternalUncompressAllTags( - &decompressor, &writer, uncompressed_len); - uncompressed->Append(buf, writer.Produced()); - return result; - } else { - SnappySinkAllocator allocator(uncompressed); - SnappyScatteredWriter writer(allocator); - return InternalUncompressAllTags(&decompressor, &writer, uncompressed_len); - } -} - -} // end namespace snappy -} // end namespace butil diff --git a/src/butil/third_party/snappy/snappy.h b/src/butil/third_party/snappy/snappy.h deleted file mode 100644 index a096030e4d..0000000000 --- a/src/butil/third_party/snappy/snappy.h +++ /dev/null @@ -1,210 +0,0 @@ -// Copyright 2005 and onwards Google Inc. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are -// met: -// -// * Redistributions of source code must retain the above copyright -// notice, this list of conditions and the following disclaimer. -// * Redistributions in binary form must reproduce the above -// copyright notice, this list of conditions and the following disclaimer -// in the documentation and/or other materials provided with the -// distribution. -// * Neither the name of Google Inc. nor the names of its -// contributors may be used to endorse or promote products derived from -// this software without specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR -// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -// -// A light-weight compression algorithm. It is designed for speed of -// compression and decompression, rather than for the utmost in space -// savings. -// -// For getting better compression ratios when you are compressing data -// with long repeated sequences or compressing data that is similar to -// other data, while still compressing fast, you might look at first -// using BMDiff and then compressing the output of BMDiff with -// Snappy. - -#ifndef BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_H__ -#define BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_H__ - -#include "butil/basictypes.h" -#include - -namespace butil { -namespace snappy { -class Source; -class Sink; - -// Windows does not have an iovec type, yet the concept is universally useful. -// It is simple to define it ourselves, so we put it inside our own namespace. -struct iovec { - void* iov_base; - size_t iov_len; -}; - -// ------------------------------------------------------------------------ -// Generic compression/decompression routines. -// ------------------------------------------------------------------------ - -// Compress the bytes read from "*source" and append to "*sink". Return the -// number of bytes written. -size_t Compress(Source* source, Sink* sink); - -// Find the uncompressed length of the given stream, as given by the header. -// Note that the true length could deviate from this; the stream could e.g. -// be truncated. -// -// Also note that this leaves "*source" in a state that is unsuitable for -// further operations, such as RawUncompress(). You will need to rewind -// or recreate the source yourself before attempting any further calls. -bool GetUncompressedLength(Source* source, uint32_t* result); - -// ------------------------------------------------------------------------ -// Higher-level string based routines (should be sufficient for most users) -// ------------------------------------------------------------------------ - -// Sets "*output" to the compressed version of "input[0,input_length-1]". -// Original contents of *output are lost. -// -// REQUIRES: "input[]" is not an alias of "*output". -size_t Compress(const char* input, size_t input_length, std::string* output); - -// Decompresses "compressed[0,compressed_length-1]" to "*uncompressed". -// Original contents of "*uncompressed" are lost. -// -// REQUIRES: "compressed[]" is not an alias of "*uncompressed". -// -// returns false if the message is corrupted and could not be decompressed -bool Uncompress(const char* compressed, size_t compressed_length, - std::string* uncompressed); - -// Decompresses "compressed" to "*uncompressed". -// -// returns false if the message is corrupted and could not be decompressed -bool Uncompress(Source* compressed, Sink* uncompressed); - -// This routine uncompresses as much of the "compressed" as possible -// into sink. It returns the number of valid bytes added to sink -// (extra invalid bytes may have been added due to errors; the caller -// should ignore those). The emitted data typically has length -// GetUncompressedLength(), but may be shorter if an error is -// encountered. -size_t UncompressAsMuchAsPossible(Source* compressed, Sink* uncompressed); - -// ------------------------------------------------------------------------ -// Lower-level character array based routines. May be useful for -// efficiency reasons in certain circumstances. -// ------------------------------------------------------------------------ - -// REQUIRES: "compressed" must point to an area of memory that is at -// least "MaxCompressedLength(input_length)" bytes in length. -// -// Takes the data stored in "input[0..input_length]" and stores -// it in the array pointed to by "compressed". -// -// "*compressed_length" is set to the length of the compressed output. -// -// Example: -// char* output = new char[snappy::MaxCompressedLength(input_length)]; -// size_t output_length; -// RawCompress(input, input_length, output, &output_length); -// ... Process(output, output_length) ... -// delete [] output; -void RawCompress(const char* input, - size_t input_length, - char* compressed, - size_t* compressed_length); - -// Given data in "compressed[0..compressed_length-1]" generated by -// calling the Snappy::Compress routine, this routine -// stores the uncompressed data to -// uncompressed[0..GetUncompressedLength(compressed)-1] -// returns false if the message is corrupted and could not be decrypted -bool RawUncompress(const char* compressed, size_t compressed_length, - char* uncompressed); - -// Given data from the byte source 'compressed' generated by calling -// the Snappy::Compress routine, this routine stores the uncompressed -// data to -// uncompressed[0..GetUncompressedLength(compressed,compressed_length)-1] -// returns false if the message is corrupted and could not be decrypted -bool RawUncompress(Source* compressed, char* uncompressed); - -// Given data in "compressed[0..compressed_length-1]" generated by -// calling the Snappy::Compress routine, this routine -// stores the uncompressed data to the iovec "iov". The number of physical -// buffers in "iov" is given by iov_cnt and their cumulative size -// must be at least GetUncompressedLength(compressed). The individual buffers -// in "iov" must not overlap with each other. -// -// returns false if the message is corrupted and could not be decrypted -bool RawUncompressToIOVec(const char* compressed, size_t compressed_length, - const struct iovec* iov, size_t iov_cnt); - -// Given data from the byte source 'compressed' generated by calling -// the Snappy::Compress routine, this routine stores the uncompressed -// data to the iovec "iov". The number of physical -// buffers in "iov" is given by iov_cnt and their cumulative size -// must be at least GetUncompressedLength(compressed). The individual buffers -// in "iov" must not overlap with each other. -// -// returns false if the message is corrupted and could not be decrypted -bool RawUncompressToIOVec(Source* compressed, const struct iovec* iov, - size_t iov_cnt); - -// Returns the maximal size of the compressed representation of -// input data that is "source_bytes" bytes in length; -size_t MaxCompressedLength(size_t source_bytes); - -// REQUIRES: "compressed[]" was produced by RawCompress() or Compress() -// Returns true and stores the length of the uncompressed data in -// *result normally. Returns false on parsing error. -// This operation takes O(1) time. -bool GetUncompressedLength(const char* compressed, size_t compressed_length, - size_t* result); - -// Returns true iff the contents of "compressed[]" can be uncompressed -// successfully. Does not return the uncompressed data. Takes -// time proportional to compressed_length, but is usually at least -// a factor of four faster than actual decompression. -bool IsValidCompressedBuffer(const char* compressed, - size_t compressed_length); - -// Returns true iff the contents of "compressed" can be uncompressed -// successfully. Does not return the uncompressed data. Takes -// time proportional to *compressed length, but is usually at least -// a factor of four faster than actual decompression. -// On success, consumes all of *compressed. On failure, consumes an -// unspecified prefix of *compressed. -bool IsValidCompressed(Source* compressed); - -// The size of a compression block. Note that many parts of the compression -// code assumes that kBlockSize <= 65536; in particular, the hash table -// can only store 16-bit offsets, and EmitCopy() also assumes the offset -// is 65535 bytes or less. Note also that if you change this, it will -// affect the framing format (see framing_format.txt). -// -// Note that there might be older data around that is compressed with larger -// block sizes, so the decompression code should not rely on the -// non-existence of long backreferences. -static const int kBlockLog = 16; -static const size_t kBlockSize = 1 << kBlockLog; - -static const int kMaxHashTableBits = 14; -static const size_t kMaxHashTableSize = 1 << kMaxHashTableBits; -} // end namespace snappy -} // end namespace butil - -#endif // BUTIL_THIRD_PARTY_SNAPPY_SNAPPY_H__ diff --git a/test/brpc_snappy_compress_unittest.cpp b/test/brpc_snappy_compress_unittest.cpp index 94b54dfdb9..bf12aed04b 100644 --- a/test/brpc_snappy_compress_unittest.cpp +++ b/test/brpc_snappy_compress_unittest.cpp @@ -21,7 +21,7 @@ #include #include "gperftools_helper.h" -#include "butil/third_party/snappy/snappy.h" +#include "snappy.h" #include "butil/macros.h" #include "butil/iobuf.h" #include "butil/time.h" @@ -62,11 +62,11 @@ inline void CompressMessage(const char* method_name, static bool SnappyDecompressIOBuf(char* input, size_t len, butil::IOBuf* buf) { size_t decompress_length; - if (!butil::snappy::GetUncompressedLength(input, len, &decompress_length)) { + if (!snappy::GetUncompressedLength(input, len, &decompress_length)) { return false; } char* output = new char[decompress_length]; - if (!butil::snappy::RawUncompress(input, len, output)) { + if (!snappy::RawUncompress(input, len, output)) { delete [] output; return false; } @@ -149,17 +149,17 @@ TEST_F(test_compress_method, snappy_test) { butil::IOBuf buf; std::string output; std::string append_string; - ASSERT_TRUE(butil::snappy::Compress(text, len, &output)); + ASSERT_TRUE(snappy::Compress(text, len, &output)); size_t com_len1 = output.size(); const char* s_text = "123456"; - ASSERT_TRUE(butil::snappy::Compress(s_text, strlen(s_text), &append_string)); + ASSERT_TRUE(snappy::Compress(s_text, strlen(s_text), &append_string)); output.append(append_string); std::string uncompress_str; std::string uncompress_str_t; char* ptr = const_cast(output.c_str()); - ASSERT_TRUE(butil::snappy::Uncompress(ptr, com_len1, &uncompress_str)); + ASSERT_TRUE(snappy::Uncompress(ptr, com_len1, &uncompress_str)); ptr = const_cast(append_string.c_str()); - ASSERT_TRUE(butil::snappy::Uncompress(ptr, strlen(ptr), &uncompress_str_t)); + ASSERT_TRUE(snappy::Uncompress(ptr, strlen(ptr), &uncompress_str_t)); delete [] text; }