This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "Hurd".
The branch, master has been updated via 2c7ecdc6ec8f9d9a27aa7e4e82fa2d84fa55fe9b (commit) via d0c565fc35e8dc3daa5fb6e9a514c34873e6b204 (commit) via f6730b267a90ad73116e50b027e869cbe0b01211 (commit) via 6349d15921134adb4491eb9ce87720a0281a7bd6 (commit) via 94fecd72f41542c8dfa82bdf7b47742f8c29b321 (commit) via 80485401a9a5e9df03bd3a1503bc5e59d1f2e5c1 (commit) from 1d1da90042d2ee7a8215dc6291b54bc1ebe59fe4 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 2c7ecdc6ec8f9d9a27aa7e4e82fa2d84fa55fe9b Author: Justus Winter <4win...@informatik.uni-hamburg.de> Date: Thu May 29 02:03:03 2014 +0200 libdiskfs: use a hash table for the name cache Previously, name cache lookup operation completed in O(n) time. This means that making the cache too large would decrease the performance. Therefore it was required to tune the size. Implement the name cache using a hash table. We use buckets of a fixed size. We approximate the least-frequently used cache algorithm by counting the number of lookups using saturating arithmetic in the two lowest bits of the pointer to the name. Using this strategy we achieve a constant worst-case lookup and insertion time. Since we are not bound by the size of the cache anymore, increase its size from 200 to 1024. * libdiskfs/name-cache.c: Implement the name cache using a hash table. (diskfs_enter_lookup_cache): Change accordingly. (diskfs_purge_lookup_cache): Likewise. (diskfs_check_lookup_cache): Likewise. Also, hard code a cache miss for the parent of the root directory and merge unlocking and releasing of node references. commit d0c565fc35e8dc3daa5fb6e9a514c34873e6b204 Author: Justus Winter <4win...@informatik.uni-hamburg.de> Date: Wed May 28 16:48:04 2014 +0200 libdiskfs: remove the statistics code from the name cache The current name cache lookup operation completes in O(n) time. This means that making the cache too large would decrease the performance. Therefore it was required to tune the size, hence the need for statistics. We will use a data structure with worst case constant lookup times in the future, removing the need to fine tune the cache size. * libdiskfs/name-cache.c: Remove the statistics code from the name cache. commit f6730b267a90ad73116e50b027e869cbe0b01211 Author: Justus Winter <4win...@informatik.uni-hamburg.de> Date: Sun May 18 14:06:30 2014 +0200 trans/fakeroot: use netfs_node_netnode instead of np->nn When using fat nodes, expressions of the form E->nn can be rewritten as netfs_node_netnode (E). This is much faster as it only involves a offset calculation. For reference, I used the following semantic patch to create the patch: @@ expression E; @@ - E->nn + netfs_node_netnode (E) * trans/fakeroot.c: Use netfs_node_netnode instead of np->nn. commit 6349d15921134adb4491eb9ce87720a0281a7bd6 Author: Justus Winter <4win...@informatik.uni-hamburg.de> Date: Sun May 18 13:45:14 2014 +0200 trans/fakeroot: use fat nodes to simplify the node cache Previously, fakeroot stored netnodes in the hash table. But we are not interested in a cache for netnodes, we need a node cache. So fakeroot kept pointers to the associated node object in each netnode object. Use fat netfs nodes, which combine node and netnode objects. * trans/fakeroot.c (struct netnode): Remove np. (idport_ihash): Fix ihash location pointer offset. (new_node): Allocate fat nodes, store the node pointer in the hash table. (netfs_node_norefs): Adjust accordingly. (netfs_S_dir_lookup): Likewise. commit 94fecd72f41542c8dfa82bdf7b47742f8c29b321 Author: Justus Winter <4win...@informatik.uni-hamburg.de> Date: Sun May 18 13:34:12 2014 +0200 libnetfs: add netfs_make_node_alloc to allocate fat nodes libnetfs has two kind of nodes, struct node and struct netnode. struct node is used to store libnetfs specific data, while struct netnode contains user supplied data. Previously, both objects were allocated separatly, and a pointer from the node to the netnode provided a mapping from the former to the latter. Provide a function netfs_make_node_alloc that allocates both nodes in a contiguous region. This reduces the memory allocation overhead when creating nodes. It also makes the relation between node and netnode a simple offset calculation. Provide two functions to compute the netnode address from the node address and vice-versa. Most notably, this makes implementing a cache on top of libnetfs easier. Auxiliary data for the cache can be stored in the user-defined netnode, and the fat node can be used as the value. * libnetfs/make-node.c (init_node): Move initialization here. (netfs_make_node): Use init_node. (netfs_make_node_alloc): New function to allocate fat nodes. * libnetfs/netfs.h (netfs_make_node_alloc): New declaration. (_netfs_sizeof_struct_node): Likewise. (netfs_node_netnode): Compute netnode address from node address. (netfs_netnode_node): And vice-versa. * libnetfs/init-init.c (_netfs_sizeof_struct_node): New variable. commit 80485401a9a5e9df03bd3a1503bc5e59d1f2e5c1 Author: Justus Winter <4win...@informatik.uni-hamburg.de> Date: Fri May 16 23:06:33 2014 +0200 libdiskfs: add diskfs_make_node_alloc to allocate fat nodes libdiskfs has two kind of nodes, struct node and struct netnode. struct node is used to store libdiskfs specific data, while struct netnode contains user supplied data. Previously, both objects were allocated separatly, and a pointer from the node to the netnode provided a mapping from the former to the latter. Provide a function diskfs_make_node_alloc that allocates both nodes in a contiguous region. This reduces the memory allocation overhead when creating nodes. It also makes the relation between node and netnode a simple offset calculation. Provide two functions to compute the netnode address from the node address and vice-versa. Most notably, this makes implementing a cache on top of libdiskfs easier. Auxiliary data for the cache can be stored in the user-defined netnode, and the fat node can be used as the value. * libdiskfs/node-make.c (init_node): Move initialization here. (diskfs_make_node): Use init_node. (diskfs_make_node_alloc): New function to allocate fat nodes. * libdiskfs/diskfs.h (diskfs_make_node_alloc): New declaration. (_diskfs_sizeof_struct_node): Likewise. (diskfs_node_disknode): Compute disknode address from node address. (diskfs_disknode_node): And vice-versa. * libdiskfs/init-init.c (_diskfs_sizeof_struct_node): New variable. ----------------------------------------------------------------------- Summary of changes: libdiskfs/diskfs.h | 27 +++ libdiskfs/init-init.c | 4 + libdiskfs/name-cache.c | 410 ++++++++++++++++++++++++++++++------------------ libdiskfs/node-make.c | 39 ++++- libnetfs/init-init.c | 3 + libnetfs/make-node.c | 29 +++- libnetfs/netfs.h | 27 +++ trans/fakeroot.c | 135 ++++++++-------- 8 files changed, 439 insertions(+), 235 deletions(-) hooks/post-receive -- Hurd