melisa 0.1.0

data/ext/marisa/tools/cmdopt.cc

@@ -0,0 +1,298 @@
+#include <stdio.h>
+
+#include "cmdopt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+
+// Moves `optind' to the end and shifts other arguments.
+static void cmdopt_shift(cmdopt_t *h) {
+  int   i;
+  char *tmp;
+
+  tmp = h->argv[h->optind];
+  for (i = h->optind; i < h->argc - 1; i++) {
+    h->argv[i] = h->argv[i + 1];
+  }
+  h->argv[i] = tmp;
+
+  h->nextchar = NULL;
+  h->optnum--;
+}
+
+// Moves to the next argument.
+static void cmdopt_next(cmdopt_t *h) {
+  h->optind++;
+  h->nextchar = NULL;
+}
+
+// Checks if the current argument is an option or not.
+static int cmdopt_check(cmdopt_t *h) {
+  int         ret = 1;
+  const char *arg = h->argv[h->optind];
+
+  if (*arg++ != '-') {
+    return 0;
+  }
+
+  if (*arg == '-') {
+    arg++;
+    ret++;
+  }
+
+  return ret - (*arg == '\0');
+}
+
+// Gets an argument of the current option.
+static void cmdopt_getopt(cmdopt_t *h) {
+  // Moves to the next argument if the current argument has no more characters.
+  if (*h->nextchar == '\0') {
+    cmdopt_next(h);
+    h->nextchar = h->argv[h->optind];
+  }
+
+  // Checks whether the current option has an argument or not.
+  if (h->optind < h->optnum) {
+    h->optarg = h->nextchar;
+    cmdopt_next(h);
+  } else {
+    h->optarg = NULL;
+  }
+}
+
+// Searches an option.
+static int cmdopt_search(cmdopt_t *h) {
+  const char *ptr;
+
+  // Updates an option character.
+  h->optopt = *h->nextchar++;
+
+  for (ptr = h->optstring; *ptr != '\0'; ptr++) {
+    if (*ptr == h->optopt) {
+      // Gets an option argument if required.
+      if (ptr[1] == ':') {
+        cmdopt_getopt(h);
+
+        // Returns ':' if there is no argument.
+        if (h->optarg == NULL && ptr[2] != ':') {
+          return ':';
+        }
+      }
+      return h->optopt;
+    }
+  }
+
+  if (h->optopt == '-') {
+    cmdopt_next(h);
+    while (h->optind < h->optnum) {
+      cmdopt_shift(h);
+    }
+    return -1;
+  }
+
+  // Returns '?' if the option character is undefined.
+  return '?';
+}
+
+// Compares a long option with an argument and returns the length of the
+// matched prefix.
+static int cmdopt_match_len(const char *opt, const char *arg) {
+  int len = 0;
+
+  // Returns 0 if there is a mismatch.
+  while ((*arg != '\0') && (*arg != '=')) {
+    if (*arg++ != *opt++) {
+      return 0;
+    }
+    len++;
+  }
+
+  // Returns a negative value in case of a perfect match.
+  if ((*arg == '\0') || (*arg == '=')) {
+    return -len;
+  }
+
+  return len;
+}
+
+// Checks long options.
+static int cmdopt_match(cmdopt_t *h) {
+  int i, len;
+  int max = 0, max_optind = -1;
+
+  // Returns -1 if there are no long options.
+  if (h->longopts == NULL) {
+    return max_optind;
+  }
+
+  for (i = 0; h->longopts[i].name != NULL; i++) {
+    len = cmdopt_match_len(h->longopts[i].name, h->nextchar);
+    if (len < 0) {
+      // In case of a perfect match.
+      h->nextchar -= len;
+      return i;
+    } else if (len > max) {
+      // In case of a prefix match.
+      max = len;
+      max_optind = i;
+    } else if (len == max) {
+      // There are other candidates.
+      max_optind = -1;
+    }
+  }
+
+  // If there is no perfect match, adopts the longest one.
+  h->nextchar += max;
+  return max_optind;
+}
+
+// Gets an argument of a long option.
+static void cmdopt_getopt_long(cmdopt_t *h) {
+  if (*h->nextchar == '=') {
+    h->optarg = h->nextchar + 1;
+    cmdopt_next(h);
+  } else {
+    cmdopt_next(h);
+
+    // Checks whether there are more options or not.
+    if (h->optind < h->optnum) {
+      h->optarg = h->argv[h->optind];
+      cmdopt_next(h);
+    } else {
+      h->optarg = NULL;
+    }
+  }
+}
+
+// Searches long options.
+static int cmdopt_search_long(cmdopt_t *h) {
+  const cmdopt_option *option;
+
+  // Keeps the long option.
+  h->optlong = h->argv[h->optind];
+
+  // Gets the next option.
+  h->longindex = cmdopt_match(h);
+  if (h->longindex  < 0) {
+    cmdopt_next(h);
+    return '?';
+  }
+
+  // Gets an argument if required.
+  option = h->longopts + h->longindex;
+  if (option->has_arg) {
+    cmdopt_getopt_long(h);
+
+    // Return ':' if there are no more arguments.
+    if (h->optarg == NULL) {
+      return ':';
+    }
+  } else if (*h->nextchar == '=') {
+    // Returns '?' for an extra option argument.
+    cmdopt_getopt_long(h);
+    return '?';
+  }
+
+  // Overwrites a variable if specified in settings.
+  if (option->flag != NULL) {
+    *option->flag = option->val;
+    return 0;
+  }
+
+  return option->val;
+}
+
+// Analyze command line option.
+static int cmdopt_main(cmdopt_t *h) {
+  int type;
+
+  // Initializes the internal state.
+  h->optopt = 0;
+  h->optlong = NULL;
+  h->optarg = NULL;
+  h->longindex = 0;
+
+  while (h->optind < h->optnum) {
+    if (h->nextchar == NULL) {
+      // Checks whether the next argument is an option or not.
+      type = cmdopt_check(h);
+      if (type == 0) {
+        cmdopt_shift(h);
+      } else {
+        h->nextchar = h->argv[h->optind] + type;
+        if (type == 2) {
+          return cmdopt_search_long(h);
+        }
+      }
+    } else {
+      if (*h->nextchar == '\0') {
+        cmdopt_next(h);
+        continue;
+      }
+      // Searches an option string.
+      return cmdopt_search(h);
+    }
+  }
+
+  return -1;
+}
+
+// cmdopt_init() initializes a cmdopt_t for successive cmdopt_get()s.
+void cmdopt_init(cmdopt_t *h, int argc, char **argv,
+    const char *optstring, const cmdopt_option *longopts) {
+  static const char empty_optstring[] = "";
+
+  h->argc = argc;
+  h->argv = argv;
+  h->optnum = h->argc;
+
+  h->longopts = longopts;
+  h->optstring = (optstring != NULL) ? optstring : empty_optstring;
+
+  h->optind = 1;
+  h->nextchar = NULL;
+  h->optarg = NULL;
+  h->optopt = 0;
+  h->optlong = NULL;
+  h->opterr = 1;
+  h->longindex = 0;
+}
+
+// cmdopt_get() analyzes command line arguments and gets the next option.
+int cmdopt_get(cmdopt_t *h) {
+  int value = cmdopt_main(h);
+
+  // Prints a warning to the standard error stream if enabled.
+  if (h->opterr) {
+    if (value == ':') {
+      // Warning for a lack of an option argument.
+      if (h->optlong == NULL) {
+        fprintf(stderr, "option requires an argument -- %c\n", h->optopt);
+      } else {
+        fprintf(stderr, "option `--%s' requires an argument\n",
+            h->longopts[h->longindex].name);
+      }
+    } else if (value == '?') {
+      // Warning for an invalid option.
+      if (h->optlong == NULL) {
+        fprintf(stderr, "invalid option -- %c\n", h->optopt);
+      } else {
+        fprintf(stderr, "unrecognized option `%s'\n", h->optlong);
+      }
+    } else if ((value != -1) && (h->opterr == 2)) {
+      // Actually this is not for warning, but for debugging.
+      if (h->optlong == NULL) {
+        fprintf(stderr, "option with `%s' -- %c\n", h->optarg, h->optopt);
+      } else {
+        fprintf(stderr, "option `--%s' with `%s'\n",
+            h->longopts[h->longindex].name, h->optarg);
+      }
+    }
+  }
+  return value;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus

data/ext/marisa/tools/cmdopt.h

@@ -0,0 +1,58 @@
+#ifndef MARISA_CMDOPT_H_
+#define MARISA_CMDOPT_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct cmdopt_option_ {
+  // `name' specifies the name of this option.
+  // An array of options must be terminated with an option whose name == NULL.
+  const char *name;
+
+  // `has_name' specifies whether an option takes an argument or not.
+  // 0 specifies that this option does not have any argument.
+  // 1 specifies that this option has an argument.
+  // 2 specifies that this option may have an argument.
+  int  has_arg;
+
+  // `flag' specifies an integer variable which is overwritten by cmdopt_next()
+  // with its return value.
+  int *flag;
+
+  // `val' specifies a return value of cmdopt_next(). This value is returned
+  // when cmdopt_next() finds this option.
+  int  val;
+} cmdopt_option;
+
+typedef struct cmdopt_t_ {
+  // Command line arguments.
+  int    argc;
+  char **argv;
+
+  // Option settings.
+  const cmdopt_option *longopts;
+  const char          *optstring;
+
+  int   optind;     // Index of the next argument.
+  char *nextchar;   // Next character.
+  char *optarg;     // Argument of the last option.
+  int   optopt;     // Label of the last option.
+  char *optlong;    // Long option.
+  int   opterr;     // Warning level (0: nothing, 1: warning, 2: all).
+  int   longindex;  // Index of the last long option.
+  int   optnum;     // Number of options.
+} cmdopt_t;
+
+// cmdopt_init() initializes a cmdopt_t for successive cmdopt_next()s.
+void cmdopt_init(cmdopt_t *h, int argc, char **argv,
+    const char *optstring, const cmdopt_option *longopts);
+
+// cmdopt_get() analyzes command line arguments and gets the next option.
+int cmdopt_get(cmdopt_t *h);
+
+#ifdef  __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // MARISA_CMDOPT_H_

data/ext/marisa/tools/marisa-benchmark.cc

@@ -0,0 +1,418 @@
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <marisa.h>
+
+#include "cmdopt.h"
+
+namespace {
+
+int param_min_num_tries = 1;
+int param_max_num_tries = 5;
+marisa::TailMode param_tail_mode = MARISA_DEFAULT_TAIL;
+marisa::NodeOrder param_node_order = MARISA_DEFAULT_ORDER;
+marisa::CacheLevel param_cache_level = MARISA_DEFAULT_CACHE;
+bool param_with_predict = true;
+bool param_print_speed = true;
+
+class Clock {
+ public:
+  Clock() : cl_(std::clock()) {}
+
+  void reset() {
+    cl_ = std::clock();
+  }
+
+  double elasped() const {
+    std::clock_t cur = std::clock();
+    return 1.0 * (cur - cl_) / CLOCKS_PER_SEC;
+  }
+
+ private:
+  std::clock_t cl_;
+};
+
+void print_help(const char *cmd) {
+  std::cerr << "Usage: " << cmd << " [OPTION]... [FILE]...\n\n"
+      "Options:\n"
+      "  -N, --min-num-tries=[N]  limit the number of tries"
+      " [" << MARISA_MIN_NUM_TRIES << ", " << MARISA_MAX_NUM_TRIES
+      << "] (default: 1)\n"
+      "  -n, --max-num-tries=[N]  limit the number of tries"
+      " [" << MARISA_MIN_NUM_TRIES << ", " << MARISA_MAX_NUM_TRIES
+      << "] (default: 10)\n"
+      "  -t, --text-tail      build a dictionary with text TAIL (default)\n"
+      "  -b, --binary-tail    build a dictionary with binary TAIL\n"
+      "  -w, --weight-order   arrange siblings in weight order (default)\n"
+      "  -l, --label-order    arrange siblings in label order\n"
+      "  -c, --cache-level=[N]    specify the cache size"
+      " [1, 5] (default: 3)\n"
+      "  -P, --with-predict       include predictive search (default)\n"
+      "  -p, --without-predict    skip predictive search\n"
+      "  -S, --print-speed    print speed [1000 keys/s] (default)\n"
+      "  -s, --print-time     print time [ns/key]\n"
+      "  -h, --help           print this help\n"
+      << std::endl;
+}
+
+void print_config() {
+  std::cout << "Number of tries: " << param_min_num_tries
+      << " - " << param_max_num_tries << std::endl;
+
+  std::cout << "TAIL mode: ";
+  switch (param_tail_mode) {
+    case MARISA_TEXT_TAIL: {
+      std::cout << "Text mode" << std::endl;
+      break;
+    }
+    case MARISA_BINARY_TAIL: {
+      std::cout << "Binary mode" << std::endl;
+      break;
+    }
+  }
+
+  std::cout << "Node order: ";
+  switch (param_node_order) {
+    case MARISA_LABEL_ORDER: {
+      std::cout << "Ascending label order" << std::endl;
+      break;
+    }
+    case MARISA_WEIGHT_ORDER: {
+      std::cout << "Descending weight order" << std::endl;
+      break;
+    }
+  }
+
+  std::cout << "Cache level: ";
+  switch (param_cache_level) {
+    case MARISA_HUGE_CACHE: {
+      std::cout << "Huge cache" << std::endl;
+      break;
+    }
+    case MARISA_LARGE_CACHE: {
+      std::cout << "Large cache" << std::endl;
+      break;
+    }
+    case MARISA_NORMAL_CACHE: {
+      std::cout << "Normal cache" << std::endl;
+      break;
+    }
+    case MARISA_SMALL_CACHE: {
+      std::cout << "Small cache" << std::endl;
+      break;
+    }
+    case MARISA_TINY_CACHE: {
+      std::cout << "Tiny cache" << std::endl;
+      break;
+    }
+  }
+}
+
+void print_time_info(std::size_t num_keys, double elasped) {
+  if (param_print_speed) {
+    if (elasped == 0.0) {
+      std::printf(" %8s", "-");
+    } else {
+      std::printf(" %8.2f", num_keys / elasped / 1000.0);
+    }
+  } else {
+    if ((elasped == 0.0) || (num_keys == 0)) {
+      std::printf(" %8s", "-");
+    } else {
+      std::printf(" %8.1f", 1000000000.0 * elasped / num_keys);
+    }
+  }
+}
+
+void read_keys(std::istream &input, marisa::Keyset *keyset,
+    std::vector<float> *weights) {
+  std::string line;
+  while (std::getline(input, line)) {
+    const std::string::size_type delim_pos = line.find_last_of('\t');
+    float weight = 1.0F;
+    if (delim_pos != line.npos) {
+      char *end_of_value;
+      weight = (float)std::strtod(&line[delim_pos + 1], &end_of_value);
+      if (*end_of_value == '\0') {
+        line.resize(delim_pos);
+      }
+    }
+    keyset->push_back(line.c_str(), line.length());
+    weights->push_back(weight);
+  }
+}
+
+int read_keys(const char * const *args, std::size_t num_args,
+    marisa::Keyset *keyset, std::vector<float> *weights) {
+  if (num_args == 0) {
+    read_keys(std::cin, keyset, weights);
+  }
+  for (std::size_t i = 0; i < num_args; ++i) {
+    std::ifstream input_file(args[i], std::ios::binary);
+    if (!input_file) {
+      std::cerr << "error: failed to open: " << args[i] << std::endl;
+      return 10;
+    }
+    read_keys(input_file, keyset, weights);
+  }
+  std::cout << "Number of keys: " << keyset->size() << std::endl;
+  std::cout << "Total length: " << keyset->total_length() << std::endl;
+  return 0;
+}
+
+void benchmark_build(marisa::Keyset &keyset,
+    const std::vector<float> &weights, int num_tries, marisa::Trie *trie) {
+  for (std::size_t i = 0; i < keyset.size(); ++i) {
+    keyset[i].set_weight(weights[i]);
+  }
+  Clock cl;
+  trie->build(keyset, num_tries | param_tail_mode | param_node_order |
+      param_cache_level);
+  std::printf(" %10lu", (unsigned long)trie->io_size());
+  print_time_info(keyset.size(), cl.elasped());
+}
+
+void benchmark_lookup(const marisa::Trie &trie,
+    const marisa::Keyset &keyset) {
+  Clock cl;
+  marisa::Agent agent;
+  for (std::size_t i = 0; i < keyset.size(); ++i) {
+    agent.set_query(keyset[i].ptr(), keyset[i].length());
+    if (!trie.lookup(agent) || (agent.key().id() != keyset[i].id())) {
+      std::cerr << "error: lookup() failed" << std::endl;
+      return;
+    }
+  }
+  print_time_info(keyset.size(), cl.elasped());
+}
+
+void benchmark_reverse_lookup(const marisa::Trie &trie,
+    const marisa::Keyset &keyset) {
+  Clock cl;
+  marisa::Agent agent;
+  for (std::size_t i = 0; i < keyset.size(); ++i) {
+    agent.set_query(keyset[i].id());
+    trie.reverse_lookup(agent);
+    if ((agent.key().id() != keyset[i].id()) ||
+        (agent.key().length() != keyset[i].length()) ||
+        (std::memcmp(agent.key().ptr(), keyset[i].ptr(),
+            agent.key().length()) != 0)) {
+      std::cerr << "error: reverse_lookup() failed" << std::endl;
+      return;
+    }
+  }
+  print_time_info(keyset.size(), cl.elasped());
+}
+
+void benchmark_common_prefix_search(const marisa::Trie &trie,
+    const marisa::Keyset &keyset) {
+  Clock cl;
+  marisa::Agent agent;
+  for (std::size_t i = 0; i < keyset.size(); ++i) {
+    agent.set_query(keyset[i].ptr(), keyset[i].length());
+    while (trie.common_prefix_search(agent)) {
+      if (agent.key().id() > keyset[i].id()) {
+        std::cerr << "error: common_prefix_search() failed" << std::endl;
+        return;
+      }
+    }
+    if (agent.key().id() != keyset[i].id()) {
+      std::cerr << "error: common_prefix_search() failed" << std::endl;
+      return;
+    }
+  }
+  print_time_info(keyset.size(), cl.elasped());
+}
+
+void benchmark_predictive_search(const marisa::Trie &trie,
+    const marisa::Keyset &keyset) {
+  if (!param_with_predict) {
+    print_time_info(keyset.size(), 0.0);
+    return;
+  }
+
+  Clock cl;
+  marisa::Agent agent;
+  for (std::size_t i = 0; i < keyset.size(); ++i) {
+    agent.set_query(keyset[i].ptr(), keyset[i].length());
+    if (!trie.predictive_search(agent) ||
+        (agent.key().id() != keyset[i].id())) {
+      std::cerr << "error: predictive_search() failed" << std::endl;
+      return;
+    }
+    while (trie.predictive_search(agent)) {
+      if (agent.key().id() <= keyset[i].id()) {
+        std::cerr << "error: predictive_search() failed" << std::endl;
+        return;
+      }
+    }
+  }
+  print_time_info(keyset.size(), cl.elasped());
+}
+
+void benchmark(marisa::Keyset &keyset, const std::vector<float> &weights,
+    int num_tries) {
+  std::printf("%6d", num_tries);
+  marisa::Trie trie;
+  benchmark_build(keyset, weights, num_tries, &trie);
+  if (!trie.empty()) {
+    benchmark_lookup(trie, keyset);
+    benchmark_reverse_lookup(trie, keyset);
+    benchmark_common_prefix_search(trie, keyset);
+    benchmark_predictive_search(trie, keyset);
+  }
+  std::printf("\n");
+}
+
+int benchmark(const char * const *args, std::size_t num_args) try {
+  marisa::Keyset keyset;
+  std::vector<float> weights;
+  const int ret = read_keys(args, num_args, &keyset, &weights);
+  if (ret != 0) {
+    return ret;
+  }
+  std::printf("------+----------+--------+--------+"
+      "--------+--------+--------\n");
+  std::printf("%6s %10s %8s %8s %8s %8s %8s\n",
+      "#tries", "size", "build", "lookup", "reverse", "prefix", "predict");
+  std::printf("%6s %10s %8s %8s %8s %8s %8s\n",
+      "", "", "", "", "lookup", "search", "search");
+  if (param_print_speed) {
+    std::printf("%6s %10s %8s %8s %8s %8s %8s\n",
+        "", "[bytes]",
+        "[K/s]", "[K/s]", "[K/s]", "[K/s]", "[K/s]");
+  } else {
+    std::printf("%6s %10s %8s %8s %8s %8s %8s\n",
+        "", "[bytes]", "[ns]", "[ns]", "[ns]", "[ns]", "[ns]");
+  }
+  std::printf("------+----------+--------+--------+"
+      "--------+--------+--------\n");
+  for (int i = param_min_num_tries; i <= param_max_num_tries; ++i) {
+    benchmark(keyset, weights, i);
+  }
+  std::printf("------+----------+--------+--------+"
+      "--------+--------+--------\n");
+  return 0;
+} catch (const marisa::Exception &ex) {
+  std::cerr << ex.what() << std::endl;
+  return -1;
+}
+
+}  // namespace
+
+int main(int argc, char *argv[]) {
+  std::ios::sync_with_stdio(false);
+
+  ::cmdopt_option long_options[] = {
+    { "min-num-tries", 1, NULL, 'N' },
+    { "max-num-tries", 1, NULL, 'n' },
+    { "text-tail", 0, NULL, 't' },
+    { "binary-tail", 0, NULL, 'b' },
+    { "weight-order", 0, NULL, 'w' },
+    { "label-order", 0, NULL, 'l' },
+    { "cache-level", 1, NULL, 'c' },
+    { "predict-on", 0, NULL, 'P' },
+    { "predict-off", 0, NULL, 'p' },
+    { "print-speed", 0, NULL, 'S' },
+    { "print-time", 0, NULL, 's' },
+    { "help", 0, NULL, 'h' },
+    { NULL, 0, NULL, 0 }
+  };
+  ::cmdopt_t cmdopt;
+  ::cmdopt_init(&cmdopt, argc, argv, "N:n:tbwlc:PpSsh", long_options);
+  int label;
+  while ((label = ::cmdopt_get(&cmdopt)) != -1) {
+    switch (label) {
+      case 'N': {
+        char *end_of_value;
+        const long value = std::strtol(cmdopt.optarg, &end_of_value, 10);
+        if ((*end_of_value != '\0') || (value <= 0) ||
+            (value > MARISA_MAX_NUM_TRIES)) {
+          std::cerr << "error: option `-n' with an invalid argument: "
+              << cmdopt.optarg << std::endl;
+          return 1;
+        }
+        param_min_num_tries = (int)value;
+        break;
+      }
+      case 'n': {
+        char *end_of_value;
+        const long value = std::strtol(cmdopt.optarg, &end_of_value, 10);
+        if ((*end_of_value != '\0') || (value <= 0) ||
+            (value > MARISA_MAX_NUM_TRIES)) {
+          std::cerr << "error: option `-n' with an invalid argument: "
+              << cmdopt.optarg << std::endl;
+          return 2;
+        }
+        param_max_num_tries = (int)value;
+        break;
+      }
+      case 't': {
+        param_tail_mode = MARISA_TEXT_TAIL;
+        break;
+      }
+      case 'b': {
+        param_tail_mode = MARISA_BINARY_TAIL;
+        break;
+      }
+      case 'w': {
+        param_node_order = MARISA_WEIGHT_ORDER;
+        break;
+      }
+      case 'l': {
+        param_node_order = MARISA_LABEL_ORDER;
+        break;
+      }
+      case 'c': {
+        char *end_of_value;
+        const long value = std::strtol(cmdopt.optarg, &end_of_value, 10);
+        if ((*end_of_value != '\0') || (value < 1) || (value > 5)) {
+          std::cerr << "error: option `-c' with an invalid argument: "
+              << cmdopt.optarg << std::endl;
+          return 3;
+        } else if (value == 1) {
+          param_cache_level = MARISA_TINY_CACHE;
+        } else if (value == 2) {
+          param_cache_level = MARISA_SMALL_CACHE;
+        } else if (value == 3) {
+          param_cache_level = MARISA_NORMAL_CACHE;
+        } else if (value == 4) {
+          param_cache_level = MARISA_LARGE_CACHE;
+        } else if (value == 5) {
+          param_cache_level = MARISA_HUGE_CACHE;
+        }
+        break;
+      }
+      case 'P': {
+        param_with_predict = true;
+        break;
+      }
+      case 'p': {
+        param_with_predict = false;
+        break;
+      }
+      case 'S': {
+        param_print_speed = true;
+        break;
+      }
+      case 's': {
+        param_print_speed = false;
+        break;
+      }
+      case 'h': {
+        print_help(argv[0]);
+        return 0;
+      }
+      default: {
+        return 1;
+      }
+    }
+  }
+  print_config();
+  return benchmark(cmdopt.argv + cmdopt.optind, cmdopt.argc - cmdopt.optind);
+}