--------
*chunk*
- when the encoding function is called, it returns chunks of the same
- size. Data chunks which can be concatenated to reconstruct the original
- object and coding chunks which can be used to rebuild a lost chunk.
+ When the encoding function is called, it returns chunks of the same
+ size as each other. There are two kinds of chunks: (1) *data
+ chunks*, which can be concatenated to reconstruct the original
+ object, and (2) *coding chunks*, which can be used to rebuild a
+ lost chunk.
*chunk rank*
- the index of a chunk when returned by the encoding function. The
- rank of the first chunk is 0, the rank of the second chunk is 1
- etc.
-
-*stripe*
- when an object is too large to be encoded with a single call,
- each set of chunks created by a call to the encoding function is
- called a stripe.
-
-*shard|strip*
- an ordered sequence of chunks of the same rank from the same
- object. For a given placement group, each OSD contains shards of
- the same rank. When dealing with objects that are encoded with a
- single operation, *chunk* is sometime used instead of *shard*
- because the shard is made of a single chunk. The *chunks* in a
- *shard* are ordered according to the rank of the stripe they belong
- to.
+ The index of a chunk, as determined by the encoding function. The
+ rank of the first chunk is 0, the rank of the second chunk is 1,
+ and so on.
*K*
- the number of data *chunks*, i.e. the number of *chunks* in which the
- original object is divided. For instance if *K* = 2 a 10KB object
- will be divided into *K* objects of 5KB each.
+ The number of data chunks into which an object is divided. For
+ example, if *K* = 2, then a 10KB object is divided into two objects
+ of 5KB each.
*M*
- the number of coding *chunks*, i.e. the number of additional *chunks*
- computed by the encoding functions. If there are 2 coding *chunks*,
- it means 2 OSDs can be out without losing data.
+ The number of coding chunks computed by the encoding function. *M*
+ is equal to the number of OSDs that can be missing from the cluster
+ without the cluster suffering data loss. For example, if there are
+ two coding chunks, then two OSDs can be missing without data loss.
*N*
- the number of data *chunks* plus the number of coding *chunks*,
- i.e. *K+M*.
+ The number of data chunks plus the number of coding chunks: that
+ is, *K* + *M*.
*rate*
- the proportion of the *chunks* that contains useful information, i.e. *K/N*.
- For instance, for *K* = 9 and *M* = 3 (i.e. *K+M* = *N* = 12) the rate is
- *K* = 9 / *N* = 12 = 0.75, i.e. 75% of the chunks contain useful information.
+ The proportion of the total chunks containing useful information:
+ that is, *K* divided by *N*. For example, suppose that *K* = 9 and
+ *M* = 3. This would mean that *N* = 12 (because *K* + *M* = 9 + 3).
+ Therefore, the *rate* (*K* / *N*) would be 9 / 12 = 0.75. In other
+ words, 75% of the chunks would contain useful information.
+
+*shard* (also called *strip*)
+ An ordered sequence of chunks of the same rank from the same object. For a
+ given placement group, each OSD contains shards of the same rank. In the
+ special case in which an object is encoded with only one call to the
+ encoding function, the term *chunk* may be used instead of *shard* because
+ the shard is made of a single chunk. The chunks in a shard are ordered
+ according to the rank of the stripe (see *stripe* below) they belong to.
+
+
+*stripe*
+ If an object is so large that encoding it requires more than one
+ call to the encoding function, each of these calls creates a set of
+ chunks called a *stripe*.
The definitions are illustrated as follows (PG stands for placement group):
::
| ... | | ... |
+-------------------------+ +-------------------------+
-Table of content
-----------------
+Table of contents
+-----------------
.. toctree::
:maxdepth: 1
projects / ceph.git / blobdiff