tests/lib/test_heavy_wq.c

   1 /*
   2  * This file is part of Quagga.
   3  *
   4  * Quagga is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License as published by the
   6  * Free Software Foundation; either version 2, or (at your option) any
   7  * later version.
   8  *
   9  * Quagga is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; see the file COPYING; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 /* This programme shows the effects of 'heavy' long-running functions
  20  * on the cooperative threading model.
  21  *
  22  * Run it with a config file containing 'password whatever', telnet to it
  23  * (it defaults to port 4000) and enter the 'clear foo string' command.
  24  * then type whatever and observe that the vty interface is unresponsive
  25  * for quite a period of time, due to the clear_something command
  26  * taking a very long time to complete.
  27  */
  28 #include <zebra.h>
  29
  30 #include "thread.h"
  31 #include "vty.h"
  32 #include "command.h"
  33 #include "memory.h"
  34 #include "log.h"
  35 #include "workqueue.h"
  36 #include <math.h>
  37
  38 #include "tests.h"
  39
  40 DEFINE_MGROUP(TEST_HEAVYWQ, "heavy-wq test")
  41 DEFINE_MTYPE_STATIC(TEST_HEAVYWQ, WQ_NODE, "heavy_wq_node")
  42 DEFINE_MTYPE_STATIC(TEST_HEAVYWQ, WQ_NODE_STR, "heavy_wq_node->str")
  43
  44 extern struct thread_master *master;
  45 static struct work_queue *heavy_wq;
  46
  47 struct heavy_wq_node {
  48         char *str;
  49         int i;
  50 };
  51
  52 enum { ITERS_FIRST = 0,
  53        ITERS_ERR = 100,
  54        ITERS_LATER = 400,
  55        ITERS_PRINT = 10,
  56        ITERS_MAX = 1000,
  57 };
  58
  59 static void heavy_wq_add(struct vty *vty, const char *str, int i)
  60 {
  61         struct heavy_wq_node *hn;
  62
  63         hn = XCALLOC(MTYPE_WQ_NODE, sizeof(struct heavy_wq_node));
  64
  65         hn->i = i;
  66         hn->str = XSTRDUP(MTYPE_WQ_NODE_STR, str);
  67
  68         work_queue_add(heavy_wq, hn);
  69
  70         return;
  71 }
  72
  73 static void slow_func_err(struct work_queue *wq, struct work_queue_item *item)
  74 {
  75         printf("%s: running error function\n", __func__);
  76 }
  77
  78 static void slow_func_del(struct work_queue *wq, void *data)
  79 {
  80         struct heavy_wq_node *hn = data;
  81         assert(hn && hn->str);
  82         printf("%s: %s\n", __func__, hn->str);
  83         XFREE(MTYPE_WQ_NODE_STR, hn->str);
  84         hn->str = NULL;
  85         XFREE(MTYPE_WQ_NODE, hn);
  86 }
  87
  88 static wq_item_status slow_func(struct work_queue *wq, void *data)
  89 {
  90         struct heavy_wq_node *hn = data;
  91         double x = 1;
  92         int j;
  93
  94         assert(hn && hn->str);
  95
  96         for (j = 0; j < 300; j++)
  97                 x += sin(x) * j;
  98
  99         if ((hn->i % ITERS_LATER) == 0)
 100                 return WQ_RETRY_LATER;
 101
 102         if ((hn->i % ITERS_ERR) == 0)
 103                 return WQ_RETRY_NOW;
 104
 105         if ((hn->i % ITERS_PRINT) == 0)
 106                 printf("%s did %d, x = %g\n", hn->str, hn->i, x);
 107
 108         return WQ_SUCCESS;
 109 }
 110
 111 static void clear_something(struct vty *vty, const char *str)
 112 {
 113         int i;
 114
 115         /* this could be like iterating through 150k of route_table
 116          * or worse, iterating through a list of peers, to bgp_stop them with
 117          * each having 150k route tables to process...
 118          */
 119         for (i = ITERS_FIRST; i < ITERS_MAX; i++)
 120                 heavy_wq_add(vty, str, i);
 121 }
 122
 123 DEFUN (clear_foo,
 124        clear_foo_cmd,
 125        "clear foo LINE...",
 126        "clear command\n"
 127        "arbitrary string\n")
 128 {
 129         char *str;
 130         if (!argc) {
 131                 vty_out(vty, "%% string argument required\n");
 132                 return CMD_WARNING;
 133         }
 134
 135         str = argv_concat(argv, argc, 0);
 136
 137         clear_something(vty, str);
 138         XFREE(MTYPE_TMP, str);
 139         return CMD_SUCCESS;
 140 }
 141
 142 static int heavy_wq_init(void)
 143 {
 144         heavy_wq = work_queue_new(master, "heavy_work_queue");
 145
 146         heavy_wq->spec.workfunc = &slow_func;
 147         heavy_wq->spec.errorfunc = &slow_func_err;
 148         heavy_wq->spec.del_item_data = &slow_func_del;
 149         heavy_wq->spec.max_retries = 3;
 150         heavy_wq->spec.hold = 1000;
 151
 152         return 0;
 153 }
 154
 155 void test_init(void)
 156 {
 157         install_element(VIEW_NODE, &clear_foo_cmd);
 158         heavy_wq_init();
 159 }