summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorJenkins <jenkins@review.openstack.org>2017-09-13 20:06:51 +0000
committerGerrit Code Review <review@openstack.org>2017-09-13 20:06:51 +0000
commit504c09b3fe7025c0e4d3c9c0bd11b08b20f74508 (patch)
treeca5363effc8cb199bf9f94f546d771cab6cbb8ef
parente426aee95b616778e4a8e484c3a56c691a2b9c52 (diff)
parent0f5bc4eaffe0bb6e95175bbf25a14306497d4054 (diff)
Merge "re-org of README"
-rw-r--r--README.md348
-rw-r--r--doc/api_definition.md275
-rw-r--r--doc/code_organization.md60
3 files changed, 336 insertions, 347 deletions
diff --git a/README.md b/README.md
index 619ceae..bb8469c 100644
--- a/README.md
+++ b/README.md
@@ -34,13 +34,6 @@ Highlights
34 34
35---- 35----
36 36
37License
38==========
39
40liberasurecode is distributed under the terms of the **BSD** license.
41
42----
43
44Active Users 37Active Users
45==================== 38====================
46 39
@@ -61,7 +54,7 @@ Install dependencies -
61 $ sudo apt-get install build-essential autoconf automake libtool 54 $ sudo apt-get install build-essential autoconf automake libtool
62``` 55```
63 56
64 Fedora/RedHat/Centos hosts: 57 Fedora/RedHat/CentOS hosts:
65 58
66```sh 59```sh
67 $ sudo yum install -y gcc make autoconf automake libtool 60 $ sudo yum install -y gcc make autoconf automake libtool
@@ -80,345 +73,6 @@ top-level directory:
80 73
81---- 74----
82 75
83liberasurecode API Definition
84=============================
85
86``` c
87
88/* liberasurecode frontend API functions */
89
90/**
91 * Create a liberasurecode instance and return a descriptor
92 * for use with EC operations (encode, decode, reconstruct)
93 *
94 * @param id - one of the supported backends as
95 * defined by ec_backend_id_t
96 * @param ec_args - arguments to the EC backend
97 * arguments common to all backends
98 * k - number of data fragments
99 * m - number of parity fragments
100 * w - word size, in bits
101 * hd - hamming distance (=m for Reed-Solomon)
102 * ct - fragment checksum type (stored with the fragment metadata)
103 * backend-specific arguments
104 * null_args - arguments for the null backend
105 * flat_xor_hd, jerasure do not require any special args
106 *
107 * @return liberasurecode instance descriptor (int > 0)
108 */
109int liberasurecode_instance_create(const ec_backend_id_t id,
110 struct ec_args *args);
111
112/**
113 * Close a liberasurecode instance
114 *
115 * @param desc - liberasurecode descriptor to close
116 *
117 * @return 0 on success, otherwise non-zero error code
118 */
119int liberasurecode_instance_destroy(int desc);
120
121
122/**
123 * Erasure encode a data buffer
124 *
125 * @param desc - liberasurecode descriptor/handle
126 * from liberasurecode_instance_create()
127 * @param orig_data - data to encode
128 * @param orig_data_size - length of data to encode
129 * @param encoded_data - pointer to _output_ array (char **) of k data
130 * fragments (char *), allocated by the callee
131 * @param encoded_parity - pointer to _output_ array (char **) of m parity
132 * fragments (char *), allocated by the callee
133 * @param fragment_len - pointer to _output_ length of each fragment, assuming
134 * all fragments are the same length
135 *
136 * @return 0 on success, -error code otherwise
137 */
138int liberasurecode_encode(int desc,
139 const char *orig_data, uint64_t orig_data_size, /* input */
140 char ***encoded_data, char ***encoded_parity, /* output */
141 uint64_t *fragment_len); /* output */
142
143/**
144 * Cleanup structures allocated by librasurecode_encode
145 *
146 * The caller has no context, so cannot safely free memory
147 * allocated by liberasurecode, so it must pass the
148 * deallocation responsibility back to liberasurecode.
149 *
150 * @param desc - liberasurecode descriptor/handle
151 * from liberasurecode_instance_create()
152 * @param encoded_data - (char **) array of k data
153 * fragments (char *), allocated by liberasurecode_encode
154 * @param encoded_parity - (char **) array of m parity
155 * fragments (char *), allocated by liberasurecode_encode
156 *
157 * @return 0 in success; -error otherwise
158 */
159int liberasurecode_encode_cleanup(int desc, char **encoded_data,
160 char **encoded_parity);
161
162/**
163 * Reconstruct original data from a set of k encoded fragments
164 *
165 * @param desc - liberasurecode descriptor/handle
166 * from liberasurecode_instance_create()
167 * @param fragments - erasure encoded fragments (> = k)
168 * @param num_fragments - number of fragments being passed in
169 * @param fragment_len - length of each fragment (assume they are the same)
170 * @param force_metadata_checks - force fragment metadata checks (default: 0)
171 * @param out_data - _output_ pointer to decoded data
172 * @param out_data_len - _output_ length of decoded output
173 * (both output data pointers are allocated by liberasurecode,
174 * caller invokes liberasurecode_decode_clean() after it has
175 * read decoded data in 'out_data')
176 *
177 * @return 0 on success, -error code otherwise
178 */
179int liberasurecode_decode(int desc,
180 char **available_fragments, /* input */
181 int num_fragments, uint64_t fragment_len, /* input */
182 int force_metadata_checks, /* input */
183 char **out_data, uint64_t *out_data_len); /* output */
184
185/**
186 * Cleanup structures allocated by librasurecode_decode
187 *
188 * The caller has no context, so cannot safely free memory
189 * allocated by liberasurecode, so it must pass the
190 * deallocation responsibility back to liberasurecode.
191 *
192 * @param desc - liberasurecode descriptor/handle
193 * from liberasurecode_instance_create()
194 * @param data - (char *) buffer of data decoded by librasurecode_decode
195 *
196 * @return 0 on success; -error otherwise
197 */
198int liberasurecode_decode_cleanup(int desc, char *data);
199
200/**
201 * Reconstruct a missing fragment from a subset of available fragments
202 *
203 * @param desc - liberasurecode descriptor/handle
204 * from liberasurecode_instance_create()
205 * @param available_fragments - erasure encoded fragments
206 * @param num_fragments - number of fragments being passed in
207 * @param fragment_len - size in bytes of the fragments
208 * @param destination_idx - missing idx to reconstruct
209 * @param out_fragment - output of reconstruct
210 *
211 * @return 0 on success, -error code otherwise
212 */
213int liberasurecode_reconstruct_fragment(int desc,
214 char **available_fragments, /* input */
215 int num_fragments, uint64_t fragment_len, /* input */
216 int destination_idx, /* input */
217 char* out_fragment); /* output */
218
219/**
220 * Return a list of lists with valid rebuild indexes given
221 * a list of missing indexes.
222 *
223 * @desc: liberasurecode instance descriptor (obtained with
224 * liberasurecode_instance_create)
225 * @fragments_to_reconstruct list of indexes to reconstruct
226 * @fragments_to_exclude list of indexes to exclude from
227 * reconstruction equation
228 * @fragments_needed list of fragments needed to reconstruct
229 * fragments in fragments_to_reconstruct
230 *
231 * @return 0 on success, non-zero on error
232 */
233int liberasurecode_fragments_needed(int desc,
234 int *fragments_to_reconstruct,
235 int *fragments_to_exclude,
236 int *fragments_needed);
237
238```
239
240Erasure Code Fragment Checksum Types Supported
241----------------------------------------------
242
243``` c
244
245/* Checksum types supported for fragment metadata stored in each fragment */
246typedef enum {
247 CHKSUM_NONE = 0, /* "none" (default) */
248 CHKSUM_CRC32 = 1, /* "crc32" */
249 CHKSUM_TYPES_MAX,
250} ec_checksum_type_t;
251
252```
253
254Erasure Code Fragment Checksum API
255----------------------------------
256
257``` c
258
259struct __attribute__((__packed__))
260fragment_metadata
261{
262 uint32_t idx; /* 4 */
263 uint32_t size; /* 4 */
264 uint32_t frag_backend_metadata_size; /* 4 */
265 uint64_t orig_data_size; /* 8 */
266 uint8_t chksum_type; /* 1 */
267 uint32_t chksum[LIBERASURECODE_MAX_CHECKSUM_LEN]; /* 32 */
268 uint8_t chksum_mismatch; /* 1 */
269 uint8_t backend_id; /* 1 */
270 uint32_t backend_version; /* 4 */
271} fragment_metadata_t;
272
273#define FRAGSIZE_2_BLOCKSIZE(fragment_size) \
274 (fragment_size - sizeof(fragment_header_t))
275
276/**
277 * Get opaque metadata for a fragment. The metadata is opaque to the
278 * client, but meaningful to the underlying library. It is used to verify
279 * stripes in verify_stripe_metadata().
280 *
281 * @param fragment - fragment data pointer
282 * @param fragment_metadata - pointer to allocated buffer of size at least
283 * sizeof(struct fragment_metadata) to hold fragment metadata struct
284 *
285 * @return 0 on success, non-zero on error
286 */
287//EDL: This needs to be implemented
288int liberasurecode_get_fragment_metadata(char *fragment,
289 fragment_metadata_t *fragment_metadata);
290
291/**
292* Verify that the specified pointer points to a well formed fragment that can
293* be processed by both this instance of liberasurecode and the specified
294* backend.
295*
296* @param desc - liberasurecode descriptor/handle
297* from liberasurecode_instance_create()
298* @param fragment - fragment to verify
299*
300* @return 1 if fragment validation fails, 0 otherwise.
301*/
302int is_invalid_fragment(int desc, char *fragment);
303
304/**
305 * Verify a subset of fragments generated by encode()
306 *
307 * @param desc - liberasurecode descriptor/handle
308 * from liberasurecode_instance_create()
309 * @param fragments - fragments part of the EC stripe to verify
310 * @param num_fragments - number of fragments part of the EC stripe
311 *
312 * @return 1 if stripe checksum verification is successful, 0 otherwise
313 */
314int liberasurecode_verify_stripe_metadata(int desc,
315 char **fragments, int num_fragments);
316
317/* ==~=*=~===~=*=~==~=*=~== liberasurecode Helpers ==~*==~=*=~==~=~=*=~==~= */
318
319/**
320 * This computes the aligned size of a buffer passed into
321 * the encode function. The encode function must pad fragments
322 * to be algined with the word size (w) and the last fragment also
323 * needs to be aligned. This computes the sum of the algined fragment
324 * sizes for a given buffer to encode.
325 *
326 * @param desc - liberasurecode descriptor/handle
327 * from liberasurecode_instance_create()
328 * @param data_len - original data length in bytes
329 *
330 * @return aligned length, or -error code on error
331 */
332int liberasurecode_get_aligned_data_size(int desc, uint64_t data_len);
333
334/**
335 * This will return the minimum encode size, which is the minimum
336 * buffer size that can be encoded.
337 *
338 * @param desc - liberasurecode descriptor/handle
339 * from liberasurecode_instance_create()
340 *
341 * @return minimum data length length, or -error code on error
342 */
343int liberasurecode_get_minimum_encode_size(int desc);
344
345/**
346 * This will return the fragment size, which is each fragment data
347 * length the backend will allocate when encoding.
348 *
349 * @param desc - liberasurecode descriptor/handle
350 * from liberasurecode_instance_create()
351 * @param data_len - original data length in bytes
352 *
353 * @return fragment size - sizeof(fragment_header) + size
354 * + frag_backend_metadata_size
355 */
356int liberasurecode_get_fragment_size(int desc, int data_len);
357```
358
359----
360
361Code organization
362=================
363```
364 |-- include
365 | +-- erasurecode
366 | | +-- erasurecode.h --> liberasurecode frontend API header
367 | | +-- erasurecode_backend.h --> liberasurecode backend API header
368 | +-- xor_codes --> headers for the built-in XOR codes
369 |
370 |-- src
371 | |-- erasurecode.c --> liberasurecode API implementation
372 | | (frontend + backend)
373 | |-- backends
374 | | +-- null
375 | | +--- null.c --> 'null' erasure code backend (template backend)
376 | | +-- xor
377 | | +--- flat_xor_hd.c --> 'flat_xor_hd' erasure code backend (built-in)
378 | | +-- jerasure
379 | | +-- jerasure_rs_cauchy.c --> 'jerasure_rs_vand' erasure code backend (jerasure.org)
380 | | +-- jerasure_rs_vand.c --> 'jerasure_rs_cauchy' erasure code backend (jerasure.org)
381 | | +-- isa-l
382 | | +-- isa_l_rs_vand.c --> 'isa_l_rs_vand' erasure code backend (Intel)
383 | | +-- shss
384 | | +-- shss.c --> 'shss' erasure code backend (NTT Labs)
385 | | +-- phazrio
386 | | +-- libphazr.c --> 'libphazr' erasure code backend (Phazr.IO)
387 | |
388 | |-- builtin
389 | | +-- xor_codes --> XOR HD code backend, built-in erasure
390 | | | code implementation (shared library)
391 | | +-- xor_code.c
392 | | +-- xor_hd_code.c
393 | | +-- rs_vand --> liberasurecode native Reed Soloman codes
394 | |
395 | +-- utils
396 | +-- chksum --> fragment checksum utils for erasure
397 | +-- alg_sig.c coded fragments
398 | +-- crc32.c
399 |
400 |-- doc --> API Documentation
401 | +-- Doxyfile
402 | +-- html
403 |
404 |--- test --> Test routines
405 | +-- builtin
406 | | +-- xor_codes
407 | +-- liberasurecode_test.c
408 | +-- utils
409 |
410 |-- autogen.sh
411 |-- configure.ac
412 |-- Makefile.am
413 |-- README
414 |-- NEWS
415 |-- COPYING
416 |-- AUTHORS
417 |-- INSTALL
418 +-- ChangeLog
419```
420---
421
422References 76References
423========== 77==========
424 78
diff --git a/doc/api_definition.md b/doc/api_definition.md
new file mode 100644
index 0000000..90e2eaa
--- /dev/null
+++ b/doc/api_definition.md
@@ -0,0 +1,275 @@
1liberasurecode API Definition
2=============================
3
4``` c
5
6/* liberasurecode frontend API functions */
7
8/**
9 * Create a liberasurecode instance and return a descriptor
10 * for use with EC operations (encode, decode, reconstruct)
11 *
12 * @param id - one of the supported backends as
13 * defined by ec_backend_id_t
14 * @param ec_args - arguments to the EC backend
15 * arguments common to all backends
16 * k - number of data fragments
17 * m - number of parity fragments
18 * w - word size, in bits
19 * hd - hamming distance (=m for Reed-Solomon)
20 * ct - fragment checksum type (stored with the fragment metadata)
21 * backend-specific arguments
22 * null_args - arguments for the null backend
23 * flat_xor_hd, jerasure do not require any special args
24 *
25 * @return liberasurecode instance descriptor (int > 0)
26 */
27int liberasurecode_instance_create(const ec_backend_id_t id,
28 struct ec_args *args);
29
30/**
31 * Close a liberasurecode instance
32 *
33 * @param desc - liberasurecode descriptor to close
34 *
35 * @return 0 on success, otherwise non-zero error code
36 */
37int liberasurecode_instance_destroy(int desc);
38
39
40/**
41 * Erasure encode a data buffer
42 *
43 * @param desc - liberasurecode descriptor/handle
44 * from liberasurecode_instance_create()
45 * @param orig_data - data to encode
46 * @param orig_data_size - length of data to encode
47 * @param encoded_data - pointer to _output_ array (char **) of k data
48 * fragments (char *), allocated by the callee
49 * @param encoded_parity - pointer to _output_ array (char **) of m parity
50 * fragments (char *), allocated by the callee
51 * @param fragment_len - pointer to _output_ length of each fragment, assuming
52 * all fragments are the same length
53 *
54 * @return 0 on success, -error code otherwise
55 */
56int liberasurecode_encode(int desc,
57 const char *orig_data, uint64_t orig_data_size, /* input */
58 char ***encoded_data, char ***encoded_parity, /* output */
59 uint64_t *fragment_len); /* output */
60
61/**
62 * Cleanup structures allocated by librasurecode_encode
63 *
64 * The caller has no context, so cannot safely free memory
65 * allocated by liberasurecode, so it must pass the
66 * deallocation responsibility back to liberasurecode.
67 *
68 * @param desc - liberasurecode descriptor/handle
69 * from liberasurecode_instance_create()
70 * @param encoded_data - (char **) array of k data
71 * fragments (char *), allocated by liberasurecode_encode
72 * @param encoded_parity - (char **) array of m parity
73 * fragments (char *), allocated by liberasurecode_encode
74 *
75 * @return 0 in success; -error otherwise
76 */
77int liberasurecode_encode_cleanup(int desc, char **encoded_data,
78 char **encoded_parity);
79
80/**
81 * Reconstruct original data from a set of k encoded fragments
82 *
83 * @param desc - liberasurecode descriptor/handle
84 * from liberasurecode_instance_create()
85 * @param fragments - erasure encoded fragments (> = k)
86 * @param num_fragments - number of fragments being passed in
87 * @param fragment_len - length of each fragment (assume they are the same)
88 * @param force_metadata_checks - force fragment metadata checks (default: 0)
89 * @param out_data - _output_ pointer to decoded data
90 * @param out_data_len - _output_ length of decoded output
91 * (both output data pointers are allocated by liberasurecode,
92 * caller invokes liberasurecode_decode_clean() after it has
93 * read decoded data in 'out_data')
94 *
95 * @return 0 on success, -error code otherwise
96 */
97int liberasurecode_decode(int desc,
98 char **available_fragments, /* input */
99 int num_fragments, uint64_t fragment_len, /* input */
100 int force_metadata_checks, /* input */
101 char **out_data, uint64_t *out_data_len); /* output */
102
103/**
104 * Cleanup structures allocated by librasurecode_decode
105 *
106 * The caller has no context, so cannot safely free memory
107 * allocated by liberasurecode, so it must pass the
108 * deallocation responsibility back to liberasurecode.
109 *
110 * @param desc - liberasurecode descriptor/handle
111 * from liberasurecode_instance_create()
112 * @param data - (char *) buffer of data decoded by librasurecode_decode
113 *
114 * @return 0 on success; -error otherwise
115 */
116int liberasurecode_decode_cleanup(int desc, char *data);
117
118/**
119 * Reconstruct a missing fragment from a subset of available fragments
120 *
121 * @param desc - liberasurecode descriptor/handle
122 * from liberasurecode_instance_create()
123 * @param available_fragments - erasure encoded fragments
124 * @param num_fragments - number of fragments being passed in
125 * @param fragment_len - size in bytes of the fragments
126 * @param destination_idx - missing idx to reconstruct
127 * @param out_fragment - output of reconstruct
128 *
129 * @return 0 on success, -error code otherwise
130 */
131int liberasurecode_reconstruct_fragment(int desc,
132 char **available_fragments, /* input */
133 int num_fragments, uint64_t fragment_len, /* input */
134 int destination_idx, /* input */
135 char* out_fragment); /* output */
136
137/**
138 * Return a list of lists with valid rebuild indexes given
139 * a list of missing indexes.
140 *
141 * @desc: liberasurecode instance descriptor (obtained with
142 * liberasurecode_instance_create)
143 * @fragments_to_reconstruct list of indexes to reconstruct
144 * @fragments_to_exclude list of indexes to exclude from
145 * reconstruction equation
146 * @fragments_needed list of fragments needed to reconstruct
147 * fragments in fragments_to_reconstruct
148 *
149 * @return 0 on success, non-zero on error
150 */
151int liberasurecode_fragments_needed(int desc,
152 int *fragments_to_reconstruct,
153 int *fragments_to_exclude,
154 int *fragments_needed);
155
156```
157
158Erasure Code Fragment Checksum Types Supported
159----------------------------------------------
160
161``` c
162
163/* Checksum types supported for fragment metadata stored in each fragment */
164typedef enum {
165 CHKSUM_NONE = 0, /* "none" (default) */
166 CHKSUM_CRC32 = 1, /* "crc32" */
167 CHKSUM_TYPES_MAX,
168} ec_checksum_type_t;
169
170```
171
172Erasure Code Fragment Checksum API
173----------------------------------
174
175``` c
176
177struct __attribute__((__packed__))
178fragment_metadata
179{
180 uint32_t idx; /* 4 */
181 uint32_t size; /* 4 */
182 uint32_t frag_backend_metadata_size; /* 4 */
183 uint64_t orig_data_size; /* 8 */
184 uint8_t chksum_type; /* 1 */
185 uint32_t chksum[LIBERASURECODE_MAX_CHECKSUM_LEN]; /* 32 */
186 uint8_t chksum_mismatch; /* 1 */
187 uint8_t backend_id; /* 1 */
188 uint32_t backend_version; /* 4 */
189} fragment_metadata_t;
190
191#define FRAGSIZE_2_BLOCKSIZE(fragment_size) \
192 (fragment_size - sizeof(fragment_header_t))
193
194/**
195 * Get opaque metadata for a fragment. The metadata is opaque to the
196 * client, but meaningful to the underlying library. It is used to verify
197 * stripes in verify_stripe_metadata().
198 *
199 * @param fragment - fragment data pointer
200 * @param fragment_metadata - pointer to allocated buffer of size at least
201 * sizeof(struct fragment_metadata) to hold fragment metadata struct
202 *
203 * @return 0 on success, non-zero on error
204 */
205//EDL: This needs to be implemented
206int liberasurecode_get_fragment_metadata(char *fragment,
207 fragment_metadata_t *fragment_metadata);
208
209/**
210* Verify that the specified pointer points to a well formed fragment that can
211* be processed by both this instance of liberasurecode and the specified
212* backend.
213*
214* @param desc - liberasurecode descriptor/handle
215* from liberasurecode_instance_create()
216* @param fragment - fragment to verify
217*
218* @return 1 if fragment validation fails, 0 otherwise.
219*/
220int is_invalid_fragment(int desc, char *fragment);
221
222/**
223 * Verify a subset of fragments generated by encode()
224 *
225 * @param desc - liberasurecode descriptor/handle
226 * from liberasurecode_instance_create()
227 * @param fragments - fragments part of the EC stripe to verify
228 * @param num_fragments - number of fragments part of the EC stripe
229 *
230 * @return 1 if stripe checksum verification is successful, 0 otherwise
231 */
232int liberasurecode_verify_stripe_metadata(int desc,
233 char **fragments, int num_fragments);
234
235/* ==~=*=~===~=*=~==~=*=~== liberasurecode Helpers ==~*==~=*=~==~=~=*=~==~= */
236
237/**
238 * This computes the aligned size of a buffer passed into
239 * the encode function. The encode function must pad fragments
240 * to be algined with the word size (w) and the last fragment also
241 * needs to be aligned. This computes the sum of the algined fragment
242 * sizes for a given buffer to encode.
243 *
244 * @param desc - liberasurecode descriptor/handle
245 * from liberasurecode_instance_create()
246 * @param data_len - original data length in bytes
247 *
248 * @return aligned length, or -error code on error
249 */
250int liberasurecode_get_aligned_data_size(int desc, uint64_t data_len);
251
252/**
253 * This will return the minimum encode size, which is the minimum
254 * buffer size that can be encoded.
255 *
256 * @param desc - liberasurecode descriptor/handle
257 * from liberasurecode_instance_create()
258 *
259 * @return minimum data length length, or -error code on error
260 */
261int liberasurecode_get_minimum_encode_size(int desc);
262
263/**
264 * This will return the fragment size, which is each fragment data
265 * length the backend will allocate when encoding.
266 *
267 * @param desc - liberasurecode descriptor/handle
268 * from liberasurecode_instance_create()
269 * @param data_len - original data length in bytes
270 *
271 * @return fragment size - sizeof(fragment_header) + size
272 * + frag_backend_metadata_size
273 */
274int liberasurecode_get_fragment_size(int desc, int data_len);
275``` \ No newline at end of file
diff --git a/doc/code_organization.md b/doc/code_organization.md
new file mode 100644
index 0000000..adf2a95
--- /dev/null
+++ b/doc/code_organization.md
@@ -0,0 +1,60 @@
1Code organization
2=================
3```
4 |-- include
5 | +-- erasurecode
6 | | +-- erasurecode.h --> liberasurecode frontend API header
7 | | +-- erasurecode_backend.h --> liberasurecode backend API header
8 | +-- xor_codes --> headers for the built-in XOR codes
9 |
10 |-- src
11 | |-- erasurecode.c --> liberasurecode API implementation
12 | | (frontend + backend)
13 | |-- backends
14 | | +-- null
15 | | +--- null.c --> 'null' erasure code backend (template backend)
16 | | +-- xor
17 | | +--- flat_xor_hd.c --> 'flat_xor_hd' erasure code backend (built-in)
18 | | +-- jerasure
19 | | +-- jerasure_rs_cauchy.c --> 'jerasure_rs_vand' erasure code backend (jerasure.org)
20 | | +-- jerasure_rs_vand.c --> 'jerasure_rs_cauchy' erasure code backend (jerasure.org)
21 | | +-- isa-l
22 | | +-- isa_l_rs_vand.c --> 'isa_l_rs_vand' erasure code backend (Intel)
23 | | +-- shss
24 | | +-- shss.c --> 'shss' erasure code backend (NTT Labs)
25 | | +-- phazrio
26 | | +-- libphazr.c --> 'libphazr' erasure code backend (Phazr.IO)
27 | |
28 | |-- builtin
29 | | +-- xor_codes --> XOR HD code backend, built-in erasure
30 | | | code implementation (shared library)
31 | | +-- xor_code.c
32 | | +-- xor_hd_code.c
33 | | +-- rs_vand --> liberasurecode native Reed Soloman codes
34 | |
35 | +-- utils
36 | +-- chksum --> fragment checksum utils for erasure
37 | +-- alg_sig.c coded fragments
38 | +-- crc32.c
39 |
40 |-- doc --> API Documentation
41 | +-- Doxyfile
42 | +-- html
43 |
44 |--- test --> Test routines
45 | +-- builtin
46 | | +-- xor_codes
47 | +-- liberasurecode_test.c
48 | +-- utils
49 |
50 |-- autogen.sh
51 |-- configure.ac
52 |-- Makefile.am
53 |-- README
54 |-- NEWS
55 |-- COPYING
56 |-- AUTHORS
57 |-- INSTALL
58 +-- ChangeLog
59```
60--- \ No newline at end of file