src/regex/perf-regex.c

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2012 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file src/regex/perf-regex.c
  23  * @brief Test how long it takes to create a automaton from a string regex.
  24  * @author Bartlomiej Polot
  25  */
  26 #include <regex.h>
  27 #include <time.h>
  28 #include "platform.h"
  29 #include "regex_internal_lib.h"
  30 #include "regex_test_lib.h"
  31
  32
  33 /**
  34  * Print information about the given node and its edges
  35  * to stdout.
  36  *
  37  * @param cls closure, unused.
  38  * @param key hash for current state.
  39  * @param proof proof for current state.
  40  * @param accepting GNUNET_YES if this is an accepting state, GNUNET_NO if not.
  41  * @param num_edges number of edges leaving current state.
  42  * @param edges edges leaving current state.
  43  */
  44 static void
  45 print_edge (void *cls,
  46             const struct GNUNET_HashCode *key,
  47             const char *proof,
  48             int accepting,
  49             unsigned int num_edges,
  50             const struct REGEX_BLOCK_Edge *edges)
  51 {
  52   unsigned int i;
  53
  54   printf ("%s: %s, proof: `%s'\n",
  55           GNUNET_h2s (key),
  56           accepting ? "ACCEPTING" : "",
  57           proof);
  58   for (i = 0; i < num_edges; i++)
  59     printf ("    `%s': %s\n",
  60             edges[i].label,
  61             GNUNET_h2s (&edges[i].destination));
  62 }
  63
  64
  65 /**
  66  * The main function of the regex performace test.
  67  *
  68  * Read a set of regex from a file, combine them and create a DFA from the
  69  * resulting combined regex.
  70  *
  71  * @param argc number of arguments from the command line
  72  * @param argv command line arguments
  73  * @return 0 ok, 1 on error
  74  */
  75 int
  76 main (int argc, char *const *argv)
  77 {
  78   struct REGEX_INTERNAL_Automaton*dfa;
  79   char **regexes;
  80   char *buffer;
  81   char *regex;
  82   int compression;
  83   unsigned int alphabet_size;
  84   long size;
  85
  86   GNUNET_log_setup ("perf-regex", "DEBUG", NULL);
  87   if (4 != argc)
  88   {
  89     fprintf (stderr,
  90              "Usage: %s REGEX_FILE ALPHABET_SIZE COMPRESSION\n",
  91              argv[0]);
  92     return 1;
  93   }
  94   regexes = REGEX_TEST_read_from_file (argv[1]);
  95   if (NULL == regexes)
  96   {
  97     fprintf (stderr,
  98              "Failed to read regexes from `%s'\n",
  99              argv[1]);
 100     return 2;
 101   }
 102   alphabet_size = atoi (argv[2]);
 103   compression = atoi (argv[3]);
 104   printf ("********* PERF-REGEX *********'\n");
 105   printf ("Using:\n file '%s'\n Alphabet size %u\n compression %d\n",
 106           argv[1], alphabet_size, compression);
 107   fflush (stdout);
 108   buffer = REGEX_TEST_combine (regexes, alphabet_size);
 109   GNUNET_asprintf (&regex, "GNUNET_REGEX_PROFILER_(%s)(0|1)*", buffer);
 110   size = strlen (regex);
 111
 112   fprintf (stderr,
 113            "Combined regex (%ld bytes):\n%s\n",
 114            size,
 115            regex);
 116   dfa = REGEX_INTERNAL_construct_dfa (regex, size, compression);
 117   printf ("********* ALL EDGES *********'\n");
 118   REGEX_INTERNAL_iterate_all_edges (dfa, &print_edge, NULL);
 119   printf ("\n\n********* REACHABLE EDGES *********'\n");
 120   REGEX_INTERNAL_iterate_reachable_edges (dfa, &print_edge, NULL);
 121   REGEX_INTERNAL_automaton_destroy (dfa);
 122   GNUNET_free (buffer);
 123   REGEX_TEST_free_from_file (regexes);
 124   GNUNET_free (regex);
 125   return 0;
 126 }
 127
 128
 129 /* end of prof-regex.c */