ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/time.C
(Generate patch)

Comparing deliantra/server/common/time.C (file contents):
Revision 1.1 by elmex, Sun Aug 13 17:16:01 2006 UTC vs.
Revision 1.3 by root, Thu Aug 24 13:13:48 2006 UTC

1/* 1/*
2 * static char *rcsid_time_c = 2 * static char *rcsid_time_c =
3 * "$Id: time.C,v 1.1 2006/08/13 17:16:01 elmex Exp $"; 3 * "$Id: time.C,v 1.3 2006/08/24 13:13:48 root Exp $";
4 */ 4 */
5 5
6/* 6/*
7 CrossFire, A Multiplayer game for X-windows 7 CrossFire, A Multiplayer game for X-windows
8 8
… …
37#endif /* win32 */ 37#endif /* win32 */
38 38
39/* 39/*
40 * Gloabal variables: 40 * Gloabal variables:
41 */ 41 */
42long max_time = MAX_TIME;
43struct timeval last_time;
44 42
45#define PBUFLEN 100
46long process_utime_save[PBUFLEN];
47long psaveind; 43long psaveind;
48long process_max_utime = 0;
49long process_min_utime = 999999999;
50long process_tot_mtime;
51long pticks; 44long pticks;
52long process_utime_long_count;
53 45
54const char *season_name[] = 46const char *season_name[] =
55{ 47{
56 "The Season of New Year", 48 "The Season of New Year",
57 "The Season of Growth", 49 "The Season of Growth",
… …
88 "Month of the Devourers", 80 "Month of the Devourers",
89 "Month of Sorig", 81 "Month of Sorig",
90 "Month of the Ancient Darkness", 82 "Month of the Ancient Darkness",
91 "Month of Gorokh" 83 "Month of Gorokh"
92}; 84};
93
94/*
95 * Initialise all variables used in the timing routines.
96 */
97
98void
99reset_sleep(void)
100{
101 int i;
102 for(i = 0; i < PBUFLEN; i++)
103 process_utime_save[i] = 0;
104 psaveind = 0;
105 process_max_utime = 0;
106 process_min_utime = 999999999;
107 process_tot_mtime = 0;
108 pticks = 0;
109
110 (void) GETTIMEOFDAY(&last_time);
111}
112
113void
114log_time(long process_utime)
115{
116 pticks++;
117 if (++psaveind >= PBUFLEN)
118 psaveind = 0;
119 process_utime_save[psaveind] = process_utime;
120 if (process_utime > process_max_utime)
121 process_max_utime = process_utime;
122 if (process_utime < process_min_utime)
123 process_min_utime = process_utime;
124 process_tot_mtime += process_utime/1000;
125}
126
127/*
128 * enough_elapsed_time will return true if the time passed since
129 * last tick is more than max-time.
130 */
131
132int
133enough_elapsed_time(void)
134{
135 static struct timeval new_time;
136 long elapsed_utime;
137
138 (void) GETTIMEOFDAY(&new_time);
139
140 elapsed_utime = (new_time.tv_sec - last_time.tv_sec) * 1000000 +
141 new_time.tv_usec - last_time.tv_usec;
142 if (elapsed_utime > max_time) {
143 log_time(elapsed_utime);
144 last_time.tv_sec = new_time.tv_sec;
145 last_time.tv_usec = new_time.tv_usec;
146 return 1;
147 }
148 return 0;
149}
150
151/*
152 * sleep_delta checks how much time has elapsed since last tick.
153 * If it is less than max_time, the remaining time is slept with select().
154 */
155
156void
157sleep_delta(void)
158{
159 static struct timeval new_time;
160 long sleep_sec, sleep_usec;
161
162 (void) GETTIMEOFDAY(&new_time);
163
164 sleep_sec = last_time.tv_sec - new_time.tv_sec;
165 sleep_usec = max_time - (new_time.tv_usec - last_time.tv_usec);
166
167 /* This is very ugly, but probably the fastest for our use: */
168 while (sleep_usec < 0) {
169 sleep_usec += 1000000;
170 sleep_sec -= 1;
171 }
172 while (sleep_usec > 1000000) {
173 sleep_usec -= 1000000;
174 sleep_sec +=1;
175 }
176
177 log_time((new_time.tv_sec - last_time.tv_sec)*1000000
178 + new_time.tv_usec - last_time.tv_usec);
179
180 if (sleep_sec >= 0 && sleep_usec > 0) {
181 static struct timeval sleep_time;
182 sleep_time.tv_sec = sleep_sec;
183 sleep_time.tv_usec = sleep_usec;
184
185#ifndef WIN32 /* 'select' doesn't work on Windows, 'Sleep' is used instead */
186 select(0, NULL, NULL, NULL, &sleep_time);
187#else
188 if (sleep_time.tv_sec) Sleep(sleep_time.tv_sec*1000);
189 Sleep((int)(sleep_time.tv_usec/1000.));
190#endif
191 }
192 else
193 process_utime_long_count++;
194 /*
195 * Set last_time to when we're expected to wake up:
196 */
197 last_time.tv_usec += max_time;
198 while (last_time.tv_usec > 1000000) {
199 last_time.tv_usec -= 1000000;
200 last_time.tv_sec++;
201 }
202 /*
203 * Don't do too much catching up:
204 * (Things can still get jerky on a slow/loaded computer)
205 */
206 if (last_time.tv_sec * 1000000 + last_time.tv_usec <
207 new_time.tv_sec * 1000000 + new_time.tv_usec)
208 {
209 last_time.tv_sec = new_time.tv_sec;
210 last_time.tv_usec = new_time.tv_usec;
211 }
212}
213
214void
215set_max_time(long t) {
216 max_time = t;
217}
218 85
219extern unsigned long todtick; 86extern unsigned long todtick;
220 87
221void 88void
222get_tod(timeofday_t *tod) 89get_tod(timeofday_t *tod)
… …
272 139
273 sprintf(errmsg, "Time of Year: %s", season_name[tod.season]); 140 sprintf(errmsg, "Time of Year: %s", season_name[tod.season]);
274 new_draw_info(NDI_UNIQUE, 0,op,errmsg); 141 new_draw_info(NDI_UNIQUE, 0,op,errmsg);
275} 142}
276 143
277void
278time_info(object *op)
279{
280 int tot = 0, maxt = 0, mint = 99999999, long_count = 0, i;
281
282 print_tod(op);
283 if (!QUERY_FLAG(op,FLAG_WIZ))
284 return;
285
286 new_draw_info (NDI_UNIQUE, 0,op,"Total time:");
287 sprintf(errmsg,"ticks=%ld time=%ld.%2ld",
288 pticks, process_tot_mtime/1000, process_tot_mtime%1000);
289 new_draw_info (NDI_UNIQUE, 0,op,errmsg);
290 sprintf(errmsg,"avg time=%ldms max time=%ldms min time=%ldms",
291 process_tot_mtime/pticks, process_max_utime/1000,
292 process_min_utime/1000);
293 new_draw_info (NDI_UNIQUE, 0,op,errmsg);
294 sprintf(errmsg,"ticks longer than max time (%ldms) = %ld (%ld%%)",
295 max_time/1000,
296 process_utime_long_count, 100*process_utime_long_count/pticks);
297 new_draw_info (NDI_UNIQUE, 0,op,errmsg);
298
299 sprintf(errmsg,"Time last %ld ticks:", pticks > PBUFLEN ? PBUFLEN : pticks);
300 new_draw_info (NDI_UNIQUE, 0,op,errmsg);
301
302 for (i = 0; i < (pticks > PBUFLEN ? PBUFLEN : pticks); i++) {
303 tot += process_utime_save[i];
304 if (process_utime_save[i] > maxt) maxt = process_utime_save[i];
305 if (process_utime_save[i] < mint) mint = process_utime_save[i];
306 if (process_utime_save[i] > max_time) long_count++;
307 }
308
309 sprintf(errmsg,"avg time=%ldms max time=%dms min time=%dms",
310 tot/(pticks > PBUFLEN ? PBUFLEN : pticks)/1000, maxt/1000,
311 mint/1000);
312 new_draw_info (NDI_UNIQUE, 0,op,errmsg);
313 sprintf(errmsg,"ticks longer than max time (%ldms) = %d (%ld%%)",
314 max_time/1000, long_count,
315 100*long_count/(pticks > PBUFLEN ? PBUFLEN : pticks));
316 new_draw_info (NDI_UNIQUE, 0,op,errmsg);
317}
318
319long 144long
320seconds(void) 145seconds(void)
321{ 146{
322 struct timeval now; 147 struct timeval now;
323 148

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines