From: Michael Matz Date: Fri, 28 Dec 2007 00:04:38 +0000 (+0000) Subject: Memory efficient representation of the dirtree (important for X-Git-Tag: BASE-SuSE-Code-12_1-Branch~1038 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=10bf69e1d9eb04f4da1c60593333110eb05a9531;p=platform%2Fupstream%2Flibsolv.git Memory efficient representation of the dirtree (important for unabridged packages.DU). Store and reread the dirtree (in a hacky way, should use the info block). Make dumpattr show the directory names. On disk the same info as in my 10.3 packages.DU (1.4MB, 330 KB gzipped) only takes 146 KB. --- diff --git a/src/attr_store.c b/src/attr_store.c index 1870532..1ac16c0 100644 --- a/src/attr_store.c +++ b/src/attr_store.c @@ -96,6 +96,37 @@ setup_dirs (Attrstore *s) stringpool_init (&s->dirtree.ss, ss_init_strs); } +#if 0 +static void +dir_setup_flatsons (Dirtree *d) +{ + if (d->flatsons) + return; + if (!d->nflatdirs) + return; + d->flatsons = xcalloc (d->nflatdirs, sizeof (d->flatsons[0])); + unsigned firstson = -1; + unsigned i; + for (i = 0; i < d->nflatdirs; i++) + if (d->flatdirs[i] & 1) + /* A node, i.e. potential son. */ + { + if (firstson == -1) + firstson = i; + } + else if (d->flatdirs[i] & 2) + /* An intermediate parent pointer. */ + ; + else + /* The final parent pointer. Remember the first son. */ + { + assert (firstson != -1); + d->flatsons[d->flatdirs[i] >> 2] = firstson; + firstson = -1; + } +} +#endif + static unsigned dir_lookup_1 (Attrstore *s, unsigned dir, const char *name, unsigned insert) { @@ -188,17 +219,30 @@ endmatch2: unsigned dir_parent (Attrstore *s, unsigned dir) { - return s->dirtree.dirs[dir].parent; + if (s->dirtree.dirs) + return s->dirtree.dirs[dir].parent; + /* We have the packed representation. */ + unsigned p; + while ((p = s->dirtree.flatdirs[dir]) & 1) + dir++; + return p >> 2; } void dir2str (Attrstore *s, unsigned dir, char **str, unsigned *len) { unsigned l = 0; - Id ids[s->dirtree.dirstack_size + 1]; + Id ids[256]; unsigned i, ii; - for (i = 0; dir > 1; dir = dir_parent (s, dir), i++) - ids[i] = s->dirtree.dirs[dir].name; + if (s->dirtree.dirs) + for (i = 0; i < 256 && dir > 1; dir = dir_parent (s, dir), i++) + ids[i] = s->dirtree.dirs[dir].name; + else + for (i = 0; i < 256 && dir > 1; dir = dir_parent (s, dir), i++) + { + assert (s->dirtree.flatdirs[dir] & 1); + ids[i] = s->dirtree.flatdirs[dir] >> 1; + } ii = i; l = 1; for (i = 0; i < ii; i++) @@ -787,6 +831,47 @@ add_key (Attrstore *s, Id name, unsigned type, unsigned size) return s->nkeys++; } +#define DIR_BLOCK 1023 +#define CACHE_LINE 32 +#define CACHE_LINE_ELEMS (CACHE_LINE / sizeof(unsigned)) + +static void +finalize_dirs_rec (Dirtree *d, unsigned dir) +{ + unsigned c, parent; + if (!d->dirs[dir].child) + return; + parent = d->dirmap[dir]; + assert(parent); + parent--; + for (c = d->dirs[dir].child; c; c = d->dirs[c].sibling) + { + unsigned id = d->dirs[c].name; + if ((d->nflatdirs & (CACHE_LINE_ELEMS - 1)) == CACHE_LINE_ELEMS - 1) + add_elem (d->flatdirs, d->nflatdirs, parent * 4 + 2, DIR_BLOCK); + d->dirmap[c] = d->nflatdirs + 1; + add_elem (d->flatdirs, d->nflatdirs, id * 2 + 1, DIR_BLOCK); + } + add_elem (d->flatdirs, d->nflatdirs, parent * 4, DIR_BLOCK); + for (c = d->dirs[dir].child; c; c = d->dirs[c].sibling) + finalize_dirs_rec (d, c); +} + +static void +finalize_dirtree (Dirtree *d) +{ + if (d->nflatdirs || !d->ndirs) + return; + d->dirmap = calloc (d->ndirs, sizeof (d->dirmap[0])); + d->nflatdirs = 0; + d->flatdirs = 0; + d->flatsons = 0; + d->dirmap[1] = d->nflatdirs + 1; + finalize_dirs_rec (d, 1); + xfree (d->dirs); + d->dirs = 0; +} + void attr_store_pack (Attrstore *s) { @@ -794,6 +879,8 @@ attr_store_pack (Attrstore *s) unsigned int old_mem = 0; if (s->packed) return; + finalize_dirtree (&s->dirtree); + s->ent2attr = xcalloc (s->entries, sizeof (s->ent2attr[0])); s->flat_attrs = 0; s->attr_next_free = 0; @@ -802,6 +889,8 @@ attr_store_pack (Attrstore *s) s->schemata = 0; s->schemaofs = 0; + Id id_diskusage = str2id (s->pool, "diskusage", 0); + add_num (s->flat_attrs, s->attr_next_free, 0, FLAT_ATTR_BLOCK); add_elem (s->schemata, s->szschemata, 0, SCHEMA_BLOCK); add_elem (s->schemaofs, s->nschemata, 0, SCHEMA_BLOCK); @@ -878,7 +967,14 @@ attr_store_pack (Attrstore *s) { const int *il = nv[ofs].v.intlist; int len = *il++; - //add_num (s->flat_attrs, s->attr_next_free, len, FLAT_ATTR_BLOCK); + if (s->dirtree.dirmap + && s->keys[nv[ofs].key].name == id_diskusage) + { + unsigned i; + assert (!(len % 3)); + for (i = 1; i <= len; i += 3) + nv[ofs].v.intlist[i] = s->dirtree.dirmap[nv[ofs].v.intlist[i]] - 1; + } old_mem += 4 * (len + 1); while (len--) { @@ -911,6 +1007,8 @@ attr_store_pack (Attrstore *s) old_mem += s->entries * sizeof (s->attrs[0]); free (s->attrs); s->attrs = 0; + xfree (s->dirtree.dirmap); + s->dirtree.dirmap = 0; /* Remove the hashtable too, it will be build on demand in str2localid the next time we call it, which should not happen while in packed mode. */ @@ -1015,6 +1113,7 @@ attr_store_unpack (Attrstore *s) xfree (s->schemata); s->schemata = 0; s->szschemata = 0; + /* XXX unpack the dirtree */ } static void @@ -1247,6 +1346,28 @@ write_attr_store (FILE *fp, Attrstore *s) exit (1); } + /* XXX write the dirtree as info block. */ + write_id (fp, s->dirtree.ndirs); + if (s->dirtree.ndirs) + { + for (i = 1, local_ssize = 0; i < (unsigned)s->dirtree.ss.nstrings; i++) + local_ssize += 1 + strlen (s->dirtree.ss.stringspace + s->dirtree.ss.strings[i]); + + write_u32 (fp, s->dirtree.ss.nstrings); + write_u32 (fp, local_ssize); + for (i = 1; i < (unsigned)s->dirtree.ss.nstrings; i++) + { + const char *str = s->dirtree.ss.stringspace + s->dirtree.ss.strings[i]; + if (fwrite(str, strlen(str) + 1, 1, fp) != 1) + { + perror("write error"); + exit(1); + } + } + write_id (fp, s->dirtree.nflatdirs); + for (i = 0; i < s->dirtree.nflatdirs; i++) + write_id (fp, s->dirtree.flatdirs[i]); + } write_pages (fp, s); } @@ -1483,12 +1604,51 @@ read_or_setup_pages (FILE *fp, Attrstore *s) } } +static void +read_stringpool (FILE *fp, Stringpool *ss, unsigned nstrings) +{ + unsigned i; + unsigned local_ssize; + /* Slightly hacky. Our local string pool already contains "" and + "". We write out the "" too, so we have to read over it. We write it + out to be compatible with the SOLV file and to not have to introduce + merging and mapping the string IDs. */ + local_ssize = read_u32 (fp) - 1; + char *strsp = (char *)xrealloc(ss->stringspace, ss->sstrings + local_ssize + 1); + Offset *str = (Offset *)xrealloc(ss->strings, nstrings * sizeof(Offset)); + + ss->stringspace = strsp; + ss->strings = str; + strsp += ss->sstrings; + + unsigned char ignore_char = 1; + if (fread(&ignore_char, 1, 1, fp) != 1 + || (local_ssize && fread(strsp, local_ssize, 1, fp) != 1) + || ignore_char != 0) + { + perror ("read error while reading strings"); + exit(1); + } + strsp[local_ssize] = 0; + + /* Don't build hashtable here, it will be built on demand by str2localid + should we call that. */ + + strsp = ss->stringspace; + ss->nstrings = nstrings; + for (i = 0; i < nstrings; i++) + { + str[i] = strsp - ss->stringspace; + strsp += strlen (strsp) + 1; + } + ss->sstrings = strsp - ss->stringspace; +} + Attrstore * attr_store_read (FILE *fp, Pool *pool) { unsigned nentries; unsigned i; - unsigned local_ssize; unsigned nstrings, nschemata; Attrstore *s = new_store (pool); @@ -1520,39 +1680,7 @@ attr_store_read (FILE *fp, Pool *pool) exit (1); } - /* Slightly hacky. Our local string pool already contains "" and - "". We write out the "" too, so we have to read over it. We write it - out to be compatible with the SOLV file and to not have to introduce - merging and mapping the string IDs. */ - local_ssize = read_u32 (fp) - 1; - char *strsp = (char *)xrealloc(s->ss.stringspace, s->ss.sstrings + local_ssize + 1); - Offset *str = (Offset *)xrealloc(s->ss.strings, (nstrings) * sizeof(Offset)); - - s->ss.stringspace = strsp; - s->ss.strings = str; - strsp += s->ss.sstrings; - - unsigned char ignore_char = 1; - if (fread(&ignore_char, 1, 1, fp) != 1 - || (local_ssize && fread(strsp, local_ssize, 1, fp) != 1) - || ignore_char != 0) - { - perror ("read error while reading strings"); - exit(1); - } - strsp[local_ssize] = 0; - - /* Don't build hashtable here, it will be built on demand by str2localid - should we call that. */ - - strsp = s->ss.stringspace; - s->ss.nstrings = nstrings; - for (i = 0; i < nstrings; i++) - { - str[i] = strsp - s->ss.stringspace; - strsp += strlen (strsp) + 1; - } - s->ss.sstrings = strsp - s->ss.stringspace; + read_stringpool (fp, &s->ss, nstrings); s->keys = xrealloc (s->keys, ((s->nkeys + KEY_BLOCK) & ~KEY_BLOCK) * sizeof (s->keys[0])); /* s->keys[0] is initialized in new_store. */ @@ -1603,6 +1731,22 @@ attr_store_read (FILE *fp, Pool *pool) exit (1); } + s->dirtree.ndirs = read_id (fp, 0); + if (s->dirtree.ndirs) + { + unsigned ndirs = s->dirtree.ndirs; + setup_dirs (s); + xfree (s->dirtree.dirs); + s->dirtree.dirs = 0; + s->dirtree.ndirs = ndirs; + + nstrings = read_u32 (fp); + read_stringpool (fp, &s->dirtree.ss, nstrings); + s->dirtree.nflatdirs = read_id (fp, 0); + s->dirtree.flatdirs = xmalloc (s->dirtree.nflatdirs * sizeof (s->dirtree.flatdirs[0])); + for (i = 0; i < s->dirtree.nflatdirs; i++) + s->dirtree.flatdirs[i] = read_id (fp, 0); + } read_or_setup_pages (fp, s); s->packed = 1; diff --git a/src/attr_store_p.h b/src/attr_store_p.h index 981d383..d8b007c 100644 --- a/src/attr_store_p.h +++ b/src/attr_store_p.h @@ -47,6 +47,18 @@ typedef struct _Dir Id name; } Dir; +typedef struct _Dirtree { + Dir *dirs; + unsigned ndirs; + Stringpool ss; + unsigned *dirstack; + unsigned ndirstack, dirstack_size; + unsigned *flatdirs; + unsigned nflatdirs; + unsigned *flatsons; + unsigned *dirmap; +} Dirtree; + struct _Attrstore { Pool *pool; @@ -65,13 +77,7 @@ struct _Attrstore Stringpool ss; - struct Dirtree { - Dir *dirs; - unsigned ndirs; - Stringpool ss; - unsigned *dirstack; - unsigned ndirstack, dirstack_size; - } dirtree; + Dirtree dirtree; /* A space efficient in memory representation. It's read-only. */ /* flat_attrs[ent2attr[i]] are the attrs for entity i. */ diff --git a/tools/dumpattr.c b/tools/dumpattr.c index 3fb8d4f..87657d3 100644 --- a/tools/dumpattr.c +++ b/tools/dumpattr.c @@ -18,6 +18,38 @@ #include "pool.h" #include "attr_store_p.h" +static Id id_diskusage; + +static void +dump_diskusage (Attrstore *s, const unsigned char *numlist) +{ + char sbuf[1024]; + char *buf = sbuf; + unsigned slen = sizeof (sbuf); + fprintf (stdout, "DU\n"); + while (1) + { + unsigned dirid, filesz, filenum; + int val; + get_num (numlist, val); + dirid = (val & 63) | ((val >> 1) & ~63); + if (!(val & 64)) + break; + get_num (numlist, val); + filesz = (val & 63) | ((val >> 1) & ~63); + if (!(val & 64)) + break; + get_num (numlist, val); + filenum = (val & 63) | ((val >> 1) & ~63); + dir2str (s, dirid, &buf, &slen); + fprintf (stdout, " %s %d %d %d\n", buf, dirid, filesz, filenum); + if (!(val & 64)) + break; + } + if (buf != sbuf) + free (buf); +} + static void dump_attrs (Attrstore *s, unsigned int entry) { @@ -43,19 +75,22 @@ dump_attrs (Attrstore *s, unsigned int entry) fprintf (stdout, "str %s\n", ai.as_string); break; case TYPE_ATTR_INTLIST: - { - fprintf (stdout, "lint\n "); - while (1) - { - int val; - get_num (ai.as_numlist, val); - fprintf (stdout, " %d", (val & 63) | ((val >> 1) & ~63)); - if (!(val & 64)) - break; - } - fprintf (stdout, "\n"); - break; - } + if (ai.name == id_diskusage) + dump_diskusage (s, ai.as_numlist); + else + { + fprintf (stdout, "lint\n "); + while (1) + { + int val; + get_num (ai.as_numlist, val); + fprintf (stdout, " %d", (val & 63) | ((val >> 1) & ~63)); + if (!(val & 64)) + break; + } + fprintf (stdout, "\n"); + } + break; case TYPE_ATTR_LOCALIDS: { fprintf (stdout, "lids"); @@ -93,6 +128,7 @@ main (int argc, char *argv[]) unsigned int i; Pool *pool = pool_create (); Attrstore *s = attr_store_read (stdin, pool); + id_diskusage = str2id (pool, "diskusage", 0); /* For now test the packing code. */ attr_store_unpack (s); attr_store_pack (s);