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