Trees in the Reiser4 Filesystem, Part I

The basic structure of the new ReiserFS—graphs vs. trees, keys, nodes and blocks.

One way of organizing information is to
put it into trees. When we organize information in a computer, we
typically sort it into piles called nodes, with a name (pointer)
for each pile. Some of the nodes contain pointers, and we can look
through the nodes to find those pointers to (usually other) nodes.

We are interested particularly in how to organize so we
actually can find things when we search for them. A tree is an
organizational structure that has some useful properties for that
purpose. We define a tree as follows:

A tree is a set of nodes organized into a root node
and zero or more additional sets of nodes, called subtrees.

Each of the subtrees is a tree.

No node in the tree points to the root node, and
exactly one pointer from a node in the tree points to each non-root
node in the tree.

The root node has a pointer to each of its
subtrees, that is, a pointer to the root node of the
subtree.

Note that a single node with no pointers is a tree, because
it is the root node. Also, a tree can be a linear tree of nodes
without branches.

Figure 1. Write Performance (30 Copies Linux Kernel 2.4.18)

Figure 2. Read Performance (Reading Linux Kernel 2.4.18 Source
Code)

Fine Points of the Definition

It is interesting to argue about whether finite should be a
part of the definition of trees. There are many ways of defining
trees, and which is the best definition depends on your purpose.
Professor Donald Knuth supplies several definitions of tree. As his
primary definition of tree he even supplies one which has no
pointers, edges or lines in the definition, only sets of
nodes.

Knuth defines trees as being finite sets of nodes. There are
papers on inifinte trees on the Internet. I think it more
appropriate to consider finite an additional qualifier on trees,
rather than bundling finite into the definition. However, I
personally only deal with finite trees in my research.

Edge is a term often used in tree definitions. A pointer is
unidirectional, meaning you can follow it from the node that has it
to the node it points to, but you cannot follow it back from the
node it points to, to the node that has it. An edge, however, is
bidirectional, meaning you can follow it in both directions.

Here are three alternative tree definitions, which are
interesting in how they are mathematically equivalent to each
other. They are not equivalent to the definition I supplied,
because edges are not equivalent to pointers. For all three of
these definitions, let there be no more than one edge connecting
the same two nodes:

a set of vertices (aka points) connected by edges
(aka lines) for which the number of edges is one less than the
number of vertices;

a set of vertices connected by edges that have no
cycles (a cycle is a path from a vertex to itself);

or a set of vertices connected by edges for which
there is exactly one path connecting any two vertices.

These three alternative definitions do not have a unique root
in their tree, and such trees are called free trees.

The definition I supplied is a definition of a rooted tree,
not a free tree. It also has no cycles, it has one less pointer
than it has nodes, and there is exactly one path from the root to
any node.

Graphs vs. Trees

Consider the purposes for which you might want to use a graph
and those for which you might want to use a tree. In a tree there
is exactly one path from the root to each node in the tree, and a
tree has the minimum number of pointers sufficient to connect all
the nodes. This makes it a simple and efficient structure. Trees
are useful when efficiency with minimal complexity is desired and
when there is no need to reach a node by more than one
route.

Reiser4 has both graphs and trees, with trees used when the
filesystem chooses the organization (in what we call the storage
layer, which tries to be simple and efficient) and graphs when the
user chooses the organization (in the semantic layer, which tries
to be expressive so that the user can do whatever he or she
wants).

Keys

We assign a key to everything stored in the tree. We find
things by their keys, and using them gives us additional
flexibility in how we sort things. If the keys are small, we have a
compact means of specifying enough information to find the thing.
It also limits what information we can use for finding
things.

This limit restricts the key's usefulness, and so we have a
storage layer, which finds things by keys, and a semantic layer,
which has a rich naming system (described in Part II of this
article). The storage layer chooses keys for things solely to
organize storage in a way that improves performance, and the
semantic layer understands names that have meaning to users. As you
read, you might want to think about whether this is a useful
separation that allows the freedom to add improvements that aid
performance in the storage layer, while escaping paying a price for
the side effects of those improvements on the flexible naming
objectives of the semantic layer.

As Linux continues to play an ever increasing role in corporate data centers and institutions, ensuring the integrity and protection of these systems must be a priority. With 60% of the world's websites and an increasing share of organization's mission-critical workloads running on Linux, failing to stop malware and other advanced threats on Linux can increasingly impact an organization's reputation and bottom line.

Most companies incorporate backup procedures for critical data, which can be restored quickly if a loss occurs. However, fewer companies are prepared for catastrophic system failures, in which they lose all data, the entire operating system, applications, settings, patches and more, reducing their system(s) to “bare metal.” After all, before data can be restored to a system, there must be a system to restore it to.

In this one hour webinar, learn how to enhance your existing backup strategies for better disaster recovery preparedness using Storix System Backup Administrator (SBAdmin), a highly flexible bare-metal recovery solution for UNIX and Linux systems.