test_sched.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 *
 * Copyright (C) 2009, Digium, Inc.
 *
 * Russell Bryant <[email protected]>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 */

/*! \file
 *
 * \brief ast_sched performance test module
 *
 * \author Russell Bryant <[email protected]>
 */

/*** MODULEINFO
   <depend>TEST_FRAMEWORK</depend>
   <support_level>core</support_level>
 ***/

#include "asterisk.h"

#include <inttypes.h>

#include "asterisk/module.h"
#include "asterisk/utils.h"
#include "asterisk/sched.h"
#include "asterisk/test.h"
#include "asterisk/cli.h"

static int sched_cb(const void *data)
{
   return 0;
}

static int order_check;
static int order_check_failed;

static void sched_order_check(struct ast_test *test, int order)
{
   ++order_check;
   if (order_check != order) {
      ast_test_status_update(test, "Unexpected execution order: expected:%d got:%d\n",
         order, order_check);
      order_check_failed = 1;
   }
}

static int sched_order_1_cb(const void *data)
{
   sched_order_check((void *) data, 1);
   return 0;
}

static int sched_order_2_cb(const void *data)
{
   sched_order_check((void *) data, 2);
   return 0;
}

static int sched_order_3_cb(const void *data)
{
   sched_order_check((void *) data, 3);
   return 0;
}

static int sched_order_4_cb(const void *data)
{
   sched_order_check((void *) data, 4);
   return 0;
}

static int sched_order_5_cb(const void *data)
{
   sched_order_check((void *) data, 5);
   return 0;
}

static int sched_order_6_cb(const void *data)
{
   sched_order_check((void *) data, 6);
   return 0;
}

static int sched_order_7_cb(const void *data)
{
   sched_order_check((void *) data, 7);
   return 0;
}

static int sched_order_8_cb(const void *data)
{
   sched_order_check((void *) data, 8);
   return 0;
}

AST_TEST_DEFINE(sched_test_order)
{
   struct ast_sched_context *con;
   enum ast_test_result_state res = AST_TEST_FAIL;
   int id1, id2, id3, wait;

   switch (cmd) {
   case TEST_INIT:
      info->name = "sched_test_order";
      info->category = "/main/sched/";
      info->summary = "Test ordering of events in the scheduler API";
      info->description =
         "This test ensures that events are properly ordered by the "
         "time they are scheduled to execute in the scheduler API.";
      return AST_TEST_NOT_RUN;
   case TEST_EXECUTE:
      break;
   }

   if (!(con = ast_sched_context_create())) {
      ast_test_status_update(test,
            "Test failed - could not create scheduler context\n");
      return AST_TEST_FAIL;
   }

   /* Add 3 scheduler entries, and then remove them, ensuring that the result
    * of ast_sched_wait() looks appropriate at each step along the way. */

   if ((wait = ast_sched_wait(con)) != -1) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned -1, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   if ((id1 = ast_sched_add(con, 100000, sched_cb, NULL)) == -1) {
      ast_test_status_update(test, "Failed to add scheduler entry\n");
      goto return_cleanup;
   }

   if ((wait = ast_sched_wait(con)) > 100000) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned <= 100000, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   if ((id2 = ast_sched_add(con, 10000, sched_cb, NULL)) == -1) {
      ast_test_status_update(test, "Failed to add scheduler entry\n");
      goto return_cleanup;
   }

   if ((wait = ast_sched_wait(con)) > 10000) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned <= 10000, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   if ((id3 = ast_sched_add(con, 1000, sched_cb, NULL)) == -1) {
      ast_test_status_update(test, "Failed to add scheduler entry\n");
      goto return_cleanup;
   }

   if ((wait = ast_sched_wait(con)) > 1000) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned <= 1000, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   if (ast_sched_del(con, id3) == -1) {
      ast_test_status_update(test, "Failed to remove scheduler entry\n");
      goto return_cleanup;
   }

   if ((wait = ast_sched_wait(con)) <= 1000) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned > 1000, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   if (ast_sched_del(con, id2) == -1) {
      ast_test_status_update(test, "Failed to remove scheduler entry\n");
      goto return_cleanup;
   }

   if ((wait = ast_sched_wait(con)) <= 10000) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned > 10000, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   if (ast_sched_del(con, id1) == -1) {
      ast_test_status_update(test, "Failed to remove scheduler entry\n");
      goto return_cleanup;
   }

   if ((wait = ast_sched_wait(con)) != -1) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned -1, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   /*
    * Schedule immediate and delayed entries to check the order
    * that they get executed.  They must get executed at the
    * time they expire in the order they were added.
    */
#define DELAYED_SAME_EXPIRE      300 /* ms */
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_1_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_1_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_2_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_2_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_3_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_3_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_4_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_4_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_5_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_5_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_6_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_6_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_7_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, 0, sched_order_7_cb, test), res, return_cleanup);
   ast_test_validate_cleanup(test, -1 < ast_sched_add(con, DELAYED_SAME_EXPIRE, sched_order_8_cb, test), res, return_cleanup);

   /* Check order of scheduled immediate entries. */
   order_check = 0;
   order_check_failed = 0;
   usleep(50 * 1000);/* Ensure that all the immediate entries are ready to expire */
   ast_test_validate_cleanup(test, 7 == ast_sched_runq(con), res, return_cleanup);
   ast_test_validate_cleanup(test, !order_check_failed, res, return_cleanup);

   /* Check order of scheduled entries expiring at the same time. */
   order_check = 0;
   order_check_failed = 0;
   usleep((DELAYED_SAME_EXPIRE + 50) * 1000);/* Ensure that all the delayed entries are ready to expire */
   ast_test_validate_cleanup(test, 8 == ast_sched_runq(con), res, return_cleanup);
   ast_test_validate_cleanup(test, !order_check_failed, res, return_cleanup);

   if ((wait = ast_sched_wait(con)) != -1) {
      ast_test_status_update(test,
            "ast_sched_wait() should have returned -1, returned '%d'\n",
            wait);
      goto return_cleanup;
   }

   res = AST_TEST_PASS;

return_cleanup:
   ast_sched_context_destroy(con);

   return res;
}

static char *handle_cli_sched_bench(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
   struct ast_sched_context *con;
   struct timeval start;
   unsigned int num, i;
   int *sched_ids = NULL;

   switch (cmd) {
   case CLI_INIT:
      e->command = "sched benchmark";
      e->usage = ""
         "Usage: sched benchmark <num>\n"
         "";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != e->args + 1) {
      return CLI_SHOWUSAGE;
   }

   if (sscanf(a->argv[e->args], "%u", &num) != 1) {
      return CLI_SHOWUSAGE;
   }

   if (!(con = ast_sched_context_create())) {
      ast_cli(a->fd, "Test failed - could not create scheduler context\n");
      return CLI_FAILURE;
   }

   if (!(sched_ids = ast_malloc(sizeof(*sched_ids) * num))) {
      ast_cli(a->fd, "Test failed - memory allocation failure\n");
      goto return_cleanup;
   }

   ast_cli(a->fd, "Testing ast_sched_add() performance - timing how long it takes "
         "to add %u entries at random time intervals from 0 to 60 seconds\n", num);

   start = ast_tvnow();

   for (i = 0; i < num; i++) {
      long when = labs(ast_random()) % 60000;
      if ((sched_ids[i] = ast_sched_add(con, when, sched_cb, NULL)) == -1) {
         ast_cli(a->fd, "Test failed - sched_add returned -1\n");
         goto return_cleanup;
      }
   }

   ast_cli(a->fd, "Test complete - %" PRIi64 " us\n", ast_tvdiff_us(ast_tvnow(), start));

   ast_cli(a->fd, "Testing ast_sched_del() performance - timing how long it takes "
         "to delete %u entries with random time intervals from 0 to 60 seconds\n", num);

   start = ast_tvnow();

   for (i = 0; i < num; i++) {
      if (ast_sched_del(con, sched_ids[i]) == -1) {
         ast_cli(a->fd, "Test failed - sched_del returned -1\n");
         goto return_cleanup;
      }
   }

   ast_cli(a->fd, "Test complete - %" PRIi64 " us\n", ast_tvdiff_us(ast_tvnow(), start));

return_cleanup:
   ast_sched_context_destroy(con);
   if (sched_ids) {
      ast_free(sched_ids);
   }

   return CLI_SUCCESS;
}

static struct ast_cli_entry cli_sched[] = {
   AST_CLI_DEFINE(handle_cli_sched_bench, "Benchmark ast_sched add/del performance"),
};

static int unload_module(void)
{
   AST_TEST_UNREGISTER(sched_test_order);
   ast_cli_unregister_multiple(cli_sched, ARRAY_LEN(cli_sched));
   return 0;
}

static int load_module(void)
{
   AST_TEST_REGISTER(sched_test_order);
   ast_cli_register_multiple(cli_sched, ARRAY_LEN(cli_sched));
   return AST_MODULE_LOAD_SUCCESS;
}

AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "ast_sched performance test module");