[moira.git] / server / cache.qc

/*
 *	$Source$
 *	$Author$
 *	$Header$
 *
 *	Copyright (C) 1989 by the Massachusetts Institute of Technology
 *	For copying and distribution information, please see the file
 *	<mit-copyright.h>.
 *
 */

#ifndef lint
static char *rcsid_qsupport_qc = "$Header$";
#endif lint

#include <mit-copyright.h>
#include "query.h"
#include "sms_server.h"


extern char *whoami, *strsave();
extern int ingres_errno, sms_errcode;


/*** NOTE **************************************************************
 *
 *	This code depends each type starting with a unique letter.  If
 *    any new types are added to the system that begin with the same
 *    letter as one of the existing types:
 *		User
 *		List
 *		String
 *		Machine
 *		Cluster
 *		Filesystem
 *    then we will have to rework the code that only looks at the first
 *    letter of the types.
 *
 ***********************************************************************
 */

/* Cache parameters: */
#define CACHESIZE 101		/* number of cache slots */
#define NAMESZ 257		/* max size of a name */

struct item {
    char name[NAMESZ];
    char type[9];
    int id;
    int use;
};

static struct item  cache[CACHESIZE];
static struct item *ncache[CACHESIZE];
static struct item *icache[CACHESIZE];

/* use counter for implementing LRU */
static int use = 1;
/* statistics counters */
int cachehits = 0, cachemisses = 0;

/* ID hash function */
#define hashid(id, type) (((id) + *(type)) % CACHESIZE)


/* Name hash function. */

int hashname(name, type)
register char *name;
char *type;
{
    register int val = *type;

    while (*name)
      val = val<<5 - val + *name++ - '`';
    return(val % CACHESIZE);
}


/* Initialize the cache, flushing any old data, and report the statistics
 * if the cache was previously in use.
 */

flush_cache()
{
    int i;

    if (cachehits + cachemisses != 0)
      com_err(whoami, 0, "Flushing cache; %d hits, %d misses, %d%% hit rate",
	      cachehits, cachemisses,
	      (100 * cachehits) / (cachehits + cachemisses));
    cachehits = cachemisses = 0;
    for (i = 0; i < CACHESIZE; i++) {
	cache[i].use = 0;
	ncache[i] = NULL;
	icache[i] = NULL;
    }
}


/* Do a name to ID translation.  id will be updated with the answer if
 * it is available, and as a side effect the cache is updated.
 */

int name_to_id(name, type, id)
char *name;
char *type;
int *id;
##{
    struct item *i, *mini;
##  char *iname;
##  int j, rowcount;
    int ctr, minv;

    i = ncache[hashname(name, type)];
    if (i && !strcmp(name, i->name) && !strcasecmp(type, i->type)) {
	*id = i->id;
	i->use = use++;
	cachehits++;
	return(SMS_SUCCESS);
    }

    cachemisses++;
    iname = name;

    switch (*type) {
    case 'U':
    case 'u':
##	repeat retrieve (j = users.users_id) where users.#login=@iname
	break;
    case 'L':
    case 'l':
##	repeat retrieve (j = list.list_id) where list.#name=@iname
	break;
    case 'M':
    case 'm':
##	repeat retrieve (j = machine.mach_id) where machine.#name=uppercase(@iname)
	break;
    case 'C':
    case 'c':
##	repeat retrieve (j = cluster.clu_id) where cluster.#name=@iname
	break;
    case 'F':
    case 'f':
##	repeat retrieve (j = filesys.filsys_id) where filesys.#label=@iname
	break;
    case 'S':
    case 's':
##	repeat retrieve (j = strings.string_id) where strings.#string=@iname
	break;
    default:
	return(SMS_INTERNAL);
    }
##  inquire_equel(rowcount = "rowcount")
    if (ingres_errno) return(sms_errcode);
    if (rowcount == 0)
      return(SMS_NO_MATCH);
    if (rowcount > 1)
      return(SMS_NOT_UNIQUE);
    *id = j;
    if (name[0] == '#' && !strcasecmp(type, "USER"))
      return(SMS_SUCCESS);
    minv = use;
    for (i = &cache[0]; i < &cache[CACHESIZE]; i++) {
	if (i->use < minv) {
	    minv = i->use;
	    mini = i;
	    if (minv == 0)
	      break;
	}
    }
    mini->id = j;
    mini->use = use++;
    strcpy(mini->name, name);
    strcpy(mini->type, type);
    ncache[hashname(name, type)] = icache[hashid(j, type)] = mini;
    return(SMS_SUCCESS);
##}


/* Perform an ID to name mapping.  name should be a pointer to a pointer to
 * malloc'ed data.  The buffer it refers to will be freed, and a new buffer
 * allocated with the answer.
 */

int id_to_name(id, type, name)
int id;
char *type;
char **name;
##{
    struct item *i, *mini;
##  char iname[NAMESZ];
##  int j, rowcount;
    int ctr, minv;

    i = icache[hashid(id, type)];
    if (i && id == i->id && !strcasecmp(type, i->type)) {
	free(*name);
	*name = strsave(i->name);
	i->use = use++;
	cachehits++;
	return(SMS_SUCCESS);
    }

    cachemisses++;
    j = id;

    switch (*type) {
    case 'U':
    case 'u':
##	repeat retrieve (iname = users.login) where users.users_id=@j
	break;
    case 'L':
    case 'l':
##	repeat retrieve (iname = list.name) where list.list_id=@j
	break;
    case 'M':
    case 'm':
##	repeat retrieve (iname = machine.name) where machine.mach_id=@j
	break;
    case 'C':
    case 'c':
##	repeat retrieve (iname = cluster.name) where cluster.clu_id=@j
	break;
    case 'F':
    case 'f':
##	repeat retrieve (iname = filesys.label) where filesys.filsys_id=@j
	break;
    case 'S':
    case 's':
##	repeat retrieve (iname = strings.string) where strings.string_id=@j
	break;
    default:
	return(SMS_INTERNAL);
    }
##  inquire_equel(rowcount = "rowcount")
    if (ingres_errno) return(sms_errcode);
    if (rowcount == 0) {
	free(*name);
	sprintf(iname, "#%d", j);
	*name = strsave(iname);
	return(SMS_NO_MATCH);
    }
    if (rowcount != 1)
      return(SMS_INTERNAL);
    free(*name);
    *name = strsave(strtrim(iname));
    if (**name == '#' && !strcasecmp(type, "USER"))
      return(SMS_SUCCESS);
    minv = use;
    for (i = &cache[0]; i < &cache[CACHESIZE]; i++) {
	if (i->use < minv) {
	    minv = i->use;
	    mini = i;
	    if (minv == 0)
	      break;
	}
    }
    mini->id = id;
    mini->use = use++;
    strcpy(mini->name, *name);
    strcpy(mini->type, type);
    ncache[hashname(name, type)] = icache[hashid(id, type)] = mini;
    return(SMS_SUCCESS);
##}


/* Explicitly add something to the cache without doing a lookup in the
 * database.
 */

cache_entry(name, type, id)
char *name;
char *type;
int id;
{
    int minv;
    struct item *i, *mini;

    i = icache[hashid(id, type)];
    if (i->id == id &&
	!strcasecmp(i->type, type) &&
	!strcmp(i->name, name))
      return(SMS_SUCCESS);
    minv = use;
    if (i)
      mini = i;
    else
      for (i = &cache[0]; i < &cache[CACHESIZE]; i++) {
	  if (i->use < minv) {
	      minv = i->use;
	      mini = i;
	      if (minv == 0)
		break;
	  }
      }
    mini->id = id;
    mini->use = use++;
    strcpy(mini->name, name);
    strcpy(mini->type, type);
    ncache[hashname(name, type)] = icache[hashid(id, type)] = mini;
}


/* Flush something that may or may not already be in the cache. */

flush_name(name, type)
char *name;
char *type;
{
    struct item *i;

    i = ncache[hashname(name, type)];
    if (i && !strcmp(name, i->name) && !strcasecmp(type, i->type)) {
	ncache[hashname(name, type)] = NULL;
	icache[hashid(i->id, type)] = NULL;
	i->use = 0;
	return(SMS_SUCCESS);
    }
}
Commit	Line	Data
dc37f07c	1	/*
	2	* $Source$
	3	* $Author$
	4	* $Header$
	5	*
	6	* Copyright (C) 1989 by the Massachusetts Institute of Technology
	7	* For copying and distribution information, please see the file
	8	* <mit-copyright.h>.
	9	*
	10	*/
	11
	12	#ifndef lint
	13	static char *rcsid_qsupport_qc = "$Header$";
	14	#endif lint
	15
	16	#include <mit-copyright.h>
	17	#include "query.h"
	18	#include "sms_server.h"
	19
	20
	21	extern char whoami, strsave();
	22	extern int ingres_errno, sms_errcode;
	23
	24
	25	/* NOTE ************************************************************
	26	*
	27	* This code depends each type starting with a unique letter. If
	28	* any new types are added to the system that begin with the same
	29	* letter as one of the existing types:
	30	* User
	31	* List
	32	* String
	33	* Machine
	34	* Cluster
	35	* Filesystem
	36	* then we will have to rework the code that only looks at the first
	37	* letter of the types.
	38	*
	39	***********************************************************************
	40	*/
	41
	42	/* Cache parameters: */
	43	#define CACHESIZE 101 /* number of cache slots */
	44	#define NAMESZ 257 /* max size of a name */
	45
	46	struct item {
	47	char name[NAMESZ];
	48	char type[9];
	49	int id;
	50	int use;
	51	};
	52
	53	static struct item cache[CACHESIZE];
	54	static struct item *ncache[CACHESIZE];
	55	static struct item *icache[CACHESIZE];
	56
	57	/* use counter for implementing LRU */
	58	static int use = 1;
	59	/* statistics counters */
	60	int cachehits = 0, cachemisses = 0;
	61
	62	/* ID hash function */
	63	#define hashid(id, type) (((id) + *(type)) % CACHESIZE)
	64
65
66	/* Name hash function. */
67
68	int hashname(name, type)
69	register char *name;
70	char *type;
71	{
72	register int val = *type;
73
74	while (*name)
75	val = val<<5 - val + *name++ - '`';
76	return(val % CACHESIZE);
77	}
78
79
80	/* Initialize the cache, flushing any old data, and report the statistics
81	* if the cache was previously in use.
82	*/
83
84	flush_cache()
85	{
86	int i;
87
88	if (cachehits + cachemisses != 0)
89	com_err(whoami, 0, "Flushing cache; %d hits, %d misses, %d%% hit rate",
90	cachehits, cachemisses,
91	(100 * cachehits) / (cachehits + cachemisses));
92	cachehits = cachemisses = 0;
93	for (i = 0; i < CACHESIZE; i++) {
94	cache[i].use = 0;
95	ncache[i] = NULL;
96	icache[i] = NULL;
97	}
98	}
99
100
101	/* Do a name to ID translation. id will be updated with the answer if
102	* it is available, and as a side effect the cache is updated.
103	*/
104
105	int name_to_id(name, type, id)
106	char *name;
107	char *type;
108	int *id;
109	##{
110	struct item i, mini;
111	## char *iname;
112	## int j, rowcount;
113	int ctr, minv;
114
115	i = ncache[hashname(name, type)];
116	if (i && !strcmp(name, i->name) && !strcasecmp(type, i->type)) {
117	*id = i->id;
118	i->use = use++;
119	cachehits++;
120	return(SMS_SUCCESS);
121	}
122
123	cachemisses++;
124	iname = name;
125
126	switch (*type) {
127	case 'U':
128	case 'u':
129	## repeat retrieve (j = users.users_id) where users.#login=@iname
130	break;
131	case 'L':
132	case 'l':
133	## repeat retrieve (j = list.list_id) where list.#name=@iname
134	break;
135	case 'M':
136	case 'm':
137	## repeat retrieve (j = machine.mach_id) where machine.#name=uppercase(@iname)
138	break;
139	case 'C':
140	case 'c':
141	## repeat retrieve (j = cluster.clu_id) where cluster.#name=@iname
142	break;
143	case 'F':
144	case 'f':
145	## repeat retrieve (j = filesys.filsys_id) where filesys.#label=@iname
146	break;
147	case 'S':
148	case 's':
149	## repeat retrieve (j = strings.string_id) where strings.#string=@iname
150	break;
151	default:
152	return(SMS_INTERNAL);
153	}
154	## inquire_equel(rowcount = "rowcount")
155	if (ingres_errno) return(sms_errcode);
156	if (rowcount == 0)
157	return(SMS_NO_MATCH);
158	if (rowcount > 1)
159	return(SMS_NOT_UNIQUE);
160	*id = j;
161	if (name[0] == '#' && !strcasecmp(type, "USER"))
162	return(SMS_SUCCESS);
163	minv = use;
164	for (i = &cache[0]; i < &cache[CACHESIZE]; i++) {
165	if (i->use < minv) {
166	minv = i->use;
167	mini = i;
168	if (minv == 0)
169	break;
170	}
171	}
172	mini->id = j;
173	mini->use = use++;
174	strcpy(mini->name, name);
175	strcpy(mini->type, type);
176	ncache[hashname(name, type)] = icache[hashid(j, type)] = mini;
177	return(SMS_SUCCESS);
178	##}
179
180
181	/* Perform an ID to name mapping. name should be a pointer to a pointer to
182	* malloc'ed data. The buffer it refers to will be freed, and a new buffer
183	* allocated with the answer.
184	*/
185
186	int id_to_name(id, type, name)
187	int id;
188	char *type;
189	char **name;
190	##{
191	struct item i, mini;
192	## char iname[NAMESZ];
193	## int j, rowcount;
194	int ctr, minv;
195
196	i = icache[hashid(id, type)];
197	if (i && id == i->id && !strcasecmp(type, i->type)) {
198	free(*name);
199	*name = strsave(i->name);
200	i->use = use++;
201	cachehits++;
202	return(SMS_SUCCESS);
203	}
204
205	cachemisses++;
206	j = id;
207
208	switch (*type) {
209	case 'U':
210	case 'u':
211	## repeat retrieve (iname = users.login) where users.users_id=@j
212	break;
213	case 'L':
214	case 'l':
215	## repeat retrieve (iname = list.name) where list.list_id=@j
216	break;
217	case 'M':
218	case 'm':
219	## repeat retrieve (iname = machine.name) where machine.mach_id=@j
220	break;
221	case 'C':
222	case 'c':
223	## repeat retrieve (iname = cluster.name) where cluster.clu_id=@j
224	break;
225	case 'F':
226	case 'f':
227	## repeat retrieve (iname = filesys.label) where filesys.filsys_id=@j
228	break;
229	case 'S':
230	case 's':
231	## repeat retrieve (iname = strings.string) where strings.string_id=@j
232	break;
233	default:
234	return(SMS_INTERNAL);
235	}
236	## inquire_equel(rowcount = "rowcount")
237	if (ingres_errno) return(sms_errcode);
238	if (rowcount == 0) {
239	free(*name);
240	sprintf(iname, "#%d", j);
241	*name = strsave(iname);
242	return(SMS_NO_MATCH);
243	}
244	if (rowcount != 1)
245	return(SMS_INTERNAL);
246	free(*name);
247	*name = strsave(strtrim(iname));
248	if (**name == '#' && !strcasecmp(type, "USER"))
249	return(SMS_SUCCESS);
250	minv = use;
251	for (i = &cache[0]; i < &cache[CACHESIZE]; i++) {
252	if (i->use < minv) {
253	minv = i->use;
254	mini = i;
255	if (minv == 0)
256	break;
257	}
258	}
259	mini->id = id;
260	mini->use = use++;
261	strcpy(mini->name, *name);
262	strcpy(mini->type, type);
263	ncache[hashname(name, type)] = icache[hashid(id, type)] = mini;
264	return(SMS_SUCCESS);
265	##}
266
267
268	/* Explicitly add something to the cache without doing a lookup in the
269	* database.
270	*/
271
272	cache_entry(name, type, id)
273	char *name;
274	char *type;
275	int id;
276	{
277	int minv;
278	struct item i, mini;
279
280	i = icache[hashid(id, type)];
281	if (i->id == id &&
282	!strcasecmp(i->type, type) &&
283	!strcmp(i->name, name))
284	return(SMS_SUCCESS);
285	minv = use;
286	if (i)
287	mini = i;
288	else
289	for (i = &cache[0]; i < &cache[CACHESIZE]; i++) {
290	if (i->use < minv) {
291	minv = i->use;
292	mini = i;
293	if (minv == 0)
294	break;
295	}
296	}
297	mini->id = id;
298	mini->use = use++;
299	strcpy(mini->name, name);
300	strcpy(mini->type, type);
301	ncache[hashname(name, type)] = icache[hashid(id, type)] = mini;
302	}
303
304
305	/* Flush something that may or may not already be in the cache. */
306
307	flush_name(name, type)
308	char *name;
309	char *type;
310	{
311	struct item *i;
312
313	i = ncache[hashname(name, type)];
314	if (i && !strcmp(name, i->name) && !strcasecmp(type, i->type)) {
315	ncache[hashname(name, type)] = NULL;
316	icache[hashid(i->id, type)] = NULL;
317	i->use = 0;
318	return(SMS_SUCCESS);
319	}
320	}