path: root/src/mintdb/perf_taler_mintdb_interpreter.c

/*
   This file is part of TALER
   Copyright (C) 2014, 2015 Christian Grothoff (and other contributing authors)

   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.

   TALER 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.

   You should have received a copy of the GNU General Public License along with
   TALER; see the file COPYING.  If not, If not, see <http://www.gnu.org/licenses/>
   */
/**
 * @file mintdb/perf_taler_mintdb_interpreter.c
 * @brief Interpreter library for mint database performance analysis
 * @author Nicolas Fournier
 */
#include "platform.h"
#include "perf_taler_mintdb_interpreter.h"
#include "perf_taler_mintdb_init.h"
#include "gauger.h"


/**
 * Represents the state of the interpreter
 */
struct PERF_TALER_MINTDB_interpreter_state
{
  /**
   * State of the commands
   */
  struct PERF_TALER_MINTDB_Cmd *cmd;

  /**
   * Database plugin
   */
  struct TALER_MINTDB_Plugin *plugin;

  /**
   * Current database session
   */
  struct TALER_MINTDB_Session *session;

  /**
   * The current index of the interpreter
   */
  int i;
};

/**
 * Free the memory of @a data, with data of type @a type
 */
static void
data_free (union PERF_TALER_MINTDB_Data *data, enum PERF_TALER_MINTDB_Type type)
{
  switch (type)
  {
    case PERF_TALER_MINTDB_DEPOSIT:
      PERF_TALER_MINTDB_deposit_free (data->deposit);
      data->deposit = NULL;
      return;

    case PERF_TALER_MINTDB_BLINDCOIN:
      PERF_TALER_MINTDB_collectable_blindcoin_free (data->blindcoin);
      data->blindcoin = NULL;
      return;

    case PERF_TALER_MINTDB_RESERVE:
      PERF_TALER_MINTDB_reserve_free (data->reserve);
      data->reserve = NULL;
      return;

    case PERF_TALER_MINTDB_DENOMINATION_INFO:
      PERF_TALER_MINTDB_denomination_free (data->dki);
      data->dki = NULL;
      return;

    case PERF_TALER_MINTDB_COIN_INFO:
      PERF_TALER_MINTDB_coin_public_info_free (data->cpi);
      data->cpi = NULL;
      return;

    default:
      return;
  }
} 



/**
 * Finds the first command in cmd with the name search
 *
 * @return the index of the first command with name search
 * GNUNET_SYSERR if none found
 */
static int
cmd_find (const struct  PERF_TALER_MINTDB_Cmd *cmd, const char *search)
{
  int i;

  for (i=0; PERF_TALER_MINTDB_CMD_END != cmd[i].command; i++)
    if (0 == strcmp (cmd[i].label, search))
      return i;
  return GNUNET_SYSERR;
}


/**
 * Initialization of a command array      
 */
static int
cmd_init (struct PERF_TALER_MINTDB_Cmd cmd[])
{
  int i = 0;
  for (i=0; PERF_TALER_MINTDB_CMD_END != cmd[i].command; i++)
  {
    switch (cmd[i].command)
    {
      case PERF_TALER_MINTDB_CMD_SAVE_ARRAY:
        // Allocation of memory for saving data
        cmd[i].details.save_array.data_saved = 
          GNUNET_new_array (cmd[i].details.save_array.nb_saved, 
                            union PERF_TALER_MINTDB_Data);
        break;

      case PERF_TALER_MINTDB_CMD_LOAD_ARRAY:
        // Creating the permutation array to randomize the data order
        cmd[i].details.load_array.permutation =
          GNUNET_CRYPTO_random_permute (
                                        GNUNET_CRYPTO_QUALITY_WEAK,
                                        cmd[cmd_find (cmd, 
                                                      cmd[i].details
                                                        .load_array.label_save)]
                                        .details.save_array.nb_saved);

        // Initializing the type based on the type of the saved array
        cmd[i].exposed_type = cmd[cmd_find (cmd, 
                                            cmd[i].details.load_array.label_save)]
          .details.save_array.type_saved;
        break;

      default:
        break;
    }
  }
  return GNUNET_OK;
}


/**
 * Free the memory of the command chain
 */
static int
cmd_clean (struct PERF_TALER_MINTDB_Cmd cmd[])
{
  int i = 0;
  for (i = 0; PERF_TALER_MINTDB_CMD_END != cmd[i].command; i++)
  {
    switch (cmd[i].command)
    {
      case PERF_TALER_MINTDB_CMD_SAVE_ARRAY:
        {
          int j;
          for (j = 0; j < cmd[i].details.save_array.nb_saved; j++)
          {
            data_free (&cmd[i].details.save_array.data_saved[j],
                       cmd[i].details.save_array.type_saved);
          }

          GNUNET_free (cmd[i].details.save_array.data_saved);
          cmd[i].details.save_array.data_saved = NULL;
        }

      case PERF_TALER_MINTDB_CMD_LOAD_ARRAY:
        GNUNET_free (cmd[i].details.load_array.permutation);
        break;

      default:
        data_free (&cmd[i].exposed, cmd[i].exposed_type);
        break;

    }
    i++;
  }
  return GNUNET_OK;
};


/**
 * Handles the command END_LOOP for the interpreter
 */
static void
interpret_end_loop (struct PERF_TALER_MINTDB_interpreter_state *state)
{
  int jump = cmd_find (state->cmd, 
                       state->cmd[state->i].details.end_loop.label_loop);
  
  state->cmd[jump].details.loop.curr_iteration++;
  // If the loop is not finished
  if (state->cmd[jump].details.loop.max_iterations > 
      state->cmd[jump].details.loop.curr_iteration)
  {
    // jump back to the start
    state->i = jump;
  }else{
    // Reset the loop counter and continue running
    state->cmd[jump].details.loop.curr_iteration = 0;
  }
  // Cleaning up the memory in the loop
  int j;
  for (j = jump; j < state->i; j++)
  {
    // If the exposed variable has not been copied it is freed
    if ( GNUNET_NO == state->cmd[j].exposed_saved)
      data_free (&state->cmd[j].exposed, state->cmd[j].exposed_type);
    state->cmd[j].exposed_saved = GNUNET_NO;
  }
}

static void
interpret_save_array (struct PERF_TALER_MINTDB_interpreter_state *state)
{
  int loop_index;
  int selection_chance;
  // Array initialization on first loop iteration
  // Alows for nested loops
  if (0 == state->cmd[cmd_find (state->cmd, 
                                state->cmd[state->i]
                                .details.save_array.label_loop)]
      .details.loop.curr_iteration)
  {
    state->cmd[state->i].details.save_array.index = 0;
  }
  loop_index = cmd_find (state->cmd, 
                         state->cmd[state->i].details.save_array.label_loop);
  // The probobility distribution of the saved items will be a little biased 
  // against the few last items but it should not be a big problem.
  selection_chance = state->cmd[loop_index].details.loop.max_iterations /
    state->cmd[state->i].details.save_array.nb_saved;
  /*
   * If the remaining sapce is equal to the remaining number of
   * iterations, the item is automaticly saved.
   *
   * Else it is saved only if rdn is 0
   */
  if (((state->cmd[loop_index].details.loop.max_iterations - 
        state->cmd[loop_index].details.loop.curr_iteration) ==
       (state->cmd[state->i].details.save_array.nb_saved - 
        state->cmd[state->i].details.save_array.index))
      || (0 == GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, 
                                         selection_chance)))
  {
    union PERF_TALER_MINTDB_Data *save_location;
    union PERF_TALER_MINTDB_Data *item_saved;

    save_location = &state->cmd[state->i].details.save_array
      .data_saved[state->cmd[state->i].details.save_array.index];
    item_saved = &state->cmd[cmd_find (state->cmd, 
                                       state->cmd[state->i]
                                       .details.save_array.label_save)]
      .exposed;
    switch (state->cmd[state->i].details.save_array.type_saved)
    {
      case PERF_TALER_MINTDB_TIME:
        save_location->time = item_saved->time;
        break;

      case PERF_TALER_MINTDB_DEPOSIT:
        save_location->deposit = item_saved->deposit;
        break;

      case PERF_TALER_MINTDB_BLINDCOIN:
        save_location->blindcoin = item_saved->blindcoin;
        break;

      case PERF_TALER_MINTDB_RESERVE:
        save_location->reserve = item_saved->reserve;
        break;

      case PERF_TALER_MINTDB_DENOMINATION_INFO:
        save_location->dki = item_saved->dki;
        break;

      case PERF_TALER_MINTDB_COIN_INFO:
        save_location->cpi = item_saved->cpi;
        break;

      default:
        break;
    }
    state->cmd[cmd_find (state->cmd,
                         state->cmd[state->i].details.save_array.label_save)]
      .exposed_saved = GNUNET_YES;
    state->cmd[state->i].details.save_array.index++;
  }
}

/**
 * Main interpreter loop.
 * 
 */
static int
interpret (struct PERF_TALER_MINTDB_interpreter_state *state)
{

  for (state->i=0; PERF_TALER_MINTDB_CMD_END != state->cmd[state->i].command; state->i++)
  {
    switch (state->cmd[state->i].command)
    {
      case PERF_TALER_MINTDB_CMD_END:
        return GNUNET_YES;

      case PERF_TALER_MINTDB_CMD_DEBUG:
        printf ("%s\n", state->cmd[state->i].label);
        break;

      case PERF_TALER_MINTDB_CMD_LOOP:
        break;

      case PERF_TALER_MINTDB_CMD_END_LOOP:
        interpret_end_loop (state);
        break;

      case PERF_TALER_MINTDB_CMD_GET_TIME:
        clock_gettime (CLOCK_MONOTONIC, &state->cmd[state->i].exposed.time);
        break;

      case PERF_TALER_MINTDB_CMD_GAUGER:
        {
          int start_index, stop_index; 
          struct timespec start, stop;
          unsigned long elapsed_ms;
          start_index  = cmd_find (state->cmd, 
                                   state->cmd[state->i].details.gauger.label_start);
          stop_index  = cmd_find (state->cmd, 
                                  state->cmd[state->i].details.gauger.label_stop);
          start = state->cmd [start_index].exposed.time;
          stop = state->cmd [stop_index].exposed.time;
          elapsed_ms = (start.tv_sec - stop.tv_sec) * 1000 + 
            (start.tv_nsec - stop.tv_nsec) / 1000000;

          GAUGER ("MINTDB", 
                  state->cmd[state->i].details.gauger.description, 
                  elapsed_ms, 
                  "milliseconds");
        }
        break;

      case PERF_TALER_MINTDB_CMD_NEW_SESSION:
        state->session = state->plugin->get_session (state->plugin->cls, GNUNET_YES);
        break;

      case PERF_TALER_MINTDB_CMD_START_TRANSACTION:
        state->plugin->start (state->plugin->cls, state->session);
        break;

      case PERF_TALER_MINTDB_CMD_COMMIT_TRANSACTION:
        state->plugin->commit (state->plugin->cls, state->session);
        break;

      case PERF_TALER_MINTDB_CMD_ABORT_TRANSACTION:
        state->plugin->rollback (state->plugin->cls, state->session);

      case PERF_TALER_MINTDB_CMD_SAVE_ARRAY:
        interpret_save_array (state);
//        {
//          int loop_index;
//          int proba;
//          int rnd;
//          // Array initialization on first loop iteration
//          // Alows for nested loops
//          if (0 == state->cmd[cmd_find (state->cmd, 
//                                        state->cmd[state->i]
//                                        .details.save_array.label_loop)]
//              .details.loop.curr_iteration)
//          {
//            state->cmd[state->i].details.save_array.index = 0;
//          }
//          loop_index = cmd_find (state->cmd, 
//                                 state->cmd[state->i].details.save_array.label_loop);
//          // The probobility distribution of the saved items will be a little biased 
//          // against the few last items but it should not be a big problem.
//          proba = state->cmd[loop_index].details.loop.max_iterations /
//            state->cmd[state->i].details.save_array.nb_saved;
//          rnd = GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK, proba);
//          /*
//           * If the remaining sapce is equal to the remaining number of
//           * iterations, the item is automaticly saved.
//           *
//           * Else it is saved only if rdn is 0
//           */
//          if (((state->cmd[loop_index].details.loop.max_iterations - 
//                state->cmd[loop_index].details.loop.curr_iteration) ==
//               (state->cmd[state->i].details.save_array.nb_saved - 
//                state->cmd[state->i].details.save_array.index))
//              || (rnd == 0))
//          {
//            union PERF_TALER_MINTDB_Data *save_location;
//            union PERF_TALER_MINTDB_Data *item_saved;
//
//            save_location = &state->cmd[state->i].details.save_array
//              .data_saved[state->cmd[state->i].details.save_array.index];
//            item_saved = &state->cmd[cmd_find (state->cmd, 
//                                               state->cmd[state->i]
//                                                .details.save_array.label_save)]
//              .exposed;
//            switch (state->cmd[state->i].details.save_array.type_saved)
//            {
//              case PERF_TALER_MINTDB_DEPOSIT:
//                save_location->deposit = item_saved->deposit;
//                break;
//
//              case PERF_TALER_MINTDB_TIME:
//                save_location->time = item_saved->time;
//                break;
//
//              default:
//                break;
//            }
//            state->cmd[cmd_find (state->cmd,
//                                state->cmd[state->i].details.save_array.label_save)]
//              .exposed_saved = GNUNET_YES;
//            state->cmd[state->i].details.save_array.index++;
//          }
//        }
        break;

      case PERF_TALER_MINTDB_CMD_LOAD_ARRAY:
        {
          int loop_index, save_index;
          union PERF_TALER_MINTDB_Data loaded_data;
          loop_index = cmd_find (state->cmd, 
                                 state->cmd[state->i].details.load_array.label_loop);
          save_index = cmd_find (state->cmd, 
                                 state->cmd[state->i].details.load_array.label_save);
          /* Extracting the data from the loop_indexth indice in save_index
           * array.
           */
          loaded_data = state->cmd[save_index].details.save_array.data_saved[
            state->cmd[state->i].details.load_array.permutation[
              state->cmd[loop_index].details.loop.curr_iteration]];

          switch (state->cmd[state->i].exposed_type)
          {
            case PERF_TALER_MINTDB_DEPOSIT:
              state->cmd[state->i].exposed.deposit = loaded_data.deposit;
              break;

            case PERF_TALER_MINTDB_TIME:
              state->cmd[state->i].exposed.time = loaded_data.time;
              break;

            default:
              break;
          }
        }
        break;

      case PERF_TALER_MINTDB_CMD_INSERT_DEPOSIT:
        {
         struct TALER_MINTDB_Deposit *deposit =
           PERF_TALER_MINTDB_deposit_init ();

         GNUNET_assert (
                        state->plugin->insert_deposit (state->plugin->cls, 
                                                       state->session, 
                                                       deposit));
         state->cmd[state->i].exposed.deposit = deposit;
        }
        break;

      case PERF_TALER_MINTDB_CMD_GET_DEPOSIT:
        {
          struct TALER_MINTDB_Deposit *deposit = 
            state->cmd[cmd_find (state->cmd, 
                                 state->cmd[state->i]
                                 .details.get_deposit.label_source)]
            .exposed.deposit; // Get the deposit from the source
          state->plugin->have_deposit (state->plugin->cls, 
                                       state->session, deposit);
        }
        break;

      default :
        break;
    }
  }
  return GNUNET_OK;
}


/**
 * Runs the commands given in @a cmd, working with
 * the database referenced by @a db_plugin
 */
int
PERF_TALER_MINTDB_interpret (struct TALER_MINTDB_Plugin *db_plugin,
                             struct PERF_TALER_MINTDB_Cmd cmd[])
{
  struct PERF_TALER_MINTDB_interpreter_state state = 
  {.i = 0, .cmd = cmd, .plugin = db_plugin};

  // Initializing commands
  cmd_init (state.cmd);
  // Running the interpreter
  GNUNET_assert(NULL !=
                (state.session = db_plugin->get_session (db_plugin->cls, GNUNET_YES)));
  interpret (&state);
  // Cleaning the memory
  cmd_clean (cmd);
  return GNUNET_YES;
}