server/common/shstr.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * 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
 * the Free Software Foundation, either version 3 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, see <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

/*
 * shstr.C
 */

#include <cstring>
#include <cstdlib>
#include <glib.h>
#include <tr1/unordered_set>

#include "global.h"

size_t shstr_alloc;

typedef std::tr1::unordered_set <const char *, str_hash, str_equal, slice_allocator<const char *> > HT;

static HT ht;
static int next_gc;

static const char *
makevec (const char *s)
{
  int len = strlen (s);
  int alloc = sizeof (uint32_t) * 2 + len + 1;

  shstr_alloc += alloc;
  char *v = (char *)g_slice_alloc (alloc);
  v += sizeof (uint32_t) * 2;

  shstr::length (v) = len;
  shstr::refcnt (v) = 1;

  memcpy (v, s, len + 1);

  return v;
}

shstr_vec<sizeof "(null)"> shstr_tmp::nullvec = { 0, 0xffffffff, "(null)" };

const char *
shstr::find (const char *s)
{
  if (!s)
    return s;

  auto (i, ht.find (s));

  return i != ht.end ()? *i : 0;
}

const char *
shstr::intern (const char *s)
{
  if (!s)
    return null ();

  if (const char *found = find (s))
    {
      ++refcnt (found);
      return found;
    }

  --next_gc;
  s = makevec (s);
  ht.insert (s);
  return s;
}

// periodically test refcounts == 0 for a few strings
// this is the ONLY thing that erases stuff from ht. keep it that way.
void
shstr::gc ()
{
  if (expect_true (next_gc > 0))
    return;

  static const char *curpos;

  auto (i, curpos ? ht.find (curpos) : ht.begin ());

  if (i == ht.end ())
    i = ht.begin ();

  int n = ht.size () / 256 + 16;
  next_gc += n >> 1;

  for (;;)
    {
      if (i == ht.end ())
        {
          curpos = 0;
          return;
        }
      else if (!--n)
        break;
      else if (!refcnt (*i))
        {
          auto (o, i++);
          const char *s = *o;

          ht.erase (o);

          //printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
          int alloc = sizeof (uint32_t) * 2 + length (s) + 1;
          shstr_alloc -= alloc;
          g_slice_free1 (alloc, (void *)(s - sizeof (uint32_t) * 2));
        }
      else
        ++i;
    }

  curpos = *i;
}

// declare these here to get correct initialisation order
#define def2(id,str) const shstr id (str);
#define def(id)      def2(shstr_ ## id, # id)
# include "shstrinc.h"
#undef def
#undef def2

shstr skill_names[NUM_SKILLS];

//TODO: this should of course not be here

/* buf_overflow() - we don't want to exceed the buffer size of 
 * buf1 by adding on buf2! Returns true if overflow will occur.
 */
int
buf_overflow (const char *buf1, const char *buf2, int bufsize)
{
  int len1 = 0, len2 = 0;

  if (buf1)
    len1 = strlen (buf1);

  if (buf2)
    len2 = strlen (buf2);

  if ((len1 + len2) >= bufsize)
    return 1;

  return 0;
}
Revision:	1.38
Committed:	Thu Jan 1 21:15:12 2009 UTC (15 years, 4 months ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	rel-2_80, rel-2_76, rel-2_77, rel-2_75, rel-2_79, rel-2_78
Changes since 1.37:	+8 -5 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.28	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	root	1.23	*
4	root	1.29	* Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	root	1.23	*
6	root	1.28	* Deliantra is free software: you can redistribute it and/or modify
7	root	1.24	* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10	root	1.23	*
11	root	1.24	* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15	root	1.23	*
16	root	1.24	* You should have received a copy of the GNU General Public License
17			* along with this program. If not, see <http://www.gnu.org/licenses/>.
18	root	1.23	*
19	root	1.28	* The authors can be reached via e-mail to <support@deliantra.net>
20	root	1.22	*/
21
22			/*
23	root	1.3	* shstr.C
24	elmex	1.1	*/
25
26	root	1.3	#include <cstring>
27			#include <cstdlib>
28	root	1.10	#include <glib.h>
29	root	1.3	#include <tr1/unordered_set>
30	elmex	1.1
31	root	1.16	#include "global.h"
32	elmex	1.1
33	root	1.26	size_t shstr_alloc;
34
35	root	1.31	typedef std::tr1::unordered_set <const char , str_hash, str_equal, slice_allocator<const char > > HT;
36	elmex	1.1
37	root	1.16	static HT ht;
38	root	1.29	static int next_gc;
39	elmex	1.1
40	root	1.13	static const char *
41			makevec (const char *s)
42	root	1.7	{
43	root	1.17	int len = strlen (s);
44	root	1.38	int alloc = sizeof (uint32_t) * 2 + len + 1;
45	root	1.7
46	root	1.38	shstr_alloc += alloc;
47			char v = (char )g_slice_alloc (alloc);
48			v += sizeof (uint32_t) * 2;
49	root	1.7
50			shstr::length (v) = len;
51			shstr::refcnt (v) = 1;
52
53	root	1.38	memcpy (v, s, len + 1);
54	root	1.7
55	root	1.8	return v;
56	root	1.7	}
57
58	root	1.33	shstr_vec<sizeof "(null)"> shstr_tmp::nullvec = { 0, 0xffffffff, "(null)" };
59	root	1.15
60	elmex	1.1	const char *
61	root	1.3	shstr::find (const char *s)
62			{
63	root	1.4	if (!s)
64			return s;
65
66	root	1.21	auto (i, ht.find (s));
67	elmex	1.1
68	root	1.13	return i != ht.end ()? *i : 0;
69	elmex	1.1	}
70
71			const char *
72	root	1.3	shstr::intern (const char *s)
73			{
74	root	1.4	if (!s)
75	root	1.33	return null ();
76	elmex	1.1
77	root	1.4	if (const char *found = find (s))
78	root	1.5	{
79			++refcnt (found);
80			return found;
81			}
82	elmex	1.1
83	root	1.29	--next_gc;
84	root	1.7	s = makevec (s);
85			ht.insert (s);
86			return s;
87	elmex	1.1	}
88
89	root	1.5	// periodically test refcounts == 0 for a few strings
90			// this is the ONLY thing that erases stuff from ht. keep it that way.
91	elmex	1.1	void
92	root	1.3	shstr::gc ()
93			{
94	root	1.29	if (expect_true (next_gc > 0))
95			return;
96
97	root	1.5	static const char *curpos;
98
99	root	1.21	auto (i, curpos ? ht.find (curpos) : ht.begin ());
100	root	1.5
101			if (i == ht.end ())
102			i = ht.begin ();
103
104	root	1.11	int n = ht.size () / 256 + 16;
105	root	1.29	next_gc += n >> 1;
106	root	1.6
107			for (;;)
108	root	1.5	{
109			if (i == ht.end ())
110			{
111			curpos = 0;
112			return;
113			}
114	root	1.6	else if (!--n)
115			break;
116			else if (!refcnt (*i))
117	root	1.5	{
118	root	1.21	auto (o, i++);
119	root	1.5	const char s = o;
120	root	1.13
121	root	1.5	ht.erase (o);
122
123			//printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
124	root	1.38	int alloc = sizeof (uint32_t) * 2 + length (s) + 1;
125			shstr_alloc -= alloc;
126			g_slice_free1 (alloc, (void )(s - sizeof (uint32_t) 2));
127	root	1.5	}
128			else
129			++i;
130			}
131
132			curpos = *i;
133	elmex	1.1	}
134
135	root	1.25	// declare these here to get correct initialisation order
136	root	1.37	#define def2(id,str) const shstr id (str);
137			#define def(id) def2(shstr_ ## id, # id)
138	root	1.25	# include "shstrinc.h"
139			#undef def
140	root	1.36	#undef def2
141	root	1.25
142	root	1.16	shstr skill_names[NUM_SKILLS];
143
144	root	1.5	//TODO: this should of course not be here
145	root	1.13
146	elmex	1.1	/* buf_overflow() - we don't want to exceed the buffer size of
147			* buf1 by adding on buf2! Returns true if overflow will occur.
148			*/
149	root	1.13	int
150	elmex	1.1	buf_overflow (const char buf1, const char buf2, int bufsize)
151			{
152	root	1.13	int len1 = 0, len2 = 0;
153	elmex	1.1
154	root	1.13	if (buf1)
155			len1 = strlen (buf1);
156	root	1.26
157	root	1.13	if (buf2)
158			len2 = strlen (buf2);
159	root	1.26
160	root	1.13	if ((len1 + len2) >= bufsize)
161			return 1;
162	root	1.22
163	root	1.13	return 0;
164	elmex	1.1	}