MG Mud User | 88f1247 | 2016-06-24 23:31:02 +0200 | [diff] [blame^] | 1 | #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 | |
| 21 | nosave float hbstat, obstat; |
| 22 | nosave mapping lastwarning=([]); |
| 23 | nosave int *lasttime = utime(); |
| 24 | nosave int lasthbcount = absolute_hb_count(); |
| 25 | float *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) |
| 28 | float *lag = allocate(6,0.0); |
| 29 | int *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) |
| 32 | int *hbs = allocate(6); |
| 33 | int *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) |
| 36 | int *callouts = allocate(6); |
| 37 | |
| 38 | void 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 | |
| 56 | int 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 |
| 64 | private 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 | |
| 193 | protected 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 | |
| 260 | float *read_lag_data() { |
| 261 | return ({lag[2],lag[4],lag[5]}); |
| 262 | } |
| 263 | float *read_ext_lag_data() { |
| 264 | return copy(lag); |
| 265 | } |
| 266 | int *read_hb_data() { |
| 267 | return copy(hbs); |
| 268 | } |
| 269 | int *read_co_data() { |
| 270 | return copy(callouts); |
| 271 | } |
| 272 | |