1/* 2 * $Id: heavy-thread.c,v 1.2 2005/04/25 16:42:24 paul Exp $ 3 * 4 * This file is part of Quagga. 5 * 6 * Quagga is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License as published by the 8 * Free Software Foundation; either version 2, or (at your option) any 9 * later version. 10 * 11 * Quagga is distributed in the hope that it will be useful, but 12 * WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 14 * General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with Quagga; see the file COPYING. If not, write to the Free 18 * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 19 * 02111-1307, USA. 20 */ 21 22/* This programme shows the effects of 'heavy' long-running functions 23 * on the cooperative threading model, as demonstrated by heavy.c, and how 24 * they can be mitigated using a background thread. 25 * 26 * Run it with a config file containing 'password whatever', telnet to it 27 * (it defaults to port 4000) and enter the 'clear foo string' command. 28 * then type whatever and observe that, unlike heavy.c, the vty interface 29 * remains responsive. 30 */ 31#include <zebra.h> 32#include <math.h> 33 34#include "thread.h" 35#include "vty.h" 36#include "command.h" 37#include "memory.h" 38#include "log.h" 39 40extern struct thread_master *master; 41 42enum 43{ 44 ITERS_FIRST = 0, 45 ITERS_ERR = 100, 46 ITERS_LATER = 400, 47 ITERS_PRINT = 10, 48 ITERS_MAX = 1000, 49}; 50 51struct work_state { 52 struct vty *vty; 53 char *str; 54 int i; 55}; 56 57static void 58slow_func (struct vty *vty, const char *str, const int i) 59{ 60 double x = 1; 61 int j; 62 63 for (j = 0; j < 300; j++) 64 x += sin(x)*j; 65 66 if ((i % ITERS_LATER) == 0) 67 printf ("%s: %d, temporary error, save this somehow and do it later..\n", 68 __func__, i); 69 70 if ((i % ITERS_ERR) == 0) 71 printf ("%s: hard error\n", __func__); 72 73 if ((i % ITERS_PRINT) == 0) 74 printf ("%s did %d, x = %g\n", str, i, x); 75} 76 77static int 78clear_something (struct thread *thread) 79{ 80 struct work_state *ws = THREAD_ARG(thread); 81 82 /* this could be like iterating through 150k of route_table 83 * or worse, iterating through a list of peers, to bgp_stop them with 84 * each having 150k route tables to process... 85 */ 86 while (ws->i < ITERS_MAX) 87 { 88 slow_func(ws->vty, ws->str, ws->i); 89 ws->i++; 90 if (thread_should_yield(thread)) 91 { 92 thread_add_background(master, clear_something, ws, 0); 93 return 0; 94 } 95 } 96 97 /* All done! */ 98 XFREE (MTYPE_TMP, ws->str); 99 XFREE (MTYPE_TMP, ws); 100 return 0; 101} 102 103DEFUN (clear_foo, 104 clear_foo_cmd, 105 "clear foo .LINE", 106 "clear command\n" 107 "arbitrary string\n") 108{ 109 char *str; 110 struct work_state *ws; 111 112 if (!argc) 113 { 114 vty_out (vty, "%% string argument required%s", VTY_NEWLINE); 115 return CMD_WARNING; 116 } 117 118 str = argv_concat (argv, argc, 0); 119 120 if ((ws = XMALLOC(MTYPE_TMP, sizeof(*ws))) == NULL) 121 { 122 zlog_err ("%s: unable to allocate work_state", __func__); 123 return CMD_WARNING; 124 } 125 126 if (!(ws->str = XSTRDUP (MTYPE_TMP, str))) 127 { 128 zlog_err ("%s: unable to xstrdup", __func__); 129 XFREE (MTYPE_TMP, ws); 130 return CMD_WARNING; 131 } 132 133 ws->vty = vty; 134 ws->i = ITERS_FIRST; 135 136 thread_add_background(master, clear_something, ws, 0); 137 138 return CMD_SUCCESS; 139} 140 141void 142test_init() 143{ 144 install_element (VIEW_NODE, &clear_foo_cmd); 145} 146