cdb_make.h File Reference

#include "buffer.h"
#include <rz_types.h>

Go to the source code of this file.

Classes
struct	cdb_hp
struct	cdb_hplist
struct	cdb_make

Macros
#define	CDB_HPLIST   1000

Functions
int	cdb_make_start (struct cdb_make *, int)
int	cdb_make_addbegin (struct cdb_make *, unsigned int, unsigned int)
int	cdb_make_addend (struct cdb_make *, unsigned int, unsigned int, ut32)
int	cdb_make_add (struct cdb_make *, const char *, unsigned int, const char *, unsigned int)
int	cdb_make_finish (struct cdb_make *)

Macro Definition Documentation

CDB_HPLIST

#define CDB_HPLIST   1000

Definition at line 14 of file cdb_make.h.

Function Documentation

cdb_make_add()

int cdb_make_add	(	struct cdb_make *	c,
		const char *	key,
		unsigned int	keylen,
		const char *	data,
		unsigned int	datalen
	)

Definition at line 108 of file cdb_make.c.

                                                                                                   {
    /* add tailing \0 to allow mmap to work later */
    keylen++;
    datalen++;
    if (!cdb_make_addbegin(c, keylen, datalen)) {
        return 0;
    }
    if (!buffer_putalign(&c->b, key, keylen)) {
        return 0;
    }
    if (!buffer_putalign(&c->b, data, datalen)) {
        return 0;
    }
    return cdb_make_addend(c, keylen, datalen, sdb_hash(key));
}

References buffer_putalign(), c, cdb_make_addbegin(), cdb_make_addend(), key, and sdb_hash().

Referenced by sdb_disk_insert().

cdb_make_addbegin()

int cdb_make_addbegin	(	struct cdb_make *	c,
		unsigned int	keylen,
		unsigned int	datalen
	)

Definition at line 100 of file cdb_make.c.

                                                                     {
    ut8 buf[KVLSZ];
    if (!pack_kvlen(buf, keylen, datalen)) {
        return 0;
    }
    return buffer_putalign(&c->b, (const char *)buf, KVLSZ);
}

References buffer_putalign(), c, KVLSZ, and pack_kvlen().

Referenced by cdb_make_add().

cdb_make_addend()

int cdb_make_addend	(	struct cdb_make *	c,
		unsigned int	keylen,
		unsigned int	datalen,
		ut32	h
	)

Definition at line 63 of file cdb_make.c.

                                                                           {
    ut32 u;
    struct cdb_hplist *head = c->head;
    if (!head || (head->num >= CDB_HPLIST)) {
        if (!(head = R_ANEW(struct cdb_hplist))) {
            return 0;
        }
        head->num = 0;
        head->next = c->head;
        c->head = head;
    }
    head->hp[head->num].h = h;
    head->hp[head->num].p = c->pos;
    head->num++;
    c->numentries++;
    c->count[255 & h]++;
    u = c->count[255 & h] * 2;
    if (u > c->memsize) {
        c->memsize = u;
    }
    return incpos(c, KVLSZ + keylen + datalen);
}

References c, CDB_HPLIST, h, test-lz4-versions::head, incpos(), KVLSZ, and R_ANEW.

Referenced by cdb_make_add().

cdb_make_finish()

int cdb_make_finish

(

struct cdb_make *

c

)

Definition at line 124 of file cdb_make.c.

                                        {
    int i;
    char buf[8];
    struct cdb_hp *hp;
    struct cdb_hplist *x, *n;
    ut32 len, u, memsize, count, where;
 
    memsize = c->memsize + c->numentries;
    if (memsize > (UT32_MAX / sizeof(struct cdb_hp))) {
        return 0;
    }
    c->split = (struct cdb_hp *)cdb_alloc(memsize * sizeof(struct cdb_hp));
    if (!c->split) {
        return 0;
    }
    c->hash = c->split + c->numentries;
 
    for (u = i = 0; i < 256; i++) {
        u += c->count[i]; /* bounded by numentries, so no overflow */
        c->start[i] = u;
    }
 
    for (x = c->head; x; x = x->next) {
        i = x->num;
        while (i--) {
            c->split[--c->start[255 & x->hp[i].h]] = x->hp[i];
        }
    }
 
    for (i = 0; i < 256; i++) {
        count = c->count[i];
        len = count << 1;
        ut32_pack(c->final + 4 * i, c->pos);
        for (u = 0; u < len; u++) {
            c->hash[u].h = c->hash[u].p = 0;
        }
        hp = c->split + c->start[i];
        for (u = 0; u < count; u++) {
            where = (hp->h >> 8) % len;
            while (c->hash[where].p) {
                if (++where == len) {
                    where = 0;
                }
            }
            c->hash[where] = *hp++;
        }
        for (u = 0; u < len; u++) {
            ut32_pack(buf, c->hash[u].h);
            ut32_pack(buf + 4, c->hash[u].p);
            if (!buffer_putalign(&c->b, buf, 8)) {
                return 0;
            }
            if (!incpos(c, 8)) {
                return 0;
            }
        }
    }
 
    if (!buffer_flush(&c->b)) {
        return 0;
    }
    if (!seek_set(c->fd, 0)) {
        return 0;
    }
    // free childs
    for (x = c->head; x;) {
        n = x->next;
        cdb_alloc_free(x);
        x = n;
    }
    cdb_alloc_free(c->split);
    return buffer_putflush(&c->b, c->final, sizeof c->final);
}

References buffer_flush(), buffer_putalign(), buffer_putflush(), c, cdb_alloc(), cdb_alloc_free(), count, cdb_hp::h, i, incpos(), len, n, seek_set(), UT32_MAX, ut32_pack(), and x.

Referenced by sdb_disk_finish().

cdb_make_start()

int cdb_make_start	(	struct cdb_make *	c,
		int	fd
	)

Definition at line 37 of file cdb_make.c.

                                               {
    int i;
    c->head = 0;
    c->split = 0;
    c->hash = 0;
    c->numentries = 0;
    c->fd = fd;
    c->pos = sizeof(c->final);
    buffer_init(&c->b, (BufferOp)write, fd, c->bspace, sizeof(c->bspace));
    c->memsize = 1;
    for (i = 0; i < 256; i++) {
        c->count[i] = 0;
    }
    return seek_set(fd, c->pos);
}

References buffer_init(), c, fd, i, seek_set(), and write.

Referenced by sdb_disk_create().