blob: 6d238607bccbd297fed6c64a09a22be53050feec [file] [log] [blame]
MG Mud User88f12472016-06-24 23:31:02 +02001#pragma strong_types,save_types,rtt_checks
2#pragma no_clone
3#pragma no_shadow
4#pragma no_inherit
5#pragma pedantic
6
7#include <driver_info.h>
8
9#ifndef DEBUG
10#define DEBUG(x) if (find_player("zesstra"))\
11 tell_object(find_player("zesstra"),"LAG: "+x+"\n")
12#endif
13
14#define SAVEFILE __DIR__+"save/lag-o-daemon"
15#define LOG(x) log_file("LAG",x,200000);
16#define LOGMAX(x) log_file("LAGMAX",x,300000);
17
18// Anzahl an zu merkenden Werten (1800==3600s)
19#define MESSWERTE 1800
20
21nosave float hbstat, obstat;
22nosave mapping lastwarning=([]);
23nosave int *lasttime = utime();
24nosave int lasthbcount = absolute_hb_count();
25float *lagdata = allocate(MESSWERTE,0.0);
26// Lags fuer die letzten 2s (1 HB), 20s (10 HB), 60s (30 HB),
27// 300s (150 HB), 900s (450 HB), 3600s (1800 HB)
28float *lag = allocate(6,0.0);
29int *hbdata = allocate(MESSWERTE);
30// Lags fuer die letzten 2s (1 HB), 20s (10 HB), 60s (30 HB),
31// 300s (150 HB), 900s (450 HB), 3600s (1800 HB)
32int *hbs = allocate(6);
33int *codata = allocate(MESSWERTE);
34// Lags fuer die letzten 2s (1 HB), 20s (10 HB), 60s (30 HB),
35// 300s (150 HB), 900s (450 HB), 3600s (1800 HB)
36int *callouts = allocate(6);
37
38void create() {
39 seteuid(getuid());
40 // Bei nicht einlesbaren Savefile und nach Reboot Werte neu initialisieren.
41 // Denn dann ist die Differenz der HBs bedeutungslos. Erkennung ploetzlich
42 // kleinere HB-Zahl.
43 if (!restore_object(SAVEFILE)
44 || efun::driver_info(DI_NUM_HEARTBEAT_TOTAL_CYCLES) < lasthbcount)
45 {
46 lagdata = allocate(MESSWERTE,0.0);
47 lag = allocate(6,0.0);
48 hbdata = allocate(MESSWERTE);
49 hbs = allocate(6);
50 codata = allocate(MESSWERTE);
51 callouts = allocate(6);
52 }
53 set_heart_beat(1);
54}
55
56int remove(int silent) {
57 save_object(SAVEFILE);
58 destruct(this_object());
59 return 1;
60}
61
62// liefert Mittelwertarray zurueck
63//TODO: <int|string>* results
64private mixed calc_averages(mixed data, mixed results, int index, float scale) {
65 float tmp;
66 int t;
67
68 if (!scale) scale=1.0;
69
70 // 2s
71 results[0] = to_float(data[index]) * scale;
72
73 // alle 10s / 5 HBs den 20s-Wert neu berechnen
74 if ( index%5 == 1) {
75 if (index<9) {
76 foreach(int i: index-4+MESSWERTE .. MESSWERTE-1) {
77 tmp+=data[i];
78 t++;
79 }
80 foreach(int i: 0 .. index) {
81 tmp+=data[i];
82 t++;
83 }
84 }
85 else {
86 foreach(int i: index-9 .. index) {
87 tmp+=data[i];
88 t++;
89 }
90 }
91 results[1]=tmp/to_float(t) * scale;
92 }
93
94 // alle 10s / 5 HBs den 60s-Wert neu berechnen, aber in anderem HB als den
95 // 10s-Wert
96 if ( index%5 == 3) {
97 tmp=0.0;
98 t=0;
99 if (index<29) {
100 foreach(int i: index-14+MESSWERTE .. MESSWERTE-1) {
101 tmp+=data[i];
102 t++;
103 }
104 foreach(int i: 0 .. index) {
105 tmp+=data[i];
106 t++;
107 }
108 }
109 else {
110 foreach(int i: index-29 .. index) {
111 tmp+=data[i];
112 t++;
113 }
114 }
115 results[2]=tmp/to_float(t) * scale;
116 }
117
118 // 300s
119 // alle 40s / 20 HBs den 300s-Wert neu berechnen.
120 if ( index%20 == 12) {
121 tmp=0.0;
122 t=0;
123 if (index<149) {
124 foreach(int i: index-74+MESSWERTE .. MESSWERTE-1) {
125 tmp+=data[i];
126 t++;
127 }
128 foreach(int i: 0 .. index) {
129 tmp+=data[i];
130 t++;
131 }
132 }
133 else {
134 foreach(int i: index-149 .. index) {
135 tmp+=data[i];
136 t++;
137 }
138 }
139 results[3]=tmp/to_float(t) * scale;
140 }
141
142
143 // 900s
144 // alle 80s / 40 HBs den 900s-Wert neu berechnen.
145 if ( index%40 == 31) {
146 tmp=0.0;
147 t=0;
148 if (index<449) {
149 foreach(int i: index-224+MESSWERTE .. MESSWERTE-1) {
150 tmp+=data[i];
151 t++;
152 }
153 foreach(int i: 0 .. index) {
154 tmp+=data[i];
155 t++;
156 }
157 }
158 else {
159 foreach(int i: index-449 .. index) {
160 tmp+=data[i];
161 t++;
162 }
163 }
164 results[4]=tmp/to_float(t) * scale;
165 }
166
167 // 3600s
168 // alle 300s / 150 HBs den 3600s-Wert neu berechnen.
169 if ( index%150 == 128) {
170 tmp=0.0;
171 t=0;
172 if (index<1799) {
173 foreach(int i: index-899+MESSWERTE .. MESSWERTE-1) {
174 tmp+=data[i];
175 t++;
176 }
177 foreach(int i: 0 .. index) {
178 tmp+=data[i];
179 t++;
180 }
181 }
182 else {
183 foreach(int i: index-1799 .. index) {
184 tmp+=data[i];
185 t++;
186 }
187 }
188 results[5]=tmp/to_float(t) * scale;
189 }
190 return results;
191}
192
193protected void heart_beat() {
194 int hbcount=efun::driver_info(DI_NUM_HEARTBEAT_TOTAL_CYCLES);
195 // per Modulo Index auf 0 - 449 begrenzen
196 int index=hbcount%MESSWERTE;
197
198 // mass fuer das lag ist das Verhaeltnis von vergangener Sollzeit (Differenz
199 // HB-Counts * 2) und vergangener Istzeit (Differenz von time()). Und das
200 // ganze wird dann als Abweichung von 1 gespeichert (0, wenn kein Lag)
201 int *nowtime = utime();
202 float timediff = to_float((nowtime[0]-lasttime[0]))
203 + to_float(nowtime[1]-lasttime[1])/1000000.0;
204
205// lagdata[index] = 1.0 -
206// (to_float((hbcount - lasthbcount) * __HEART_BEAT_INTERVAL__)
207// / timediff);
208// lagdata[index] = (timediff -
209// to_float((hbcount - lasthbcount) * __HEART_BEAT_INTERVAL__)) /
210// to_float((hbcount - lasthbcount) * __HEART_BEAT_INTERVAL__);
211 lagdata[index] = abs(to_float((hbcount - lasthbcount) * __HEART_BEAT_INTERVAL__)
212 - timediff) /
213 to_float((hbcount - lasthbcount) * __HEART_BEAT_INTERVAL__);
214
215
216 hbdata[index] = efun::driver_info(DI_NUM_HEARTBEATS_LAST_PROCESSED);
217 codata[index] = efun::driver_info(DI_NUM_CALLOUTS);
218
219 /*
220 DEBUG(sprintf("Index: %d: %d/%.6f => %:6f /1\n",index,
221 (hbcount - lasthbcount)*2,
222 timediff, lagdata[index]));
223 */
224 lasthbcount=hbcount;
225 lasttime=nowtime;
226
227 lag = calc_averages(lagdata, lag, index, 100.0);
228 // Multiplizieren mit 100
229 //DEBUG(sprintf("%O\n",lag));
230 //lag = map(lag, function float (float f) {return f*100.0;} );
231 //DEBUG(sprintf("%O\n",lag));
232 hbs = map(calc_averages(hbdata, hbs, index,1.0),#'to_int);
233 callouts = map(calc_averages(codata, callouts, index,1.0),#'to_int);
234
235 // und ausserdem mal etwas loggen fuer den Moment
236 if (lag[0] > 1000 || callouts[0] > 1000)
237 {
238 LOGMAX(sprintf("%s, %d, %d, %:6f, %:6f, %:6f, %:6f, %:6f, %:6f, "
239 "%d, %d, %d, %d, %d, %d, "
240 "%d, %d, %d, %d, %d, %d, \n",
241 strftime("%y%m%d-%H%M%S"),time(),hbcount,
242 lag[0],lag[1],lag[2],lag[3],lag[4],lag[5],
243 hbs[0],hbs[1],hbs[2],hbs[3],hbs[4],hbs[5],
244 callouts[0],callouts[1],callouts[2],callouts[3],callouts[4],
245 callouts[5]));
246 }
247 else if (hbcount%80 == 0 || lag[0] > 10)
248 {
249 LOG(sprintf("%s, %d, %d, %:6f, %:6f, %:6f, %:6f, %:6f, %:6f, "
250 "%d, %d, %d, %d, %d, %d, "
251 "%d, %d, %d, %d, %d, %d, \n",
252 strftime("%y%m%d-%H%M%S"),time(),hbcount,
253 lag[0],lag[1],lag[2],lag[3],lag[4],lag[5],
254 hbs[0],hbs[1],hbs[2],hbs[3],hbs[4],hbs[5],
255 callouts[0],callouts[1],callouts[2],callouts[3],callouts[4],
256 callouts[5]));
257 }
258}
259
260float *read_lag_data() {
261 return ({lag[2],lag[4],lag[5]});
262}
263float *read_ext_lag_data() {
264 return copy(lag);
265}
266int *read_hb_data() {
267 return copy(hbs);
268}
269int *read_co_data() {
270 return copy(callouts);
271}
272