--- deliantra/server/common/utils.C 2007/07/10 05:51:37 1.61 +++ deliantra/server/common/utils.C 2008/08/30 05:19:03 1.79 @@ -1,11 +1,11 @@ /* - * This file is part of Crossfire TRT, the Roguelike Realtime MORPG. + * This file is part of Deliantra, the Roguelike Realtime MMORPG. * - * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team + * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team * Copyright (©) 1992,2007 Frank Tore Johansen * - * Crossfire TRT is free software: you can redistribute it and/or modify + * Deliantra 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 3 of the License, or * (at your option) any later version. @@ -18,7 +18,7 @@ * You should have received a copy of the GNU General Public License * along with this program. If not, see . * - * The authors can be reached via e-mail to + * The authors can be reached via e-mail to */ /* @@ -33,20 +33,24 @@ #include #include -#include #include +#include +#include + #include -rand_gen rndm; +refcnt_base::refcnt_t refcnt_dummy; +ssize_t slice_alloc; +rand_gen rndm, rmg_rndm; void tausworthe_random_generator::seed (uint32_t seed) { - state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U; - state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U; - state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U; - state [3] = state [2] * 69069U; if (state [0] < 128) state [0] += 128U; + state [0] = seed * 69069U; if (state [0] < 2U) state [0] += 2U; + state [1] = state [0] * 69069U; if (state [0] < 8U) state [0] += 8U; + state [2] = state [1] * 69069U; if (state [0] < 16U) state [0] += 16U; + state [3] = state [2] * 69069U; if (state [0] < 128U) state [0] += 128U; for (int i = 11; --i; ) operator ()(); @@ -94,13 +98,9 @@ int random_roll (int r_min, int r_max, const object *op, int goodbad) { - int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ + r_max = max (r_min, r_max); - if (r_max < r_min) - { - LOG (llevError | logBacktrace, "Calling random_roll with min=%d max=%d\n", r_min, r_max); - return r_min; - } + int base = r_max - r_min > 1 ? 20 : 50; /* d2 and d3 are corner cases */ if (op->type == PLAYER) { @@ -120,17 +120,11 @@ * for exp loss calculations for players changing religions. */ sint64 -random_roll64 (sint64 min, sint64 max, const object *op, int goodbad) +random_roll64 (sint64 r_min, sint64 r_max, const object *op, int goodbad) { - sint64 omin = min; - sint64 diff = max - min + 1; - int base = diff > 2 ? 20 : 50; /* d2 and d3 are corner cases */ - - if (diff < 0) - { - LOG (llevError | logBacktrace, "Calling random_roll64 with min=%" PRId64 " max=%" PRId64 "\n", min, max); - return (min); /* avoids a float exception */ - } + sint64 omin = r_min; + sint64 range = max (0, r_max - r_min + 1); + int base = range > 2 ? 20 : 50; /* d2 and d3 are corner cases */ /* * Make a call to get two 32 bit unsigned random numbers, and just to @@ -139,24 +133,24 @@ sint64 ran = (sint64) rndm.next () ^ ((sint64) rndm.next () << 31); if (op->type != PLAYER) - return ((ran % diff) + min); + return ((ran % range) + r_min); int luck = op->stats.luck; - if (rndm (base) < MIN (10, abs (luck))) + if (rndm (base) < min (10, abs (luck))) { /* we have a winner */ ((luck > 0) ? (luck = 1) : (luck = -1)); - diff -= luck; - if (diff < 1) + range -= luck; + if (range < 1) return (omin); /*check again */ - ((goodbad) ? (min += luck) : (diff)); + ((goodbad) ? (r_min += luck) : (range)); - return (MAX (omin, MIN (max, (ran % diff) + min))); + return (max (omin, min (r_max, (ran % range) + r_min))); } - return ran % diff + min; + return ran % range + r_min; } /* @@ -214,13 +208,12 @@ if (name == mt->name) return mt; - return materialt; + return 0; } /* when doing transmutation of objects, we have to recheck the resistances, * as some that did not apply previously, may apply now. */ - void transmute_materialname (object *op, const object *change) { @@ -419,7 +412,6 @@ * This function will also strip all trailing non alphanumeric characters. * It does not insert an oxford comma. */ - void make_list_like (char *input) { @@ -460,9 +452,23 @@ if (!fork ()) { signal (SIGABRT, SIG_DFL); + // try to put corefiles into a subdirectory, if existing, to allow // an administrator to reduce the I/O load. chdir ("cores"); + + // try to detach us from as many external dependencies as possible + // as coredumping can take time by closing all fd's. + { + struct rlimit lim; + + if (getrlimit (RLIMIT_NOFILE, &lim)) + lim.rlim_cur = 1024; + + for (int i = 0; i < lim.rlim_cur; ++i) + close (i); + } + abort (); } @@ -471,15 +477,12 @@ void *salloc_ (int n) throw (std::bad_alloc) { -#ifdef PREFER_MALLOC - void *ptr = malloc (n); -#else void *ptr = g_slice_alloc (n); -#endif if (!ptr) throw std::bad_alloc (); + slice_alloc += n; return ptr; } @@ -495,6 +498,49 @@ return ptr; } +/******************************************************************************/ + +#if DEBUG_SALLOC + +#define MAGIC 0xa1b2c35543deadLL + +void *g_slice_alloc (unsigned long size) +{ + unsigned long *p = (unsigned long *) (g_slice_alloc)(size + sizeof (unsigned long)); + *p++ = size ^ MAGIC; + //fprintf (stderr, "g_slice_alloc %ld %p\n", size, p);//D + return (void *)p; +} + +void *g_slice_alloc0 (unsigned long size) +{ + return memset (g_slice_alloc (size), 0, size); +} + +void g_slice_free1 (unsigned long size, void *ptr) +{ + //fprintf (stderr, "g_slice_free %ld %p\n", size, ptr);//D + if (expect_true (ptr)) + { + unsigned long *p = (unsigned long *)ptr; + unsigned long s = *--p ^ MAGIC; + + if (size != (unsigned long)(*p ^ MAGIC)) + { + LOG (logBacktrace | llevError, "slice free size (%lx) doesn't match alloc size (%lx)\n", size, s); + abort (); + } + + *p = MAGIC; + + (g_slice_free1)(s + sizeof (unsigned long), p); + } +} + +#endif + +/******************************************************************************/ + void assign (char *dst, const char *src, int maxlen) { if (!src) @@ -519,40 +565,19 @@ memcpy (dst, src, len + 1); } -const std::string +const char * format (const char *format, ...) { - int len; + static dynbuf_text buf; - { - char buf[128]; + buf.clear (); - va_list ap; - va_start (ap, format); - len = vsnprintf (buf, sizeof (buf), format, ap); - va_end (ap); - - assert (len >= 0); // shield againstz broken vsnprintf's - - // was our static buffer short enough? - if (len < sizeof (buf)) - return std::string (buf, len); - } - - { - // longer, try harder - char *buf = salloc (len + 1); - - va_list ap; - va_start (ap, format); - vsnprintf (buf, len + 1, format, ap); - va_end (ap); - - const std::string s (buf, len); - sfree (buf, len + 1); - - return buf; - } + va_list ap; + va_start (ap, format); + buf.vprintf (format, ap); + va_end (ap); + + return buf; } tstamp now () @@ -630,4 +655,26 @@ 0x2d02ef8dL }; +void thread::start (void *(*start_routine)(void *), void *arg) +{ + pthread_attr_t attr; + + pthread_attr_init (&attr); + pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); + pthread_attr_setstacksize (&attr, PTHREAD_STACK_MIN < sizeof (long) * 4096 + ? sizeof (long) * 4096 : PTHREAD_STACK_MIN); +#ifdef PTHREAD_SCOPE_PROCESS + pthread_attr_setscope (&attr, PTHREAD_SCOPE_PROCESS); +#endif + + sigset_t fullsigset, oldsigset; + sigfillset (&fullsigset); + + pthread_sigmask (SIG_SETMASK, &fullsigset, &oldsigset); + + if (pthread_create (&id, &attr, start_routine, arg)) + cleanup ("unable to create a new thread"); + + pthread_sigmask (SIG_SETMASK, &oldsigset, 0); +}