quickstep-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From zu...@apache.org
Subject [46/52] [partial] incubator-quickstep git commit: Make the third party directory leaner.
Date Sun, 29 Jan 2017 02:08:20 GMT
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 – 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() {}


Mime
View raw message