-/* $Id: rsbetween.c,v 1.21 2004-08-24 15:00:16 heikki Exp $
+/* $Id: rsbetween.c,v 1.22 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
int (*cmp)(const void *p1, const void *p2);
char *(*printer)(const void *p1, char *buf);
struct rset_between_rfd *rfd_list;
+ struct rset_between_rfd *free_list;
};
struct rset_between_rfd {
info->cmp = cmp;
info->printer = printer;
info->rfd_list = NULL;
+ info->free_list = NULL;
rnew->priv=info;
return rnew;
}
-/*
-static void *r_create_between (RSET ct, const struct rset_control *sel,
- void *parms)
-{
- rset_between_parms *between_parms = (rset_between_parms *) parms;
- struct rset_between_info *info;
-
- info = (struct rset_between_info *) xmalloc (sizeof(*info));
- info->key_size = between_parms->key_size;
- info->rset_l = between_parms->rset_l;
- info->rset_m = between_parms->rset_m;
- info->rset_r = between_parms->rset_r;
- info->rset_attr = between_parms->rset_attr;
- info->cmp = between_parms->cmp;
- info->printer = between_parms->printer;
- info->rfd_list = NULL;
- return info;
-}
-*/
-
static void r_delete_between (RSET ct)
{
logf (LOG_FATAL, "between set type is read-only");
return NULL;
}
- rfd = (struct rset_between_rfd *) nmem_malloc(ct->nmem, (sizeof(*rfd)));
+ rfd=info->free_list;
+ if (rfd)
+ info->free_list=rfd->next;
+ else {
+ rfd = (struct rset_between_rfd *) nmem_malloc(ct->nmem, (sizeof(*rfd)));
+ rfd->buf_l = nmem_malloc(ct->nmem, (info->key_size));
+ rfd->buf_m = nmem_malloc(ct->nmem, (info->key_size));
+ rfd->buf_r = nmem_malloc(ct->nmem, (info->key_size));
+ rfd->buf_attr = nmem_malloc(ct->nmem, (info->key_size));
+ }
rfd->next = info->rfd_list;
info->rfd_list = rfd;
rfd->info = info;
- rfd->buf_l = nmem_malloc(ct->nmem, (info->key_size));
- rfd->buf_m = nmem_malloc(ct->nmem, (info->key_size));
- rfd->buf_r = nmem_malloc(ct->nmem, (info->key_size));
- rfd->buf_attr = nmem_malloc(ct->nmem, (info->key_size));
-
rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
rfd->rfd_m = rset_open (info->rset_m, RSETF_READ);
rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
if (*rfdp == rfd)
{
+ struct rset_between_rfd *rfd_tmp=*rfdp;
rset_close (info->rset_l, (*rfdp)->rfd_l);
rset_close (info->rset_m, (*rfdp)->rfd_m);
rset_close (info->rset_r, (*rfdp)->rfd_r);
if (info->rset_attr)
rset_close (info->rset_attr, (*rfdp)->rfd_attr);
-
*rfdp = (*rfdp)->next;
+ rfd_tmp->next=info->free_list;
+ info->free_list=rfd_tmp;
return;
}
logf (LOG_FATAL, "r_close_between but no rfd match!");
-/* $Id: rsbool.c,v 1.43 2004-08-25 13:23:13 adam Exp $
+/* $Id: rsbool.c,v 1.44 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
rfd = info->free_list;
if (rfd)
info->free_list = rfd->next;
- else
+ else {
rfd = (struct rset_bool_rfd *) nmem_malloc(ct->nmem, sizeof(*rfd));
+ rfd->buf_l = nmem_malloc(ct->nmem, info->key_size);
+ rfd->buf_r = nmem_malloc(ct->nmem, info->key_size);
+ }
logf(LOG_DEBUG,"rsbool (%s) open [%p]", ct->control->desc, rfd);
rfd->next = info->rfd_list;
rfd->info = info;
rfd->hits=0;
- rfd->buf_l = nmem_malloc(ct->nmem, info->key_size);
- rfd->buf_r = nmem_malloc(ct->nmem, info->key_size);
rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l);
-/* $Id: rsisamb.c,v 1.17 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsisamb.c,v 1.18 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
int key_size;
int (*cmp)(const void *p1, const void *p2);
struct rset_pp_info *ispt_list;
+ struct rset_pp_info *free_list;
};
RSET rsisamb_create( NMEM nmem, int key_size,
info->is=is;
info->pos=pos;
info->ispt_list = NULL;
+ info->free_list = NULL;
rnew->priv=info;
return rnew;
}
logf (LOG_DEBUG, "risamb_open");
if (flag & RSETF_WRITE)
{
- logf (LOG_FATAL, "ISAMB set type is read-only");
- return NULL;
+ logf (LOG_FATAL, "ISAMB set type is read-only");
+ return NULL;
+ }
+ ptinfo = info->free_list;
+ if (ptinfo)
+ info->free_list=ptinfo->next;
+ else {
+ ptinfo = (struct rset_pp_info *) nmem_malloc (ct->nmem,sizeof(*ptinfo));
+ ptinfo->buf = nmem_malloc (ct->nmem,info->key_size);
}
- ptinfo = (struct rset_pp_info *) xmalloc (sizeof(*ptinfo));
ptinfo->next = info->ispt_list;
info->ispt_list = ptinfo;
ptinfo->pt = isamb_pp_open (info->is, info->pos);
ptinfo->info = info;
- ptinfo->buf = xmalloc (info->key_size);
return ptinfo;
}
for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
if (*ptinfop == rfd)
{
- xfree ((*ptinfop)->buf);
+ struct rset_pp_info *tmp=(struct rset_pp_info*) rfd;
isamb_pp_close ((*ptinfop)->pt);
*ptinfop = (*ptinfop)->next;
- xfree (rfd);
+ tmp->next=info->free_list;
+ info->free_list=tmp;
return;
}
logf (LOG_FATAL, "r_close but no rfd match!");
-/* $Id: rsisamc.c,v 1.21 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsisamc.c,v 1.22 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
int key_size;
int (*cmp)(const void *p1, const void *p2);
struct rset_pp_info *ispt_list;
+ struct rset_pp_info *free_list;
};
RSET rsisamc_create( NMEM nmem, int key_size,
info->key_size = key_size;
info->cmp = cmp;
info->ispt_list = NULL;
+ info->free_list = NULL;
info->is=is;
info->pos=pos;
rnew->priv=info;
logf (LOG_DEBUG, "risamc_open");
if (flag & RSETF_WRITE)
{
- logf (LOG_FATAL, "ISAMC set type is read-only");
- return NULL;
+ logf (LOG_FATAL, "ISAMC set type is read-only");
+ return NULL;
+ }
+ ptinfo = info->free_list;
+ if (ptinfo)
+ info->free_list=ptinfo->next;
+ else {
+ ptinfo = (struct rset_pp_info *) nmem_malloc (ct->nmem,sizeof(*ptinfo));
+ ptinfo->buf = nmem_malloc (ct->nmem,info->key_size);
}
- ptinfo = (struct rset_pp_info *) xmalloc (sizeof(*ptinfo));
ptinfo->next = info->ispt_list;
info->ispt_list = ptinfo;
ptinfo->pt = isc_pp_open (info->is, info->pos);
ptinfo->info = info;
- ptinfo->buf = xmalloc (info->key_size);
return ptinfo;
}
for (ptinfop = &info->ispt_list; *ptinfop; ptinfop = &(*ptinfop)->next)
if (*ptinfop == rfd)
{
- xfree ((*ptinfop)->buf);
+ struct rset_pp_info *tmp=(struct rset_pp_info*) rfd;
isc_pp_close ((*ptinfop)->pt);
*ptinfop = (*ptinfop)->next;
- xfree (rfd);
+ tmp->next=info->free_list;
+ info->free_list=tmp;
return;
}
logf (LOG_FATAL, "r_close but no rfd match!");
-/* $Id: rsmultior.c,v 1.6 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsmultior.c,v 1.7 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
int (*cmp)(const void *p1, const void *p2);
int no_rsets;
RSET *rsets;
- struct rset_multior_rfd *rfd_list;
+ struct rset_multior_rfd *rfd_list; /* rfds in use */
+ struct rset_multior_rfd *free_list; /* rfds free */
+ /* rfds are allocated when first opened, if nothing in freelist */
+ /* when allocated, all their pointers are allocated as well, and */
+ /* those are kept intact when in the freelist, ready to be reused */
};
static
-HEAP heap_create (int size, int key_size,
+HEAP heap_create (NMEM nmem, int size, int key_size,
int (*cmp)(const void *p1, const void *p2))
{
- HEAP h = (HEAP) xmalloc (sizeof(*h));
+ HEAP h = (HEAP) nmem_malloc (nmem, sizeof(*h));
++size; /* heap array starts at 1 */
h->heapnum = 0;
h->heapmax = size;
h->keysize = key_size;
h->cmp = cmp;
- h->heap = (struct heap_item**) xmalloc((size)*sizeof(*h->heap));
+ h->heap = (struct heap_item**) nmem_malloc(nmem,(size)*sizeof(*h->heap));
h->heap[0]=0; /* not used */
return h;
}
+static void heap_clear( HEAP h)
+{
+ assert(h);
+ h->heapnum=0;
+}
+
static void heap_destroy (HEAP h)
{
- xfree (h->heap); /* safe, they all point to the rfd */
- xfree (h);
+ /* nothing to delete, all is nmem'd, and will go away in due time */
}
info->rsets=(RSET*)nmem_malloc(rnew->nmem, no_rsets*sizeof(*rsets));
memcpy(info->rsets,rsets,no_rsets*sizeof(*rsets));
info->rfd_list = NULL;
+ info->free_list = NULL;
rnew->priv=info;
return rnew;
}
assert (info->rfd_list == NULL);
for(i=0;i<info->no_rsets;i++)
rset_delete(info->rsets[i]);
-/* xfree(info->rsets); */ /* nmem'd */
-/* xfree(info); */ /* nmem'd */
}
#if 0
static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
logf (LOG_FATAL, "multior set type is read-only");
return NULL;
}
- rfd = (struct rset_multior_rfd *) xmalloc (sizeof(*rfd));
+ rfd=info->free_list;
+ if (rfd) {
+ info->free_list=rfd->next;
+ heap_clear(rfd->h);
+ assert(rfd->items);
+ /* all other pointers shouls already be allocated, in right sizes! */
+ }
+ else {
+ rfd = (struct rset_multior_rfd *) nmem_malloc (ct->nmem,sizeof(*rfd));
+ rfd->h = heap_create( ct->nmem, info->no_rsets,
+ info->key_size, info->cmp);
+ rfd->items=(struct heap_item *) nmem_malloc(ct->nmem,
+ info->no_rsets*sizeof(*rfd->items));
+ for (i=0; i<info->no_rsets; i++){
+ rfd->items[i].rset=info->rsets[i];
+ rfd->items[i].buf=nmem_malloc(ct->nmem,info->key_size);
+ }
+ }
rfd->flag = flag;
rfd->next = info->rfd_list;
rfd->info = info;
info->rfd_list = rfd;
- rfd->h = heap_create( info->no_rsets, info->key_size, info->cmp);
rfd->prevvalue=0;
rfd->hits=0;
- rfd->items=(struct heap_item *) xmalloc(info->no_rsets*sizeof(*rfd->items));
for (i=0; i<info->no_rsets; i++){
- rfd->items[i].rset=info->rsets[i];
- rfd->items[i].buf=xmalloc(info->key_size);
- rfd->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
-/* if (item_readbuf(&(rfd->items[i]))) */
- if ( rset_read(rfd->items[i].rset, rfd->items[i].fd,
+ rfd->items[i].fd=rset_open(info->rsets[i],RSETF_READ);
+ if ( rset_read(rfd->items[i].rset, rfd->items[i].fd,
rfd->items[i].buf) )
- heap_insert(rfd->h, &(rfd->items[i]));
+ heap_insert(rfd->h, &(rfd->items[i]));
}
return rfd;
}
for (i = 0; i<info->no_rsets; i++) {
if (mrfd->items[i].fd)
rset_close(info->rsets[i],mrfd->items[i].fd);
- xfree(mrfd->items[i].buf);
}
- xfree(mrfd->items);
- if (mrfd->prevvalue)
- xfree(mrfd->prevvalue);
- xfree(mrfd);
+ mrfd->next=info->free_list;
+ info->free_list=mrfd;
return;
}
logf (LOG_FATAL, "r_close but no rfd match!");
-/* $Id: rsnull.c,v 1.22 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsnull.c,v 1.23 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002
Index Data Aps
static void r_rewind (RSFD rfd)
{
- logf (LOG_DEBUG, "rsnull_rewind");
}
static void r_pos (RSFD rfd, double *current, double *total)
-/* $Id: rsprox.c,v 1.11 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rsprox.c,v 1.12 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
Index Data Aps
int (*cmp)(const void *p1, const void *p2);
int (*getseq)(const void *p);
struct rset_prox_rfd *rfd_list;
+ struct rset_prox_rfd *free_list;
};
struct rset_prox_rfd {
info->relation=relation;
info->distance=distance;
info->rfd_list = NULL;
+ info->free_list = NULL;
rnew->priv=info;
return rnew;
}
assert (info->rfd_list == NULL);
for (i = 0; i<info->rset_no; i++)
rset_delete (info->rset[i]);
-/* xfree (info->rset); */ /* nmems! */
-/* xfree (info); */
}
-#if 0
-static void *r_create (RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_prox_parms *prox_parms = (rset_prox_parms *) parms;
- struct rset_prox_info *info;
-
- info = (struct rset_prox_info *) xmalloc (sizeof(*info));
- memcpy(&info->p, prox_parms, sizeof(struct rset_prox_parms));
- assert(info->p.rset_no >= 2);
- info->p.rset = xmalloc(info->p.rset_no * sizeof(*info->p.rset));
- memcpy(info->p.rset, prox_parms->rset,
- info->p.rset_no * sizeof(*info->p.rset));
- info->rfd_list = NULL;
- return info;
-}
-#endif
static RSFD r_open (RSET ct, int flag)
{
logf (LOG_FATAL, "prox set type is read-only");
return NULL;
}
- rfd = (struct rset_prox_rfd *) xmalloc (sizeof(*rfd));
+ rfd = info->free_list;
+ if (rfd)
+ info->free_list=rfd->next;
+ else {
+ rfd = (struct rset_prox_rfd *) xmalloc (sizeof(*rfd));
+ rfd->more = nmem_malloc (ct->nmem,sizeof(*rfd->more) * info->rset_no);
+ rfd->buf = nmem_malloc(ct->nmem,sizeof(*rfd->buf) * info->rset_no);
+ for (i = 0; i < info->rset_no; i++)
+ rfd->buf[i] = nmem_malloc(ct->nmem,info->key_size);
+ rfd->rfd = nmem_malloc(ct->nmem,sizeof(*rfd->rfd) * info->rset_no);
+ }
logf(LOG_DEBUG,"rsprox (%s) open [%p]", ct->control->desc, rfd);
rfd->next = info->rfd_list;
info->rfd_list = rfd;
rfd->info = info;
- rfd->more = xmalloc (sizeof(*rfd->more) * info->rset_no);
-
- rfd->buf = xmalloc(sizeof(*rfd->buf) * info->rset_no);
- for (i = 0; i < info->rset_no; i++)
- rfd->buf[i] = xmalloc (info->key_size);
- rfd->rfd = xmalloc(sizeof(*rfd->rfd) * info->rset_no);
- for (i = 0; i < info->rset_no; i++)
+ for (i = 0; i < info->rset_no; i++) {
rfd->rfd[i] = rset_open (info->rset[i], RSETF_READ);
-
- for (i = 0; i < info->rset_no; i++)
rfd->more[i] = rset_read (info->rset[i], rfd->rfd[i],
rfd->buf[i]);
+ }
rfd->hits=0;
return rfd;
}
if (*rfdp == rfd)
{
int i;
- for (i = 0; i<info->rset_no; i++)
- xfree ((*rfdp)->buf[i]);
- xfree ((*rfdp)->buf);
- xfree ((*rfdp)->more);
-
+ struct rset_prox_rfd *rfd_tmp=*rfdp;
for (i = 0; i<info->rset_no; i++)
rset_close (info->rset[i], (*rfdp)->rfd[i]);
- xfree ((*rfdp)->rfd);
-
*rfdp = (*rfdp)->next;
- xfree (rfd);
+ rfd_tmp->next=info->free_list;
+ info->free_list=rfd_tmp;
return;
}
logf (LOG_FATAL, "r_close but no rfd match!");
-/* $Id: rstemp.c,v 1.45 2004-08-24 14:25:16 heikki Exp $
+/* $Id: rstemp.c,v 1.46 2004-08-26 11:11:59 heikki Exp $
Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
Index Data Aps
static void r_close (RSFD rfd);
static void r_delete (RSET ct);
static void r_rewind (RSFD rfd);
-/* static int r_count (RSET ct);*/
static int r_read (RSFD rfd, void *buf);
static int r_write (RSFD rfd, const void *buf);
static void r_pos (RSFD rfd, double *current, double *total);
-/* FIXME - Use the nmem instead of xmalloc all the way through */
static const struct rset_control control =
{
zint hits; /* no of hits */
char *temp_path;
int (*cmp)(const void *p1, const void *p2);
- struct rset_temp_rfd *rfd_list;
+ struct rset_temp_rfd *rfd_list; /* rfds in use */
+ struct rset_temp_rfd *free_list; /* fully alloc'd rfds waiting for reuse*/
};
struct rset_temp_rfd {
RSET rnew=rset_create_base(&control, nmem);
struct rset_temp_info *info;
- info = (struct rset_temp_info *) nmem_malloc ( rnew->nmem, sizeof(*info));
+ info = (struct rset_temp_info *) nmem_malloc(rnew->nmem, sizeof(*info));
info->fd = -1;
info->fname = NULL;
info->key_size = key_size;
info->hits = 0;
info->cmp = cmp;
info->rfd_list = NULL;
+ info->free_list = NULL;
if (!temp_path)
info->temp_path = NULL;
return rnew;
} /* rstemp_create */
-#if 0
-static void *r_create(RSET ct, const struct rset_control *sel, void *parms)
-{
- rset_temp_parms *temp_parms = (rset_temp_parms *) parms;
- struct rset_temp_info *info;
-
- info = (struct rset_temp_info *) xmalloc (sizeof(struct rset_temp_info));
- info->fd = -1;
- info->fname = NULL;
- info->key_size = temp_parms->key_size;
- info->buf_size = 4096;
- info->buf_mem = (char *) xmalloc (info->buf_size);
- info->pos_end = 0;
- info->pos_buf = 0;
- info->dirty = 0;
- info->hits = 0;
- info->cmp = temp_parms->cmp;
- info->rfd_list = NULL;
-
- if (!temp_parms->temp_path)
- info->temp_path = NULL;
- else
- {
- info->temp_path = (char *) xmalloc (strlen(temp_parms->temp_path)+1);
- strcpy (info->temp_path, temp_parms->temp_path);
- }
-
- return info;
-}
-#endif
-
static void r_delete (RSET ct)
{
struct rset_temp_info *info = (struct rset_temp_info*) ct->priv;
exit (1);
}
}
- rfd = (struct rset_temp_rfd *) xmalloc (sizeof(*rfd));
+ rfd = info->free_list;
+ if (rfd)
+ info->free_list=rfd->next;
+ else {
+ rfd = (struct rset_temp_rfd *) xmalloc (sizeof(*rfd));
+ rfd->buf = xmalloc (info->key_size);
+ }
rfd->next = info->rfd_list;
info->rfd_list = rfd;
rfd->info = info;
r_rewind (rfd);
- rfd->buf = xmalloc (info->key_size);
-
return rfd;
}
for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
if (*rfdp == rfd)
{
+ struct rset_temp_rfd *rfd_tmp=*rfdp;
r_flush (*rfdp, 0);
- xfree ((*rfdp)->buf);
-
*rfdp = (*rfdp)->next;
- xfree (rfd);
+ rfd_tmp->next=info->free_list;
+ info->free_list=rfd_tmp;
if (!info->rfd_list && info->fname && info->fd != -1)
{