[SCM] Hurd branch, master, updated. v0.5-280-g2c7ecdc

[Justus Winter]

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 <address@hidden>
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 <address@hidden>
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 <address@hidden>
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 <address@hidden>
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 <address@hidden>
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 <address@hidden>
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