struct reclist
{
struct reclist_bucket **hashtable;
- int hashtable_size;
- int hashmask;
+ unsigned hash_size;
- struct record_cluster **flatlist;
- int flatlist_size;
int num_records;
- int pointer;
-
+ struct reclist_bucket *sorted_list;
+ struct reclist_bucket *sorted_ptr;
+ struct reclist_bucket **last;
NMEM nmem;
};
struct reclist_bucket
{
struct record_cluster *record;
- struct reclist_bucket *next;
-};
-
-#if 0
-struct reclist_sortparms *
-reclist_sortparms_insert_field_id(NMEM nmem,
- struct reclist_sortparms **sortparms,
- int field_id,
- enum conf_sortkey_type type,
- int increasing)
-{
- struct reclist_sortparms * tmp_rlsp = 0;
- // assert(nmem);
-
- if(!sortparms || field_id < 0)
- return 0;
-
- // construct new reclist_sortparms
- tmp_rlsp = nmem_malloc(nmem, sizeof(struct reclist_sortparms));
- tmp_rlsp->offset = field_id;
- tmp_rlsp->type = type;
- tmp_rlsp->increasing = increasing;
-
-
- // insert in *sortparms place, moving *sortparms one down the list
- tmp_rlsp->next = *sortparms;
- *sortparms = tmp_rlsp;
-
- return *sortparms;
-};
-#endif
-
-#if 0
-struct reclist_sortparms *
-reclist_sortparms_insert(NMEM nmem,
- struct reclist_sortparms **sortparms,
- struct conf_service * service,
- const char * name,
- int increasing)
-{
- int field_id = 0;
-
- if (!sortparms || !service || !name)
- return 0;
-
- field_id = conf_service_sortkey_field_id(service, name);
-
- if (-1 == field_id)
- return 0;
-
- return reclist_sortparms_insert_field_id(nmem, sortparms, field_id,
- service->sortkeys[field_id].type,
- increasing);
+ struct reclist_bucket *hnext;
+ struct reclist_bucket *snext;
};
-#endif
-
struct reclist_sortparms *reclist_parse_sortparms(NMEM nmem, const char *parms,
- struct conf_service *service)
+ struct conf_service *service)
{
struct reclist_sortparms *res = 0;
struct reclist_sortparms **rp = &res;
static int reclist_cmp(const void *p1, const void *p2)
{
- struct record_cluster *r1 = (*(struct record_cluster**) p1);
- struct record_cluster *r2 = (*(struct record_cluster**) p2);
+ struct record_cluster *r1 = (*(struct reclist_bucket**) p1)->record;
+ struct record_cluster *r2 = (*(struct reclist_bucket**) p2)->record;
struct reclist_sortparms *s;
int res = 0;
void reclist_sort(struct reclist *l, struct reclist_sortparms *parms)
{
+ struct reclist_bucket **flatlist = xmalloc(sizeof(*flatlist) * l->num_records);
+ struct reclist_bucket *ptr = l->sorted_list;
+ struct reclist_bucket **prev = &l->sorted_list;
+ int i = 0;
+ while (ptr)
+ {
+ flatlist[i] = ptr;
+ ptr = ptr->snext;
+ i++;
+ }
+ assert(i == l->num_records);
+
qsort_sortparms = parms;
- qsort(l->flatlist, l->num_records,
- sizeof(struct record_cluster*), reclist_cmp);
+ qsort(flatlist, l->num_records, sizeof(*flatlist), reclist_cmp);
+ for (i = 0; i < l->num_records; i++)
+ {
+ *prev = flatlist[i];
+ prev = &flatlist[i]->snext;
+ }
+ *prev = 0;
+ l->last = prev;
+
+ xfree(flatlist);
+
reclist_rewind(l);
}
struct record_cluster *reclist_read_record(struct reclist *l)
{
- if (l && l->pointer < l->num_records)
- return l->flatlist[l->pointer++];
+ if (l && l->sorted_ptr)
+ {
+ struct record_cluster *t = l->sorted_ptr->record;
+ l->sorted_ptr = l->sorted_ptr->snext;
+ return t;
+ }
else
return 0;
}
void reclist_rewind(struct reclist *l)
{
if (l)
- l->pointer = 0;
+ l->sorted_ptr = l->sorted_list;
}
-struct reclist *reclist_create(NMEM nmem, int numrecs)
+struct reclist *reclist_create(NMEM nmem)
{
- int hashsize = 1;
- struct reclist *res;
-
- assert(numrecs);
- while (hashsize < numrecs)
- hashsize <<= 1;
- res = nmem_malloc(nmem, sizeof(struct reclist));
+ struct reclist *res = nmem_malloc(nmem, sizeof(struct reclist));
+ res->hash_size = 399;
res->hashtable
- = nmem_malloc(nmem, hashsize * sizeof(struct reclist_bucket*));
- memset(res->hashtable, 0, hashsize * sizeof(struct reclist_bucket*));
- res->hashtable_size = hashsize;
+ = nmem_malloc(nmem, res->hash_size * sizeof(struct reclist_bucket*));
+ memset(res->hashtable, 0, res->hash_size * sizeof(struct reclist_bucket*));
res->nmem = nmem;
- res->hashmask = hashsize - 1; // Creates a bitmask
- res->num_records = 0;
- res->flatlist = nmem_malloc(nmem, numrecs * sizeof(struct record_cluster*));
- res->flatlist_size = numrecs;
+ res->sorted_ptr = 0;
+ res->sorted_list = 0;
+ res->last = &res->sorted_list;
+ res->num_records = 0;
return res;
}
return 0;
}
-struct record_cluster *reclist_get_cluster(struct reclist *l, int i)
-{
- return l->flatlist[i];
-}
-
// Insert a record. Return record cluster (newly formed or pre-existing)
struct record_cluster *reclist_insert( struct reclist *l,
struct conf_service *service,
assert(merge_key);
assert(total);
- bucket = jenkins_hash((unsigned char*) merge_key) & l->hashmask;
+ bucket = jenkins_hash((unsigned char*) merge_key) % l->hash_size;
- for (p = &l->hashtable[bucket]; *p; p = &(*p)->next)
+ for (p = &l->hashtable[bucket]; *p; p = &(*p)->hnext)
{
// We found a matching record. Merge them
if (!strcmp(merge_key, (*p)->record->merge_key))
break;
}
}
- if (!cluster && l->num_records < l->flatlist_size)
+ if (!cluster)
{
struct reclist_bucket *new =
- nmem_malloc(l->nmem, sizeof(struct reclist_bucket));
- struct record_cluster *newc =
- nmem_malloc(l->nmem, sizeof(struct record_cluster));
+ nmem_malloc(l->nmem, sizeof(*new));
+
+ cluster = nmem_malloc(l->nmem, sizeof(*cluster));
record->next = 0;
- new->record = newc;
- new->next = 0;
- newc->records = record;
- newc->merge_key = merge_key;
- newc->relevance = 0;
- newc->term_frequency_vec = 0;
- newc->recid = merge_key;
+ new->record = cluster;
+ new->hnext = 0;
+ cluster->records = record;
+ cluster->merge_key = merge_key;
+ cluster->relevance = 0;
+ cluster->term_frequency_vec = 0;
+ cluster->recid = merge_key;
(*total)++;
- newc->metadata = nmem_malloc(l->nmem,
- sizeof(struct record_metadata*) * service->num_metadata);
- memset(newc->metadata, 0,
+ cluster->metadata =
+ nmem_malloc(l->nmem,
+ sizeof(struct record_metadata*) * service->num_metadata);
+ memset(cluster->metadata, 0,
sizeof(struct record_metadata*) * service->num_metadata);
- newc->sortkeys = nmem_malloc(l->nmem,
- sizeof(struct record_metadata*) * service->num_sortkeys);
- memset(newc->sortkeys, 0,
+ cluster->sortkeys =
+ nmem_malloc(l->nmem, sizeof(struct record_metadata*) * service->num_sortkeys);
+ memset(cluster->sortkeys, 0,
sizeof(union data_types*) * service->num_sortkeys);
+
+ /* attach to hash list */
+ *p = new;
+
+ /* append to sorted_list */
+ *l->last = new;
+ l->last = &new->snext;
+ l->sorted_ptr = l->sorted_list;
+ new->snext = 0;
- *p = new;
- l->flatlist[l->num_records++] = newc;
- cluster = newc;
+ l->num_records++;
}
return cluster;
}