--- deliantra/server/include/util.h 2007/11/08 19:43:25 1.58 +++ deliantra/server/include/util.h 2008/05/06 16:55:26 1.75 @@ -1,7 +1,7 @@ /* * This file is part of Deliantra, the Roguelike Realtime MMORPG. * - * Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Deliantra team + * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team * * Deliantra is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -22,7 +22,9 @@ #ifndef UTIL_H__ #define UTIL_H__ -//#define PREFER_MALLOC +#define DEBUG_POISON 0x00 // poison memory before freeing it if != 0 +#define DEBUG_SALLOC 0 // add a debug wrapper around all sallocs +#define PREFER_MALLOC 0 // use malloc and not the slice allocator #if __GNUC__ >= 3 # define is_constant(c) __builtin_constant_p (c) @@ -44,6 +46,8 @@ #define expect_false(expr) expect ((expr) != 0, 0) #define expect_true(expr) expect ((expr) != 0, 1) +#include + #include #include #include @@ -54,6 +58,19 @@ #include #include +#if DEBUG_SALLOC +# define g_slice_alloc0(s) debug_slice_alloc0(s) +# define g_slice_alloc(s) debug_slice_alloc(s) +# define g_slice_free1(s,p) debug_slice_free1(s,p) +void *g_slice_alloc (unsigned long size); +void *g_slice_alloc0 (unsigned long size); +void g_slice_free1 (unsigned long size, void *ptr); +#elif PREFER_MALLOC +# define g_slice_alloc0(s) calloc (1, (s)) +# define g_slice_alloc(s) malloc ((s)) +# define g_slice_free1(s,p) free ((p)) +#endif + // use C0X decltype for auto declarations until ISO C++ sanctifies them (if ever) #define auto(var,expr) decltype(expr) var = (expr) @@ -72,6 +89,7 @@ #define IN_RANGE_EXC(val,beg,end) \ ((unsigned int)(val) - (unsigned int)(beg) < (unsigned int)(end) - (unsigned int)(beg)) +void cleanup (const char *cause, bool make_core = false); void fork_abort (const char *msg); // rationale for using (U) not (T) is to reduce signed/unsigned issues, @@ -82,6 +100,9 @@ template static inline void swap (T& a, U& b) { T t=a; a=(T)b; b=(U)t; } +template static inline T min (T a, U b, V c) { return min (a, min (b, c)); } +template static inline T max (T a, U b, V c) { return max (a, max (b, c)); } + template static inline T lerp (T val, T min_in, T max_in, T min_out, T max_out) @@ -174,7 +195,44 @@ return ((d - 1) & 7) + 1; } -extern size_t slice_alloc; // statistics +extern ssize_t slice_alloc; // statistics + +void *salloc_ (int n) throw (std::bad_alloc); +void *salloc_ (int n, void *src) throw (std::bad_alloc); + +// strictly the same as g_slice_alloc, but never returns 0 +template +inline T *salloc (int n = 1) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T)); } + +// also copies src into the new area, like "memdup" +// if src is 0, clears the memory +template +inline T *salloc (int n, T *src) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), (void *)src); } + +// clears the memory +template +inline T *salloc0(int n = 1) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), 0); } + +// for symmetry +template +inline void sfree (T *ptr, int n = 1) throw () +{ + if (expect_true (ptr)) + { + slice_alloc -= n * sizeof (T); + if (DEBUG_POISON) memset (ptr, DEBUG_POISON, n * sizeof (T)); + g_slice_free1 (n * sizeof (T), (void *)ptr); + assert (slice_alloc >= 0);//D + } +} + +// nulls the pointer +template +inline void sfree0 (T *&ptr, int n = 1) throw () +{ + sfree (ptr, n); + ptr = 0; +} // makes dynamically allocated objects zero-initialised struct zero_initialised @@ -187,56 +245,53 @@ void *operator new (size_t s) { - slice_alloc += s; - return g_slice_alloc0 (s); + return salloc0 (s); } void *operator new[] (size_t s) { - slice_alloc += s; - return g_slice_alloc0 (s); + return salloc0 (s); } void operator delete (void *p, size_t s) { - slice_alloc -= s; - g_slice_free1 (s, p); + sfree ((char *)p, s); } void operator delete[] (void *p, size_t s) { - slice_alloc -= s; - g_slice_free1 (s, p); + sfree ((char *)p, s); } }; -void *salloc_ (int n) throw (std::bad_alloc); -void *salloc_ (int n, void *src) throw (std::bad_alloc); +// makes dynamically allocated objects zero-initialised +struct slice_allocated +{ + void *operator new (size_t s, void *p) + { + return p; + } -// strictly the same as g_slice_alloc, but never returns 0 -template -inline T *salloc (int n = 1) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T)); } + void *operator new (size_t s) + { + return salloc (s); + } -// also copies src into the new area, like "memdup" -// if src is 0, clears the memory -template -inline T *salloc (int n, T *src) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), (void *)src); } + void *operator new[] (size_t s) + { + return salloc (s); + } -// clears the memory -template -inline T *salloc0(int n = 1) throw (std::bad_alloc) { return (T *)salloc_ (n * sizeof (T), 0); } + void operator delete (void *p, size_t s) + { + sfree ((char *)p, s); + } -// for symmetry -template -inline void sfree (T *ptr, int n = 1) throw () -{ -#ifdef PREFER_MALLOC - free (ptr); -#else - slice_alloc -= n * sizeof (T); - g_slice_free1 (n * sizeof (T), (void *)ptr); -#endif -} + void operator delete[] (void *p, size_t s) + { + sfree ((char *)p, s); + } +}; // a STL-compatible allocator that uses g_slice // boy, this is verbose @@ -258,7 +313,7 @@ }; slice_allocator () throw () { } - slice_allocator (const slice_allocator &o) throw () { } + slice_allocator (const slice_allocator &) throw () { } template slice_allocator (const slice_allocator &) throw () { } @@ -277,7 +332,7 @@ sfree (p, n); } - size_type max_size ()const throw () + size_type max_size () const throw () { return size_t (-1) / sizeof (Tp); } @@ -340,7 +395,7 @@ typedef tausworthe_random_generator rand_gen; -extern rand_gen rndm; +extern rand_gen rndm, rmg_rndm; INTERFACE_CLASS (attachable) struct refcnt_base @@ -549,7 +604,7 @@ typedef double tstamp; -// return current time as timestampe +// return current time as timestamp tstamp now (); int similar_direction (int a, int b); @@ -557,5 +612,50 @@ // like sprintf, but returns a "static" buffer const char *format (const char *format, ...); +///////////////////////////////////////////////////////////////////////////// +// threads, very very thin wrappers around pthreads + +struct thread +{ + pthread_t id; + + void start (void *(*start_routine)(void *), void *arg = 0); + + void cancel () + { + pthread_cancel (id); + } + + void *join () + { + void *ret; + + if (pthread_join (id, &ret)) + cleanup ("pthread_join failed", 1); + + return ret; + } +}; + +// note that mutexes are not classes +typedef pthread_mutex_t smutex; + +#if __linux && defined (PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP) + #define SMUTEX_INITIALISER PTHREAD_ADAPTIVE_MUTEX_INITIALIZER_NP +#else + #define SMUTEX_INITIALISER PTHREAD_MUTEX_INITIALIZER +#endif + +#define SMUTEX(name) smutex name = SMUTEX_INITIALISER +#define SMUTEX_LOCK(name) pthread_mutex_lock (&(name)) +#define SMUTEX_UNLOCK(name) pthread_mutex_unlock (&(name)) + +typedef pthread_cond_t scond; + +#define SCOND(name) scond name = PTHREAD_COND_INITIALIZER +#define SCOND_SIGNAL(name) pthread_cond_signal (&(name)) +#define SCOND_BROADCAST(name) pthread_cond_broadcast (&(name)) +#define SCOND_WAIT(name,mutex) pthread_cond_wait (&(name), &(mutex)) + #endif