server/common/time.c

/*
 * static char *rcsid_time_c =
 *    "$Id$";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#include <global.h>
#include <funcpoint.h>
#include <tod.h>

#ifndef WIN32 /* ---win32 exclude header */
#include <stdio.h>
#include <sys/types.h>
#include <sys/time.h>
#endif /* win32 */

/*
 * Gloabal variables:
 */
long max_time = MAX_TIME;
struct timeval last_time;

#define PBUFLEN 100
long process_utime_save[PBUFLEN];
long psaveind;
long process_max_utime = 0;
long process_min_utime = 999999999;
long process_tot_mtime;
long pticks;
long process_utime_long_count;

const char *season_name[] =
{
        "The Season of New Year",
        "The Season of Growth",
        "The Season of Harvest",
        "The Season of Decay",
        "The Season of the Blizzard",
        "\n"
};

const char *weekdays[DAYS_PER_WEEK] = {
   "the Day of the Moon",
   "the Day of the Bull",
   "the Day of the Deception",
   "the Day of Thunder",
   "the Day of Freedom",
   "the Day of the Great Gods",
   "the Day of the Sun"
};

const char *month_name[MONTHS_PER_YEAR] = {
   "Month of Winter",           /* 0 */
   "Month of the Ice Dragon",
   "Month of the Frost Giant",
   "Month of Valriel",
   "Month of Lythander",
   "Month of the Harvest",
   "Month of Gaea",
   "Month of Futility",
   "Month of the Dragon",
   "Month of the Sun",
   "Month of the Great Infernus",
   "Month of Ruggilli",
   "Month of the Dark Shades",
   "Month of the Devourers",
   "Month of Sorig",
   "Month of the Ancient Darkness",
   "Month of Gorokh"
};

/*
 * Initialise all variables used in the timing routines. 
 */

void
reset_sleep(void)
{
  int i;
  for(i = 0; i < PBUFLEN; i++)
    process_utime_save[i] = 0;
  psaveind = 0;
  process_max_utime = 0;
  process_min_utime = 999999999;
  process_tot_mtime = 0;
  pticks = 0;

  (void) GETTIMEOFDAY(&last_time);
}

void
log_time(long process_utime)
{
  pticks++;
  if (++psaveind >= PBUFLEN)
    psaveind = 0;
  process_utime_save[psaveind] = process_utime;
  if (process_utime > process_max_utime)
    process_max_utime = process_utime;
  if (process_utime < process_min_utime)
    process_min_utime = process_utime;
  process_tot_mtime += process_utime/1000;
}

/*
 * enough_elapsed_time will return true if the time passed since
 * last tick is more than max-time.
 */

int
enough_elapsed_time(void)
{
  static struct timeval new_time;
  long elapsed_utime;

  (void) GETTIMEOFDAY(&new_time);

  elapsed_utime = (new_time.tv_sec - last_time.tv_sec) * 1000000 +
                  new_time.tv_usec - last_time.tv_usec;
  if (elapsed_utime > max_time) {
    log_time(elapsed_utime);
    last_time.tv_sec = new_time.tv_sec;
    last_time.tv_usec = new_time.tv_usec;
    return 1;
  }
  return 0;
}

/*
 * sleep_delta checks how much time has elapsed since last tick.
 * If it is less than max_time, the remaining time is slept with select().
 */

void
sleep_delta(void)
{
  static struct timeval new_time;
  long sleep_sec, sleep_usec;

  (void) GETTIMEOFDAY(&new_time);

  sleep_sec = last_time.tv_sec - new_time.tv_sec;
  sleep_usec = max_time - (new_time.tv_usec - last_time.tv_usec);

  /* This is very ugly, but probably the fastest for our use: */
  while (sleep_usec < 0) {
    sleep_usec += 1000000;
    sleep_sec -= 1;
  }
  while (sleep_usec > 1000000) {
    sleep_usec -= 1000000;
    sleep_sec +=1;
  }

  log_time((new_time.tv_sec - last_time.tv_sec)*1000000
           + new_time.tv_usec - last_time.tv_usec);

  if (sleep_sec >= 0 && sleep_usec > 0) {
    static struct timeval sleep_time;
    sleep_time.tv_sec = sleep_sec;
    sleep_time.tv_usec = sleep_usec;

#ifndef WIN32 /* 'select' doesn't work on Windows, 'Sleep' is used instead */
    select(0, NULL, NULL, NULL, &sleep_time);
#else
    if (sleep_time.tv_sec) Sleep(sleep_time.tv_sec*1000);
    Sleep((int)(sleep_time.tv_usec/1000.));
#endif
  }
  else
    process_utime_long_count++;
  /*
   * Set last_time to when we're expected to wake up:
   */
  last_time.tv_usec += max_time;
  while (last_time.tv_usec > 1000000) {
    last_time.tv_usec -= 1000000;
    last_time.tv_sec++;
  }
  /*
   * Don't do too much catching up:
   * (Things can still get jerky on a slow/loaded computer)
   */
  if (last_time.tv_sec * 1000000 + last_time.tv_usec <
      new_time.tv_sec * 1000000 + new_time.tv_usec)
  {
    last_time.tv_sec = new_time.tv_sec;
    last_time.tv_usec = new_time.tv_usec;
  }
}

void
set_max_time(long t) {
  max_time = t;
}

extern unsigned long todtick;

void
get_tod(timeofday_t *tod)
{
  tod->year = todtick/HOURS_PER_YEAR;
  tod->month = (todtick/HOURS_PER_MONTH)%MONTHS_PER_YEAR;
  tod->day = (todtick%HOURS_PER_MONTH)/DAYS_PER_MONTH;
  tod->dayofweek = tod->day%DAYS_PER_WEEK;
  tod->hour = todtick%HOURS_PER_DAY;
  tod->minute = (pticks%PTICKS_PER_CLOCK)/(PTICKS_PER_CLOCK/58);
  if (tod->minute > 58)
     tod->minute = 58; /* it's imprecise at best anyhow */
  tod->weekofmonth = tod->day/WEEKS_PER_MONTH;
  if (tod->month < 3)
    tod->season = 0;
  else if (tod->month < 6)
    tod->season = 1;
  else if (tod->month < 9)
    tod->season = 2;
  else if (tod->month < 12)
    tod->season = 3;
  else
    tod->season = 4;
}

void
print_tod(object *op)
{
  timeofday_t tod;
  char *suf;
  int day;

  get_tod(&tod);
  sprintf(errmsg, "It is %d minute%s past %d o'clock %s, on %s",
    tod.minute+1, ((tod.minute+1 < 2) ? "" : "s"),
    ((tod.hour % 14 == 0) ? 14 : ((tod.hour)%14)),
    ((tod.hour >= 14) ? "pm" : "am"),
    weekdays[tod.dayofweek]);
  new_draw_info(NDI_UNIQUE, 0,op,errmsg);

  day = tod.day + 1;
  if (day == 1 || ((day % 10) == 1 && day > 20))
    suf = "st";
  else if (day == 2 || ((day % 10) == 2 && day > 20))
    suf = "nd";
  else if (day == 3 || ((day % 10) == 3 && day > 20))
    suf = "rd";
  else
    suf = "th";
  sprintf(errmsg, "The %d%s Day of the %s, Year %d", day, suf,
    month_name[tod.month], tod.year+1);
  new_draw_info(NDI_UNIQUE, 0,op,errmsg);

  sprintf(errmsg, "Time of Year: %s", season_name[tod.season]);
  new_draw_info(NDI_UNIQUE, 0,op,errmsg);
}

void
time_info(object *op)
{
  int tot = 0, maxt = 0, mint = 99999999, long_count = 0, i;

  print_tod(op);
  if (!QUERY_FLAG(op,FLAG_WIZ))
    return;

  new_draw_info (NDI_UNIQUE, 0,op,"Total time:");
  sprintf(errmsg,"ticks=%ld  time=%ld.%2ld",
          pticks, process_tot_mtime/1000, process_tot_mtime%1000);
  new_draw_info (NDI_UNIQUE, 0,op,errmsg);
  sprintf(errmsg,"avg time=%ldms  max time=%ldms  min time=%ldms",
          process_tot_mtime/pticks, process_max_utime/1000,
          process_min_utime/1000);
  new_draw_info (NDI_UNIQUE, 0,op,errmsg);
  sprintf(errmsg,"ticks longer than max time (%ldms) = %ld (%ld%%)",
          max_time/1000,
          process_utime_long_count, 100*process_utime_long_count/pticks);
  new_draw_info (NDI_UNIQUE, 0,op,errmsg);

  sprintf(errmsg,"Time last %ld ticks:", pticks > PBUFLEN ? PBUFLEN : pticks);
  new_draw_info (NDI_UNIQUE, 0,op,errmsg);

  for (i = 0; i < (pticks > PBUFLEN ? PBUFLEN : pticks); i++) {
    tot += process_utime_save[i];
    if (process_utime_save[i] > maxt) maxt = process_utime_save[i];
    if (process_utime_save[i] < mint) mint = process_utime_save[i];
    if (process_utime_save[i] > max_time) long_count++;
  }

  sprintf(errmsg,"avg time=%ldms  max time=%dms  min time=%dms",
          tot/(pticks > PBUFLEN ? PBUFLEN : pticks)/1000, maxt/1000,
          mint/1000);
  new_draw_info (NDI_UNIQUE, 0,op,errmsg);
  sprintf(errmsg,"ticks longer than max time (%ldms) = %d (%ld%%)",
          max_time/1000, long_count,
          100*long_count/(pticks > PBUFLEN ? PBUFLEN : pticks));
  new_draw_info (NDI_UNIQUE, 0,op,errmsg);
}

long
seconds(void)
{
  struct timeval now;

  (void) GETTIMEOFDAY(&now);
  return now.tv_sec;
}
Revision:	1.2
Committed:	Sun Aug 13 17:16:01 2006 UTC (20 years, 2 months ago) by elmex
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+1 -1 lines
State:	*FILE REMOVED*
Log Message:	Made server compile with C++. Removed cfanim plugin and crossedit. C++ here we come.
#	Content
1	/*
2	* static char *rcsid_time_c =
3	* "$Id$";
4	*/
5
6	/*
7	CrossFire, A Multiplayer game for X-windows
8
9	Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10	Copyright (C) 1992 Frank Tore Johansen
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 2 of the License, or
15	(at your option) 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	The authors can be reached via e-mail at crossfire-devel@real-time.com
27	*/
28
29	#include <global.h>
30	#include <funcpoint.h>
31	#include <tod.h>
32
33	#ifndef WIN32 /* ---win32 exclude header */
34	#include <stdio.h>
35	#include <sys/types.h>
36	#include <sys/time.h>
37	#endif /* win32 */
38
39	/*
40	* Gloabal variables:
41	*/
42	long max_time = MAX_TIME;
43	struct timeval last_time;
44
45	#define PBUFLEN 100
46	long process_utime_save[PBUFLEN];
47	long psaveind;
48	long process_max_utime = 0;
49	long process_min_utime = 999999999;
50	long process_tot_mtime;
51	long pticks;
52	long process_utime_long_count;
53
54	const char *season_name[] =
55	{
56	"The Season of New Year",
57	"The Season of Growth",
58	"The Season of Harvest",
59	"The Season of Decay",
60	"The Season of the Blizzard",
61	"\n"
62	};
63
64	const char *weekdays[DAYS_PER_WEEK] = {
65	"the Day of the Moon",
66	"the Day of the Bull",
67	"the Day of the Deception",
68	"the Day of Thunder",
69	"the Day of Freedom",
70	"the Day of the Great Gods",
71	"the Day of the Sun"
72	};
73
74	const char *month_name[MONTHS_PER_YEAR] = {
75	"Month of Winter", /* 0 */
76	"Month of the Ice Dragon",
77	"Month of the Frost Giant",
78	"Month of Valriel",
79	"Month of Lythander",
80	"Month of the Harvest",
81	"Month of Gaea",
82	"Month of Futility",
83	"Month of the Dragon",
84	"Month of the Sun",
85	"Month of the Great Infernus",
86	"Month of Ruggilli",
87	"Month of the Dark Shades",
88	"Month of the Devourers",
89	"Month of Sorig",
90	"Month of the Ancient Darkness",
91	"Month of Gorokh"
92	};
93
94	/*
95	* Initialise all variables used in the timing routines.
96	*/
97
98	void
99	reset_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
113	void
114	log_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
132	int
133	enough_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
156	void
157	sleep_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
214	void
215	set_max_time(long t) {
216	max_time = t;
217	}
218
219	extern unsigned long todtick;
220
221	void
222	get_tod(timeofday_t *tod)
223	{
224	tod->year = todtick/HOURS_PER_YEAR;
225	tod->month = (todtick/HOURS_PER_MONTH)%MONTHS_PER_YEAR;
226	tod->day = (todtick%HOURS_PER_MONTH)/DAYS_PER_MONTH;
227	tod->dayofweek = tod->day%DAYS_PER_WEEK;
228	tod->hour = todtick%HOURS_PER_DAY;
229	tod->minute = (pticks%PTICKS_PER_CLOCK)/(PTICKS_PER_CLOCK/58);
230	if (tod->minute > 58)
231	tod->minute = 58; /* it's imprecise at best anyhow */
232	tod->weekofmonth = tod->day/WEEKS_PER_MONTH;
233	if (tod->month < 3)
234	tod->season = 0;
235	else if (tod->month < 6)
236	tod->season = 1;
237	else if (tod->month < 9)
238	tod->season = 2;
239	else if (tod->month < 12)
240	tod->season = 3;
241	else
242	tod->season = 4;
243	}
244
245	void
246	print_tod(object *op)
247	{
248	timeofday_t tod;
249	char *suf;
250	int day;
251
252	get_tod(&tod);
253	sprintf(errmsg, "It is %d minute%s past %d o'clock %s, on %s",
254	tod.minute+1, ((tod.minute+1 < 2) ? "" : "s"),
255	((tod.hour % 14 == 0) ? 14 : ((tod.hour)%14)),
256	((tod.hour >= 14) ? "pm" : "am"),
257	weekdays[tod.dayofweek]);
258	new_draw_info(NDI_UNIQUE, 0,op,errmsg);
259
260	day = tod.day + 1;
261	if (day == 1 \|\| ((day % 10) == 1 && day > 20))
262	suf = "st";
263	else if (day == 2 \|\| ((day % 10) == 2 && day > 20))
264	suf = "nd";
265	else if (day == 3 \|\| ((day % 10) == 3 && day > 20))
266	suf = "rd";
267	else
268	suf = "th";
269	sprintf(errmsg, "The %d%s Day of the %s, Year %d", day, suf,
270	month_name[tod.month], tod.year+1);
271	new_draw_info(NDI_UNIQUE, 0,op,errmsg);
272
273	sprintf(errmsg, "Time of Year: %s", season_name[tod.season]);
274	new_draw_info(NDI_UNIQUE, 0,op,errmsg);
275	}
276
277	void
278	time_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
319	long
320	seconds(void)
321	{
322	struct timeval now;
323
324	(void) GETTIMEOFDAY(&now);
325	return now.tv_sec;
326	}