server/common/shstr.C

/*
 * shstr.C
 */

#include <cstring>
#include <cstdlib>

#include <glib.h>

#include <tr1/unordered_set>

#include "shstr.h"
#include "util.h"

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

static HT ht;

static const char *makevec (const char *s)
{
  int len = strlen (s);

  const char *v = (const char *)(2 + (int *)g_slice_alloc (sizeof (int) * 2 + len + 1));

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

  memcpy ((char *)v, s, len + 1);

  return v;
}

const char *shstr::null = makevec ("<nil>");

// what weird misoptimisation is this again?
const shstr undead_name ("undead");

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

  HT::iterator 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;
    }

  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 ()
{
  static const char *curpos;

  HT::iterator i = curpos ? ht.find (curpos) : ht.begin ();

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

  // go through all strings roughly once every 4 minutes
  int n = ht.size () / 256 + 16;

  for (;;)
    {
      if (i == ht.end ())
        {
          curpos = 0;
          return;
        }
      else if (!--n)
        break;
      else if (!refcnt (*i))
        {
          HT::iterator 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));
          g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *)s);
        }
      else
        ++i;
    }

  curpos = *i;
}

//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.12
Committed:	Thu Sep 7 07:52:58 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+0 -2 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	elmex	1.1	/*
2	root	1.3	* shstr.C
3	elmex	1.1	*/
4
5	root	1.3	#include <cstring>
6			#include <cstdlib>
7
8	root	1.10	#include <glib.h>
9
10	root	1.3	#include <tr1/unordered_set>
11	elmex	1.1
12			#include "shstr.h"
13	root	1.9	#include "util.h"
14	elmex	1.1
15	root	1.9	typedef std::tr1::unordered_set<const char *, str_hash, str_equal> HT;
16	elmex	1.1
17	root	1.3	static HT ht;
18	elmex	1.1
19	root	1.7	static const char makevec (const char s)
20			{
21			int len = strlen (s);
22
23	root	1.10	const char v = (const char )(2 + (int )g_slice_alloc (sizeof (int) 2 + len + 1));
24	root	1.7
25			shstr::length (v) = len;
26			shstr::refcnt (v) = 1;
27
28			memcpy ((char *)v, s, len + 1);
29
30	root	1.8	return v;
31	root	1.7	}
32
33			const char *shstr::null = makevec ("<nil>");
34
35	root	1.8	// what weird misoptimisation is this again?
36			const shstr undead_name ("undead");
37
38	elmex	1.1	const char *
39	root	1.3	shstr::find (const char *s)
40			{
41	root	1.4	if (!s)
42			return s;
43
44	root	1.3	HT::iterator i = ht.find (s);
45	elmex	1.1
46	root	1.3	return i != ht.end ()
47	root	1.5	? *i
48	root	1.3	: 0;
49	elmex	1.1	}
50
51			const char *
52	root	1.3	shstr::intern (const char *s)
53			{
54	root	1.4	if (!s)
55	root	1.7	return null;
56	elmex	1.1
57	root	1.4	if (const char *found = find (s))
58	root	1.5	{
59			++refcnt (found);
60			return found;
61			}
62	elmex	1.1
63	root	1.7	s = makevec (s);
64			ht.insert (s);
65			return s;
66	elmex	1.1	}
67
68	root	1.5	// periodically test refcounts == 0 for a few strings
69			// this is the ONLY thing that erases stuff from ht. keep it that way.
70	elmex	1.1	void
71	root	1.3	shstr::gc ()
72			{
73	root	1.5	static const char *curpos;
74
75			HT::iterator i = curpos ? ht.find (curpos) : ht.begin ();
76
77			if (i == ht.end ())
78			i = ht.begin ();
79
80			// go through all strings roughly once every 4 minutes
81	root	1.11	int n = ht.size () / 256 + 16;
82	root	1.6
83			for (;;)
84	root	1.5	{
85			if (i == ht.end ())
86			{
87			curpos = 0;
88			return;
89			}
90	root	1.6	else if (!--n)
91			break;
92			else if (!refcnt (*i))
93	root	1.5	{
94			HT::iterator o = i++;
95			const char s = o;
96			ht.erase (o);
97
98			//printf ("GC %4d %3d %d >%s<%d\n", (int)ht.size (), n, shstr::refcnt (s), s, shstr::length (s));
99	root	1.10	g_slice_free1 (sizeof (int) * 2 + length (s) + 1, -2 + (int *)s);
100	root	1.5	}
101			else
102			++i;
103			}
104
105			curpos = *i;
106	elmex	1.1	}
107
108	root	1.5	//TODO: this should of course not be here
109	elmex	1.1	/* buf_overflow() - we don't want to exceed the buffer size of
110			* buf1 by adding on buf2! Returns true if overflow will occur.
111			*/
112
113			int
114			buf_overflow (const char buf1, const char buf2, int bufsize)
115			{
116	root	1.3	int len1 = 0, len2 = 0;
117	elmex	1.1
118			if (buf1)
119	root	1.2	len1 = strlen (buf1);
120	elmex	1.1	if (buf2)
121	root	1.2	len2 = strlen (buf2);
122	elmex	1.1	if ((len1 + len2) >= bufsize)
123	root	1.2	return 1;
124	elmex	1.1	return 0;
125			}
126