You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by ji...@apache.org on 2017/01/31 07:05:51 UTC
[46/62] [abbrv] [partial] incubator-quickstep git commit: Make the
third party directory leaner.
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/cpplint/lint_everything.py
----------------------------------------------------------------------
diff --git a/third_party/cpplint/lint_everything.py b/third_party/cpplint/lint_everything.py
deleted file mode 100755
index 75aa2d4..0000000
--- a/third_party/cpplint/lint_everything.py
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env python2
-
-import os
-import subprocess
-import sys
-
-EXCLUDED_PREFIXES = ['./.', './third_party', './build', './parser/preprocessed']
-
-call_args = ['/usr/bin/env', 'python2', './third_party/cpplint/cpplint.py']
-
-print "Running cpplint on entire source tree. This may take a minute or two..."
-
-for (dirpath, dirnames, filenames) in os.walk('.'):
- filtered = False
- for prefix in EXCLUDED_PREFIXES:
- if dirpath.startswith(prefix):
- filtered = True
- if not filtered:
- for filename in filenames:
- if filename.endswith('.hpp') or filename.endswith('.cpp'):
- call_args.append(dirpath + '/' + filename)
-
-sys.exit(subprocess.call(call_args))
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/download_and_patch_prerequisites.sh
----------------------------------------------------------------------
diff --git a/third_party/download_and_patch_prerequisites.sh b/third_party/download_and_patch_prerequisites.sh
new file mode 100755
index 0000000..e63db23
--- /dev/null
+++ b/third_party/download_and_patch_prerequisites.sh
@@ -0,0 +1,106 @@
+#!/bin/bash
+
+# Check if the prerequisite bash programs exist on the system.
+for cmd in curl tar; do
+ echo -n "Checking if ${cmd} is present ..."
+ if ! hash ${cmd} 2>/dev/null; then
+ echo ""
+ echo "ERROR: Program ${cmd} is not installed on the system."
+ exit 1
+ else
+ echo "ok"
+ fi
+done
+
+THIRD_PARTY_DIR=`pwd`
+if [ "${PWD##*/}" != "third_party" ]; then
+ echo "ERROR: This script can be run only from the third party directory"
+ exit 1
+fi
+
+THIRD_PARTY_SRC_DIR=${THIRD_PARTY_DIR}/src
+if [ ! -d "$THIRD_PARTY_SRC_DIR" ]; then
+ mkdir -p ${THIRD_PARTY_SRC_DIR}
+fi
+
+PATCH_DIR=${THIRD_PARTY_DIR}/patches
+cd src/
+
+third_party_dir_names=("benchmark"
+ "gflags"
+ "googletest"
+ "linenoise"
+ "re2"
+ "gperftools"
+ )
+
+third_party_lib_urls=("https://github.com/google/benchmark/archive/v1.1.0.tar.gz"
+ "https://github.com/gflags/gflags/archive/v2.2.0.tar.gz"
+ "https://github.com/google/googletest/archive/release-1.8.0.tar.gz"
+ "https://github.com/antirez/linenoise/archive/1.0.tar.gz"
+ "https://github.com/google/re2/archive/2017-01-01.tar.gz"
+ "https://github.com/gperftools/gperftools/releases/download/gperftools-2.5/gperftools-2.5.tar.gz"
+ )
+
+downloaded_archive_names=("v1.1.0.tar.gz"
+ "v2.2.0.tar.gz"
+ "release-1.8.0.tar.gz"
+ "1.0.tar.gz"
+ "2017-01-01.tar.gz"
+ "gperftools-2.5.tar.gz"
+ )
+
+tar_options=("-xzf"
+ "-xzf"
+ "-xzf"
+ "-xzf"
+ "-xzf"
+ "-xzf"
+ )
+
+for ((lib_index=0; lib_index < ${#third_party_dir_names[*]}; lib_index++))
+do
+ # If the third party directory is not present, create it.
+ if [ ! -d ${third_party_dir_names[lib_index]} ]; then
+ mkdir ${third_party_dir_names[lib_index]}
+ fi
+
+ # Downaload the compressed archive for the third party library.
+ curl_cmd="curl -L -O ${third_party_lib_urls[lib_index]}"
+ echo "Downloading from ${third_party_lib_urls[lib_index]} ..."
+ echo ${curl_cmd}
+ eval ${curl_cmd}
+ if [ -f ${downloaded_archive_names[lib_index]} ]; then
+ echo "File ${downloaded_archive_names[lib_index]} downloaded successfully"
+
+ # Uncompress the archive to its designated directory.
+ # The strip-components option will ensure that all the files directly end up
+ # in the desired directory, without any intermediate hierarchy level.
+ tar_cmd="tar ${tar_options[lib_index]} ${downloaded_archive_names[lib_index]} -C ${third_party_dir_names[lib_index]} --strip-components=1"
+ echo ${tar_cmd}
+ echo "Extracting from ${downloaded_archive_names[lib_index]} ..."
+ eval ${tar_cmd}
+
+ # Delete the compressed archive.
+ rm -rf ${downloaded_archive_names[lib_index]}
+ else
+ echo "Error downloading file ${downloaded_archive_names[lib_index]} from ${third_party_lib_urls[lib_index]}"
+ fi
+done
+
+# Apply patches now.
+cp ${PATCH_DIR}/linenoise/CMakeLists.txt ${THIRD_PARTY_SRC_DIR}/linenoise
+
+# Apply re2 patch.
+cd ${THIRD_PARTY_SRC_DIR}/re2
+patch -p0 < ${PATCH_DIR}/re2/re2CMake.patch
+cd ${THIRD_PARTY_SRC_DIR}
+
+# Apply benchmark patches.
+cd ${THIRD_PARTY_SRC_DIR}/benchmark
+patch -p0 < ${PATCH_DIR}/benchmark/benchmarkCMake.patch
+cd ${THIRD_PARTY_SRC_DIR}/benchmark/src
+patch -p0 < ${PATCH_DIR}/benchmark/benchmarkSrcCMakeLists.patch
+
+# Back to the third_party directory.
+cd ${THIRD_PARTY_DIR}
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/farmhash/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/third_party/farmhash/CMakeLists.txt b/third_party/farmhash/CMakeLists.txt
deleted file mode 100644
index eac40de..0000000
--- a/third_party/farmhash/CMakeLists.txt
+++ /dev/null
@@ -1,54 +0,0 @@
-include(CheckCXXSourceCompiles)
-
-# Compile FarmHash with C++11 support.
-set_property(
- DIRECTORY
- APPEND PROPERTY COMPILE_DEFINITIONS FARMHASH_CAN_USE_CXX11
-)
-
-# Check if __builtin_expect is available.
-CHECK_CXX_SOURCE_COMPILES("
- int main(int argc, char **argv) {
- if (__builtin_expect(argc, 1)) {
- return 0;
- } else {
- return argc;
- }
- }
-" HAVE_BUILTIN_EXPECT)
-if (NOT HAVE_BUILTIN_EXPECT)
- set_property(
- DIRECTORY
- APPEND PROPERTY COMPILE_DEFINITIONS FARMHASH_NO_BUILTIN_EXPECT
- )
-endif()
-
-# Check endianness.
-include(TestBigEndian)
-TEST_BIG_ENDIAN(WORDS_BIGENDIAN)
-if (WORDS_BIGENDIAN)
- set_property(
- DIRECTORY
- APPEND PROPERTY COMPILE_DEFINITIONS WORDS_BIGENDIAN
- )
-endif()
-
-# TODO(chasseur): FarmHash conditionally compiles fast versions of hash
-# functions that use SSSE3, SSE4.1, SSE4.2, AES-NI, and AVX, where available,
-# which are turned on based on preprocessor macros defined by GCC and other
-# similar compilers (e.g. Clang, ICC) when those instructions sets are usable.
-# MSVC sets __AVX__ when AVX is available, but does NOT set symbols for any
-# other instruction set extensions optionally used by FarmHash, so building
-# with MSVC will fall back on generic x86 versions of some internal hashing
-# functions. Try to work out a portable way of detecting the other extensions
-# and enabling them under MSVC.
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-add_library(farmhash farmhash.cc)
-
-# Supress GCC warnings about overflow in farmhash only.
-include(CheckCXXCompilerFlag)
-CHECK_CXX_COMPILER_FLAG("-Wno-overflow" COMPILER_HAS_WNO_OVERFLOW)
-if (COMPILER_HAS_WNO_OVERFLOW)
- set_target_properties(farmhash PROPERTIES COMPILE_FLAGS "-Wno-overflow")
-endif()
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/farmhash/COPYING
----------------------------------------------------------------------
diff --git a/third_party/farmhash/COPYING b/third_party/farmhash/COPYING
deleted file mode 100644
index 8176e66..0000000
--- a/third_party/farmhash/COPYING
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright (c) 2014 Google, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/farmhash/NEWS
----------------------------------------------------------------------
diff --git a/third_party/farmhash/NEWS b/third_party/farmhash/NEWS
deleted file mode 100644
index 1732717..0000000
--- a/third_party/farmhash/NEWS
+++ /dev/null
@@ -1,19 +0,0 @@
-FarmHash v1.1, March 1, 2015
-
- * Added a new 64-bit hash function (namespace farmhashte) that is
- substantially faster for long strings. It requires SSE4.1. If
- AVX instructions are available then it should be slightly faster (e.g.,
- use g++ -mavx).
- * Added a 32-bit hash function trivially derived from the above. Useful
- on CPUs with SSE4.1 or AVX.
- * Added new 64-bit hash functions derived from FarmHash v1.0
- (namespaces farmhashuo and farmhashxo). My testing suggests that for
- some string lengths these are speedier than the old standby (farmhashna).
- * Compiling with FARMHASH_NO_BUILTIN_EXPECT defined will now eliminate
- FarmHash's usage of __builtin_expect. Thanks to Cory Riddell for
- suggesting this.
- * Improved some comments, the README, etc.
-
-FarmHash v1.0, March 31, 2014
-
- * Initial release
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/farmhash/README
----------------------------------------------------------------------
diff --git a/third_party/farmhash/README b/third_party/farmhash/README
deleted file mode 100644
index 146936d..0000000
--- a/third_party/farmhash/README
+++ /dev/null
@@ -1,163 +0,0 @@
-FarmHash, a family of hash functions.
-Version 1.1
-
-Introduction
-============
-
-A general overview of hash functions and their use is available in the file
-Understanding_Hash_Functions in this directory. It may be helpful to read it
-before using FarmHash.
-
-FarmHash provides hash functions for strings and other data. The functions
-mix the input bits thoroughly but are not suitable for cryptography. See
-"Hash Quality," below, for details on how FarmHash was tested and so on.
-
-We provide reference implementations in C++, with a friendly MIT license.
-
-All members of the FarmHash family were designed with heavy reliance on
-previous work by Jyrki Alakuijala, Austin Appleby, Bob Jenkins, and others.
-
-
-Recommended Usage
-=================
-
-Our belief is that the typical hash function is mostly used for in-memory hash
-tables and similar. That use case allows hash functions that differ on
-different platforms, and that change from time to time. For this, I recommend
-using wrapper functions in a .h file with comments such as, "may change from
-time to time, may differ on different platforms, and may change depending on
-NDEBUG."
-
-Some projects may also require a forever-fixed, portable hash function. Again
-we recommend using wrapper functions in a .h, but in this case the comments on
-them would be very different.
-
-We have provided a sample of these wrapper functions in src/farmhash.h. Our
-hope is that most people will need nothing more than src/farmhash.h and
-src/farmhash.cc. Those two files are a usable and relatively portable library.
-(One portability snag: if your compiler doesn't have __builtin_expect then
-you may need to define FARMHASH_NO_BUILTIN_EXPECT.) For those that prefer
-using a configure script (perhaps because they want to "make install" later),
-FarmHash has one, but for many people it's best to ignore it.
-
-Note that the wrapper functions such as Hash() in src/farmhash.h can select
-one of several hash functions. The selection is done at compile time, based
-on your machine architecture (e.g., sizeof(size_t)) and the availability of
-vector instructions (e.g., SSE4.1).
-
-To get the best performance from FarmHash, one will need to think a bit about
-when to use compiler flags that allow vector instructions and such: -maes,
--msse4.2, -mavx, etc., or their equivalents for other compilers. Those are
-the g++ flags that make g++ emit more types of machine instructions than it
-otherwise would. For example, if you are confident that you will only be
-using FarmHash on systems with SSE4.2 and/or AES, you may communicate that to
-the compiler as explained in src/farmhash.cc. If not, use -maes, -mavx, etc.,
-when you can, and the appropriate choices will be made by via conditional
-compilation in src/farmhash.cc.
-
-It may be beneficial to try -O3 or other compiler flags as well. I also have
-found feedback-directed optimization (FDO) to improve the speed of FarmHash.
-
-The "configure" script: creating config.h
-=========================================
-
-We provide reference implementations of several FarmHash functions, written in
-C++. The build system is based on autoconf. It defaults the C++ compiler
-flags to "-g -O2", which may or may not be best.
-
-If you are planning to use the configure script, I generally recommend
-trying this first, unless you know that your system lacks AVX and/or AESNI:
-
- ./configure CXXFLAGS="-g -mavx -maes -O3"
- make all check
-
-If that fails, you can retry with -mavx and/or -maes removed, or with -mavx replaced by
--msse4.1 or -msse4.2.
-
-Please see below for thoughts on cross-platform testing, if that is a concern.
-Finally, if you want to install a library, you may use
-
- make install
-
-Some useful flags for configure include:
-
- --enable-optional-builtin-expect: This causes __builtin_expect to be optional.
- If you don't use this flag, the assumption is that FarmHash will be compiled
- with compilers that provide __builtin_expect. In practice, some FarmHash
- variants may be slightly faster if __builtin_expect is available, but it
- isn't very important and affects speed only.
-
-Further Details
-===============
-
-The above instructions will produce a single source-level library that
-includes multiple hash functions. It will use conditional compilation, and
-perhaps GCC's multiversioning, to select among the functions. In addition,
-"make all check" will create an object file using your chosen compiler, and
-test it. The object file won't necessarily contain all the code that would be
-used if you were to compile the code on other platforms. The downside of this
-is obvious: the paths not tested may not actually work if and when you try
-them. The FarmHash developers try hard to prevent such problems; please let
-us know if you find bugs.
-
-To aid your cross-platform testing, for each relevant platform you may
-compile your program that uses farmhash.cc with the preprocessor flag
-FARMHASHSELFTEST equal to 1. This causes a FarmHash self test to run
-at program startup; the self test writes output to stdout and then
-calls std::exit(). You can see this in action by running "make check":
-see src/farm-test.cc for details.
-
-There's also a trivial workaround to force particular functions to be used:
-modify the wrapper functions in hash.h. You can prevent choices being made via
-conditional compilation or multiversioning by choosing FarmHash variants with
-names like farmhashaa::Hash32, farmhashab::Hash64, etc.: those compute the same
-hash function regardless of conditional compilation, multiversioning, or
-endianness. Consult their comments and ifdefs to learn their requirements: for
-example, they are not all guaranteed to work on all platforms.
-
-Known Issues
-============
-
-1) FarmHash was developed with little-endian architectures in mind. It should
-work on big-endian too, but less work has gone into optimizing for those
-platforms. To make FarmHash work properly on big-endian platforms you may
-need to modify the wrapper .h file and/or your compiler flags to arrange for
-FARMHASH_BIG_ENDIAN to be defined, though there is logic that tries to figure
-it out automatically.
-
-2) FarmHash's implementation is fairly complex.
-
-3) The techniques described in dev/INSTRUCTIONS to let hash function
-developers regenerate src/*.cc from dev/* are hacky and not so portable.
-
-Hash Quality
-============
-
-We like to test hash functions with SMHasher, among other things.
-SMHasher isn't perfect, but it seems to find almost any significant flaw.
-SMHasher is available at http://code.google.com/p/smhasher/
-
-SMHasher is designed to pass a 32-bit seed to the hash functions it tests.
-For our functions that accept a seed, we use the given seed directly (padded
-with zeroes as needed); for our functions that don't accept a seed, we hash
-the concatenation of the given seed and the input string.
-
-Some minor flaws in 32-bit and 64-bit functions are harmless, as we
-expect the primary use of these functions will be in hash tables. We
-may have gone slightly overboard in trying to please SMHasher and other
-similar tests, but we don't want anyone to choose a different hash function
-because of some minor issue reported by a quality test.
-
-If your setup is similar enough to mine, it's easy to use SMHasher and other
-tools yourself via the "builder" in the dev directory. See dev/INSTRUCTIONS.
-(Improvements to that directory are a relatively low priority, and code
-there is never going to be as portable as the other parts of FarmHash.)
-
-For more information
-====================
-
-http://code.google.com/p/farmhash/
-
-farmhash-discuss@googlegroups.com
-
-Please feel free to send us comments, questions, bug reports, or patches.
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/farmhash/Understanding_Hash_Functions
----------------------------------------------------------------------
diff --git a/third_party/farmhash/Understanding_Hash_Functions b/third_party/farmhash/Understanding_Hash_Functions
deleted file mode 100644
index 8d203c4..0000000
--- a/third_party/farmhash/Understanding_Hash_Functions
+++ /dev/null
@@ -1,162 +0,0 @@
-UNDERSTANDING HASH FUNCTIONS
-by Geoff Pike
-
-Version 0.2 --- early draft --- comments and questions welcome!
-References appear in square brackets.
-
-1 INTRODUCTION
-
-Hashing has proven tremendously useful in constructing various fast
-data structures and algorithms. It is typically possible to simplify
-the analysis of hash-based algorithms if one assumes that the relevant
-hash functions are high quality. At the other extreme, if the
-relevant hash functions were always to return the same value, many
-hash-based algorithms become algorithms that are slower, simpler, but still well-known.
-For example, a chaining hash table devolves into a linked list.
-
-There are many possible definitions of hash function quality. For
-example, one might want a list of keys and their hashes to provide no
-pattern that would allow an opponent to predict anything about the
-hashes of other keys. Although I cannot prove it, I think I can meet
-this and many other definitions of quality with
-
- f(s) = SHA-3(concatenation of z and s),
-
-where z is some secret string known only to me. This well-known trick
-provides, I think, more high-quality hash functions than anyone will
-need, though greater computational power in the future may push us to
-replace SHA-3 from time to time.
-
-In short, discussions about choosing a hash function are almost always
-discussions about speed, energy consumption, or similar. Concerns
-about hash quality are easy to fix, for a price.
-
-2 ANATOMY OF A HASH FUNCTION
-
-Hash functions that input strings of arbitrary length are written in
-terms of an internal state, S. In many cases the internal state is a
-fixed number of bits and will fit in machine registers. One generic
-sketch of a string hash is:
-
- let S = some initial value
- let c = the length of S in bits
- while (input is not exhausted) {
- let t = the next c bits of input (padded with zeroes if less than c remain)
- S = M(S xor t)
- }
- let n = the number of bytes hashed
- return F(S, n)
-
-where M is a hash function that inputs and outputs c bits, and F is a
-hash function that inputs c bits (plus, say, 64 for its second argument)
-and outputs however many bits one needs to return. In some sense we have
-reduced the string-hashing problem to two integer hashing problems.
-
-2.1 INTEGER HASHING TECHNIQUES
-
-A hash function that inputs and outputs the same number of bits, say,
-32, can use reversible bit-twiddling operations, each of which is
-"onto" in the mathematical sense. For example, multiplication by an
-odd constant is reversible, as all odd numbers are relatively prime to
-2^32. Other commonly used reversible operations include:
- o Adding or xoring a constant
- o Bitwise rotation or other bitwise permutations
- o bit j = (bit j) xor (bit k) for unequal constants j and k
- o "Shift mix": S = S xor (S >> k), where k is, say, 17
- o Replacing a fixed-length bit string with its cyclic redundancy
- checksum, perhaps via _mm_crc32_u32(f, <some constant>) [Pike]
-
-Each of the above is a "bad" hash function that inputs and outputs
-the same number of bits. One can simply compose two or more of those
-bad hash functions to construct a higher-quality hash function.
-
-One common quality goal for integer hashing (and string hashing) is
-that flipping the 19th bit, or any other small change, applied to
-multiple input keys, causes a seemingly unpredictable difference each
-time. Similarly, any change to an input should lead to a seemingly
-unpredictable selection of the output bits to flip.
-
-Therefore, if we want a high-quality hash function that inputs c bits
-and outputs fewer than c bits, we can simply truncate the output of a
-high-quality hash function that inputs and outputs c bits.
-
-To give a concrete example, here is Bob Jenkins' mix(), published in
-1996 [Jenkins]. Its input is 96 bits in three 32-bit variables, and its output
-is 96 bits. However, one may use a subset of the output bits, as every
-output bit is affected by every non-empty subset of the input bits.
-
- Input: a, b, and c
- Algorithm:
- a -= b; a -= c; a ^= (c>>13);
- b -= c; b -= a; b ^= (a<<8);
- c -= a; c -= b; c ^= (b>>13);
- a -= b; a -= c; a ^= (c>>12);
- b -= c; b -= a; b ^= (a<<16);
- c -= a; c -= b; c ^= (b>>5);
- a -= b; a -= c; a ^= (c>>3);
- b -= c; b -= a; b ^= (a<<10);
- c -= a; c -= b; c ^= (b>>15);
- Output: a, b, and c
-
-2.2 VARIATIONS ON STRING HASHING
-
-There are three variations on our initial sketch worth noting.
-
-First, for speed, one can special-case short inputs, as the CityHash
-and FarmHash algorithms do. The number of special cases can be
-reduced by using loads that may overlap: for example, a hash of a 9-
-to 16-byte string can be implemented by a hash that inputs two 8-byte
-values (the first 8 and last 8 bytes of the input string) and the string
-length [CityHash, FarmHash].
-
-Second, one may choose different means of incorporating input bits
-into the internal state. One example: the mixing of S and input bits
-may be interleaved with the mixing of parts of S and other parts of S.
-Another example: the input bits processed in a loop iteration might be
-xor'ed into multiple places in S, rather than just one, or might be
-hashed with each other before touching S [Murmur]. The advantages and
-disadvantages of these are unclear.
-
-Third, one may repeatedly "squeeze information" from S, by remixing it with
-itself and then revealing a subset of S. This is convenient when one would
-like a family of hash functions with different output lengths. A special
-case of the idea, called the "sponge construction," has been well studied and
-adopted by the authors of Keccak and others [SHA-3].
-
-3 HASH FUNCTIONS FOR HASH TABLES
-
-It isn't hard to find real-life examples where hash tables or the hash
-functions for them take more than 5% of a program's CPU time.
-Improvements to hash tables and their hash functions are therefore a
-classic example of software performance tuning. Unfortunately, the
-best choice may be platform-dependent, so to avoid writing your own
-collection of #ifdefs, please consider selecting something like the
-FarmHash family of hash functions, that supply decent
-platform-dependent logic for you.
-
-To tune a program, often one will replace an existing hash function with a
-faster, lower-quality hash function, despite the increased chance of unlucky
-or pathological performance problems. Clever algorithms can mitigate this
-risk. For example, hash tables can start with one hash function and then
-switch to another if things seem to be going poorly. Therefore, one should
-rarely plan to spend much CPU time on a secure hash function (such as SHA-3)
-or a near-universal hash function (such as VHASH) when seeking the best
-possible performance from a hash table. Against that, those types of hash
-functions can limit the risk of pathological performance problems when one is
-designing around typical hash-based algorithms that stick with a single hash
-function no matter how it behaves on the data at hand.
-
-4
-
-REFERENCES
-
-[Murmur] Appleby, Austin. https://code.google.com/p/smhasher,
- https://sites.google.com/site/murmurhash/
-[SMHasher] Appleby, Austin. https://code.google.com/p/smhasher
-[SHA-3] Bertoni, Guido, et al. http://keccak.noekeon.org/
-[Jenkins] Jenkins, Bob. http://burtleburtle.net/bob/hash/doobs.html
-[VHASH] Krovetz, Ted. Message authentication on 64-bit architectures. In
- Selected Areas of Cryptography \u2013 SAC 2006. Springer-Verlag, 2006.
-[CityHash] Pike, Geoff and Alakuijala, Jyrki. https://code.google.com/p/cityhash
-[FarmHash] Pike, Geoff. https://code.google.com/p/farmhash
-[Pike] Pike, Geoff. http://www.stanford.edu/class/ee380/Abstracts/121017-slides.pdf
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/9661f956/third_party/farmhash/farm-test.cc
----------------------------------------------------------------------
diff --git a/third_party/farmhash/farm-test.cc b/third_party/farmhash/farm-test.cc
deleted file mode 100644
index 91c9b6d..0000000
--- a/third_party/farmhash/farm-test.cc
+++ /dev/null
@@ -1,38 +0,0 @@
-// Copyright (c) 2014 Google, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-//
-// FarmHash, by Geoff Pike
-
-//
-// FarmHash, by Geoff Pike
-
-// Compiling farmhash.cc with FARMHASHSELFTEST to 1 causes self-test
-// code to run at program startup.
-#define FARMHASHSELFTEST 1
-
-// Turn off DebugTweak() and similar.
-#define FARMHASH_DEBUG 0
-
-// Make it easy to detect unavailable functions by forcing them to return 0.
-#define FARMHASH_DIE_IF_MISCONFIGURED do { return 0; } while (0)
-
-#include "farmhash.cc"
-
-int main() {}