Author: Kev <klmitch@mit.edu>
[ircu2.10.12-pk.git] / ircd / userload.c
1 /*
2  * Userload module by Michael L. VanLoon (mlv) <michaelv@iastate.edu>
3  * Written 2/93.  Originally grafted into irc2.7.2g 4/93.
4  * 
5  * Rewritten 9/97 by Carlo Wood (Run) <carlo@runaway.xs4all.nl>
6  * because previous version used ridiculous amounts of memory
7  * (stored all loads of the passed three days ~ 8 megs).
8  *
9  * IRC - Internet Relay Chat, ircd/userload.c
10  * Copyright (C) 1990 University of Oulu, Computing Center
11  *
12  * This program is free software; you can redistribute it and/or modify
13  * it under the terms of the GNU General Public License as published by
14  * the Free Software Foundation; either version 1, or (at your option)
15  * any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25  *
26  * $Id$
27  */
28 #include "config.h"
29
30 #include "userload.h"
31 #include "client.h"
32 #include "ircd.h"
33 #include "msg.h"
34 #include "numnicks.h"
35 #include "querycmds.h"
36 #include "s_misc.h"
37 #include "send.h"
38 #include "struct.h"
39 #include "sys.h"
40
41 #include <stdio.h>
42 #include <string.h>
43 #include <time.h>
44
45 struct current_load_st current_load;    /* The current load */
46
47 static struct current_load_st cspm_sum; /* Number of connections times number
48                                            of seconds per minute. */
49 static struct current_load_st csph_sum; /* Number of connections times number
50                                            of seconds per hour. */
51 static struct current_load_st cspm[60]; /* Last 60 minutes */
52 static struct current_load_st csph[72]; /* Last 72 hours */
53
54 static int m_index, h_index;    /* Array indexes */
55
56 /*
57  * update_load
58  *
59  * A new connection was added or removed.
60  */
61 void update_load(void)
62 {
63   static struct tm tm_now;      /* Current time. */
64   static time_t last_sec;       /* Seconds of last time that
65                                    update_load() called. */
66   static time_t last_min;
67   static time_t last;           /* Last time that update_load() was called. */
68   static struct current_load_st last_load;      /* The load last time that
69                                                    update_load() was called. */
70   static int initialized;       /* Boolean, set when initialized. */
71   int diff_time;        /* Temp. variable used to hold time intervals
72                                    in seconds, minutes or hours. */
73
74   /* Update `current_load' */
75   current_load.client_count = UserStats.local_clients;
76   current_load.conn_count = UserStats.local_clients + UserStats.local_servers;
77
78   /* Nothing needed when still in the same second */
79   if (!(diff_time = CurrentTime - last))
80   {
81     last_load = current_load;   /* Update last_load to be the load last
82                                    time that update_load() was called. */
83     return;
84   }
85
86   /* If we get here we entered a new second */
87
88   /*
89    * Make sure we keep the accurate time in 'tm_now'
90    */
91   if ((tm_now.tm_sec += diff_time) > 59)
92   {
93     /* This is done once every minute */
94     diff_time = tm_now.tm_sec / 60;
95     tm_now.tm_sec -= 60 * diff_time;
96     if ((tm_now.tm_min += diff_time) > 59)
97     {
98       /* This is done once every hour */
99       diff_time = tm_now.tm_min / 60;
100       tm_now.tm_min -= 60 * diff_time;
101       if ((tm_now.tm_hour += diff_time) > 23)
102       {
103         tm_now = *localtime(&CurrentTime);      /* Only called once a day */
104         if (!initialized)
105         {
106           initialized = 1;
107           last_sec = 60;
108           last_min = tm_now.tm_min;
109         }
110       }
111     }
112
113     /* If we get here we entered a new minute */
114
115     /* Finish the calculation of cspm of the last minute first: */
116     diff_time = 60 - last_sec;
117     cspm_sum.conn_count += last_load.conn_count * diff_time;
118     cspm_sum.client_count += last_load.client_count * diff_time;
119     cspm_sum.local_count += last_load.local_count * diff_time;
120
121     /* Add the completed minute to the Connections*Seconds/Hour sum */
122     csph_sum.conn_count += cspm_sum.conn_count - cspm[m_index].conn_count;
123     csph_sum.client_count += cspm_sum.client_count - cspm[m_index].client_count;
124     csph_sum.local_count += cspm_sum.local_count - cspm[m_index].local_count;
125
126     /* Store the completed minute in an array */
127     cspm[m_index] = cspm_sum;
128
129     /* How long did last_cspm last ? */
130     diff_time = tm_now.tm_min - last_min;
131     last_min = tm_now.tm_min;
132
133     if (diff_time < 0)
134       diff_time += 60;          /* update_load() must be called at
135                                    _least_ once an hour */
136
137     if (diff_time > 1)          /* Did more then one minute pass ? */
138     {
139       /* Calculate the constant load during those extra minutes */
140       cspm_sum.conn_count = last_load.conn_count * 60;
141       cspm_sum.client_count = last_load.client_count * 60;
142       cspm_sum.local_count = last_load.local_count * 60;
143     }
144
145     for (;;)
146     {
147       /* Increase minute index */
148       if (++m_index == 60)
149       {
150         m_index = 0;
151         /* Keep a list of the last 72 hours */
152         csph[h_index] = csph_sum;
153         if (++h_index == 72)
154           h_index = 0;
155       }
156
157       if (--diff_time <= 0)     /* '<' to prevent endless loop if update_load()
158                                    was not called once an hour :/ */
159         break;
160
161       /* Add extra minutes to the Connections*Seconds/Hour sum */
162       csph_sum.conn_count += cspm_sum.conn_count - cspm[m_index].conn_count;
163       csph_sum.client_count +=
164           cspm_sum.client_count - cspm[m_index].client_count;
165       csph_sum.local_count += cspm_sum.local_count - cspm[m_index].local_count;
166
167       /* Store extra minutes in the array */
168       cspm[m_index] = cspm_sum;
169     }
170
171     /* Now start the calculation of the new minute: */
172     last_sec = tm_now.tm_sec;
173     cspm_sum.conn_count = last_load.conn_count * last_sec;
174     cspm_sum.client_count = last_load.client_count * last_sec;
175     cspm_sum.local_count = last_load.local_count * last_sec;
176   }
177   else
178   {
179     /* A new second, but the same minute as last time */
180     /* How long did last_load last ? */
181     diff_time = tm_now.tm_sec - last_sec;
182     last_sec = tm_now.tm_sec;
183     if (diff_time == 1)         /* Just one second ? */
184     {
185       cspm_sum.conn_count += last_load.conn_count;
186       cspm_sum.client_count += last_load.client_count;
187       cspm_sum.local_count += last_load.local_count;
188     }
189     else
190     {
191       /* More then one second */
192       /* At most 3 integer multiplication per second */
193       cspm_sum.conn_count += last_load.conn_count * diff_time;
194       cspm_sum.client_count += last_load.client_count * diff_time;
195       cspm_sum.local_count += last_load.local_count * diff_time;
196     }
197   }
198   last_load = current_load;     /* Update last_load to be the load last
199                                    time that update_load() was called. */
200   last = CurrentTime;
201 }
202
203 void calc_load(struct Client *sptr)
204 {
205   /* *INDENT-OFF* */
206   static const char *header =
207   /*   ----.-  ----.-  ----  ----  ----   ------------ */
208       "Minute  Hour    Day   Yest. YYest. Userload for:";
209   /* *INDENT-ON* */
210   static const char *what[3] = {
211     "local clients",
212     "total clients",
213     "total connections"
214   };
215   int i, j, times[5][3];        /* [min,hour,day,Yest,YYest]
216                                    [local,client,conn] */
217   int last_m_index = m_index, last_h_index = h_index;
218
219   update_load();                /* We want stats accurate as of *now* */
220
221   if (--last_m_index < 0)
222     last_m_index = 59;
223   times[0][0] = (cspm[last_m_index].local_count + 3) / 6;
224   times[0][1] = (cspm[last_m_index].client_count + 3) / 6;
225   times[0][2] = (cspm[last_m_index].conn_count + 3) / 6;
226
227   times[1][0] = (csph_sum.local_count + 180) / 360;
228   times[1][1] = (csph_sum.client_count + 180) / 360;
229   times[1][2] = (csph_sum.conn_count + 180) / 360;
230
231   for (i = 2; i < 5; ++i)
232   {
233     times[i][0] = 43200;
234     times[i][1] = 43200;
235     times[i][2] = 43200;
236     for (j = 0; j < 24; ++j)
237     {
238       if (--last_h_index < 0)
239         last_h_index = 71;
240       times[i][0] += csph[last_h_index].local_count;
241       times[i][1] += csph[last_h_index].client_count;
242       times[i][2] += csph[last_h_index].conn_count;
243     }
244     times[i][0] /= 86400;
245     times[i][1] /= 86400;
246     times[i][2] /= 86400;
247   }
248
249   sendcmdto_one(&me, CMD_NOTICE, sptr, "%C :%s", sptr, header);
250   for (i = 0; i < 3; ++i)
251     sendcmdto_one(&me, CMD_NOTICE, sptr,
252                   "%C :%4d.%1d  %4d.%1d  %4d  %4d  %4d   %s", sptr,
253                   times[0][i] / 10, times[0][i] % 10,
254                   times[1][i] / 10, times[1][i] % 10,
255                   times[2][i], times[3][i], times[4][i], what[i]);
256 }
257
258 void initload(void)
259 {
260   memset(&current_load, 0, sizeof(current_load));
261   update_load();                /* Initialize the load list */
262 }