FT-248 Remove dead code from tools/

tools/CMakeLists.txt

 set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS _GNU_SOURCE DONT_DEPRECATE_ERRNO)
 
-set(utils tokudb_gen tokudb_load tokudb_dump)
+set(utils tokudb_dump)
 foreach(util ${utils})
   add_executable(${util} ${util})
-  set_target_properties(${util} PROPERTIES
-    COMPILE_DEFINITIONS "IS_TDB=1;USE_TDB=1;TDB_IS_STATIC=1")
   target_link_libraries(${util} ${LIBTOKUDB}_static ft_static z lzma ${LIBTOKUPORTABILITY}_static ${CMAKE_THREAD_LIBS_INIT} ${EXTRA_SYSTEM_LIBS})
 
   add_space_separated_property(TARGET ${util} COMPILE_FLAGS -fvisibility=hidden)

tools/parseTraceFiles.py

-#!/usr/bin/env python
-
-import sys
-try:
-    data = open(sys.argv[1])
-except:
-    print "Could not open '%s'" % (sys.argv[1][0])
-    exit(0)
-
-ts_factor = 1.
-ts_prev = 0.
-
-threadlist = []
-
-for line in data:
-    line = line.rstrip("\n")
-    vals = line.split()
-    [n, tid, ts, funcline] = vals[0:4]
-    # 'note' is all text following funcline
-    note = ''
-    for v in vals[4:-1]:
-        note += v+' '
-    note += vals[-1]
-
-    if ( note == 'calibrate done' ):
-        ts_factor = float(ts) - ts_prev
-        print "Factor = ", ts_factor, "("+str(ts_factor/1000000000)[0:4]+"GHz)"
-
-    time = (float(ts)-ts_prev)/ts_factor
-
-    # create a list of threads
-    #  - each thread has a list of <note,time> pairs, where time is the accumulated time for that note
-    #  - search threadlist for thread_id (tid)
-    #      - if found, search corresponding list of <note,time> pairs for the current note
-    #             - if found, update (+=) the time
-    #             - if not found, create a new <note,time> pair
-    #      - if not found, create a new thread,<note,time> entry
-    found_thread = 0
-    for thread in threadlist:
-        if tid == thread[0]:
-            found_thread = 1
-            notetimelist = thread[1]
-            found_note = 0
-            for notetime in notetimelist:
-                if note == notetime[0]:
-                    found_note = 1
-                    notetime[1] += time
-                    break
-            if found_note == 0:
-                thread[1].append([note, time])
-            break
-    if found_thread == 0:
-        notetime = []
-        notetime.append([note, time])
-        threadlist.append([tid, notetime])
-
-    ts_prev = float(ts)
-
-# trim out unneeded
-for thread in threadlist:
-    trimlist = []
-    for notetime in thread[1]:
-        if notetime[0][0:9] == 'calibrate':
-            trimlist.append(notetime)
-    for notetime in trimlist:
-        thread[1].remove(notetime)
-print ''
-
-# sum times to calculate percent (of 100)
-total_time = 0
-for thread in threadlist:
-    for [note, time] in thread[1]:
-        total_time += time
-
-print '    thread         operation      time(sec)   percent'
-for thread in threadlist:
-    print 'tid : %5s' % thread[0]
-    for [note, time] in thread[1]:
-        print '           %20s    %f %5d' % (note, time, 100. * time/total_time)
-
-
-    

tools/tokudb_common.h

-/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*- */
-// vim: ft=cpp:expandtab:ts=8:sw=4:softtabstop=4:
-#ident "$Id$"
-
-/*
-COPYING CONDITIONS NOTICE:
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of version 2 of the GNU General Public License as
-  published by the Free Software Foundation, and provided that the
-  following conditions are met:
-
-      * Redistributions of source code must retain this COPYING
-        CONDITIONS NOTICE, the COPYRIGHT NOTICE (below), the
-        DISCLAIMER (below), the UNIVERSITY PATENT NOTICE (below), the
-        PATENT MARKING NOTICE (below), and the PATENT RIGHTS
-        GRANT (below).
-
-      * Redistributions in binary form must reproduce this COPYING
-        CONDITIONS NOTICE, the COPYRIGHT NOTICE (below), the
-        DISCLAIMER (below), the UNIVERSITY PATENT NOTICE (below), the
-        PATENT MARKING NOTICE (below), and the PATENT RIGHTS
-        GRANT (below) in the documentation and/or other materials
-        provided with the distribution.
-
-  You should have received a copy of the GNU General Public License
-  along with this program; if not, write to the Free Software
-  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-  02110-1301, USA.
-
-COPYRIGHT NOTICE:
-
-  TokuDB, Tokutek Fractal Tree Indexing Library.
-  Copyright (C) 2007-2013 Tokutek, Inc.
-
-DISCLAIMER:
-
-  This program is distributed in the hope that it will be useful, but
-  WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  General Public License for more details.
-
-UNIVERSITY PATENT NOTICE:
-
-  The technology is licensed by the Massachusetts Institute of
-  Technology, Rutgers State University of New Jersey, and the Research
-  Foundation of State University of New York at Stony Brook under
-  United States of America Serial No. 11/760379 and to the patents
-  and/or patent applications resulting from it.
-
-PATENT MARKING NOTICE:
-
-  This software is covered by US Patent No. 8,185,551.
-  This software is covered by US Patent No. 8,489,638.
-
-PATENT RIGHTS GRANT:
-
-  "THIS IMPLEMENTATION" means the copyrightable works distributed by
-  Tokutek as part of the Fractal Tree project.
-
-  "PATENT CLAIMS" means the claims of patents that are owned or
-  licensable by Tokutek, both currently or in the future; and that in
-  the absence of this license would be infringed by THIS
-  IMPLEMENTATION or by using or running THIS IMPLEMENTATION.
-
-  "PATENT CHALLENGE" shall mean a challenge to the validity,
-  patentability, enforceability and/or non-infringement of any of the
-  PATENT CLAIMS or otherwise opposing any of the PATENT CLAIMS.
-
-  Tokutek hereby grants to you, for the term and geographical scope of
-  the PATENT CLAIMS, a non-exclusive, no-charge, royalty-free,
-  irrevocable (except as stated in this section) patent license to
-  make, have made, use, offer to sell, sell, import, transfer, and
-  otherwise run, modify, and propagate the contents of THIS
-  IMPLEMENTATION, where such license applies only to the PATENT
-  CLAIMS.  This grant does not include claims that would be infringed
-  only as a consequence of further modifications of THIS
-  IMPLEMENTATION.  If you or your agent or licensee institute or order
-  or agree to the institution of patent litigation against any entity
-  (including a cross-claim or counterclaim in a lawsuit) alleging that
-  THIS IMPLEMENTATION constitutes direct or contributory patent
-  infringement, or inducement of patent infringement, then any rights
-  granted to you under this License shall terminate as of the date
-  such litigation is filed.  If you or your agent or exclusive
-  licensee institute or order or agree to the institution of a PATENT
-  CHALLENGE, then Tokutek may terminate any rights granted to you
-  under this License.
-*/
-
-#pragma once
-
-#ident "Copyright (c) 2007-2013 Tokutek Inc.  All rights reserved."
-
-#include <stdlib.h>
-#include <stdint.h>
-#include <limits.h>
-#include <db.h>
-#include <inttypes.h>
-#include <signal.h>
-#include <memory.h>
-
-#define SET_BITS(bitvector, bits)      ((bitvector) |= (bits))
-#define REMOVE_BITS(bitvector, bits)   ((bitvector) &= ~(bits))
-#define IS_SET_ANY(bitvector, bits)    ((bitvector) & (bits))
-#define IS_SET_ALL(bitvector, bits)    (((bitvector) & (bits)) == (bits))
-
-#define IS_POWER_OF_2(num)             ((num) > 0 && ((num) & ((num) - 1)) == 0)

tools/tokudb_dump.cc

@@ -88,6 +88,10 @@ PATENT RIGHTS GRANT:
 
 #ident "Copyright (c) 2007, 2008 Tokutek Inc.  All rights reserved."
 
+#include <db.h>
+
+#include <toku_stdlib.h>
+#include <toku_stdint.h>
 #include <toku_portability.h>
 #include <toku_assert.h>
 #include <stdio.h>
@@ -97,8 +101,8 @@ PATENT RIGHTS GRANT:
 #include <ctype.h>
 #include <errno.h>
 #include <getopt.h>
-#include <db.h>
-#include "tokudb_common.h"
+#include <signal.h>
+#include <memory.h>
 
 typedef struct {
    bool     leadingspace;
@@ -120,7 +124,245 @@ typedef struct {
 } dump_globals;
 
 dump_globals g;
-#include "tokudb_common_funcs.h"
+
+#define SET_BITS(bitvector, bits)      ((bitvector) |= (bits))
+#define REMOVE_BITS(bitvector, bits)   ((bitvector) &= ~(bits))
+#define IS_SET_ANY(bitvector, bits)    ((bitvector) & (bits))
+#define IS_SET_ALL(bitvector, bits)    (((bitvector) & (bits)) == (bits))
+
+#define IS_POWER_OF_2(num)             ((num) > 0 && ((num) & ((num) - 1)) == 0)
+
+//DB_ENV->err disabled since it does not use db_strerror
+#define PRINT_ERROR(retval, ...)                                  \
+do {                                                              \
+if (0) g.dbenv->err(g.dbenv, retval, __VA_ARGS__);                \
+else {                                                            \
+   fprintf(stderr, "\tIn %s:%d %s()\n", __FILE__, __LINE__, __FUNCTION__); \
+   fprintf(stderr, "%s: %s:", g.progname, db_strerror(retval));   \
+   fprintf(stderr, __VA_ARGS__);                                  \
+   fprintf(stderr, "\n");                                         \
+   fflush(stderr);                                                \
+}                                                                 \
+} while (0)
+
+//DB_ENV->err disabled since it does not use db_strerror, errx does not exist.
+#define PRINT_ERRORX(...)                                               \
+do {                                                              \
+if (0) g.dbenv->err(g.dbenv, 0, __VA_ARGS__);                     \
+else {                                                            \
+   fprintf(stderr, "\tIn %s:%d %s()\n", __FILE__, __LINE__, __FUNCTION__); \
+   fprintf(stderr, "%s: ", g.progname);                           \
+   fprintf(stderr, __VA_ARGS__);                                  \
+   fprintf(stderr, "\n");                                         \
+   fflush(stderr);                                                \
+}                                                                 \
+} while (0)
+
+int   strtoint32  (char* str,  int32_t* num,  int32_t min,  int32_t max, int base);
+int   strtouint32 (char* str, uint32_t* num, uint32_t min, uint32_t max, int base);
+int   strtoint64  (char* str,  int64_t* num,  int64_t min,  int64_t max, int base);
+int   strtouint64 (char* str, uint64_t* num, uint64_t min, uint64_t max, int base);
+
+/*
+ * Convert a string to an integer of type "type".
+ *
+ *
+ * Sets errno and returns:
+ *    EINVAL: str == NULL, num == NULL, or string not of the form [ \t]*[+-]?[0-9]+
+ *    ERANGE: value out of range specified. (Range of [min, max])
+ *
+ * *num is unchanged on error.
+ * Returns:
+ *
+ */
+#define DEF_STR_TO(name, type, bigtype, strtofunc, frmt)       \
+int name(char* str, type* num, type min, type max, int base)   \
+{                                                              \
+   char* test;                                                 \
+   bigtype value;                                              \
+                                                               \
+   assert(str);                                                \
+   assert(num);                                                \
+   assert(min <= max);                                         \
+   assert(g.dbenv || g.progname);                              \
+   assert(base == 0 || (base >= 2 && base <= 36));             \
+                                                               \
+   errno = 0;                                                  \
+   while (isspace(*str)) str++;                                \
+   value = strtofunc(str, &test, base);                        \
+   if ((*test != '\0' && *test != '\n') || test == str) {      \
+      PRINT_ERRORX("%s: Invalid numeric argument\n", str);           \
+      errno = EINVAL;                                          \
+      goto error;                                              \
+   }                                                           \
+   if (errno != 0) {                                           \
+      PRINT_ERROR(errno, "%s\n", str);                               \
+   }                                                           \
+   if (value < min) {                                          \
+      PRINT_ERRORX("%s: Less than minimum value (%" frmt ")\n", str, min); \
+      goto error;                                              \
+   }                                                           \
+   if (value > max) {                                          \
+      PRINT_ERRORX("%s: Greater than maximum value (%" frmt ")\n", str, max); \
+      goto error;                                              \
+   }                                                           \
+   *num = value;                                               \
+   return EXIT_SUCCESS;                                        \
+error:                                                         \
+   return errno;                                               \
+}
+
+DEF_STR_TO(strtoint32,  int32_t,  int64_t,  strtoll,  PRId32)
+DEF_STR_TO(strtouint32, uint32_t, uint64_t, strtoull, PRIu32)
+DEF_STR_TO(strtoint64,  int64_t,  int64_t,  strtoll,  PRId64)
+DEF_STR_TO(strtouint64, uint64_t, uint64_t, strtoull, PRIu64)
+
+static inline void
+outputbyte(uint8_t ch)
+{
+   if (g.plaintext) {
+      if (ch == '\\')         printf("\\\\");
+      else if (isprint(ch))   printf("%c", ch);
+      else                    printf("\\%02x", ch);
+   }
+   else printf("%02x", ch);
+}
+
+static inline void
+outputstring(char* str)
+{
+   char* p;
+
+   for (p = str; *p != '\0'; p++) {
+      outputbyte((uint8_t)*p);
+   }
+}
+
+static inline void
+outputplaintextstring(char* str)
+{
+   bool old_plaintext = g.plaintext;
+   g.plaintext = true;
+   outputstring(str);
+   g.plaintext = old_plaintext;
+}
+
+static inline int
+hextoint(int ch)
+{
+   if (ch >= '0' && ch <= '9') {
+      return ch - '0';
+   }
+   if (ch >= 'a' && ch <= 'z') {
+      return ch - 'a' + 10;
+   }
+   if (ch >= 'A' && ch <= 'Z') {
+      return ch - 'A' + 10;
+   }
+   return EOF;
+}
+
+static inline int
+printabletocstring(char* inputstr, char** poutputstr)
+{
+   char highch;
+   char lowch;
+   char nextch;
+   char* cstring;
+
+   assert(inputstr);
+   assert(poutputstr);
+   assert(*poutputstr == NULL);
+
+   cstring = (char*)toku_malloc((strlen(inputstr) + 1) * sizeof(char));
+   if (cstring == NULL) {
+      PRINT_ERROR(errno, "printabletocstring");
+      goto error;
+   }
+
+   for (*poutputstr = cstring; *inputstr != '\0'; inputstr++) {
+      if (*inputstr == '\\') {
+         if ((highch = *++inputstr) == '\\') {
+            *cstring++ = '\\';
+            continue;
+         }
+         if (highch == '\0' || (lowch = *++inputstr) == '\0') {
+            PRINT_ERROR(0, "unexpected end of input data or key/data pair");
+            goto error;
+         }
+         if (!isxdigit(highch)) {
+            PRINT_ERROR(0, "Unexpected '%c' (non-hex) input.\n", highch);
+            goto error;
+         }
+         if (!isxdigit(lowch)) {
+            PRINT_ERROR(0, "Unexpected '%c' (non-hex) input.\n", lowch);
+            goto error;
+         }
+         nextch = (char)((hextoint(highch) << 4) | hextoint(lowch));
+         if (nextch == '\0') {
+            /* Database names are c strings, and cannot have extra NULL terminators. */
+            PRINT_ERROR(0, "Unexpected '\\00' in input.\n");
+            goto error;
+         }
+         *cstring++ = nextch;
+      }
+      else *cstring++ = *inputstr;
+   }
+   /* Terminate the string. */
+   *cstring = '\0';
+   return EXIT_SUCCESS;
+
+error:
+   PRINT_ERROR(0, "Quitting out due to errors.\n");
+   return EXIT_FAILURE;
+}
+
+static inline int
+verify_library_version(void)
+{
+   int major;
+   int minor;
+   
+   db_version(&major, &minor, NULL);
+   if (major != DB_VERSION_MAJOR || minor != DB_VERSION_MINOR) {
+      PRINT_ERRORX("version %d.%d doesn't match library version %d.%d\n",
+             DB_VERSION_MAJOR, DB_VERSION_MINOR, major, minor);
+      return EXIT_FAILURE;
+   }
+   return EXIT_SUCCESS;
+}
+
+static int last_caught = 0;
+
+static void catch_signal(int which_signal) {
+    last_caught = which_signal;
+    if (last_caught == 0) last_caught = SIGINT;
+}
+
+static inline void
+init_catch_signals(void) {
+    signal(SIGINT, catch_signal);
+    signal(SIGTERM, catch_signal);
+#ifdef SIGHUP
+    signal(SIGHUP, catch_signal);
+#endif
+#ifdef SIGPIPE
+    signal(SIGPIPE, catch_signal);
+#endif
+}
+
+static inline int
+caught_any_signals(void) {
+    return last_caught != 0;
+}
+
+static inline void
+resend_signals(void) {
+    if (last_caught) {
+        signal(last_caught, SIG_DFL);
+        raise(last_caught);
+    }
+}
 
 static int   usage          (void);
 static int   create_init_env(void);
@@ -131,7 +373,7 @@ static int   dump_footer    (void);
 static int   dump_header    (void);
 static int   close_database (void);
 
-int test_main(int argc, char *const argv[]) {
+int main(int argc, char *const argv[]) {
    int ch;
    int retval;