├── AUTHORS ├── NEWS ├── ChangeLog ├── .gitattributes ├── Manual.pdf ├── performance.PNG ├── Makefile.am ├── include ├── timing.h ├── liberation.h ├── cauchy.h ├── reed_sol.h └── galois.h ├── Examples ├── .gitignore ├── test_galois.c ├── encode_decode.sh ├── Makefile.am ├── time_all_gfs_argv_init.sh ├── test_all_gfs.sh ├── jerasure_01.c ├── jerasure_02.c ├── reed_sol_02.c ├── cauchy_01.c ├── reed_sol_04.c ├── jerasure_04.c ├── jerasure_03.c ├── reed_sol_test_gf.c ├── reed_sol_03.c ├── reed_sol_01.c ├── liberation_01.c ├── jerasure_05.c ├── reed_sol_time_gf.c ├── jerasure_07.c ├── jerasure_06.c ├── jerasure_08.c ├── cauchy_04.c ├── cauchy_02.c └── cauchy_03.c ├── .gitignore ├── src ├── Makefile.am ├── timing.c ├── liberation.c ├── reed_sol.c └── galois.c ├── m4 ├── ax_require_defined.m4 ├── ax_gcc_x86_cpuid.m4 ├── ax_check_compile_flag.m4 ├── ax_gcc_x86_avx_xgetbv.m4 └── ax_ext.m4 ├── configure.ac ├── COPYING ├── License.txt └── README.md /AUTHORS: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /NEWS: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /ChangeLog: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | *.ac eol=lf 2 | *.am eol=lf 3 | *.sh eol=lf 4 | -------------------------------------------------------------------------------- /Manual.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jvlla/Jerasure_xor_optimization/optimizated_xor/Manual.pdf -------------------------------------------------------------------------------- /performance.PNG: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jvlla/Jerasure_xor_optimization/optimizated_xor/performance.PNG -------------------------------------------------------------------------------- /Makefile.am: -------------------------------------------------------------------------------- 1 | # Jerasure Automake file 2 | 3 | SUBDIRS = src Examples 4 | 5 | EXTRA_DIST = Manual.pdf PERF.txt 6 | -------------------------------------------------------------------------------- /include/timing.h: -------------------------------------------------------------------------------- 1 | #ifndef JERASURE_INCLUDED__TIMING_H 2 | #define JERASURE_INCLUDED__TIMING_H 3 | 4 | double timing_delta(struct timespec * t1, struct timespec * t2); 5 | #endif 6 | -------------------------------------------------------------------------------- /Examples/.gitignore: -------------------------------------------------------------------------------- 1 | /cauchy_[0-9][0-9] 2 | /decoder 3 | /encoder 4 | /jerasure_[0-9][0-9] 5 | /liberation_[0-9][0-9] 6 | /reed_sol_[0-9][0-9] 7 | /reed_sol_test_gf 8 | /reed_sol_time_gf 9 | /test_galois 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /INSTALL 2 | Makefile 3 | Makefile.in 4 | /aclocal.m4 5 | /autom4te.cache/ 6 | /autoscan.log 7 | /build-aux/ 8 | /config.log 9 | /config.status 10 | /configure 11 | /configure.scan 12 | .deps/ 13 | /include/config.h 14 | /include/config.h.in 15 | /include/stamp-h1 16 | .libs/ 17 | /libtool 18 | /m4/libtool.m4 19 | /m4/ltoptions.m4 20 | /m4/ltsugar.m4 21 | /m4/ltversion.m4 22 | /m4/lt~obsolete.m4 23 | *.l[ao] 24 | *.[ao] 25 | *~ 26 | .dirstamp 27 | *.log 28 | *.trs 29 | -------------------------------------------------------------------------------- /Examples/test_galois.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include "galois.h" 3 | 4 | int main(int argc, char **argv) 5 | { 6 | assert(galois_init_default_field(4) == 0); 7 | assert(galois_uninit_field(4) == 0); 8 | assert(galois_init_default_field(4) == 0); 9 | assert(galois_uninit_field(4) == 0); 10 | 11 | assert(galois_init_default_field(8) == 0); 12 | assert(galois_uninit_field(8) == 0); 13 | assert(galois_init_default_field(8) == 0); 14 | assert(galois_uninit_field(8) == 0); 15 | 16 | return 0; 17 | } 18 | /* 19 | * Local Variables: 20 | * compile-command: "make test_galois && 21 | * libtool --mode=execute valgrind --tool=memcheck --leak-check=full ./test_galois" 22 | * End: 23 | */ 24 | -------------------------------------------------------------------------------- /src/Makefile.am: -------------------------------------------------------------------------------- 1 | # Jerasure AM file 2 | 3 | AM_CPPFLAGS = -I$(top_srcdir)/include 4 | AM_CFLAGS = -march=native 5 | 6 | lib_LTLIBRARIES = libJerasure.la 7 | libJerasure_la_SOURCES = galois.c jerasure.c reed_sol.c cauchy.c liberation.c 8 | libJerasure_la_LDFLAGS = -version-info 2:0:0 9 | libJerasure_la_LIBADD = -lgf_complete 10 | include_HEADERS = ../include/jerasure.h 11 | 12 | # Install additional Jerasure header files in their own directory. 13 | jerasureincludedir = $(includedir)/jerasure 14 | jerasureinclude_HEADERS = \ 15 | ../include/cauchy.h \ 16 | ../include/galois.h \ 17 | ../include/liberation.h \ 18 | ../include/reed_sol.h 19 | 20 | noinst_HEADERS = ../include/timing.h 21 | noinst_LIBRARIES = libtiming.a 22 | libtiming_a_SOURCES = timing.c 23 | -------------------------------------------------------------------------------- /Examples/encode_decode.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash -e 2 | # 3 | # Copyright (C) 2014 Red Hat 4 | # 5 | # Author: Loic Dachary 6 | # 7 | # This program is free software; you can redistribute it and/or modify 8 | # it under the terms of the GNU Library Public License as published by 9 | # the Free Software Foundation; either version 2, or (at your option) 10 | # any later version. 11 | # 12 | # This program is distributed in the hope that it will be useful, 13 | # but WITHOUT ANY WARRANTY; without even the implied warranty of 14 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 | # GNU Library Public License for more details. 16 | # 17 | trap "rm -fr T Coding" EXIT 18 | 19 | dd if=/dev/urandom of=T bs=4096 count=1 20 | ./encoder T 3 2 reed_sol_van 8 0 0 21 | ./decoder T 22 | -------------------------------------------------------------------------------- /src/timing.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include "timing.h" 4 | #define LIMIT 100 5 | 6 | double timing_delta(struct timespec * t1, struct timespec * t2) 7 | { 8 | static double timing_time = 0; 9 | 10 | if (timing_time == 0) { 11 | // first time call timing_delta(), calculate the time spend by clock_gettime() 12 | struct timespec time_out_begin, time_out_end, time_in_begin, time_in_end; 13 | for (int i = 0; i < LIMIT; ++i) 14 | { 15 | clock_gettime(CLOCK_REALTIME, &time_out_begin); 16 | clock_gettime(CLOCK_REALTIME, &time_in_begin); 17 | clock_gettime(CLOCK_REALTIME, &time_in_end); 18 | clock_gettime(CLOCK_REALTIME, &time_out_end); 19 | timing_time += (double)(time_out_end.tv_nsec - time_out_begin.tv_nsec); 20 | } 21 | timing_time /= LIMIT; 22 | } 23 | 24 | return (double)t2->tv_sec - t1->tv_sec + (t2->tv_nsec - t1->tv_nsec - timing_time) / 1e9; 25 | } 26 | -------------------------------------------------------------------------------- /m4/ax_require_defined.m4: -------------------------------------------------------------------------------- 1 | # =========================================================================== 2 | # http://www.gnu.org/software/autoconf-archive/ax_require_defined.html 3 | # =========================================================================== 4 | # 5 | # SYNOPSIS 6 | # 7 | # AX_REQUIRE_DEFINED(MACRO) 8 | # 9 | # DESCRIPTION 10 | # 11 | # AX_REQUIRE_DEFINED is a simple helper for making sure other macros have 12 | # been defined and thus are available for use. This avoids random issues 13 | # where a macro isn't expanded. Instead the configure script emits a 14 | # non-fatal: 15 | # 16 | # ./configure: line 1673: AX_CFLAGS_WARN_ALL: command not found 17 | # 18 | # It's like AC_REQUIRE except it doesn't expand the required macro. 19 | # 20 | # Here's an example: 21 | # 22 | # AX_REQUIRE_DEFINED([AX_CHECK_LINK_FLAG]) 23 | # 24 | # LICENSE 25 | # 26 | # Copyright (c) 2014 Mike Frysinger 27 | # 28 | # Copying and distribution of this file, with or without modification, are 29 | # permitted in any medium without royalty provided the copyright notice 30 | # and this notice are preserved. This file is offered as-is, without any 31 | # warranty. 32 | 33 | #serial 1 34 | 35 | AC_DEFUN([AX_REQUIRE_DEFINED], [dnl 36 | m4_ifndef([$1], [m4_fatal([macro ]$1[ is not defined; is a m4 file missing?])]) 37 | ])dnl AX_REQUIRE_DEFINED 38 | -------------------------------------------------------------------------------- /configure.ac: -------------------------------------------------------------------------------- 1 | # Jerasure autoconf template 2 | 3 | AC_PREREQ([2.65]) 4 | AC_INIT([Jerasure], [2.0], [], [], 5 | [https://jerasure.org/jerasure/jerasure]) 6 | AC_CONFIG_SRCDIR([src/jerasure.c]) 7 | AC_CONFIG_HEADERS([include/config.h]) 8 | 9 | AC_CONFIG_AUX_DIR([build-aux]) 10 | AC_CONFIG_MACRO_DIR([m4]) 11 | 12 | AM_INIT_AUTOMAKE([1.13 -Wall -Wno-extra-portability]) 13 | 14 | # Package default C compiler flags. 15 | dnl This must be before LT_INIT and AC_PROG_CC. 16 | : ${CFLAGS='-g -O3 -Wall'} 17 | 18 | LT_INIT([disable-static]) 19 | 20 | # Checks for programs. 21 | AC_PROG_CC 22 | 23 | # Checks for libraries. 24 | AC_CHECK_LIB([pthread], [main]) 25 | AC_CHECK_LIB([gf_complete], [gf_init_easy], [], 26 | [AC_MSG_FAILURE( 27 | [You need to have gf_complete installed. 28 | gf_complete is available from http://jerasure.org/jerasure/gf-complete]) 29 | ]) 30 | 31 | # Checks for header files. 32 | AC_CHECK_HEADERS([stddef.h stdint.h stdlib.h string.h sys/time.h unistd.h]) 33 | AC_CHECK_HEADERS([gf_complete.h gf_general.h gf_method.h gf_rand.h]) 34 | 35 | # Checks for typedefs, structures, and compiler characteristics. 36 | AC_TYPE_UINT32_T 37 | AC_TYPE_UINT64_T 38 | AX_EXT 39 | 40 | AC_ARG_ENABLE([sse], 41 | AS_HELP_STRING([--disable-sse], [Build without SSE optimizations]), 42 | [if test "x$enableval" = "xno" ; then 43 | SIMD_FLAGS="" 44 | echo "DISABLED SSE!!!" 45 | fi] 46 | ) 47 | 48 | # Checks for library functions. 49 | AC_FUNC_MALLOC 50 | AC_CHECK_FUNCS([bzero getcwd gettimeofday mkdir strchr strdup strrchr]) 51 | 52 | AC_CONFIG_FILES([Examples/Makefile 53 | Makefile 54 | src/Makefile]) 55 | AC_OUTPUT 56 | -------------------------------------------------------------------------------- /COPYING: -------------------------------------------------------------------------------- 1 | 2 | Copyright (c) 2013, James S. Plank and Kevin Greenan 3 | All rights reserved. 4 | 5 | Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure Coding Techniques 6 | 7 | Revision 2.0: Galois Field backend now links to GF-Complete 8 | 9 | Redistribution and use in source and binary forms, with or without 10 | modification, are permitted provided that the following conditions 11 | are met: 12 | 13 | - Redistributions of source code must retain the above copyright 14 | notice, this list of conditions and the following disclaimer. 15 | 16 | - Redistributions in binary form must reproduce the above copyright 17 | notice, this list of conditions and the following disclaimer in 18 | the documentation and/or other materials provided with the 19 | distribution. 20 | 21 | - Neither the name of the University of Tennessee nor the names of its 22 | contributors may be used to endorse or promote products derived 23 | from this software without specific prior written permission. 24 | 25 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 26 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 27 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 28 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 29 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 30 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 31 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 32 | OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 33 | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 35 | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 | POSSIBILITY OF SUCH DAMAGE. 37 | 38 | -------------------------------------------------------------------------------- /License.txt: -------------------------------------------------------------------------------- 1 | 2 | Copyright (c) 2013, James S. Plank and Kevin Greenan 3 | All rights reserved. 4 | 5 | Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure Coding Techniques 6 | 7 | Revision 2.0: Galois Field backend now links to GF-Complete 8 | 9 | Redistribution and use in source and binary forms, with or without 10 | modification, are permitted provided that the following conditions 11 | are met: 12 | 13 | - Redistributions of source code must retain the above copyright 14 | notice, this list of conditions and the following disclaimer. 15 | 16 | - Redistributions in binary form must reproduce the above copyright 17 | notice, this list of conditions and the following disclaimer in 18 | the documentation and/or other materials provided with the 19 | distribution. 20 | 21 | - Neither the name of the University of Tennessee nor the names of its 22 | contributors may be used to endorse or promote products derived 23 | from this software without specific prior written permission. 24 | 25 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 26 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 27 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 28 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 29 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 30 | INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 31 | BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 32 | OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 33 | AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 34 | LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 35 | WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 | POSSIBILITY OF SUCH DAMAGE. 37 | 38 | -------------------------------------------------------------------------------- /Examples/Makefile.am: -------------------------------------------------------------------------------- 1 | # Jerasure AM file 2 | 3 | AM_CPPFLAGS = -I$(top_srcdir)/include 4 | AM_CFLAGS = -march=native 5 | 6 | bin_PROGRAMS = jerasure_01 \ 7 | jerasure_02 \ 8 | jerasure_03 \ 9 | jerasure_04 \ 10 | jerasure_05 \ 11 | jerasure_06 \ 12 | jerasure_07 \ 13 | jerasure_08 \ 14 | reed_sol_01 \ 15 | reed_sol_02 \ 16 | reed_sol_03 \ 17 | reed_sol_04 \ 18 | reed_sol_test_gf \ 19 | reed_sol_time_gf \ 20 | cauchy_01 \ 21 | cauchy_02 \ 22 | cauchy_03 \ 23 | cauchy_04 \ 24 | liberation_01 \ 25 | encoder \ 26 | decoder 27 | 28 | check_PROGRAMS = 29 | 30 | TESTS=test_all_gfs.sh encode_decode.sh $(check_PROGRAMS) 31 | 32 | dist_noinst_SCRIPTS = test_all_gfs.sh time_all_gfs_argv_init.sh 33 | 34 | test_galois_SOURCES = test_galois.c 35 | check_PROGRAMS += test_galois 36 | 37 | jerasure_01_SOURCES = jerasure_01.c 38 | jerasure_02_SOURCES = jerasure_02.c 39 | jerasure_03_SOURCES = jerasure_03.c 40 | jerasure_04_SOURCES = jerasure_04.c 41 | jerasure_05_SOURCES = jerasure_05.c 42 | jerasure_06_SOURCES = jerasure_06.c 43 | jerasure_07_SOURCES = jerasure_07.c 44 | jerasure_08_SOURCES = jerasure_08.c 45 | 46 | reed_sol_01_SOURCES = reed_sol_01.c 47 | reed_sol_02_SOURCES = reed_sol_02.c 48 | reed_sol_03_SOURCES = reed_sol_03.c 49 | reed_sol_04_SOURCES = reed_sol_04.c 50 | 51 | reed_sol_test_gf_SOURCES = reed_sol_test_gf.c 52 | reed_sol_time_gf_SOURCES = reed_sol_time_gf.c 53 | 54 | cauchy_01_SOURCES = cauchy_01.c 55 | cauchy_02_SOURCES = cauchy_02.c 56 | cauchy_03_SOURCES = cauchy_03.c 57 | cauchy_04_SOURCES = cauchy_04.c 58 | 59 | liberation_01_SOURCES = liberation_01.c 60 | 61 | decoder_SOURCES = decoder.c 62 | encoder_SOURCES = encoder.c 63 | 64 | LDADD = ../src/libJerasure.la 65 | decoder_LDADD = $(LDADD) ../src/libtiming.a 66 | encoder_LDADD = $(LDADD) ../src/libtiming.a 67 | reed_sol_time_gf_LDADD = $(LDADD) ../src/libtiming.a 68 | -------------------------------------------------------------------------------- /include/liberation.h: -------------------------------------------------------------------------------- 1 | /* * 2 | * Copyright (c) 2013, James S. Plank and Kevin Greenan 3 | * All rights reserved. 4 | * 5 | * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure 6 | * Coding Techniques 7 | * 8 | * Revision 2.0: Galois Field backend now links to GF-Complete 9 | * 10 | * Redistribution and use in source and binary forms, with or without 11 | * modification, are permitted provided that the following conditions 12 | * are met: 13 | * 14 | * - Redistributions of source code must retain the above copyright 15 | * notice, this list of conditions and the following disclaimer. 16 | * 17 | * - Redistributions in binary form must reproduce the above copyright 18 | * notice, this list of conditions and the following disclaimer in 19 | * the documentation and/or other materials provided with the 20 | * distribution. 21 | * 22 | * - Neither the name of the University of Tennessee nor the names of its 23 | * contributors may be used to endorse or promote products derived 24 | * from this software without specific prior written permission. 25 | * 26 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 27 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 28 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 29 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 30 | * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 31 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 32 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 33 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 34 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 36 | * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 | * POSSIBILITY OF SUCH DAMAGE. 38 | */ 39 | 40 | #pragma once 41 | 42 | #ifdef __cplusplus 43 | extern "C" { 44 | #endif 45 | 46 | extern int *liberation_coding_bitmatrix(int k, int w); 47 | extern int *liber8tion_coding_bitmatrix(int k); 48 | extern int *blaum_roth_coding_bitmatrix(int k, int w); 49 | 50 | #ifdef __cplusplus 51 | } 52 | #endif 53 | -------------------------------------------------------------------------------- /include/cauchy.h: -------------------------------------------------------------------------------- 1 | /* * 2 | * Copyright (c) 2013, James S. Plank and Kevin Greenan 3 | * All rights reserved. 4 | * 5 | * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure 6 | * Coding Techniques 7 | * 8 | * Revision 2.0: Galois Field backend now links to GF-Complete 9 | * 10 | * Redistribution and use in source and binary forms, with or without 11 | * modification, are permitted provided that the following conditions 12 | * are met: 13 | * 14 | * - Redistributions of source code must retain the above copyright 15 | * notice, this list of conditions and the following disclaimer. 16 | * 17 | * - Redistributions in binary form must reproduce the above copyright 18 | * notice, this list of conditions and the following disclaimer in 19 | * the documentation and/or other materials provided with the 20 | * distribution. 21 | * 22 | * - Neither the name of the University of Tennessee nor the names of its 23 | * contributors may be used to endorse or promote products derived 24 | * from this software without specific prior written permission. 25 | * 26 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 27 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 28 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 29 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 30 | * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 31 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 32 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 33 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 34 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 36 | * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 | * POSSIBILITY OF SUCH DAMAGE. 38 | */ 39 | 40 | #pragma once 41 | 42 | #ifdef __cplusplus 43 | extern "C" { 44 | #endif 45 | 46 | extern int *cauchy_original_coding_matrix(int k, int m, int w); 47 | extern int *cauchy_xy_coding_matrix(int k, int m, int w, int *x, int *y); 48 | extern void cauchy_improve_coding_matrix(int k, int m, int w, int *matrix); 49 | extern int *cauchy_good_general_coding_matrix(int k, int m, int w); 50 | extern int cauchy_n_ones(int n, int w); 51 | 52 | #ifdef __cplusplus 53 | } 54 | #endif 55 | -------------------------------------------------------------------------------- /Examples/time_all_gfs_argv_init.sh: -------------------------------------------------------------------------------- 1 | # 2 | # 3 | # Copyright (c) 2013, James S. Plank and Kevin Greenan 4 | # All rights reserved. 5 | # 6 | # Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure 7 | # Coding Techniques 8 | # 9 | # Revision 2.0: Galois Field backend now links to GF-Complete 10 | # 11 | # Redistribution and use in source and binary forms, with or without 12 | # modification, are permitted provided that the following conditions 13 | # are met: 14 | # 15 | # - Redistributions of source code must retain the above copyright 16 | # notice, this list of conditions and the following disclaimer. 17 | # 18 | # - Redistributions in binary form must reproduce the above copyright 19 | # notice, this list of conditions and the following disclaimer in 20 | # the documentation and/or other materials provided with the 21 | # distribution. 22 | # 23 | # - Neither the name of the University of Tennessee nor the names of its 24 | # contributors may be used to endorse or promote products derived 25 | # from this software without specific prior written permission. 26 | # 27 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 28 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 29 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 30 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 31 | # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 32 | # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 33 | # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 34 | # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 35 | # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 | # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 37 | # WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 38 | # POSSIBILITY OF SUCH DAMAGE. 39 | # 40 | GF_COMPLETE_DIR=/usr/local/bin 41 | GF_METHODS=${GF_COMPLETE_DIR}/gf_methods 42 | ITERATIONS=128 43 | BUFSIZE=65536 44 | k=12 45 | m=3 46 | seed=1370 47 | 48 | for w in 8 16 32 ; do 49 | ${GF_METHODS} $w -B -L | awk -F: '{ if ($1 == "w='$w'") print $2; }' | 50 | while read method; do 51 | echo "Testing ${k} ${m} ${w} ${seed} ${ITERATIONS} ${BUFSIZE} ${method}" 52 | ./reed_sol_time_gf ${k} ${m} ${w} ${seed} ${ITERATIONS} ${BUFSIZE} ${method} | tail -n 2 53 | if [[ $? != "0" ]]; then 54 | echo "Failed test for ${k} ${m} ${w} ${seed} ${ITERATIONS} ${BUFSIZE} ${method}" 55 | exit 1 56 | fi 57 | done 58 | 59 | if [[ $? == "1" ]]; then 60 | exit 1 61 | fi 62 | done 63 | 64 | echo "Passed all tests!" 65 | -------------------------------------------------------------------------------- /include/reed_sol.h: -------------------------------------------------------------------------------- 1 | /* * 2 | * Copyright (c) 2013, James S. Plank and Kevin Greenan 3 | * All rights reserved. 4 | * 5 | * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure 6 | * Coding Techniques 7 | * 8 | * Revision 2.0: Galois Field backend now links to GF-Complete 9 | * 10 | * Redistribution and use in source and binary forms, with or without 11 | * modification, are permitted provided that the following conditions 12 | * are met: 13 | * 14 | * - Redistributions of source code must retain the above copyright 15 | * notice, this list of conditions and the following disclaimer. 16 | * 17 | * - Redistributions in binary form must reproduce the above copyright 18 | * notice, this list of conditions and the following disclaimer in 19 | * the documentation and/or other materials provided with the 20 | * distribution. 21 | * 22 | * - Neither the name of the University of Tennessee nor the names of its 23 | * contributors may be used to endorse or promote products derived 24 | * from this software without specific prior written permission. 25 | * 26 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 27 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 28 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 29 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 30 | * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 31 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 32 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 33 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 34 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 36 | * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 | * POSSIBILITY OF SUCH DAMAGE. 38 | */ 39 | 40 | #pragma once 41 | 42 | #ifdef __cplusplus 43 | extern "C" { 44 | #endif 45 | 46 | extern int *reed_sol_vandermonde_coding_matrix(int k, int m, int w); 47 | extern int *reed_sol_extended_vandermonde_matrix(int rows, int cols, int w); 48 | extern int *reed_sol_big_vandermonde_distribution_matrix(int rows, int cols, int w); 49 | 50 | extern int reed_sol_r6_encode(int k, int w, char **data_ptrs, char **coding_ptrs, int size); 51 | extern int *reed_sol_r6_coding_matrix(int k, int w); 52 | 53 | extern void reed_sol_galois_w08_region_multby_2(char *region, int nbytes); 54 | extern void reed_sol_galois_w16_region_multby_2(char *region, int nbytes); 55 | extern void reed_sol_galois_w32_region_multby_2(char *region, int nbytes); 56 | 57 | #ifdef __cplusplus 58 | } 59 | #endif 60 | -------------------------------------------------------------------------------- /Examples/test_all_gfs.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | # 3 | # Copyright (c) 2013, James S. Plank and Kevin Greenan 4 | # All rights reserved. 5 | # 6 | # Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure 7 | # Coding Techniques 8 | # 9 | # Revision 2.0: Galois Field backend now links to GF-Complete 10 | # 11 | # Redistribution and use in source and binary forms, with or without 12 | # modification, are permitted provided that the following conditions 13 | # are met: 14 | # 15 | # - Redistributions of source code must retain the above copyright 16 | # notice, this list of conditions and the following disclaimer. 17 | # 18 | # - Redistributions in binary form must reproduce the above copyright 19 | # notice, this list of conditions and the following disclaimer in 20 | # the documentation and/or other materials provided with the 21 | # distribution. 22 | # 23 | # - Neither the name of the University of Tennessee nor the names of its 24 | # contributors may be used to endorse or promote products derived 25 | # from this software without specific prior written permission. 26 | # 27 | # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 28 | # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 29 | # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 30 | # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 31 | # HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 32 | # INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 33 | # BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 34 | # OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 35 | # AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 36 | # LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 37 | # WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 38 | # POSSIBILITY OF SUCH DAMAGE. 39 | # 40 | GF_METHODS=${GF_COMPLETE_DIR:-/usr/local/bin}/gf_methods 41 | k=12 42 | m=3 43 | seed=1370 44 | 45 | if ! test -x ${GF_METHODS} ; then 46 | ${GF_METHODS} 47 | exit 1 48 | fi 49 | 50 | # Test all w=8 51 | ${GF_METHODS} 8 -B -L | awk -F: '{ if ($1 == "w=8") print $2; }' | 52 | while read method; do 53 | echo "Testing ${k} ${m} 8 $seed ${method}" 54 | $VALGRIND ./reed_sol_test_gf ${k} ${m} 8 $seed ${method} | tail -n 1 55 | if [[ $? != "0" ]]; then 56 | echo "Failed test for ${k} ${m} 8 $seed ${method}" 57 | exit 1 58 | fi 59 | done 60 | 61 | if [[ $? == "1" ]]; then 62 | exit 1 63 | fi 64 | 65 | 66 | # Test all w=16 67 | ${GF_METHODS} 16 -B -L | awk -F: '{ if ($1 == "w=16") print $2; }' | 68 | while read method; do 69 | echo "Testing ${k} ${m} 16 $seed ${method}" 70 | $VALGRIND ./reed_sol_test_gf ${k} ${m} 16 $seed ${method} | tail -n 1 71 | if [[ $? != "0" ]]; then 72 | echo "Failed test for ${k} ${m} 16 $seed ${method}" 73 | exit 1 74 | fi 75 | done 76 | 77 | 78 | if [[ $? == "1" ]]; then 79 | exit 1 80 | fi 81 | 82 | # Test all w=32 83 | ${GF_METHODS} 32 -B -L | awk -F: '{ if ($1 == "w=32") print $2; }' | 84 | while read method; do 85 | echo "Testing ${k} ${m} 32 $seed ${method}" 86 | $VALGRIND ./reed_sol_test_gf ${k} ${m} 32 $seed ${method} | tail -n 1 87 | if [[ $? != "0" ]]; then 88 | echo "Failed test for ${k} ${m} 32 $seed ${method}" 89 | exit 1 90 | fi 91 | done 92 | 93 | 94 | if [[ $? == "1" ]]; then 95 | exit 1 96 | fi 97 | 98 | echo "Passed all tests!" 99 | -------------------------------------------------------------------------------- /Examples/jerasure_01.c: -------------------------------------------------------------------------------- 1 | /* * 2 | * Copyright (c) 2014, James S. Plank and Kevin Greenan 3 | * All rights reserved. 4 | * 5 | * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure 6 | * Coding Techniques 7 | * 8 | * Revision 2.0: Galois Field backend now links to GF-Complete 9 | * 10 | * Redistribution and use in source and binary forms, with or without 11 | * modification, are permitted provided that the following conditions 12 | * are met: 13 | * 14 | * - Redistributions of source code must retain the above copyright 15 | * notice, this list of conditions and the following disclaimer. 16 | * 17 | * - Redistributions in binary form must reproduce the above copyright 18 | * notice, this list of conditions and the following disclaimer in 19 | * the documentation and/or other materials provided with the 20 | * distribution. 21 | * 22 | * - Neither the name of the University of Tennessee nor the names of its 23 | * contributors may be used to endorse or promote products derived 24 | * from this software without specific prior written permission. 25 | * 26 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 27 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 28 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 29 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 30 | * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 31 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 32 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 33 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 34 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 35 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY 36 | * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 37 | * POSSIBILITY OF SUCH DAMAGE. 38 | */ 39 | 40 | /* Jerasure's authors: 41 | 42 | Revision 2.x - 2014: James S. Plank and Kevin M. Greenan. 43 | Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman. 44 | Revision 1.0 - 2007: James S. Plank. 45 | */ 46 | 47 | #include 48 | #include 49 | #include "jerasure.h" 50 | 51 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num)) 52 | 53 | static void usage(char *s) 54 | { 55 | fprintf(stderr, "usage: jerasure_01 r c w - creates and prints out a matrix in GF(2^w).\n\n"); 56 | fprintf(stderr, " Element i,j is equal to 2^(i*c+j)\n"); 57 | fprintf(stderr, " \n"); 58 | fprintf(stderr, "This demonstrates jerasure_print_matrix().\n"); 59 | if (s != NULL) fprintf(stderr, "%s\n", s); 60 | exit(1); 61 | } 62 | 63 | int main(int argc, char **argv) 64 | { 65 | int r, c, w, i, n; 66 | int *matrix; 67 | 68 | if (argc != 4) usage(NULL); 69 | if (sscanf(argv[1], "%d", &r) == 0 || r <= 0) usage("Bad r"); 70 | if (sscanf(argv[2], "%d", &c) == 0 || c <= 0) usage("Bad c"); 71 | if (sscanf(argv[3], "%d", &w) == 0 || w <= 0) usage("Bad w"); 72 | 73 | matrix = talloc(int, r*c); 74 | 75 | n = 1; 76 | for (i = 0; i < r*c; i++) { 77 | matrix[i] = n; 78 | n = galois_single_multiply(n, 2, w); 79 | } 80 | 81 | printf("jerasure_01"); 82 | for (i = 1; i < argc; i++) printf(" %s", argv[i]); 83 | printf("\n"); 84 | printf("

jerasure_01"); 85 | for (i = 1; i < argc; i++) printf(" %s", argv[i]); 86 | printf("

\n"); 87 | printf("
\n");
88 | 
89 |   jerasure_print_matrix(matrix, r, c, w);
90 |   return 0;
91 | }
92 | 
93 | 


--------------------------------------------------------------------------------
/m4/ax_gcc_x86_cpuid.m4:
--------------------------------------------------------------------------------
 1 | # ===========================================================================
 2 | #     http://www.gnu.org/software/autoconf-archive/ax_gcc_x86_cpuid.html
 3 | # ===========================================================================
 4 | #
 5 | # SYNOPSIS
 6 | #
 7 | #   AX_GCC_X86_CPUID(OP)
 8 | #
 9 | # DESCRIPTION
10 | #
11 | #   On Pentium and later x86 processors, with gcc or a compiler that has a
12 | #   compatible syntax for inline assembly instructions, run a small program
13 | #   that executes the cpuid instruction with input OP. This can be used to
14 | #   detect the CPU type.
15 | #
16 | #   On output, the values of the eax, ebx, ecx, and edx registers are stored
17 | #   as hexadecimal strings as "eax:ebx:ecx:edx" in the cache variable
18 | #   ax_cv_gcc_x86_cpuid_OP.
19 | #
20 | #   If the cpuid instruction fails (because you are running a
21 | #   cross-compiler, or because you are not using gcc, or because you are on
22 | #   a processor that doesn't have this instruction), ax_cv_gcc_x86_cpuid_OP
23 | #   is set to the string "unknown".
24 | #
25 | #   This macro mainly exists to be used in AX_GCC_ARCHFLAG.
26 | #
27 | # LICENSE
28 | #
29 | #   Copyright (c) 2008 Steven G. Johnson 
30 | #   Copyright (c) 2008 Matteo Frigo
31 | #
32 | #   This program is free software: you can redistribute it and/or modify it
33 | #   under the terms of the GNU General Public License as published by the
34 | #   Free Software Foundation, either version 3 of the License, or (at your
35 | #   option) any later version.
36 | #
37 | #   This program is distributed in the hope that it will be useful, but
38 | #   WITHOUT ANY WARRANTY; without even the implied warranty of
39 | #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
40 | #   Public License for more details.
41 | #
42 | #   You should have received a copy of the GNU General Public License along
43 | #   with this program. If not, see .
44 | #
45 | #   As a special exception, the respective Autoconf Macro's copyright owner
46 | #   gives unlimited permission to copy, distribute and modify the configure
47 | #   scripts that are the output of Autoconf when processing the Macro. You
48 | #   need not follow the terms of the GNU General Public License when using
49 | #   or distributing such scripts, even though portions of the text of the
50 | #   Macro appear in them. The GNU General Public License (GPL) does govern
51 | #   all other use of the material that constitutes the Autoconf Macro.
52 | #
53 | #   This special exception to the GPL applies to versions of the Autoconf
54 | #   Macro released by the Autoconf Archive. When you make and distribute a
55 | #   modified version of the Autoconf Macro, you may extend this special
56 | #   exception to the GPL to apply to your modified version as well.
57 | 
58 | #serial 7
59 | 
60 | AC_DEFUN([AX_GCC_X86_CPUID],
61 | [AC_REQUIRE([AC_PROG_CC])
62 | AC_LANG_PUSH([C])
63 | AC_CACHE_CHECK(for x86 cpuid $1 output, ax_cv_gcc_x86_cpuid_$1,
64 |  [AC_RUN_IFELSE([AC_LANG_PROGRAM([#include ], [
65 |      int op = $1, eax, ebx, ecx, edx;
66 |      FILE *f;
67 |       __asm__("cpuid"
68 |         : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx)
69 |         : "a" (op));
70 |      f = fopen("conftest_cpuid", "w"); if (!f) return 1;
71 |      fprintf(f, "%x:%x:%x:%x\n", eax, ebx, ecx, edx);
72 |      fclose(f);
73 |      return 0;
74 | ])],
75 |      [ax_cv_gcc_x86_cpuid_$1=`cat conftest_cpuid`; rm -f conftest_cpuid],
76 |      [ax_cv_gcc_x86_cpuid_$1=unknown; rm -f conftest_cpuid],
77 |      [ax_cv_gcc_x86_cpuid_$1=unknown])])
78 | AC_LANG_POP([C])
79 | ])
80 | 


--------------------------------------------------------------------------------
/m4/ax_check_compile_flag.m4:
--------------------------------------------------------------------------------
 1 | # ===========================================================================
 2 | #   http://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html
 3 | # ===========================================================================
 4 | #
 5 | # SYNOPSIS
 6 | #
 7 | #   AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS], [INPUT])
 8 | #
 9 | # DESCRIPTION
10 | #
11 | #   Check whether the given FLAG works with the current language's compiler
12 | #   or gives an error.  (Warnings, however, are ignored)
13 | #
14 | #   ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on
15 | #   success/failure.
16 | #
17 | #   If EXTRA-FLAGS is defined, it is added to the current language's default
18 | #   flags (e.g. CFLAGS) when the check is done.  The check is thus made with
19 | #   the flags: "CFLAGS EXTRA-FLAGS FLAG".  This can for example be used to
20 | #   force the compiler to issue an error when a bad flag is given.
21 | #
22 | #   INPUT gives an alternative input source to AC_COMPILE_IFELSE.
23 | #
24 | #   NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this
25 | #   macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG.
26 | #
27 | # LICENSE
28 | #
29 | #   Copyright (c) 2008 Guido U. Draheim 
30 | #   Copyright (c) 2011 Maarten Bosmans 
31 | #
32 | #   This program is free software: you can redistribute it and/or modify it
33 | #   under the terms of the GNU General Public License as published by the
34 | #   Free Software Foundation, either version 3 of the License, or (at your
35 | #   option) any later version.
36 | #
37 | #   This program is distributed in the hope that it will be useful, but
38 | #   WITHOUT ANY WARRANTY; without even the implied warranty of
39 | #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
40 | #   Public License for more details.
41 | #
42 | #   You should have received a copy of the GNU General Public License along
43 | #   with this program. If not, see .
44 | #
45 | #   As a special exception, the respective Autoconf Macro's copyright owner
46 | #   gives unlimited permission to copy, distribute and modify the configure
47 | #   scripts that are the output of Autoconf when processing the Macro. You
48 | #   need not follow the terms of the GNU General Public License when using
49 | #   or distributing such scripts, even though portions of the text of the
50 | #   Macro appear in them. The GNU General Public License (GPL) does govern
51 | #   all other use of the material that constitutes the Autoconf Macro.
52 | #
53 | #   This special exception to the GPL applies to versions of the Autoconf
54 | #   Macro released by the Autoconf Archive. When you make and distribute a
55 | #   modified version of the Autoconf Macro, you may extend this special
56 | #   exception to the GPL to apply to your modified version as well.
57 | 
58 | #serial 3
59 | 
60 | AC_DEFUN([AX_CHECK_COMPILE_FLAG],
61 | [AC_PREREQ(2.59)dnl for _AC_LANG_PREFIX
62 | AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl
63 | AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [
64 |   ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS
65 |   _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1"
66 |   AC_COMPILE_IFELSE([m4_default([$5],[AC_LANG_PROGRAM()])],
67 |     [AS_VAR_SET(CACHEVAR,[yes])],
68 |     [AS_VAR_SET(CACHEVAR,[no])])
69 |   _AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags])
70 | AS_IF([test x"AS_VAR_GET(CACHEVAR)" = xyes],
71 |   [m4_default([$2], :)],
72 |   [m4_default([$3], :)])
73 | AS_VAR_POPDEF([CACHEVAR])dnl
74 | ])dnl AX_CHECK_COMPILE_FLAGS
75 | 


--------------------------------------------------------------------------------
/m4/ax_gcc_x86_avx_xgetbv.m4:
--------------------------------------------------------------------------------
 1 | # ===========================================================================
 2 | #   http://www.gnu.org/software/autoconf-archive/ax_gcc_x86_avx_xgetbv.html
 3 | # ===========================================================================
 4 | #
 5 | # SYNOPSIS
 6 | #
 7 | #   AX_GCC_X86_AVX_XGETBV
 8 | #
 9 | # DESCRIPTION
10 | #
11 | #   On later x86 processors with AVX SIMD support, with gcc or a compiler
12 | #   that has a compatible syntax for inline assembly instructions, run a
13 | #   small program that executes the xgetbv instruction with input OP. This
14 | #   can be used to detect if the OS supports AVX instruction usage.
15 | #
16 | #   On output, the values of the eax and edx registers are stored as
17 | #   hexadecimal strings as "eax:edx" in the cache variable
18 | #   ax_cv_gcc_x86_avx_xgetbv.
19 | #
20 | #   If the xgetbv instruction fails (because you are running a
21 | #   cross-compiler, or because you are not using gcc, or because you are on
22 | #   a processor that doesn't have this instruction),
23 | #   ax_cv_gcc_x86_avx_xgetbv_OP is set to the string "unknown".
24 | #
25 | #   This macro mainly exists to be used in AX_EXT.
26 | #
27 | # LICENSE
28 | #
29 | #   Copyright (c) 2013 Michael Petch 
30 | #
31 | #   This program is free software: you can redistribute it and/or modify it
32 | #   under the terms of the GNU General Public License as published by the
33 | #   Free Software Foundation, either version 3 of the License, or (at your
34 | #   option) any later version.
35 | #
36 | #   This program is distributed in the hope that it will be useful, but
37 | #   WITHOUT ANY WARRANTY; without even the implied warranty of
38 | #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
39 | #   Public License for more details.
40 | #
41 | #   You should have received a copy of the GNU General Public License along
42 | #   with this program. If not, see .
43 | #
44 | #   As a special exception, the respective Autoconf Macro's copyright owner
45 | #   gives unlimited permission to copy, distribute and modify the configure
46 | #   scripts that are the output of Autoconf when processing the Macro. You
47 | #   need not follow the terms of the GNU General Public License when using
48 | #   or distributing such scripts, even though portions of the text of the
49 | #   Macro appear in them. The GNU General Public License (GPL) does govern
50 | #   all other use of the material that constitutes the Autoconf Macro.
51 | #
52 | #   This special exception to the GPL applies to versions of the Autoconf
53 | #   Macro released by the Autoconf Archive. When you make and distribute a
54 | #   modified version of the Autoconf Macro, you may extend this special
55 | #   exception to the GPL to apply to your modified version as well.
56 | 
57 | #serial 1
58 | 
59 | AC_DEFUN([AX_GCC_X86_AVX_XGETBV],
60 | [AC_REQUIRE([AC_PROG_CC])
61 | AC_LANG_PUSH([C])
62 | AC_CACHE_CHECK(for x86-AVX xgetbv $1 output, ax_cv_gcc_x86_avx_xgetbv_$1,
63 |  [AC_RUN_IFELSE([AC_LANG_PROGRAM([#include ], [
64 |      int op = $1, eax, edx;
65 |      FILE *f;
66 |       /* Opcodes for xgetbv */
67 |       __asm__(".byte 0x0f, 0x01, 0xd0"
68 |         : "=a" (eax), "=d" (edx)
69 |         : "c" (op));
70 |      f = fopen("conftest_xgetbv", "w"); if (!f) return 1;
71 |      fprintf(f, "%x:%x\n", eax, edx);
72 |      fclose(f);
73 |      return 0;
74 | ])],
75 |      [ax_cv_gcc_x86_avx_xgetbv_$1=`cat conftest_xgetbv`; rm -f conftest_xgetbv],
76 |      [ax_cv_gcc_x86_avx_xgetbv_$1=unknown; rm -f conftest_xgetbv],
77 |      [ax_cv_gcc_x86_avx_xgetbv_$1=unknown])])
78 | AC_LANG_POP([C])
79 | ])
80 | 


--------------------------------------------------------------------------------
/Examples/jerasure_02.c:
--------------------------------------------------------------------------------
 1 | /* *
 2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
 3 |  * All rights reserved.
 4 |  *
 5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
 6 |  * Coding Techniques
 7 |  *
 8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
 9 |  *
10 |  * Redistribution and use in source and binary forms, with or without
11 |  * modification, are permitted provided that the following conditions
12 |  * are met:
13 |  *
14 |  *  - Redistributions of source code must retain the above copyright
15 |  *    notice, this list of conditions and the following disclaimer.
16 |  *
17 |  *  - Redistributions in binary form must reproduce the above copyright
18 |  *    notice, this list of conditions and the following disclaimer in
19 |  *    the documentation and/or other materials provided with the
20 |  *    distribution.
21 |  *
22 |  *  - Neither the name of the University of Tennessee nor the names of its
23 |  *    contributors may be used to endorse or promote products derived
24 |  *    from this software without specific prior written permission.
25 |  *
26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 |  * POSSIBILITY OF SUCH DAMAGE.
38 |  */
39 | 
40 | /* Jerasure's authors:
41 | 
42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
44 |    Revision 1.0 - 2007: James S. Plank.
45 |  */
46 | 
47 | #include 
48 | #include 
49 | #include "jerasure.h"
50 | 
51 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
52 | 
53 | static void usage(char *s)
54 | {
55 |   fprintf(stderr, "usage: jerasure_02 r c w - Converts the matrix of jerasure_01 to a bit matrix.\n");
56 |   fprintf(stderr, "       \n");
57 |   fprintf(stderr, "This demonstrates jerasure_print_bitmatrix() and jerasure_matrix_to_bitmatrix().\n");
58 |   if (s != NULL) fprintf(stderr, "%s\n", s);
59 |   exit(1);
60 | }
61 | 
62 | int main(int argc, char **argv)
63 | {
64 |   int r, c, w, i, n;
65 |   int *matrix;
66 |   int *bitmatrix;
67 | 
68 |   if (argc != 4) usage(NULL);
69 |   if (sscanf(argv[1], "%d", &r) == 0 || r <= 0) usage("Bad r");
70 |   if (sscanf(argv[2], "%d", &c) == 0 || c <= 0) usage("Bad c");
71 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0) usage("Bad w");
72 | 
73 |   matrix = talloc(int, r*c);
74 | 
75 |   n = 1;
76 |   for (i = 0; i < r*c; i++) {
77 |     matrix[i] = n;
78 |     n = galois_single_multiply(n, 2, w);
79 |   }
80 | 
81 |   bitmatrix = jerasure_matrix_to_bitmatrix(c, r, w, matrix);
82 | 
83 |   printf("jerasure_02");
84 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
85 |   printf("\n");
86 |   printf("
jerasure_02");
87 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
88 |   printf("
\n");
89 |   printf("
\n");
90 | 
91 |   jerasure_print_bitmatrix(bitmatrix, r*w, c*w, w);
92 |   return 0;
93 | }
94 | 
95 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Jerasure
 2 | ## Introduction
 3 |   Jerasure is an open source erasure codes library create by __James S. Plank__ (University of Tennessee) and __Kevin M. Greenan__ (Box). This library implements some classic erasure codes such as Reed-Solomon Codes, Cauchy Reed-Solomon Codes, Linux RAID-6 and three Minimal Density RAID-6 codes: Blaum Roth codes, Liberation codes and Liber8tion codes. Jerasure revisioned several times and implemented some optimizations proposed in paper.  
 4 |   My optimization based on Jerasure2.0 and pays attention to the XOR based erasured codes such as CRS codes and Minimal Density RAID-6 codes, can provide over __30GB/s__ encoding speed whereas the origional implement only __5-6GB/s__.  
 5 | 
 6 | ## Installation
 7 | because optimization base on Jerasure2.0, so the installation process is same as Jerasure2.0:  
 8 | first make sure have needed tools, if use Ubuntu can install as follows:  
 9 | ```
10 | sudo apt install autoconf
11 | sudo apt install libtool
12 | ```
13 | and add /usr/local/lib to dynamic library path if not:
14 | ```
15 | sudo sh -c "echo '/usr/local/lib' >> /etc/ld.so.conf"
16 | sudo /sbin/ldconfig
17 | ```
18 | then install GF-Complete:  
19 | ```
20 | git clone git@github.com:ceph/gf-complete.git
21 | cd gf-complete/
22 | autoreconf --force --install
23 | ./configure
24 | make
25 | sudo make install
26 | cd ..
27 | ```
28 | finally, install Jerasure:  
29 | ```
30 | git clone git@github.com:jvlla/Jerasure_xor_optimizated.git
31 | cd Jerasure_xor_optimizated/
32 | autoreconf --force --install
33 | ./configure
34 | make
35 | sudo make install
36 | ```
37 | ## Use Guide
38 | Still the Manual.pdf, but the buffer need allocated by posix_memalign() otherwise Segmentation fault.
39 | 
40 | ## Performance difference
41 | use encoder with parameter "my_encode_file  6 2 cauchy_good 8 packet_size 5000000"  
42 |              "my_encode_file 10 6 cauchy_good 8 packet_size 5000000"  
43 | 

44 |     
45 | 

46 | 
47 |   With 2 coding blocks, this optimization provides up to __30GB/s__ encoding speed and __4-5__ times faster than origional implementation.  
48 |   With 6 coding blocks, this optimization provides up to __17GB/s__ encoding speed and __14-19__ times faster than origional implementation, that because origional speed drop to less than 1GB/s, and optimization can deal with high quantity calculation better so performance keeps better.  
49 |   pay attention, strip size = packetsize * w, that means this optimization can provide satisfied speed with 4k strip size, and at about 64k strip size get best performance, suitable for disk block reality.  
50 |   Besides those, single thread implementation can provide up to 21GB/s encoding speed. AVX-2 and AVX-512 instruction set different performance not much, about 2GB/s.
51 | 
52 | ## Optimization
53 | SIMD: use SIMD instruction do XOR in parallel
54 | cache: use registers store XOR intermediate value
55 | multi-thread: use threads parallel do XOR
56 | 
57 | ## Modification
58 | #### jerasure_schedule_encode() jerasure_schedule_decode_lazy()
59 |   To paralle, instead of directly call jerasure_do_scheduled_operations(), these two function first call jerasure_do_scheduled_operations_thread(), then jerasure_schedule_encode() called by jerasure_do_scheduled_operations_thread(). Also do some needed modification to support multi-thread. 
60 | #### jerasure_schedule_encode()
61 |   To reduce cache access, write some assembly codes directly control XOR operation and the loop.
62 | #### timing.c timing.h
63 |   The origional implementation uses clock() and gettimeofday(), can only giving a maximum possible precision of 1 µs. Switch to clock_gettime() can giving precision of 1 ns.
64 | #### encoder.c decoder.c
65 |   Modify to use the new timing functions and support bigger file.
66 | ## More Codes and Versions
67 |   In fact, this optimization is my undergraduate graduation project, so I tried many other optimizations base on Jerasure1.2(for easy to test), such as GPU optimization, and reproduce some optimization proposed in papers, such as PErasure(though in CPU can get better performance). If you want to know more about it, please switch to branch "grad_project". Also, what must mentioned is I think this optimization is __a general way__ to optimizate XOR based erasure codes, so implement it can also help improve performance of other libraries, welcome to use it!
68 | 


--------------------------------------------------------------------------------
/Examples/reed_sol_02.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include "jerasure.h"
 51 | #include "reed_sol.h"
 52 | 
 53 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 54 | 
 55 | static void usage(char *s)
 56 | {
 57 |   fprintf(stderr, "usage: reed_sol_02 k m w - Vandermonde matrices in GF(2^w).\n");
 58 |   fprintf(stderr, "       \n");
 59 |   fprintf(stderr, "       k+m must be <= 2^w.  This simply prints out the \n");
 60 |   fprintf(stderr, "       Vandermonde matrix in GF(2^w), and then the generator\n");
 61 |   fprintf(stderr, "       matrix that is constructed from it.  See [Plank-Ding-05] for\n");
 62 |   fprintf(stderr, "       information on how this construction proceeds\n");
 63 |   fprintf(stderr, "       \n");
 64 |   fprintf(stderr, "This demonstrates: reed_sol_extended_vandermonde_matrix()\n");
 65 |   fprintf(stderr, "                   reed_sol_big_vandermonde_coding_matrix()\n");
 66 |   fprintf(stderr, "                   reed_sol_vandermonde_coding_matrix()\n");
 67 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 68 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 69 |   exit(1);
 70 | }
 71 | 
 72 | int main(int argc, char **argv)
 73 | {
 74 |   int k, w, m;
 75 |   int *matrix;
 76 |   
 77 |   if (argc != 4) usage(NULL);
 78 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
 79 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
 80 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
 81 |   if (w <= 30 && k + m > (1 << w)) usage("k + m is too big");
 82 | 
 83 |   matrix = reed_sol_extended_vandermonde_matrix(k+m, k, w);
 84 | 
 85 |   printf("reed_sol_02 %d %d %d\n", k, m, w);
 86 |   printf("
reed_sol_02 %d %d %d
\n", k, m, w);
 87 |   printf("
\n");
 88 |   printf("Extended Vandermonde Matrix:\n\n");
 89 |   jerasure_print_matrix(matrix, k+m, k, w);
 90 |   printf("\n");
 91 | 
 92 |   matrix = reed_sol_big_vandermonde_distribution_matrix(k+m, k, w);
 93 |   printf("Vandermonde Generator Matrix (G^T):\n\n");
 94 |   jerasure_print_matrix(matrix, k+m, k, w);
 95 |   printf("\n");
 96 | 
 97 |   matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
 98 |   printf("Vandermonde Coding Matrix:\n\n");
 99 |   jerasure_print_matrix(matrix, m, k, w);
100 |   printf("\n");
101 | 
102 |   
103 |   return 0;
104 | }
105 | 


--------------------------------------------------------------------------------
/Examples/cauchy_01.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 |  
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include "cauchy.h"
 52 | #include "jerasure.h"
 53 | #include "reed_sol.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: cauchy_01 n w - Converts the value n to a bitmatrix using GF(2^w).\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "       It prints the bitmatrix, and reports on the numberof ones.\n");
 62 |   fprintf(stderr, "       Use 0x to input n in hexadecimal.\n");
 63 |   fprintf(stderr, "       W must be <= 32.\n");
 64 |   fprintf(stderr, "       \n");
 65 |   fprintf(stderr, "This demonstrates: cauchy_n_ones()\n");
 66 |   fprintf(stderr, "                   jerasure_matrix_to_bitmatrix()\n");
 67 |   fprintf(stderr, "                   jerasure_print_bitmatrix()\n");
 68 |   if (s != NULL) fprintf(stderr, "\n%s\n", s);
 69 |   exit(1);
 70 | }
 71 | 
 72 | int main(int argc, char **argv)
 73 | {
 74 |   int n;
 75 |   int i, no, w;
 76 |   int *bitmatrix;
 77 |   
 78 |   if (argc != 3) usage(NULL);
 79 |   if (sscanf(argv[1], "0x%x", &n) == 0) {
 80 |     if (sscanf(argv[1], "%d", &n) == 0) usage("Bad n");
 81 |   }
 82 |   if (sscanf(argv[2], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
 83 |   if (w == 31) {
 84 |     if (n & 0x80000000L) usage("Bad n/w combination (n not between 0 and 2^w-1)\n");
 85 |   } else if (w < 31) {
 86 |     if (n >= (1 << w)) usage("Bad n/w combination (n not between 0 and 2^w-1)\n");
 87 |   }
 88 | 
 89 |   bitmatrix = jerasure_matrix_to_bitmatrix(1, 1, w, &n);
 90 |   printf("cauchy_01 %u %d\n", w, n);
 91 |   printf("
cauchy_01 %u %d
\n", w, n);
 92 |   printf("
\n");
 93 |   if (w == 32) {
 94 |     printf("Converted the value 0x%x to the following bitmatrix:\n\n", n);
 95 |   } else {
 96 |     printf("Converted the value %d (0x%x) to the following bitmatrix:\n\n", n, n);
 97 |   }
 98 |   jerasure_print_bitmatrix(bitmatrix, w, w, w);
 99 |   printf("\n");
100 | 
101 |   no = 0;
102 |   for (i = 0; i < w*w; i++) no += bitmatrix[i];
103 |   if (no != cauchy_n_ones(n, w)) { 
104 |     fprintf(stderr, "Jerasure error: # ones in the bitmatrix (%d) doesn't match cauchy_n_ones() (%d).\n",
105 |        no, cauchy_n_ones(n, w));
106 |     exit(1);
107 |   }
108 | 
109 |   printf("# Ones: %d\n", cauchy_n_ones(n, w));
110 | 
111 |   return 0;
112 | }
113 | 


--------------------------------------------------------------------------------
/Examples/reed_sol_04.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | #include "reed_sol.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: reed_sol_04 w seed - Shows reed_sol_galois_wXX_region_multby_2\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "       w must be 8, 16 or 32.  Sets up an array of 4 random words in\n");
 62 |   fprintf(stderr, "       GF(2^w) and multiplies them by two.  \n");
 63 |   fprintf(stderr, "       \n");
 64 |   fprintf(stderr, "This demonstrates: reed_sol_galois_w08_region_multby_2()\n");
 65 |   fprintf(stderr, "                   reed_sol_galois_w16_region_multby_2()\n");
 66 |   fprintf(stderr, "                   reed_sol_galois_w32_region_multby_2()\n");
 67 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 68 |   exit(1);
 69 | }
 70 | 
 71 | int main(int argc, char **argv)
 72 | {
 73 |   unsigned char *x, *y;
 74 |   unsigned short *xs, *ys;
 75 |   unsigned int *xi, *yi;
 76 |   uint32_t seed;
 77 |   int *a32, *copy;
 78 |   int i;
 79 |   int w;
 80 |   
 81 |   if (argc != 3) usage(NULL);
 82 |   if (sscanf(argv[1], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
 83 |   if (sscanf(argv[2], "%d", &seed) == 0) usage("Bad seed");
 84 | 
 85 |   printf("reed_sol_04 %d %d\n", w, seed);
 86 |   printf("
reed_sol_04 %d %d
\n", w, seed);
 87 |   printf("
\n");
 88 | 
 89 |   MOA_Seed(seed);
 90 |   a32 = talloc(int, 4);
 91 |   copy = talloc(int, 4);
 92 |   y = (unsigned char *) a32;
 93 |   for (i = 0; i < 4*sizeof(int); i++) y[i] = MOA_Random_W(8, 1);
 94 |   memcpy(copy, a32, sizeof(int)*4);
 95 | 
 96 |   if (w == 8) {
 97 |     x = (unsigned char *) copy;
 98 |     y = (unsigned char *) a32;
 99 |     reed_sol_galois_w08_region_multby_2((char *) a32, sizeof(int)*4);
100 |     for (i = 0; i < 4*sizeof(int)/sizeof(char); i++) {
101 |        printf("Char %2d: %3u *2 = %3u\n", i, x[i], y[i]);
102 |     }
103 |   } else if (w == 16) {
104 |     xs = (unsigned short *) copy;
105 |     ys = (unsigned short *) a32;
106 |     reed_sol_galois_w16_region_multby_2((char *) a32, sizeof(int)*4);
107 |     for (i = 0; i < 4*sizeof(int)/sizeof(short); i++) {
108 |        printf("Short %2d: %5u *2 = %5u\n", i, xs[i], ys[i]);
109 |     }
110 |   } else if (w == 32) {
111 |     xi = (unsigned int *) copy;
112 |     yi = (unsigned int *) a32;
113 |     reed_sol_galois_w16_region_multby_2((char *) a32, sizeof(int)*4);
114 |     for (i = 0; i < 4*sizeof(int)/sizeof(int); i++) {
115 |        printf("Int %2d: %10u *2 = %10u\n", i, xi[i], yi[i]);
116 |     }
117 |   } 
118 | 
119 |   return 0;
120 | }
121 | 


--------------------------------------------------------------------------------
/Examples/jerasure_04.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include "jerasure.h"
 51 | 
 52 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 53 | 
 54 | static void usage(char *s)
 55 | {
 56 |   fprintf(stderr, "usage: jerasure_04 k w - Performs the analogous bit-matrix operations to jerasure_03.\n\n");
 57 |   fprintf(stderr, "       It converts the matrix to a kw*kw bit matrix and does the same operations.\n");
 58 |   fprintf(stderr, "       k must be < 2^w.\n");
 59 |   fprintf(stderr, "This demonstrates: jerasure_print_bitmatrix()\n");
 60 |   fprintf(stderr, "                   jerasure_matrix_to_bitmatrix()\n");
 61 |   fprintf(stderr, "                   jerasure_invertible_bitmatrix()\n");
 62 |   fprintf(stderr, "                   jerasure_invert_bitmatrix()\n");
 63 |   fprintf(stderr, "                   jerasure_matrix_multiply().\n");
 64 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 65 |   exit(1);
 66 | }
 67 | 
 68 | int main(int argc, char **argv)
 69 | {
 70 |   unsigned int k, w, i, j, n;
 71 |   int *matrix;
 72 |   int *bitmatrix;
 73 |   int *bitmatrix_copy;
 74 |   int *inverse;
 75 |   int *identity;
 76 | 
 77 |   if (argc != 3) usage(NULL);
 78 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
 79 |   if (sscanf(argv[2], "%d", &w) == 0 || w <= 0 || w > 31) usage("Bad w");
 80 |   if (k >= (1 << w)) usage("K too big");
 81 | 
 82 |   matrix = talloc(int, k*k);
 83 |   bitmatrix_copy = talloc(int, k*w*k*w);
 84 |   inverse = talloc(int, k*w*k*w);
 85 | 
 86 |   for (i = 0; i < k; i++) {
 87 |     for (j = 0; j < k; j++) {
 88 |       n = i ^ ((1 << w)-1-j);
 89 |       matrix[i*k+j] = (n == 0) ? 0 : galois_single_divide(1, n, w);
 90 |     }
 91 |   }
 92 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, k, w, matrix);
 93 | 
 94 |   printf("jerasure_04");
 95 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
 96 |   printf("\n");
 97 |   printf("
jerasure_04");
 98 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
 99 |   printf("
\n");
100 |   printf("
\n");
101 | 
102 |   printf("The Cauchy Bit-Matrix:\n");
103 |   jerasure_print_bitmatrix(bitmatrix, k*w, k*w, w);
104 |   memcpy(bitmatrix_copy, bitmatrix, sizeof(int)*k*w*k*w);
105 |   i = jerasure_invertible_bitmatrix(bitmatrix_copy, k*w);
106 |   printf("\nInvertible: %s\n", (i == 1) ? "Yes" : "No");
107 |   if (i == 1) {
108 |     printf("\nInverse:\n");
109 |     memcpy(bitmatrix_copy, bitmatrix, sizeof(int)*k*w*k*w);
110 |     i = jerasure_invert_bitmatrix(bitmatrix_copy, inverse, k*w);
111 |     jerasure_print_bitmatrix(inverse, k*w, k*w, w);
112 |     identity = jerasure_matrix_multiply(inverse, bitmatrix, k*w, k*w, k*w, k*w, 2);
113 |     printf("\nInverse times matrix (should be identity):\n");
114 |     jerasure_print_bitmatrix(identity, k*w, k*w, w);
115 |   }
116 |   return 0;
117 | }
118 | 
119 | 


--------------------------------------------------------------------------------
/Examples/jerasure_03.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include "jerasure.h"
 51 | 
 52 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 53 | 
 54 | static void usage(char *s)
 55 | {
 56 |   fprintf(stderr, "usage: jerasure_03 k w - Creates a kxk Cauchy matrix in GF(2^w). \n\n");
 57 |   fprintf(stderr, "       k must be < 2^w.  Element i,j is 1/(i+(2^w-j-1)).  (If that is\n");
 58 |   fprintf(stderr, "       If that is 1/0, then it sets it to zero).  \n");
 59 |   fprintf(stderr, "       It then tests whether that matrix is invertible.\n");
 60 |   fprintf(stderr, "       If it is invertible, then it prints out the inverse.\n");
 61 |   fprintf(stderr, "       Finally, it prints the product of the matrix and its inverse.\n");
 62 |   fprintf(stderr, "       \n");
 63 |   fprintf(stderr, "This demonstrates: jerasure_print_matrix()\n");
 64 |   fprintf(stderr, "                   jerasure_invertible_matrix()\n");
 65 |   fprintf(stderr, "                   jerasure_invert_matrix()\n");
 66 |   fprintf(stderr, "                   jerasure_matrix_multiply().\n");
 67 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 68 |   exit(1);
 69 | }
 70 | 
 71 | int main(int argc, char **argv)
 72 | {
 73 |   unsigned int k, w, i, j, n;
 74 |   int *matrix;
 75 |   int *matrix_copy;
 76 |   int *inverse;
 77 |   int *identity;
 78 | 
 79 |   if (argc != 3) usage(NULL);
 80 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
 81 |   if (sscanf(argv[2], "%d", &w) == 0 || w <= 0 || w > 31) usage("Bad w");
 82 |   if (k >= (1 << w)) usage("K too big");
 83 | 
 84 |   matrix = talloc(int, k*k);
 85 |   matrix_copy = talloc(int, k*k);
 86 |   inverse = talloc(int, k*k);
 87 | 
 88 |   for (i = 0; i < k; i++) {
 89 |     for (j = 0; j < k; j++) {
 90 |       n = i ^ ((1 << w)-1-j);
 91 |       matrix[i*k+j] = (n == 0) ? 0 : galois_single_divide(1, n, w);
 92 |     }
 93 |   }
 94 | 
 95 |   printf("jerasure_03");
 96 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
 97 |   printf("\n");
 98 |   printf("
jerasure_03");
 99 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
100 |   printf("
\n");
101 |   printf("
\n");
102 | 
103 |   printf("The Cauchy Matrix:\n");
104 |   jerasure_print_matrix(matrix, k, k, w);
105 |   memcpy(matrix_copy, matrix, sizeof(int)*k*k);
106 |   i = jerasure_invertible_matrix(matrix_copy, k, w);
107 |   printf("\nInvertible: %s\n", (i == 1) ? "Yes" : "No");
108 |   if (i == 1) {
109 |     printf("\nInverse:\n");
110 |     memcpy(matrix_copy, matrix, sizeof(int)*k*k);
111 |     i = jerasure_invert_matrix(matrix_copy, inverse, k, w);
112 |     jerasure_print_matrix(inverse, k, k, w);
113 |     identity = jerasure_matrix_multiply(inverse, matrix, k, k, k, k, w);
114 |     printf("\nInverse times matrix (should be identity):\n");
115 |     jerasure_print_matrix(identity, k, k, w);
116 |   }
117 |   return 0;
118 | }
119 | 
120 | 


--------------------------------------------------------------------------------
/include/galois.h:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2013, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | #pragma once
 41 | 
 42 | #include 
 43 | #include 
 44 | 
 45 | #ifdef __cplusplus
 46 | extern "C" {
 47 | #endif
 48 | 
 49 | extern int galois_init_default_field(int w);
 50 | extern int galois_uninit_field(int w);
 51 | extern void galois_change_technique(gf_t *gf, int w);
 52 | 
 53 | extern int galois_single_multiply(int a, int b, int w);
 54 | extern int galois_single_divide(int a, int b, int w);
 55 | extern int galois_inverse(int x, int w);
 56 | 
 57 | void galois_region_xor(           char *src,         /* Source Region */
 58 |                                   char *dest,        /* Dest Region (holds result) */
 59 |                                   int nbytes);      /* Number of bytes in region */
 60 | 
 61 | /* These multiply regions in w=8, w=16 and w=32.  They are much faster
 62 |    than calling galois_single_multiply.  The regions must be long word aligned. */
 63 | 
 64 | void galois_w08_region_multiply(char *region,       /* Region to multiply */
 65 |                                   int multby,       /* Number to multiply by */
 66 |                                   int nbytes,       /* Number of bytes in region */
 67 |                                   char *r2,         /* If r2 != NULL, products go here.  
 68 |                                                        Otherwise region is overwritten */
 69 |                                   int add);         /* If (r2 != NULL && add) the produce is XOR'd with r2 */
 70 | 
 71 | void galois_w16_region_multiply(char *region,       /* Region to multiply */
 72 |                                   int multby,       /* Number to multiply by */
 73 |                                   int nbytes,       /* Number of bytes in region */
 74 |                                   char *r2,         /* If r2 != NULL, products go here.  
 75 |                                                        Otherwise region is overwritten */
 76 |                                   int add);         /* If (r2 != NULL && add) the produce is XOR'd with r2 */
 77 | 
 78 | void galois_w32_region_multiply(char *region,       /* Region to multiply */
 79 |                                   int multby,       /* Number to multiply by */
 80 |                                   int nbytes,       /* Number of bytes in region */
 81 |                                   char *r2,         /* If r2 != NULL, products go here.  
 82 |                                                        Otherwise region is overwritten */
 83 |                                   int add);         /* If (r2 != NULL && add) the produce is XOR'd with r2 */
 84 | 
 85 | gf_t* galois_init_field(int w,
 86 |                              int mult_type,
 87 |                              int region_type,
 88 |                              int divide_type,
 89 |                              uint64_t prim_poly,
 90 |                              int arg1,
 91 |                              int arg2);
 92 | 
 93 | gf_t* galois_init_composite_field(int w,
 94 |                                 int region_type,
 95 |                                 int divide_type,
 96 |                                 int degree,
 97 |                                 gf_t* base_gf);
 98 | 
 99 | gf_t * galois_get_field_ptr(int w);
100 | 
101 | #ifdef __cplusplus
102 | }
103 | #endif
104 | 


--------------------------------------------------------------------------------
/Examples/reed_sol_test_gf.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include 
 53 | #include 
 54 | #include 
 55 | #include "jerasure.h"
 56 | #include "reed_sol.h"
 57 | 
 58 | #define BUFSIZE 4096
 59 | 
 60 | static void *malloc16(int size) {
 61 |     void *mem = malloc(size+16+sizeof(void*));
 62 |     void **ptr = (void**)((long)(mem+16+sizeof(void*)) & ~(15));
 63 |     ptr[-1] = mem;
 64 |     return ptr;
 65 | }
 66 | 
 67 | #if 0
 68 | // Unused for now.
 69 | static void free16(void *ptr) {
 70 |     free(((void**)ptr)[-1]);
 71 | }
 72 | #endif
 73 | 
 74 | #define talloc(type, num) (type *) malloc16(sizeof(type)*(num))
 75 | 
 76 | static void usage(char *s)
 77 | {
 78 |   fprintf(stderr, "usage: reed_sol_test_gf k m w seed (additional GF args) - Tests Reed-Solomon in GF(2^w).\n");
 79 |   fprintf(stderr, "       \n");
 80 |   fprintf(stderr, "       w must be 8, 16 or 32.  k+m must be <= 2^w.\n");
 81 |   fprintf(stderr, "       See the README for information on the additional GF args.\n");
 82 |   fprintf(stderr, "       Set up a Vandermonde-based distribution matrix and encodes k devices of\n");
 83 |   fprintf(stderr, "       %d bytes each with it.  Then it decodes.\n", BUFSIZE);
 84 |   fprintf(stderr, "       \n");
 85 |   fprintf(stderr, "This tests:        jerasure_matrix_encode()\n");
 86 |   fprintf(stderr, "                   jerasure_matrix_decode()\n");
 87 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 88 |   fprintf(stderr, "                   galois_change_technique()\n");
 89 |   fprintf(stderr, "                   reed_sol_vandermonde_coding_matrix()\n");
 90 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 91 |   exit(1);
 92 | }
 93 | 
 94 | gf_t* get_gf(int w, int argc, char **argv, int starting)
 95 | {
 96 |   gf_t *gf = (gf_t*)malloc(sizeof(gf_t));
 97 |   if (create_gf_from_argv(gf, w, argc, argv, starting) == 0) {
 98 |     free(gf);
 99 |     gf = NULL;
100 |   }
101 |   return gf;
102 | }
103 | 
104 | int main(int argc, char **argv)
105 | {
106 |   int k, w, i, m;
107 |   int *matrix;
108 |   char **data, **coding, **old_values;
109 |   int *erasures, *erased;
110 |   gf_t *gf = NULL;
111 |   uint32_t seed;
112 |   
113 |   if (argc < 6) usage("Not enough command line arguments");  
114 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
115 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
116 |   if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
117 |   if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
118 |   if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
119 | 
120 |   MOA_Seed(seed);
121 | 
122 |   gf = get_gf(w, argc, argv, 5); 
123 | 
124 |   if (gf == NULL) {
125 |     usage("Invalid arguments given for GF!\n");
126 |   }
127 | 
128 |   galois_change_technique(gf, w); 
129 | 
130 |   matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
131 | 
132 |   printf("reed_sol_test_gf");
133 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
134 |   printf("\n");
135 |   printf("
reed_sol_test_gf");
136 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
137 |   printf("
\n");
138 |   printf("
\n");
139 | 
140 |   printf("Last m rows of the generator matrix (G^T):\n\n");
141 |   jerasure_print_matrix(matrix, m, k, w);
142 |   printf("\n");
143 | 
144 |   data = talloc(char *, k);
145 |   for (i = 0; i < k; i++) {
146 |     data[i] = talloc(char, BUFSIZE);
147 |     MOA_Fill_Random_Region(data[i], BUFSIZE);
148 |   }
149 | 
150 |   coding = talloc(char *, m);
151 |   old_values = talloc(char *, m);
152 |   for (i = 0; i < m; i++) {
153 |     coding[i] = talloc(char, BUFSIZE);
154 |     old_values[i] = talloc(char, BUFSIZE);
155 |   }
156 | 
157 |   jerasure_matrix_encode(k, m, w, matrix, data, coding, BUFSIZE);
158 |   
159 |   erasures = talloc(int, (m+1));
160 |   erased = talloc(int, (k+m));
161 |   for (i = 0; i < m+k; i++) erased[i] = 0;
162 |   for (i = 0; i < m; ) {
163 |     erasures[i] = ((unsigned int)MOA_Random_W(w,1))%(k+m);
164 |     if (erased[erasures[i]] == 0) {
165 |       erased[erasures[i]] = 1;
166 |       memcpy(old_values[i], (erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], BUFSIZE);
167 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], BUFSIZE);
168 |       i++;
169 |     }
170 |   }
171 |   erasures[i] = -1;
172 | 
173 |   i = jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, BUFSIZE);
174 | 
175 |   for (i = 0; i < m; i++) {
176 |     if (erasures[i] < k) {
177 |       if (memcmp(data[erasures[i]], old_values[i], BUFSIZE)) {
178 |         fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
179 |         exit(1);
180 |       }
181 |     } else {
182 |       if (memcmp(coding[erasures[i]-k], old_values[i], BUFSIZE)) {
183 |         fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
184 |         exit(1);
185 |       }
186 |     }
187 |   }
188 |   
189 |   printf("Encoding and decoding were both successful.\n");
190 |   return 0;
191 | }
192 | 


--------------------------------------------------------------------------------
/Examples/reed_sol_03.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include "jerasure.h"
 52 | #include "reed_sol.h"
 53 | 
 54 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 55 | 
 56 | static void usage(char *s)
 57 | {
 58 |   fprintf(stderr, "usage: reed_sol_03 k w seed - Does a simple RAID-6 coding example in GF(2^w).\n");
 59 |   fprintf(stderr, "       \n");
 60 |   fprintf(stderr, "       w must be 8, 16 or 32.  k+2 must be <= 2^w.  It sets up a classic\n");
 61 |   fprintf(stderr, "       RAID-6 coding matrix based on Anvin's optimization and encodes\n");
 62 |   fprintf(stderr, "       %ld-byte devices with it.  Then it decodes.\n", sizeof(long));
 63 |   fprintf(stderr, "       \n");
 64 |   fprintf(stderr, "This demonstrates: reed_sol_r6_encode()\n");
 65 |   fprintf(stderr, "                   reed_sol_r6_coding_matrix()\n");
 66 |   fprintf(stderr, "                   jerasure_matrix_decode()\n");
 67 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 68 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 69 |   exit(1);
 70 | }
 71 | 
 72 | 
 73 | static void print_data_and_coding(int k, int m, int w, int size, 
 74 | 		char **data, char **coding) 
 75 | {
 76 |   int i, j, x;
 77 |   int n, sp;
 78 | 
 79 |   if(k > m) n = k;
 80 |   else n = m;
 81 |   sp = size * 2 + size/(w/8) + 8;
 82 | 
 83 |   printf("%-*sCoding\n", sp, "Data");
 84 |   for(i = 0; i < n; i++) {
 85 | 	  if(i < k) {
 86 | 		  printf("D%-2d:", i);
 87 | 		  for(j=0;j< size; j+=(w/8)) { 
 88 | 			  printf(" ");
 89 | 			  for(x=0;x < w/8;x++){
 90 | 				printf("%02x", (unsigned char)data[i][j+x]);
 91 | 			  }
 92 | 		  }
 93 | 		  printf("    ");
 94 | 	  }
 95 | 	  else printf("%*s", sp, "");
 96 | 	  if(i < m) {
 97 | 		  printf("C%-2d:", i);
 98 | 		  for(j=0;j< size; j+=(w/8)) { 
 99 | 			  printf(" ");
100 | 			  for(x=0;x < w/8;x++){
101 | 				printf("%02x", (unsigned char)coding[i][j+x]);
102 | 			  }
103 | 		  }
104 | 	  }
105 | 	  printf("\n");
106 |   }
107 | 	printf("\n");
108 | }
109 | 
110 | int main(int argc, char **argv)
111 | {
112 |   long l;
113 |   unsigned char uc;
114 |   int k, w, i, j, m;
115 |   int *matrix;
116 |   char **data, **coding, **dcopy, **ccopy;
117 |   int *erasures, *erased;
118 |   uint32_t seed;
119 |   
120 |   if (argc != 4) usage(NULL);
121 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
122 |   if (sscanf(argv[2], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
123 |   if (sscanf(argv[3], "%d", &seed) == 0) usage("Bad seed");
124 |   m = 2;
125 |   if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
126 | 
127 |   MOA_Seed(seed);
128 |   matrix = reed_sol_r6_coding_matrix(k, w);
129 | 
130 |   printf("reed_sol_03 %d %d %d\n", k, w, seed);
131 |   printf("
reed_sol_03 %d %d %d
\n", k, w, seed);
132 |   printf("
\n");
133 | 
134 |   printf("Last 2 rows of the Generator Matrix:\n\n");
135 |   jerasure_print_matrix(matrix, m, k, w);
136 |   printf("\n");
137 | 
138 |   data = talloc(char *, k);
139 |   dcopy = talloc(char *, k);
140 |   for (i = 0; i < k; i++) {
141 |     data[i] = talloc(char, sizeof(long));
142 |     dcopy[i] = talloc(char, sizeof(long));
143 |     for (j = 0; j < sizeof(long); j++) {
144 |       uc = MOA_Random_W(8, 1) %256;
145 |       data[i][j] = (char) uc;   
146 |     }
147 |     memcpy(dcopy[i], data[i], sizeof(long));
148 |   }
149 | 
150 |   coding = talloc(char *, m);
151 |   ccopy = talloc(char *, m);
152 |   for (i = 0; i < m; i++) {
153 |     coding[i] = talloc(char, sizeof(long));
154 |     ccopy[i] = talloc(char, sizeof(long));
155 |   }
156 | 
157 |   reed_sol_r6_encode(k, w, data, coding, sizeof(long));
158 |   for (i = 0; i < m; i++) {
159 |     memcpy(ccopy[i], coding[i], sizeof(long));
160 |   }
161 |   
162 |   printf("Encoding Complete:\n\n");
163 |   print_data_and_coding(k, m, w, sizeof(long), data, coding);
164 | 
165 |   erasures = talloc(int, (m+1));
166 |   erased = talloc(int, (k+m));
167 |   for (i = 0; i < m+k; i++) erased[i] = 0;
168 |   l = 0;
169 |   for (i = 0; i < m; ) {
170 |     erasures[i] = ((unsigned int) MOA_Random_W(w, 1))%(k+m);
171 |     if (erased[erasures[i]] == 0) {
172 |       erased[erasures[i]] = 1;
173 |       memcpy((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], &l, sizeof(long));
174 |       i++;
175 |     }
176 |   }
177 |   erasures[i] = -1;
178 | 
179 |   printf("Erased %d random devices:\n\n", m);
180 |   print_data_and_coding(k, m, w, sizeof(long), data, coding);
181 |   
182 |   i = jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, sizeof(long));
183 | 
184 |   printf("State of the system after decoding:\n\n");
185 |   print_data_and_coding(k, m, w, sizeof(long), data, coding);
186 |   
187 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)) != 0) {
188 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
189 |   }
190 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)) != 0) {
191 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
192 |   }
193 | 
194 |   return 0;
195 | }
196 | 


--------------------------------------------------------------------------------
/Examples/reed_sol_01.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | #include "reed_sol.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: reed_sol_01 k m w seed - Does a simple Reed-Solomon coding example in GF(2^w).\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "w must be 8, 16 or 32.  k+m must be <= 2^w.  It sets up a classic\n");
 62 |   fprintf(stderr, "Vandermonde-based generator matrix and encodes k devices of\n");
 63 |   fprintf(stderr, "%ld bytes each with it.  Then it decodes.\n", sizeof(long));
 64 |   fprintf(stderr, "       \n");
 65 |   fprintf(stderr, "This demonstrates: jerasure_matrix_encode()\n");
 66 |   fprintf(stderr, "                   jerasure_matrix_decode()\n");
 67 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 68 |   fprintf(stderr, "                   reed_sol_vandermonde_coding_matrix()\n");
 69 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 70 |   exit(1);
 71 | }
 72 | 
 73 | static void print_data_and_coding(int k, int m, int w, int size, 
 74 | 		char **data, char **coding) 
 75 | {
 76 |   int i, j, x;
 77 |   int n, sp;
 78 | 
 79 |   if(k > m) n = k;
 80 |   else n = m;
 81 |   sp = size * 2 + size/(w/8) + 8;
 82 | 
 83 |   printf("%-*sCoding\n", sp, "Data");
 84 |   for(i = 0; i < n; i++) {
 85 | 	  if(i < k) {
 86 | 		  printf("D%-2d:", i);
 87 | 		  for(j=0;j< size; j+=(w/8)) { 
 88 | 			  printf(" ");
 89 | 			  for(x=0;x < w/8;x++){
 90 | 				printf("%02x", (unsigned char)data[i][j+x]);
 91 | 			  }
 92 | 		  }
 93 | 		  printf("    ");
 94 | 	  }
 95 | 	  else printf("%*s", sp, "");
 96 | 	  if(i < m) {
 97 | 		  printf("C%-2d:", i);
 98 | 		  for(j=0;j< size; j+=(w/8)) { 
 99 | 			  printf(" ");
100 | 			  for(x=0;x < w/8;x++){
101 | 				printf("%02x", (unsigned char)coding[i][j+x]);
102 | 			  }
103 | 		  }
104 | 	  }
105 | 	  printf("\n");
106 |   }
107 | 	printf("\n");
108 | }
109 | 
110 | int main(int argc, char **argv)
111 | {
112 |   long l;
113 |   int k, w, i, j, m;
114 |   int *matrix;
115 |   char **data, **coding, **dcopy, **ccopy;
116 |   unsigned char uc;
117 |   int *erasures, *erased;
118 |   uint32_t seed;
119 |   
120 |   if (argc != 5) usage(NULL);
121 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
122 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
123 |   if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
124 |   if (sscanf(argv[4], "%u", &seed) == 0) usage("Bad seed");
125 |   if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
126 | 
127 |   matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
128 | 
129 |   printf("reed_sol_01 %d %d %d %d\n", k, m, w, seed);
130 |   printf("
reed_sol_01 %d %d %d %d
\n", k, m, w, seed);
131 |   printf("
\n");
132 |   printf("Last m rows of the generator Matrix (G^T):\n\n");
133 |   jerasure_print_matrix(matrix, m, k, w);
134 |   printf("\n");
135 | 
136 |   MOA_Seed(seed);
137 |   data = talloc(char *, k);
138 |   dcopy = talloc(char *, k);
139 |   for (i = 0; i < k; i++) {
140 |     data[i] = talloc(char, sizeof(long));
141 |     dcopy[i] = talloc(char, sizeof(long));
142 |     for (j = 0; j < sizeof(long); j++) {
143 |       uc = MOA_Random_W(8, 1);
144 |       data[i][j] = (char) uc;
145 |     }
146 |     memcpy(dcopy[i], data[i], sizeof(long));
147 |   }
148 | 
149 |   coding = talloc(char *, m);
150 |   ccopy = talloc(char *, m);
151 |   for (i = 0; i < m; i++) {
152 |     coding[i] = talloc(char, sizeof(long));
153 |     ccopy[i] = talloc(char, sizeof(long));
154 |   }
155 | 
156 |   jerasure_matrix_encode(k, m, w, matrix, data, coding, sizeof(long));
157 | 
158 |   for (i = 0; i < m; i++) {
159 |     memcpy(ccopy[i], coding[i], sizeof(long));
160 |   }
161 |   
162 |   printf("Encoding Complete:\n\n");
163 |   print_data_and_coding(k, m, w, sizeof(long), data, coding);
164 | 
165 |   erasures = talloc(int, (m+1));
166 |   erased = talloc(int, (k+m));
167 |   for (i = 0; i < m+k; i++) erased[i] = 0;
168 |   l = 0;
169 |   for (i = 0; i < m; ) {
170 |     erasures[i] = MOA_Random_W(31, 0)%(k+m);
171 |     if (erased[erasures[i]] == 0) {
172 |       erased[erasures[i]] = 1;
173 |       memcpy((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], &l, sizeof(long));
174 |       i++;
175 |     }
176 |   }
177 |   erasures[i] = -1;
178 | 
179 |   printf("Erased %d random devices:\n\n", m);
180 |   print_data_and_coding(k, m, w, sizeof(long), data, coding);
181 |   
182 |   i = jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, sizeof(long));
183 | 
184 |   printf("State of the system after decoding:\n\n");
185 |   print_data_and_coding(k, m, w, sizeof(long), data, coding);
186 |   
187 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)) != 0) {
188 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
189 |   }
190 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)) != 0) {
191 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
192 |   }
193 | 
194 |   return 0;
195 | }
196 | 


--------------------------------------------------------------------------------
/Examples/liberation_01.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | #include "liberation.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: liberation_01 k w seed - Liberation RAID-6 coding/decoding example in GF(2^w).\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "       w must be prime and k <= w.  It sets up a Liberation bit-matrix\n");
 62 |   fprintf(stderr, "       then it encodes k devices of w*%ld bytes using dumb bit-matrix scheduling.\n", sizeof(long));
 63 |   fprintf(stderr, "       It decodes using smart bit-matrix scheduling.\n");
 64 |   fprintf(stderr, "       \n");
 65 |   fprintf(stderr, "This demonstrates: liberation_coding_bitmatrix()\n");
 66 |   fprintf(stderr, "                   jerasure_smart_bitmatrix_to_schedule()\n");
 67 |   fprintf(stderr, "                   jerasure_dumb_bitmatrix_to_schedule()\n");
 68 |   fprintf(stderr, "                   jerasure_schedule_encode()\n");
 69 |   fprintf(stderr, "                   jerasure_schedule_decode_lazy()\n");
 70 |   fprintf(stderr, "                   jerasure_print_bitmatrix()\n");
 71 |   fprintf(stderr, "                   jerasure_get_stats()\n");
 72 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 73 |   exit(1);
 74 | }
 75 | 
 76 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 77 | {
 78 |   int i, j, x;
 79 |   unsigned char *up;
 80 | 
 81 |   printf("
\n");
 82 | 
 83 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 84 |   printf("\n");
 85 |   printf("\n");
 88 |   for (i = 0; i < ndevices; i++) {
 89 |     printf("\n");
 99 |   }
100 |   printf("
%s%x
");
 86 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
 87 |   printf("
");
 90 |     up = (unsigned char *) ptrs[i];
 91 |     for (j = 0; j < size/packetsize; j++) {
 92 |       for (x = 0; x < packetsize; x++) {
 93 |         if (x > 0 && x%4 == 0) printf(" ");
 94 |         printf("%02x", up[j*packetsize+x]);
 95 |       }
 96 |       printf("\n");
 97 |     }
 98 |     printf("
\n");
101 | }
102 | 
103 | int main(int argc, char **argv)
104 | {
105 |   int k, w, i, m;
106 |   int *bitmatrix;
107 |   char **data, **coding;
108 |   int **dumb;
109 |   int *erasures, *erased;
110 |   double stats[3];
111 |   uint32_t seed;
112 |   
113 |   if (argc != 4) usage("Wrong number of arguments");
114 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
115 |   if (sscanf(argv[2], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
116 |   if (sscanf(argv[3], "%u", &seed) == 0) usage("Bad seed");
117 |   m = 2;
118 |   if (w < k) usage("k is too big");
119 |   for (i = 2; i*i <= w; i++) if (w%i == 0) usage("w isn't prime");
120 | 
121 |   bitmatrix = liberation_coding_bitmatrix(k, w);
122 |   if (bitmatrix == NULL) {
123 |     usage("couldn't make coding matrix");
124 |   }
125 | 
126 |   printf("liberation_01");
127 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
128 |   printf("\n");
129 |   printf("
liberation_01");
130 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
131 |   printf("
\n");
132 |   printf("
\n");
133 | 
134 |   printf("Coding Bit-Matrix:\n
\n");
135 |   jerasure_print_bitmatrix(bitmatrix, w*m, w*k, w);
136 |   printf("
\n");
137 | 
138 |   dumb = jerasure_dumb_bitmatrix_to_schedule(k, m, w, bitmatrix);
139 | 
140 |   MOA_Seed(seed);
141 |   data = talloc(char *, k);
142 |   for (i = 0; i < k; i++) {
143 |     data[i] = talloc(char, sizeof(long)*w);
144 |     MOA_Fill_Random_Region(data[i], sizeof(long)*w);
145 |   }
146 | 
147 |   coding = talloc(char *, m);
148 |   for (i = 0; i < m; i++) {
149 |     coding[i] = talloc(char, sizeof(long)*w);
150 |   }
151 | 
152 |   jerasure_schedule_encode(k, m, w, dumb, data, coding, w*sizeof(long), sizeof(long));
153 |   jerasure_get_stats(stats);
154 |   printf("Smart Encoding Complete: - %.0lf XOR'd bytes.  State of the system:\n\n", stats[0]);
155 |   printf("
\n");
156 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
157 |   printf("
\n");
158 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
159 |   printf("
\n");
160 | 
161 |   erasures = talloc(int, (m+1));
162 |   erased = talloc(int, (k+m));
163 |   for (i = 0; i < m+k; i++) erased[i] = 0;
164 |   for (i = 0; i < m; ) {
165 |     erasures[i] = MOA_Random_W(30,1)%(k+m);
166 |     if (erased[erasures[i]] == 0) {
167 |       erased[erasures[i]] = 1;
168 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
169 |       i++;
170 |     }
171 |   }
172 |   erasures[i] = -1;
173 | 
174 |   printf("Erased %d random devices:\n\n", m);
175 |   printf("
\n");
176 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
177 |   printf("
\n");
178 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
179 |   printf("
\n");
180 |   
181 |   jerasure_schedule_decode_lazy(k, m, w, bitmatrix, erasures, data, coding, w*sizeof(long), sizeof(long), 1);
182 |   jerasure_get_stats(stats);
183 | 
184 |   printf("State of the system after decoding: %.0lf XOR'd bytes\n\n", stats[0]);
185 |   printf("
\n");
186 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
187 |   printf("
\n");
188 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
189 |   printf("
\n");
190 |   
191 |   return 0;
192 | }
193 | 


--------------------------------------------------------------------------------
/Examples/jerasure_05.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | 
 54 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 55 | 
 56 | static void usage(char *s)
 57 | {
 58 |   fprintf(stderr, "usage: jerasure_05 k m w size seed - Does a simple Reed-Solomon coding example in GF(2^w).\n");
 59 |   fprintf(stderr, "       \n");
 60 |   fprintf(stderr, "       k+m must be <= 2^w.  w can be 8, 16 or 32.\n");
 61 |   fprintf(stderr, "       It sets up a Cauchy generator matrix and encodes\n");
 62 |   fprintf(stderr, "       k devices of size bytes with it.  Then it decodes.\n");
 63 |   fprintf(stderr, "       After that, it decodes device 0 by using jerasure_make_decoding_matrix()\n");
 64 |   fprintf(stderr, "       and jerasure_matrix_dotprod().\n");
 65 |   fprintf(stderr, "       \n");
 66 |   fprintf(stderr, "This demonstrates: jerasure_matrix_encode()\n");
 67 |   fprintf(stderr, "                   jerasure_matrix_decode()\n");
 68 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 69 |   fprintf(stderr, "                   jerasure_make_decoding_matrix()\n");
 70 |   fprintf(stderr, "                   jerasure_matrix_dotprod()\n");
 71 |   if (s != NULL) fprintf(stderr, "\n%s\n\n", s);
 72 |   exit(1);
 73 | }
 74 | 
 75 | static void print_data_and_coding(int k, int m, int w, int size, 
 76 | 		char **data, char **coding) 
 77 | {
 78 |   int i, j, x;
 79 |   int n, sp;
 80 | 
 81 |   if(k > m) n = k;
 82 |   else n = m;
 83 |   sp = size * 2 + size/(w/8) + 8;
 84 | 
 85 |   printf("%-*sCoding\n", sp, "Data");
 86 |   for(i = 0; i < n; i++) {
 87 | 	  if(i < k) {
 88 | 		  printf("D%-2d:", i);
 89 | 		  for(j=0;j< size; j+=(w/8)) { 
 90 | 			  printf(" ");
 91 | 			  for(x=0;x < w/8;x++){
 92 | 				printf("%02x", (unsigned char)data[i][j+x]);
 93 | 			  }
 94 | 		  }
 95 | 		  printf("    ");
 96 | 	  }
 97 | 	  else printf("%*s", sp, "");
 98 | 	  if(i < m) {
 99 | 		  printf("C%-2d:", i);
100 | 		  for(j=0;j< size; j+=(w/8)) { 
101 | 			  printf(" ");
102 | 			  for(x=0;x < w/8;x++){
103 | 				printf("%02x", (unsigned char)coding[i][j+x]);
104 | 			  }
105 | 		  }
106 | 	  }
107 | 	  printf("\n");
108 |   }
109 | 	printf("\n");
110 | }
111 | 
112 | int main(int argc, char **argv)
113 | {
114 |   int k, m, w, size;
115 |   int i, j;
116 |   int *matrix;
117 |   char **data, **coding;
118 |   int *erasures, *erased;
119 |   int *decoding_matrix, *dm_ids;
120 |   uint32_t seed;
121 |   
122 |   if (argc != 6) usage(NULL);
123 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
124 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
125 |   if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
126 |   if (w < 32 && k + m > (1 << w)) usage("k + m must be <= 2 ^ w");
127 |   if (sscanf(argv[4], "%d", &size) == 0 || size % sizeof(long) != 0) 
128 | 		usage("size must be multiple of sizeof(long)");
129 |   if (sscanf(argv[5], "%d", &seed) == 0) usage("Bad seed");
130 | 
131 |   matrix = talloc(int, m*k);
132 |   for (i = 0; i < m; i++) {
133 |     for (j = 0; j < k; j++) {
134 |       matrix[i*k+j] = galois_single_divide(1, i ^ (m + j), w);
135 |     }
136 |   }
137 | 
138 |   printf("jerasure_05");
139 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
140 |   printf("\n");
141 |   printf("
jerasure_05");
142 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
143 |   printf("
\n");
144 |   printf("
\n");
145 | 
146 |   printf("The Coding Matrix (the last m rows of the Generator Matrix G^T):\n\n");
147 |   jerasure_print_matrix(matrix, m, k, w);
148 |   printf("\n");
149 | 
150 |   MOA_Seed(seed);
151 |   data = talloc(char *, k);
152 |   for (i = 0; i < k; i++) {
153 |     data[i] = talloc(char, size);
154 |     MOA_Fill_Random_Region(data[i], size);
155 |   }
156 | 
157 |   coding = talloc(char *, m);
158 |   for (i = 0; i < m; i++) {
159 |     coding[i] = talloc(char, size);
160 |   }
161 | 
162 |   jerasure_matrix_encode(k, m, w, matrix, data, coding, size);
163 |   
164 |   printf("Encoding Complete:\n\n");
165 |   print_data_and_coding(k, m, w, size, data, coding);
166 | 
167 |   erasures = talloc(int, (m+1));
168 |   erased = talloc(int, (k+m));
169 |   for (i = 0; i < m+k; i++) erased[i] = 0;
170 |   for (i = 0; i < m; ) {
171 |     erasures[i] = (MOA_Random_W(w, 1))%(k+m);
172 |     if (erased[erasures[i]] == 0) {
173 |       erased[erasures[i]] = 1;
174 | 	  
175 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], size);
176 |       i++;
177 |     }
178 |   }
179 |   erasures[i] = -1;
180 | 
181 |   printf("Erased %d random devices:\n\n", m);
182 |   print_data_and_coding(k, m, w, size, data, coding);
183 |   
184 |   i = jerasure_matrix_decode(k, m, w, matrix, 0, erasures, data, coding, size);
185 | 
186 |   printf("State of the system after decoding:\n\n");
187 |   print_data_and_coding(k, m, w, size, data, coding);
188 |   
189 |   decoding_matrix = talloc(int, k*k);
190 |   dm_ids = talloc(int, k);
191 | 
192 |   for (i = 0; i < m; i++) erased[i] = 1;
193 |   for (; i < k+m; i++) erased[i] = 0;
194 | 
195 |   jerasure_make_decoding_matrix(k, m, w, matrix, erased, decoding_matrix, dm_ids);
196 | 
197 |   printf("Suppose we erase the first %d devices.  Here is the decoding matrix:\n\n", m);
198 |   jerasure_print_matrix(decoding_matrix, k, k, w);
199 |   printf("\n");
200 |   printf("And dm_ids:\n\n");
201 |   jerasure_print_matrix(dm_ids, 1, k, w);
202 | 
203 |   bzero(data[0], size);
204 |   jerasure_matrix_dotprod(k, w, decoding_matrix, dm_ids, 0, data, coding, size);
205 | 
206 |   printf("\nAfter calling jerasure_matrix_dotprod, we calculate the value of device #0 to be:\n\n");
207 |   printf("D0 :");
208 |   for(i=0;i< size; i+=(w/8)) {
209 | 	  printf(" ");
210 | 	  for(j=0;j < w/8;j++){
211 | 		printf("%02x", (unsigned char)data[0][i+j]);
212 | 	  }
213 |   }
214 |   printf("\n\n");
215 | 
216 |   return 0;
217 | }
218 | 


--------------------------------------------------------------------------------
/Examples/reed_sol_time_gf.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include 
 53 | #include 
 54 | #include 
 55 | #include 
 56 | #include "jerasure.h"
 57 | #include "reed_sol.h"
 58 | #include "timing.h"
 59 | 
 60 | static void *malloc16(int size) {
 61 |     void *mem = malloc(size+16+sizeof(void*));
 62 |     void **ptr = (void**)((long)(mem+16+sizeof(void*)) & ~(15));
 63 |     ptr[-1] = mem;
 64 |     return ptr;
 65 | }
 66 | 
 67 | #if 0
 68 | // Unused for now.
 69 | static void free16(void *ptr) {
 70 |     free(((void**)ptr)[-1]);
 71 | }
 72 | #endif
 73 | 
 74 | #define talloc(type, num) (type *) malloc16(sizeof(type)*(num))
 75 | 
 76 | static void usage(char *s)
 77 | {
 78 |   fprintf(stderr, "usage: reed_sol_time_gf k m w seed iterations bufsize (additional GF args) - Test and time Reed-Solomon in a particular GF(2^w).\n");
 79 |   fprintf(stderr, "       \n");
 80 |   fprintf(stderr, "       w must be 8, 16 or 32.  k+m must be <= 2^w.\n");
 81 |   fprintf(stderr, "       See the README for information on the additional GF args.\n");
 82 |   fprintf(stderr, "       Set up a Vandermonde-based distribution matrix and encodes k devices of\n");
 83 |   fprintf(stderr, "       bufsize bytes each with it.  Then it decodes.\n");
 84 |   fprintf(stderr, "       \n");
 85 |   fprintf(stderr, "This tests:        jerasure_matrix_encode()\n");
 86 |   fprintf(stderr, "                   jerasure_matrix_decode()\n");
 87 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 88 |   fprintf(stderr, "                   galois_change_technique()\n");
 89 |   fprintf(stderr, "                   reed_sol_vandermonde_coding_matrix()\n");
 90 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 91 |   exit(1);
 92 | }
 93 | 
 94 | gf_t* get_gf(int w, int argc, char **argv, int starting)
 95 | {
 96 |   gf_t *gf = (gf_t*)malloc(sizeof(gf_t));
 97 |   if (create_gf_from_argv(gf, w, argc, argv, starting) == 0) {
 98 |     free(gf);
 99 |     gf = NULL;
100 |   }
101 |   return gf;
102 | }
103 | 
104 | int main(int argc, char **argv)
105 | {
106 |   int k, w, i, m, iterations, bufsize;
107 |   int *matrix;
108 |   char **data, **coding, **old_values;
109 |   int *erasures, *erased;
110 |   uint32_t seed;
111 |   struct timespec t1, t2;
112 |   double total_time = 0;
113 |   gf_t *gf = NULL;
114 |   
115 |   if (argc < 8) usage(NULL);  
116 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
117 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
118 |   if (sscanf(argv[3], "%d", &w) == 0 || (w != 8 && w != 16 && w != 32)) usage("Bad w");
119 |   if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
120 |   if (sscanf(argv[5], "%d", &iterations) == 0) usage("Bad iterations");
121 |   if (sscanf(argv[6], "%d", &bufsize) == 0) usage("Bad bufsize");
122 |   if (w <= 16 && k + m > (1 << w)) usage("k + m is too big");
123 | 
124 |   MOA_Seed(seed);
125 | 
126 |   gf = get_gf(w, argc, argv, 7); 
127 | 
128 |   if (gf == NULL) {
129 |     usage("Invalid arguments given for GF!\n");
130 |   }
131 | 
132 |   galois_change_technique(gf, w); 
133 | 
134 |   matrix = reed_sol_vandermonde_coding_matrix(k, m, w);
135 | 
136 |   printf("reed_sol_time_gf");
137 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
138 |   printf("\n");
139 |   printf("
reed_sol_time_gf");
140 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
141 |   printf("
\n");
142 |   printf("
\n");
143 | 
144 |   printf("Last m rows of the generator matrix (G^T):\n\n");
145 |   jerasure_print_matrix(matrix, m, k, w);
146 |   printf("\n");
147 | 
148 |   data = talloc(char *, k);
149 |   for (i = 0; i < k; i++) {
150 |     data[i] = talloc(char, bufsize);
151 |     MOA_Fill_Random_Region(data[i], bufsize);
152 |   }
153 | 
154 |   coding = talloc(char *, m);
155 |   old_values = talloc(char *, m);
156 |   for (i = 0; i < m; i++) {
157 |     coding[i] = talloc(char, bufsize);
158 |     old_values[i] = talloc(char, bufsize);
159 |   }
160 | 
161 |   for (i = 0; i < iterations; i++) {
162 |     clock_gettime(CLOCK_REALTIME, &t1);
163 |     jerasure_matrix_encode(k, m, w, matrix, data, coding, bufsize);
164 |     clock_gettime(CLOCK_REALTIME, &t2);
165 |     total_time += timing_delta(&t1, &t2);
166 |   }
167 | 
168 |   printf("Encode throughput for %d iterations: %.2f MB/s (%.2f sec)\n", iterations, (double)(k*iterations*bufsize/1024/1024) / total_time, total_time);
169 |   
170 |   erasures = talloc(int, (m+1));
171 |   erased = talloc(int, (k+m));
172 |   for (i = 0; i < m+k; i++) erased[i] = 0;
173 |   for (i = 0; i < m; ) {
174 |     erasures[i] = ((unsigned int)MOA_Random_W(w, 1))%(k+m);
175 |     if (erased[erasures[i]] == 0) {
176 |       erased[erasures[i]] = 1;
177 |       memcpy(old_values[i], (erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], bufsize);
178 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], bufsize);
179 |       i++;
180 |     }
181 |   }
182 |   erasures[i] = -1;
183 | 
184 |   for (i = 0; i < iterations; i++) {
185 |     clock_gettime(CLOCK_REALTIME, &t1);
186 |     jerasure_matrix_decode(k, m, w, matrix, 1, erasures, data, coding, bufsize);
187 |     clock_gettime(CLOCK_REALTIME, &t2);
188 |     total_time += timing_delta(&t1, &t2);
189 |   }
190 |   
191 |   printf("Decode throughput for %d iterations: %.2f MB/s (%.2f sec)\n", iterations, (double)(k*iterations*bufsize/1024/1024) / total_time, total_time);
192 | 
193 |   for (i = 0; i < m; i++) {
194 |     if (erasures[i] < k) {
195 |       if (memcmp(data[erasures[i]], old_values[i], bufsize)) {
196 |         fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
197 |         exit(1);
198 |       }
199 |     } else {
200 |       if (memcmp(coding[erasures[i]-k], old_values[i], bufsize)) {
201 |         fprintf(stderr, "Decoding failed for %d!\n", erasures[i]);
202 |         exit(1);
203 |       }
204 |     }
205 |   }
206 |   
207 |   return 0;
208 | }
209 | 


--------------------------------------------------------------------------------
/src/liberation.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | 
 51 | #include "galois.h"
 52 | #include "jerasure.h"
 53 | #include "liberation.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | int *liberation_coding_bitmatrix(int k, int w)
 58 | {
 59 |   int *matrix, i, j, index;
 60 | 
 61 |   if (k > w) return NULL;
 62 |   matrix = talloc(int, 2*k*w*w);
 63 |   if (matrix == NULL) return NULL;
 64 |   bzero(matrix, sizeof(int)*2*k*w*w);
 65 |   
 66 |   /* Set up identity matrices */
 67 | 
 68 |   for(i = 0; i < w; i++) {
 69 |     index = i*k*w+i;
 70 |     for (j = 0; j < k; j++) {
 71 |       matrix[index] = 1;
 72 |       index += w;
 73 |     }
 74 |   }
 75 | 
 76 |   /* Set up liberation matrices */
 77 | 
 78 |   for (j = 0; j < k; j++) {
 79 |     index = k*w*w+j*w;
 80 |     for (i = 0; i < w; i++) {
 81 |       matrix[index+(j+i)%w] = 1;
 82 |       index += (k*w);
 83 |     }
 84 |     if (j > 0) {
 85 |       i = (j*((w-1)/2))%w;
 86 |       matrix[k*w*w+j*w+i*k*w+(i+j-1)%w] = 1;
 87 |     }
 88 |   }
 89 |   return matrix;
 90 | }
 91 |   
 92 | 
 93 | int *liber8tion_coding_bitmatrix(int k)
 94 | {
 95 |   int *matrix, i, j, index;
 96 |   int w;
 97 | 
 98 |   w = 8;
 99 |   if (k > w) return NULL;
100 |   matrix = talloc(int, 2*k*w*w);
101 |   if (matrix == NULL) return NULL;
102 |   bzero(matrix, sizeof(int)*2*k*w*w);
103 |   
104 |   /* Set up identity matrices */
105 | 
106 |   for(i = 0; i < w; i++) {
107 |     index = i*k*w+i;
108 |     for (j = 0; j < k; j++) {
109 |       matrix[index] = 1;
110 |       index += w;
111 |     }
112 |   }
113 | 
114 |   /* Set up liber8tion matrices */
115 | 
116 |   index = k*w*w;
117 | 
118 |   if (k == 0) return matrix;
119 |   matrix[index+0*k*w+0*w+0] = 1;
120 |   matrix[index+1*k*w+0*w+1] = 1;
121 |   matrix[index+2*k*w+0*w+2] = 1;
122 |   matrix[index+3*k*w+0*w+3] = 1;
123 |   matrix[index+4*k*w+0*w+4] = 1;
124 |   matrix[index+5*k*w+0*w+5] = 1;
125 |   matrix[index+6*k*w+0*w+6] = 1;
126 |   matrix[index+7*k*w+0*w+7] = 1;
127 | 
128 |   if (k == 1) return matrix;
129 |   matrix[index+0*k*w+1*w+7] = 1;
130 |   matrix[index+1*k*w+1*w+3] = 1;
131 |   matrix[index+2*k*w+1*w+0] = 1;
132 |   matrix[index+3*k*w+1*w+2] = 1;
133 |   matrix[index+4*k*w+1*w+6] = 1;
134 |   matrix[index+5*k*w+1*w+1] = 1;
135 |   matrix[index+6*k*w+1*w+5] = 1;
136 |   matrix[index+7*k*w+1*w+4] = 1;
137 |   matrix[index+4*k*w+1*w+7] = 1;
138 | 
139 |   if (k == 2) return matrix;
140 |   matrix[index+0*k*w+2*w+6] = 1;
141 |   matrix[index+1*k*w+2*w+2] = 1;
142 |   matrix[index+2*k*w+2*w+4] = 1;
143 |   matrix[index+3*k*w+2*w+0] = 1;
144 |   matrix[index+4*k*w+2*w+7] = 1;
145 |   matrix[index+5*k*w+2*w+3] = 1;
146 |   matrix[index+6*k*w+2*w+1] = 1;
147 |   matrix[index+7*k*w+2*w+5] = 1;
148 |   matrix[index+1*k*w+2*w+3] = 1;
149 | 
150 |   if (k == 3) return matrix;
151 |   matrix[index+0*k*w+3*w+2] = 1;
152 |   matrix[index+1*k*w+3*w+5] = 1;
153 |   matrix[index+2*k*w+3*w+7] = 1;
154 |   matrix[index+3*k*w+3*w+6] = 1;
155 |   matrix[index+4*k*w+3*w+0] = 1;
156 |   matrix[index+5*k*w+3*w+3] = 1;
157 |   matrix[index+6*k*w+3*w+4] = 1;
158 |   matrix[index+7*k*w+3*w+1] = 1;
159 |   matrix[index+5*k*w+3*w+4] = 1;
160 | 
161 |   if (k == 4) return matrix;
162 |   matrix[index+0*k*w+4*w+5] = 1;
163 |   matrix[index+1*k*w+4*w+6] = 1;
164 |   matrix[index+2*k*w+4*w+1] = 1;
165 |   matrix[index+3*k*w+4*w+7] = 1;
166 |   matrix[index+4*k*w+4*w+2] = 1;
167 |   matrix[index+5*k*w+4*w+4] = 1;
168 |   matrix[index+6*k*w+4*w+3] = 1;
169 |   matrix[index+7*k*w+4*w+0] = 1;
170 |   matrix[index+2*k*w+4*w+0] = 1;
171 | 
172 |   if (k == 5) return matrix;
173 |   matrix[index+0*k*w+5*w+1] = 1;
174 |   matrix[index+1*k*w+5*w+2] = 1;
175 |   matrix[index+2*k*w+5*w+3] = 1;
176 |   matrix[index+3*k*w+5*w+4] = 1;
177 |   matrix[index+4*k*w+5*w+5] = 1;
178 |   matrix[index+5*k*w+5*w+6] = 1;
179 |   matrix[index+6*k*w+5*w+7] = 1;
180 |   matrix[index+7*k*w+5*w+0] = 1;
181 |   matrix[index+7*k*w+5*w+2] = 1;
182 | 
183 |   if (k == 6) return matrix;
184 |   matrix[index+0*k*w+6*w+3] = 1;
185 |   matrix[index+1*k*w+6*w+0] = 1;
186 |   matrix[index+2*k*w+6*w+6] = 1;
187 |   matrix[index+3*k*w+6*w+5] = 1;
188 |   matrix[index+4*k*w+6*w+1] = 1;
189 |   matrix[index+5*k*w+6*w+7] = 1;
190 |   matrix[index+6*k*w+6*w+4] = 1;
191 |   matrix[index+7*k*w+6*w+2] = 1;
192 |   matrix[index+6*k*w+6*w+5] = 1;
193 | 
194 |   if (k == 7) return matrix;
195 |   matrix[index+0*k*w+7*w+4] = 1;
196 |   matrix[index+1*k*w+7*w+7] = 1;
197 |   matrix[index+2*k*w+7*w+1] = 1;
198 |   matrix[index+3*k*w+7*w+5] = 1;
199 |   matrix[index+4*k*w+7*w+3] = 1;
200 |   matrix[index+5*k*w+7*w+2] = 1;
201 |   matrix[index+6*k*w+7*w+0] = 1;
202 |   matrix[index+7*k*w+7*w+6] = 1;
203 |   matrix[index+3*k*w+7*w+1] = 1;
204 | 
205 |   return matrix;
206 | }
207 |   
208 | int *blaum_roth_coding_bitmatrix(int k, int w)
209 | {
210 |   int *matrix, i, j, index, l, m, p;
211 | 
212 |   if (k > w) return NULL ;
213 | 
214 |   matrix = talloc(int, 2*k*w*w);
215 |   if (matrix == NULL) return NULL;
216 |   bzero(matrix, sizeof(int)*2*k*w*w);
217 |   
218 |   /* Set up identity matrices */
219 | 
220 |   for(i = 0; i < w; i++) {
221 |     index = i*k*w+i;
222 |     for (j = 0; j < k; j++) {
223 |       matrix[index] = 1;
224 |       index += w;
225 |     }
226 |   }
227 | 
228 |   /* Set up blaum_roth matrices -- Ignore identity */
229 | 
230 |   p = w+1;
231 |   for (j = 0; j < k; j++) {
232 |     index = k*w*w+j*w;
233 |     if (j == 0) {
234 |       for (l = 0; l < w; l++) {
235 |         matrix[index+l] = 1;
236 |         index += k*w;
237 |       }
238 |     } else {
239 |       i = j;
240 |       for (l = 1; l <= w; l++) {
241 |         if (l != p-i) {
242 |           m = l+i;
243 |           if (m >= p) m -= p;
244 |           m--;
245 |           matrix[index+m] = 1;
246 |         } else {
247 |           matrix[index+i-1] = 1;
248 |           if (i%2 == 0) {
249 |             m = i/2;
250 |           } else {
251 |             m = (p/2) + 1 + (i/2);
252 |           }
253 |           m--;
254 |           matrix[index+m] = 1;
255 |         }
256 |         index += k*w;
257 |       }
258 |     }
259 |   }
260 | 
261 |   return matrix;
262 | }
263 | 


--------------------------------------------------------------------------------
/Examples/jerasure_07.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | 
 54 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 55 | 
 56 | static void usage(char *s)
 57 | {
 58 |   fprintf(stderr, "usage: jerasure_07 k m w seed - Scheduled Cauchy Reed-Solomon coding example in GF(2^w).\n");
 59 |   fprintf(stderr, "       \n");
 60 |   fprintf(stderr, "       k+m must be <= 2^w.  It sets up a Cauchy generator matrix and encodes\n");
 61 |   fprintf(stderr, "       k sets of w*%ld bytes. It uses bit-matrix scheduling, both smart and dumb.\n", sizeof(long));
 62 |   fprintf(stderr, "       It decodes using bit-matrix scheduling, then shows an example of\n");
 63 |   fprintf(stderr, "       using jerasure_do_scheduled_operations().\n");
 64 |   fprintf(stderr, "       \n");
 65 |   fprintf(stderr, "This demonstrates: jerasure_dumb_bitmatrix_to_schedule()\n");
 66 |   fprintf(stderr, "                   jerasure_smart_bitmatrix_to_schedule()\n");
 67 |   fprintf(stderr, "                   jerasure_schedule_encode()\n");
 68 |   fprintf(stderr, "                   jerasure_schedule_decode_lazy()\n");
 69 |   fprintf(stderr, "                   jerasure_do_scheduled_operations()\n");
 70 |   fprintf(stderr, "                   jerasure_get_stats()\n");
 71 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 72 |   exit(1);
 73 | }
 74 | 
 75 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 76 | {
 77 |   int i, j, x;
 78 |   unsigned char *up;
 79 | 
 80 |   printf("
\n");
 81 | 
 82 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 83 |   printf("\n");
 84 |   printf("\n");
 87 |   for (i = 0; i < ndevices; i++) {
 88 |     printf("\n");
 98 |   }
 99 |   printf("
%s%x
");
 85 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
 86 |   printf("
");
 89 |     up = (unsigned char *) ptrs[i];
 90 |     for (j = 0; j < size/packetsize; j++) {
 91 |       for (x = 0; x < packetsize; x++) {
 92 |         if (x > 0 && x%4 == 0) printf(" ");
 93 |         printf("%02x", up[j*packetsize+x]);
 94 |       }
 95 |       printf("\n");
 96 |     }
 97 |     printf("
\n");
100 | }
101 | 
102 | int main(int argc, char **argv)
103 | {
104 |   int k, w, i, j, m;
105 |   int *matrix, *bitmatrix;
106 |   char **data, **coding, **ptrs;
107 |   int **smart, **dumb;
108 |   int *erasures, *erased;
109 |   double stats[3];
110 |   uint32_t seed;
111 |   
112 |   if (argc != 5) usage("Wrong number of arguments");
113 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
114 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
115 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
116 |   if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
117 |   if (w < 30 && (k+m) > (1 << w)) usage("k + m is too big");
118 | 
119 |   matrix = talloc(int, m*k);
120 |   for (i = 0; i < m; i++) {
121 |     for (j = 0; j < k; j++) {
122 |       matrix[i*k+j] = galois_single_divide(1, i ^ (m + j), w);
123 |     }
124 |   }
125 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
126 | 
127 |   printf("jerasure_07");
128 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
129 |   printf("\n");
130 |   printf("
jerasure_07");
131 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
132 |   printf("
\n");
133 |   printf("
\n");
134 | 
135 |   printf("Last m*w rows of the generator matrix (G^T):\n
\n");
136 |   jerasure_print_bitmatrix(bitmatrix, w*m, w*k, w);
137 |   printf("
\n");
138 |   
139 |   dumb = jerasure_dumb_bitmatrix_to_schedule(k, m, w, bitmatrix);
140 |   smart = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
141 | 
142 |   MOA_Seed(seed);
143 |   data = talloc(char *, k);
144 |   for (i = 0; i < k; i++) {
145 |     data[i] = talloc(char, sizeof(long)*w);
146 |     MOA_Fill_Random_Region(data[i], sizeof(long)*w);
147 |   }
148 | 
149 |   coding = talloc(char *, m);
150 |   for (i = 0; i < m; i++) {
151 |     coding[i] = talloc(char, sizeof(long)*w);
152 |   }
153 | 
154 |   jerasure_schedule_encode(k, m, w, dumb, data, coding, w*sizeof(long), sizeof(long));
155 |   jerasure_get_stats(stats);
156 |   printf("Dumb Encoding Complete: - %.0lf XOR'd bytes.  State of the system:\n\n", stats[0]);
157 |   printf("
\n");
158 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
159 |   printf("
\n");
160 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
161 |   printf("
\n");
162 | 
163 |   jerasure_schedule_encode(k, m, w, smart, data, coding, w*sizeof(long), sizeof(long));
164 |   jerasure_get_stats(stats);
165 |   printf("Smart Encoding Complete: - %.0lf XOR'd bytes\n\n", stats[0]);
166 |   printf("
\n");
167 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
168 |   printf("
\n");
169 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
170 |   printf("
\n");
171 | 
172 |   erasures = talloc(int, (m+1));
173 |   erased = talloc(int, (k+m));
174 |   for (i = 0; i < m+k; i++) erased[i] = 0;
175 |   for (i = 0; i < m; ) {
176 |     erasures[i] = MOA_Random_W(w, 1)%(k+m);
177 |     if (erased[erasures[i]] == 0) {
178 |       erased[erasures[i]] = 1;
179 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
180 |       i++;
181 |     }
182 |   }
183 |   erasures[i] = -1;
184 | 
185 |   printf("Erased %d random devices:\n\n", m);
186 |   printf("
\n");
187 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
188 |   printf("
\n");
189 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
190 |   printf("
\n");
191 | 
192 |   jerasure_schedule_decode_lazy(k, m, w, bitmatrix, erasures, data, coding, w*sizeof(long), sizeof(long), 1);
193 |   jerasure_get_stats(stats);
194 | 
195 |   printf("State of the system after decoding: %.0lf XOR'd bytes\n\n", stats[0]);
196 |   printf("
\n");
197 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
198 |   printf("
\n");
199 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
200 |   printf("
\n");
201 |   
202 |   ptrs = talloc(char *, (k+m));
203 |   for (i = 0; i < k; i++) ptrs[i] = data[i];
204 |   for (i = 0; i < m; i++) ptrs[k+i] = coding[i];
205 | 
206 |   for (j = 0; j < m; j++) bzero(coding[j], sizeof(long)*w);
207 |   printf("State of the system after erasing the coding devices:\n");
208 |   printf("
\n");
209 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
210 |   printf("
\n");
211 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
212 |   printf("
\n");
213 | 
214 |   jerasure_do_scheduled_operations(ptrs, smart, sizeof(long));
215 |   printf("And using jerasure_do_scheduled_operations(): %.0lf XOR'd bytes\n\n", stats[0]);
216 |   printf("
\n");
217 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
218 |   printf("
\n");
219 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
220 |   printf("
\n");
221 | 
222 |   return 0;
223 | }
224 | 


--------------------------------------------------------------------------------
/Examples/jerasure_06.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | 
 54 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 55 | 
 56 | static void usage(char *s)
 57 | {
 58 |   fprintf(stderr, "usage: jerasure_06 k m w packetsize seed\n");
 59 |   fprintf(stderr, "Does a simple Cauchy Reed-Solomon coding example in GF(2^w).\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "       k+m must be < 2^w.  Packetsize must be a multiple of sizeof(long)\n");
 62 |   fprintf(stderr, "       It sets up a Cauchy generator matrix and encodes k devices of w*packetsize bytes.\n");
 63 |   fprintf(stderr, "       After that, it decodes device 0 by using jerasure_make_decoding_bitmatrix()\n");
 64 |   fprintf(stderr, "       and jerasure_bitmatrix_dotprod().\n");
 65 |   fprintf(stderr, "       \n");
 66 |   fprintf(stderr, "This demonstrates: jerasure_bitmatrix_encode()\n");
 67 |   fprintf(stderr, "                   jerasure_bitmatrix_decode()\n");
 68 |   fprintf(stderr, "                   jerasure_print_bitmatrix()\n");
 69 |   fprintf(stderr, "                   jerasure_make_decoding_bitmatrix()\n");
 70 |   fprintf(stderr, "                   jerasure_bitmatrix_dotprod()\n");
 71 |   if (s != NULL) fprintf(stderr, "\n%s\n\n", s);
 72 |   exit(1);
 73 | }
 74 | 
 75 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 76 | {
 77 |   int i, j, x;
 78 |   unsigned char *up;
 79 | 
 80 |   printf("
\n");
 81 | 
 82 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 83 |   printf("\n");
 84 |   printf("\n");
 87 |   for (i = 0; i < ndevices; i++) {
 88 |     printf("\n");
 98 |   }
 99 |   printf("
%s%x
");
 85 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
 86 |   printf("
");
 89 |     up = (unsigned char *) ptrs[i];
 90 |     for (j = 0; j < size/packetsize; j++) {
 91 |       for (x = 0; x < packetsize; x++) {
 92 |         if (x > 0 && x%4 == 0) printf(" ");
 93 |         printf("%02x", up[j*packetsize+x]);
 94 |       }
 95 |       printf("\n");
 96 |     }
 97 |     printf("
\n");
100 | }
101 | 
102 | int main(int argc, char **argv)
103 | {
104 |   int k, w, i, j, m, psize, x;
105 |   int *matrix, *bitmatrix;
106 |   char **data, **coding;
107 |   int *erasures, *erased;
108 |   int *decoding_matrix, *dm_ids;
109 |   uint32_t seed;
110 |   
111 |   if (argc != 6) usage(NULL);
112 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
113 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
114 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
115 |   if (w < 30 && (k+m) > (1 << w)) usage("k + m is too big");
116 |   if (sscanf(argv[4], "%d", &psize) == 0 || psize <= 0) usage("Bad packetsize");
117 |   if(psize%sizeof(long) != 0) usage("Packetsize must be multiple of sizeof(long)");
118 |   if (sscanf(argv[5], "%d", &seed) == 0) usage("Bad seed");
119 | 
120 |   MOA_Seed(seed);
121 |   matrix = talloc(int, m*k);
122 |   for (i = 0; i < m; i++) {
123 |     for (j = 0; j < k; j++) {
124 |       matrix[i*k+j] = galois_single_divide(1, i ^ (m + j), w);
125 |     }
126 |   }
127 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
128 | 
129 |   printf("jerasure_06");
130 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
131 |   printf("\n");
132 |   printf("
jerasure_06");
133 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
134 |   printf("
\n");
135 | 
136 |   printf("
\n");
137 |   printf("Last (m * w) rows of the Generator Matrix: (G^T):\n
\n");
138 |   jerasure_print_bitmatrix(bitmatrix, w*m, w*k, w);
139 |   printf("
\n");
140 | 
141 |   data = talloc(char *, k);
142 |   for (i = 0; i < k; i++) {
143 |     data[i] = talloc(char, psize*w);
144 |     MOA_Fill_Random_Region(data[i], psize*w);
145 |   }
146 | 
147 |   coding = talloc(char *, m);
148 |   for (i = 0; i < m; i++) {
149 |     coding[i] = talloc(char, psize*w);
150 |   }
151 | 
152 |   jerasure_bitmatrix_encode(k, m, w, bitmatrix, data, coding, w*psize, psize);
153 |   
154 |   printf("Encoding Complete - Here is the state of the system\n\n");
155 |   printf("
\n");
156 |   print_array(data, k, psize*w, psize, "D");
157 |   printf("
\n");
158 |   print_array(coding, m, psize*w, psize, "C");
159 |   printf("
\n");
160 | 
161 |   erasures = talloc(int, (m+1));
162 |   erased = talloc(int, (k+m));
163 |   for (i = 0; i < m+k; i++) erased[i] = 0;
164 |   for (i = 0; i < m; ) {
165 |     erasures[i] = MOA_Random_W(w, 1)%(k+m);
166 |     if (erased[erasures[i]] == 0) {
167 |       erased[erasures[i]] = 1;
168 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], psize*w);
169 |       i++;
170 |     }
171 |   }
172 |   erasures[i] = -1;
173 | 
174 |   printf("Erased %d random devices:", m);
175 |   for (i = 0; erasures[i] != -1; i++) {
176 |     printf(" %c%x", ((erasures[i] < k) ? 'D' : 'C'), (erasures[i] < k ? erasures[i] : erasures[i]-k));
177 |   }
178 |   printf(". Here is the state of the system:\n");
179 | 
180 |   printf("
\n");
181 |   print_array(data, k, psize*w, psize, "D");
182 |   printf("
\n");
183 |   print_array(coding, m, psize*w, psize, "C");
184 |   printf("
\n");
185 | 
186 |   i = jerasure_bitmatrix_decode(k, m, w, bitmatrix, 0, erasures, data, coding, 
187 | 		  w*psize, psize);
188 | 
189 |   printf("Here is the state of the system after decoding:\n\n");
190 |   printf("
\n");
191 |   print_array(data, k, psize*w, psize, "D");
192 |   printf("
\n");
193 |   print_array(coding, m, psize*w, psize, "C");
194 |   printf("
\n");
195 | 
196 |   decoding_matrix = talloc(int, k*k*w*w);
197 |   dm_ids = talloc(int, k);
198 | 
199 |   x = (m < k) ? m : k;
200 | 
201 |   for (i = 0; i < x; i++) erased[i] = 1;
202 |   for (; i < k+m; i++) erased[i] = 0;
203 | 
204 |   jerasure_make_decoding_bitmatrix(k, m, w, bitmatrix, erased, decoding_matrix, dm_ids);
205 | 
206 |   printf("Suppose we erase the first %d devices.  Here is the decoding matrix:\n
\n", x);
207 |   jerasure_print_bitmatrix(decoding_matrix, k*w, k*w, w);
208 |   printf("
\n");
209 |   printf("And dm_ids:\n
\n");
210 |   jerasure_print_matrix(dm_ids, 1, k, w);
211 |   printf("
\n");
212 | 
213 |   for (i = 0; i < x; i++) bzero(data[i], w*psize);
214 | 
215 |   printf("Here is the state of the system after the erasures:\n\n");
216 |   printf("
\n");
217 |   print_array(data, k, psize*w, psize, "D");
218 |   printf("
\n");
219 |   print_array(coding, m, psize*w, psize, "C");
220 |   printf("
\n");
221 | 
222 |   for (i = 0; i < x; i++) {
223 |     jerasure_bitmatrix_dotprod(k, w, decoding_matrix+i*(k*w*w), dm_ids, i, data, coding, w*psize, psize);
224 |   }
225 | 
226 |   printf("Here is the state of the system after calling jerasure_bitmatrix_dotprod() %d time%s with the decoding matrix:\n\n", x, (x == 1) ? "" : "s");
227 |   printf("
\n");
228 |   print_array(data, k, psize*w, psize, "D");
229 |   printf("
\n");
230 |   print_array(coding, m, psize*w, psize, "C");
231 |   printf("
\n");
232 |   return 0;
233 | }
234 | 


--------------------------------------------------------------------------------
/Examples/jerasure_08.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | 
 54 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 55 | 
 56 | static void usage(char *s)
 57 | {
 58 |   fprintf(stderr, "usage: jerasure_08 k w seed - Example schedule cache usage with RAID-6\n");
 59 |   fprintf(stderr, "       \n");
 60 |   fprintf(stderr, "       m=2.  k+m must be <= 2^w.  It sets up a RAID-6 generator matrix and encodes\n");
 61 |   fprintf(stderr, "       k sets of w*%ld bytes. It creates a schedule cache for decoding.\n", sizeof(long));
 62 |   fprintf(stderr, "       It demonstrates using the schedule cache for both encoding and decoding.\n");
 63 |   fprintf(stderr, "       Then it demonstrates using jerasure_do_parity() to re-encode the first.\n");
 64 |   fprintf(stderr, "       coding device\n");
 65 |   fprintf(stderr, "       \n");
 66 |   fprintf(stderr, "This demonstrates: jerasure_generate_schedule_cache()\n");
 67 |   fprintf(stderr, "                   jerasure_smart_bitmatrix_to_schedule()\n");
 68 |   fprintf(stderr, "                   jerasure_schedule_encode()\n");
 69 |   fprintf(stderr, "                   jerasure_schedule_decode_cache()\n");
 70 |   fprintf(stderr, "                   jerasure_free_schedule()\n");
 71 |   fprintf(stderr, "                   jerasure_free_schedule_cache()\n");
 72 |   fprintf(stderr, "                   jerasure_get_stats()\n");
 73 |   fprintf(stderr, "                   jerasure_do_parity()\n");
 74 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 75 |   exit(1);
 76 | }
 77 | 
 78 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 79 | {
 80 |   int i, j, x;
 81 |   unsigned char *up;
 82 | 
 83 |   printf("
\n");
 84 | 
 85 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 86 |   printf("\n");
 87 |   printf("\n");
 90 |   for (i = 0; i < ndevices; i++) {
 91 |     printf("\n");
101 |   }
102 |   printf("
%s%x
");
 88 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
 89 |   printf("
");
 92 |     up = (unsigned char *) ptrs[i];
 93 |     for (j = 0; j < size/packetsize; j++) {
 94 |       for (x = 0; x < packetsize; x++) {
 95 |         if (x > 0 && x%4 == 0) printf(" ");
 96 |         printf("%02x", up[j*packetsize+x]);
 97 |       }
 98 |       printf("\n");
 99 |     }
100 |     printf("
\n");
103 | }
104 | 
105 | int main(int argc, char **argv)
106 | {
107 |   int k, w, i, j, m;
108 |   int *matrix, *bitmatrix;
109 |   char **data, **coding;
110 |   int **smart, ***cache;
111 |   int *erasures, *erased;
112 |   double stats[3];
113 |   uint32_t seed;
114 |   
115 |   if (argc != 4) usage("Wrong number of arguments");
116 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
117 |   if (sscanf(argv[2], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad m");
118 |   if (sscanf(argv[3], "%d", &seed) == 0) usage("Bad seed");
119 |   m = 2;
120 |   if (w < 30 && (k+m) > (1 << w)) usage("k + m is too big");
121 | 
122 |   MOA_Seed(seed);
123 | 
124 |   matrix = talloc(int, m*k);
125 |   for (j = 0; j < k; j++) matrix[j] = 1;
126 |   i = 1;
127 |   for (j = 0; j < k; j++) {
128 |     matrix[k+j] = i;
129 |     i = galois_single_multiply(i, 2, w);
130 |   }
131 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
132 | 
133 |   smart = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
134 |   cache = jerasure_generate_schedule_cache(k, m, w, bitmatrix, 1);
135 | 
136 |   data = talloc(char *, k);
137 |   for (i = 0; i < k; i++) {
138 |     data[i] = talloc(char, sizeof(long)*w);
139 |     MOA_Fill_Random_Region(data[i], sizeof(long)*w);
140 |   }
141 | 
142 |   coding = talloc(char *, m);
143 |   for (i = 0; i < m; i++) {
144 |     coding[i] = talloc(char, sizeof(long)*w);
145 |   }
146 | 
147 |   jerasure_schedule_encode(k, m, w, smart, data, coding, w*sizeof(long), sizeof(long));
148 |   jerasure_get_stats(stats);
149 | 
150 |   printf("jerasure_08");
151 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
152 |   printf("\n");
153 |   printf("
jerasure_08");
154 |   for (i = 1; i < argc; i++) printf(" %s", argv[i]);
155 |   printf("
\n");
156 |   printf("
\n");
157 | 
158 |   printf("Encoding Complete: - %.0lf XOR'd bytes.  Here is the state of the system:\n
\n", stats[0]);
159 |   printf("
\n");
160 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
161 |   printf("
\n");
162 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
163 |   printf("
\n");
164 | 
165 |   erasures = talloc(int, (m+1));
166 |   erasures[0] = k;
167 |   erasures[1] = k+1;
168 |   erasures[2] = -1;
169 |   for (j = 0; j < m; j++) bzero(coding[j], sizeof(long)*w);
170 | 
171 |   jerasure_schedule_decode_cache(k, m, w, cache, erasures, data, coding, w*sizeof(long), sizeof(long));
172 |   jerasure_get_stats(stats);
173 |   printf("Encoding Using the Schedule Cache: - %.0lf XOR'd bytes\n\n", stats[0]);
174 |   printf("
\n");
175 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
176 |   printf("
\n");
177 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
178 |   printf("
\n");
179 | 
180 |   erased = talloc(int, (k+m));
181 |   for (i = 0; i < m+k; i++) erased[i] = 0;
182 |   for (i = 0; i < m; ) {
183 |     erasures[i] = MOA_Random_W(w, 1)%(k+m);
184 |     if (erased[erasures[i]] == 0) {
185 |       erased[erasures[i]] = 1;
186 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
187 |       i++;
188 |     }
189 |   }
190 |   erasures[i] = -1;
191 | 
192 |   printf("Erased %d random devices:\n\n", m);
193 |   printf("
\n");
194 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
195 |   printf("
\n");
196 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
197 |   printf("
\n");
198 |   
199 |   jerasure_schedule_decode_cache(k, m, w, cache, erasures, data, coding, w*sizeof(long), sizeof(long));
200 |   jerasure_get_stats(stats);
201 | 
202 |   printf("State of the system after decoding: %.0lf XOR'd bytes\n\n", stats[0]);
203 |   printf("
\n");
204 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
205 |   printf("
\n");
206 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
207 |   printf("
\n");
208 |   
209 |   bzero(coding[0], sizeof(long)*w);
210 |   printf("Erased the first coding device:\n\n");
211 |   printf("
\n");
212 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
213 |   printf("
\n");
214 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
215 |   printf("
\n");
216 |   
217 |   jerasure_do_parity(k, data, coding[0], sizeof(long)*w);
218 |   printf("State of the system after using\n");
219 |   printf("jerasure_do_parity() to re-encode it:\n\n");
220 |   printf("
\n");
221 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
222 |   printf("
\n");
223 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
224 |   printf("
\n");
225 |   
226 |   jerasure_free_schedule(smart);
227 |   jerasure_free_schedule_cache(k, m, cache);
228 |   
229 |   printf("Smart schedule and cache freed.\n\n");
230 | 
231 |   return 0;
232 | }
233 | 


--------------------------------------------------------------------------------
/m4/ax_ext.m4:
--------------------------------------------------------------------------------
  1 | #
  2 | # Modified from autoconf-archive to replace AC_REQUIRE([AX_GCC_X86_*]) with
  3 | # AX_REQUIRE_DEFINED(...).
  4 | #
  5 | # ===========================================================================
  6 | #          http://www.gnu.org/software/autoconf-archive/ax_ext.html
  7 | # ===========================================================================
  8 | #
  9 | # SYNOPSIS
 10 | #
 11 | #   AX_EXT
 12 | #
 13 | # DESCRIPTION
 14 | #
 15 | #   Find supported SIMD extensions by requesting cpuid. When an SIMD
 16 | #   extension is found, the -m"simdextensionname" is added to SIMD_FLAGS if
 17 | #   compiler supports it. For example, if "sse2" is available, then "-msse2"
 18 | #   is added to SIMD_FLAGS.
 19 | #
 20 | #   This macro calls:
 21 | #
 22 | #     AC_SUBST(SIMD_FLAGS)
 23 | #
 24 | #   And defines:
 25 | #
 26 | #     HAVE_MMX / HAVE_SSE / HAVE_SSE2 / HAVE_SSE3 / HAVE_SSSE3 / HAVE_SSE4.1 / HAVE_SSE4.2 / HAVE_AVX
 27 | #
 28 | # LICENSE
 29 | #
 30 | #   Copyright (c) 2007 Christophe Tournayre 
 31 | #   Copyright (c) 2013 Michael Petch 
 32 | #
 33 | #   Copying and distribution of this file, with or without modification, are
 34 | #   permitted in any medium without royalty provided the copyright notice
 35 | #   and this notice are preserved. This file is offered as-is, without any
 36 | #   warranty.
 37 | 
 38 | #serial 13.1
 39 | 
 40 | AC_DEFUN([AX_EXT],
 41 | [
 42 |   AC_REQUIRE([AC_CANONICAL_HOST])
 43 | 
 44 |   case $host_cpu in
 45 |     powerpc*)
 46 |       AC_CACHE_CHECK([whether altivec is supported], [ax_cv_have_altivec_ext],
 47 |           [
 48 |             if test `/usr/sbin/sysctl -a 2>/dev/null| grep -c hw.optional.altivec` != 0; then
 49 |                 if test `/usr/sbin/sysctl -n hw.optional.altivec` = 1; then
 50 |                   ax_cv_have_altivec_ext=yes
 51 |                 fi
 52 |             fi
 53 |           ])
 54 | 
 55 |           if test "$ax_cv_have_altivec_ext" = yes; then
 56 |             AC_DEFINE(HAVE_ALTIVEC,,[Support Altivec instructions])
 57 |             AX_CHECK_COMPILE_FLAG(-faltivec, SIMD_FLAGS="$SIMD_FLAGS -faltivec", [])
 58 |           fi
 59 |     ;;
 60 | 
 61 | 
 62 |     i[[3456]]86*|x86_64*|amd64*)
 63 | 
 64 |       AX_REQUIRE_DEFINED([AX_GCC_X86_CPUID])
 65 |       AX_REQUIRE_DEFINED([AX_GCC_X86_AVX_XGETBV])
 66 | 
 67 |       AX_GCC_X86_CPUID(0x00000001)
 68 |       ecx=0
 69 |       edx=0
 70 |       if test "$ax_cv_gcc_x86_cpuid_0x00000001" != "unknown";
 71 |       then
 72 |         ecx=`echo $ax_cv_gcc_x86_cpuid_0x00000001 | cut -d ":" -f 3`
 73 |         edx=`echo $ax_cv_gcc_x86_cpuid_0x00000001 | cut -d ":" -f 4`
 74 |       fi
 75 | 
 76 |       AC_CACHE_CHECK([whether mmx is supported], [ax_cv_have_mmx_ext],
 77 |       [
 78 |         ax_cv_have_mmx_ext=no
 79 |         if test "$((0x$edx>>23&0x01))" = 1; then
 80 |           ax_cv_have_mmx_ext=yes
 81 |         fi
 82 |       ])
 83 | 
 84 |       AC_CACHE_CHECK([whether sse is supported], [ax_cv_have_sse_ext],
 85 |       [
 86 |         ax_cv_have_sse_ext=no
 87 |         if test "$((0x$edx>>25&0x01))" = 1; then
 88 |           ax_cv_have_sse_ext=yes
 89 |         fi
 90 |       ])
 91 | 
 92 |       AC_CACHE_CHECK([whether sse2 is supported], [ax_cv_have_sse2_ext],
 93 |       [
 94 |         ax_cv_have_sse2_ext=no
 95 |         if test "$((0x$edx>>26&0x01))" = 1; then
 96 |           ax_cv_have_sse2_ext=yes
 97 |         fi
 98 |       ])
 99 | 
100 |       AC_CACHE_CHECK([whether sse3 is supported], [ax_cv_have_sse3_ext],
101 |       [
102 |         ax_cv_have_sse3_ext=no
103 |         if test "$((0x$ecx&0x01))" = 1; then
104 |           ax_cv_have_sse3_ext=yes
105 |         fi
106 |       ])
107 | 
108 |       AC_CACHE_CHECK([whether ssse3 is supported], [ax_cv_have_ssse3_ext],
109 |       [
110 |         ax_cv_have_ssse3_ext=no
111 |         if test "$((0x$ecx>>9&0x01))" = 1; then
112 |           ax_cv_have_ssse3_ext=yes
113 |         fi
114 |       ])
115 | 
116 |       AC_CACHE_CHECK([whether sse4.1 is supported], [ax_cv_have_sse41_ext],
117 |       [
118 |         ax_cv_have_sse41_ext=no
119 |         if test "$((0x$ecx>>19&0x01))" = 1; then
120 |           ax_cv_have_sse41_ext=yes
121 |         fi
122 |       ])
123 | 
124 |       AC_CACHE_CHECK([whether sse4.2 is supported], [ax_cv_have_sse42_ext],
125 |       [
126 |         ax_cv_have_sse42_ext=no
127 |         if test "$((0x$ecx>>20&0x01))" = 1; then
128 |           ax_cv_have_sse42_ext=yes
129 |         fi
130 |       ])
131 | 
132 |       AC_CACHE_CHECK([whether avx is supported by processor], [ax_cv_have_avx_cpu_ext],
133 |       [
134 |         ax_cv_have_avx_cpu_ext=no
135 |         if test "$((0x$ecx>>28&0x01))" = 1; then
136 |           ax_cv_have_avx_cpu_ext=yes
137 |         fi
138 |       ])
139 | 
140 |       if test x"$ax_cv_have_avx_cpu_ext" = x"yes"; then
141 |         AX_GCC_X86_AVX_XGETBV(0x00000000)
142 | 
143 |         xgetbv_eax="0"
144 |         if test x"$ax_cv_gcc_x86_avx_xgetbv_0x00000000" != x"unknown"; then
145 |           xgetbv_eax=`echo $ax_cv_gcc_x86_avx_xgetbv_0x00000000 | cut -d ":" -f 1`
146 |         fi
147 | 
148 |         AC_CACHE_CHECK([whether avx is supported by operating system], [ax_cv_have_avx_ext],
149 |         [
150 |           ax_cv_have_avx_ext=no
151 | 
152 |           if test "$((0x$ecx>>27&0x01))" = 1; then
153 |             if test "$((0x$xgetbv_eax&0x6))" = 6; then
154 |               ax_cv_have_avx_ext=yes
155 |             fi
156 |           fi
157 |         ])
158 |         if test x"$ax_cv_have_avx_ext" = x"no"; then
159 |           AC_MSG_WARN([Your processor supports AVX, but your operating system doesn't])
160 |         fi
161 |       fi
162 | 
163 |       if test "$ax_cv_have_mmx_ext" = yes; then
164 |         AX_CHECK_COMPILE_FLAG(-mmmx, ax_cv_support_mmx_ext=yes, [])
165 |         if test x"$ax_cv_support_mmx_ext" = x"yes"; then
166 |           SIMD_FLAGS="$SIMD_FLAGS -mmmx"
167 |           AC_DEFINE(HAVE_MMX,,[Support mmx instructions])
168 |         else
169 |           AC_MSG_WARN([Your processor supports mmx instructions but not your compiler, can you try another compiler?])
170 |         fi
171 |       fi
172 | 
173 |       if test "$ax_cv_have_sse_ext" = yes; then
174 |         AX_CHECK_COMPILE_FLAG(-msse, ax_cv_support_sse_ext=yes, [])
175 |         if test x"$ax_cv_support_sse_ext" = x"yes"; then
176 |           SIMD_FLAGS="$SIMD_FLAGS -msse"
177 |           AC_DEFINE(HAVE_SSE,,[Support SSE (Streaming SIMD Extensions) instructions])
178 |         else
179 |           AC_MSG_WARN([Your processor supports sse instructions but not your compiler, can you try another compiler?])
180 |         fi
181 |       fi
182 | 
183 |       if test "$ax_cv_have_sse2_ext" = yes; then
184 |         AX_CHECK_COMPILE_FLAG(-msse2, ax_cv_support_sse2_ext=yes, [])
185 |         if test x"$ax_cv_support_sse2_ext" = x"yes"; then
186 |           SIMD_FLAGS="$SIMD_FLAGS -msse2"
187 |           AC_DEFINE(HAVE_SSE2,,[Support SSE2 (Streaming SIMD Extensions 2) instructions])
188 |         else
189 |           AC_MSG_WARN([Your processor supports sse2 instructions but not your compiler, can you try another compiler?])
190 |         fi
191 |       fi
192 | 
193 |       if test "$ax_cv_have_sse3_ext" = yes; then
194 |         AX_CHECK_COMPILE_FLAG(-msse3, ax_cv_support_sse3_ext=yes, [])
195 |         if test x"$ax_cv_support_sse3_ext" = x"yes"; then
196 |           SIMD_FLAGS="$SIMD_FLAGS -msse3"
197 |           AC_DEFINE(HAVE_SSE3,,[Support SSE3 (Streaming SIMD Extensions 3) instructions])
198 |         else
199 |           AC_MSG_WARN([Your processor supports sse3 instructions but not your compiler, can you try another compiler?])
200 |         fi
201 |       fi
202 | 
203 |       if test "$ax_cv_have_ssse3_ext" = yes; then
204 |         AX_CHECK_COMPILE_FLAG(-mssse3, ax_cv_support_ssse3_ext=yes, [])
205 |         if test x"$ax_cv_support_ssse3_ext" = x"yes"; then
206 |           SIMD_FLAGS="$SIMD_FLAGS -mssse3"
207 |           AC_DEFINE(HAVE_SSSE3,,[Support SSSE3 (Supplemental Streaming SIMD Extensions 3) instructions])
208 |         else
209 |           AC_MSG_WARN([Your processor supports ssse3 instructions but not your compiler, can you try another compiler?])
210 |         fi
211 |       fi
212 | 
213 |       if test "$ax_cv_have_sse41_ext" = yes; then
214 |         AX_CHECK_COMPILE_FLAG(-msse4.1, ax_cv_support_sse41_ext=yes, [])
215 |         if test x"$ax_cv_support_sse41_ext" = x"yes"; then
216 |           SIMD_FLAGS="$SIMD_FLAGS -msse4.1"
217 |           AC_DEFINE(HAVE_SSE4_1,,[Support SSSE4.1 (Streaming SIMD Extensions 4.1) instructions])
218 |         else
219 |           AC_MSG_WARN([Your processor supports sse4.1 instructions but not your compiler, can you try another compiler?])
220 |         fi
221 |       fi
222 | 
223 |       if test "$ax_cv_have_sse42_ext" = yes; then
224 |         AX_CHECK_COMPILE_FLAG(-msse4.2, ax_cv_support_sse42_ext=yes, [])
225 |         if test x"$ax_cv_support_sse42_ext" = x"yes"; then
226 |           SIMD_FLAGS="$SIMD_FLAGS -msse4.2"
227 |           AC_DEFINE(HAVE_SSE4_2,,[Support SSSE4.2 (Streaming SIMD Extensions 4.2) instructions])
228 |         else
229 |           AC_MSG_WARN([Your processor supports sse4.2 instructions but not your compiler, can you try another compiler?])
230 |         fi
231 |       fi
232 | 
233 |       if test "$ax_cv_have_avx_ext" = yes; then
234 |         AX_CHECK_COMPILE_FLAG(-mavx, ax_cv_support_avx_ext=yes, [])
235 |         if test x"$ax_cv_support_avx_ext" = x"yes"; then
236 |           SIMD_FLAGS="$SIMD_FLAGS -mavx"
237 |           AC_DEFINE(HAVE_AVX,,[Support AVX (Advanced Vector Extensions) instructions])
238 |         else
239 |           AC_MSG_WARN([Your processor supports avx instructions but not your compiler, can you try another compiler?])
240 |         fi
241 |       fi
242 | 
243 |   ;;
244 |   esac
245 | 
246 |   AC_SUBST(SIMD_FLAGS)
247 | ])
248 | 


--------------------------------------------------------------------------------
/src/reed_sol.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | 
 52 | #include 
 53 | #include "galois.h"
 54 | #include "jerasure.h"
 55 | #include "reed_sol.h"
 56 | 
 57 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 58 | 
 59 | int *reed_sol_r6_coding_matrix(int k, int w)
 60 | {
 61 |   int *matrix;
 62 |   int i, tmp;
 63 | 
 64 |   if (w != 8 && w != 16 && w != 32) return NULL;
 65 | 
 66 |   matrix = talloc(int, 2*k);
 67 |   if (matrix == NULL) return NULL;
 68 | 
 69 |   for (i = 0; i < k; i++) matrix[i] = 1;
 70 |   matrix[k] = 1;
 71 |   tmp = 1;
 72 |   for (i = 1; i < k; i++) {
 73 |     tmp = galois_single_multiply(tmp, 2, w);
 74 |     matrix[k+i] = tmp;
 75 |   }
 76 |   return matrix;
 77 | }
 78 | 
 79 | int *reed_sol_vandermonde_coding_matrix(int k, int m, int w)
 80 | {
 81 |   int i, j;
 82 |   int *vdm, *dist;
 83 | 
 84 |   vdm = reed_sol_big_vandermonde_distribution_matrix(k+m, k, w);
 85 |   if (vdm == NULL) return NULL;
 86 |   dist = talloc(int, m*k);
 87 |   if (dist == NULL) {
 88 |     free(vdm);
 89 |     return NULL;
 90 |   }
 91 | 
 92 |   i = k*k;
 93 |   for (j = 0; j < m*k; j++) {
 94 |     dist[j] = vdm[i];
 95 |     i++;
 96 |   }
 97 |   free(vdm);
 98 |   return dist;
 99 | }
100 | 
101 | static int prim08 = -1;
102 | static gf_t GF08;
103 | 
104 | void reed_sol_galois_w08_region_multby_2(char *region, int nbytes)
105 | {
106 |   if (prim08 == -1) {
107 |     prim08 = galois_single_multiply((1 << 7), 2, 8);
108 |     if (!gf_init_hard(&GF08, 8, GF_MULT_BYTWO_b, GF_REGION_DEFAULT, GF_DIVIDE_DEFAULT,
109 |                       prim08, 0, 0, NULL, NULL)) {
110 |       fprintf(stderr, "Error: Can't initialize the GF for reed_sol_galois_w08_region_multby_2\n");
111 |       assert(0);
112 |     }
113 |   }
114 |   GF08.multiply_region.w32(&GF08, region, region, 2, nbytes, 0);
115 | }
116 | 
117 | static int prim16 = -1;
118 | static gf_t GF16;
119 | 
120 | void reed_sol_galois_w16_region_multby_2(char *region, int nbytes)
121 | {
122 |   if (prim16 == -1) {
123 |     prim16 = galois_single_multiply((1 << 15), 2, 16);
124 |     if (!gf_init_hard(&GF16, 16, GF_MULT_BYTWO_b, GF_REGION_DEFAULT, GF_DIVIDE_DEFAULT,
125 |                       prim16, 0, 0, NULL, NULL)) {
126 |       fprintf(stderr, "Error: Can't initialize the GF for reed_sol_galois_w16_region_multby_2\n");
127 |       assert(0);
128 |     }
129 |   }
130 |   GF16.multiply_region.w32(&GF16, region, region, 2, nbytes, 0);
131 | }
132 | 
133 | static int prim32 = -1;
134 | static gf_t GF32;
135 | 
136 | void reed_sol_galois_w32_region_multby_2(char *region, int nbytes)
137 | {
138 |   if (prim32 == -1) {
139 |     prim32 = galois_single_multiply(((gf_val_32_t)1 << 31), 2, 32);
140 |     if (!gf_init_hard(&GF32, 32, GF_MULT_BYTWO_b, GF_REGION_DEFAULT, GF_DIVIDE_DEFAULT,
141 |                       prim32, 0, 0, NULL, NULL)) {
142 |       fprintf(stderr, "Error: Can't initialize the GF for reed_sol_galois_w32_region_multby_2\n");
143 |       assert(0);
144 |     }
145 |   }
146 |   GF32.multiply_region.w32(&GF32, region, region, 2, nbytes, 0);
147 | }
148 | 
149 | int reed_sol_r6_encode(int k, int w, char **data_ptrs, char **coding_ptrs, int size)
150 | {
151 |   int i;
152 | 
153 |   /* First, put the XOR into coding region 0 */
154 | 
155 |   memcpy(coding_ptrs[0], data_ptrs[0], size);
156 | 
157 |   for (i = 1; i < k; i++) galois_region_xor(data_ptrs[i], coding_ptrs[0], size);
158 | 
159 |   /* Next, put the sum of (2^j)*Dj into coding region 1 */
160 | 
161 |   memcpy(coding_ptrs[1], data_ptrs[k-1], size);
162 | 
163 |   for (i = k-2; i >= 0; i--) {
164 |     switch (w) {
165 |       case 8:  reed_sol_galois_w08_region_multby_2(coding_ptrs[1], size); break;
166 |       case 16: reed_sol_galois_w16_region_multby_2(coding_ptrs[1], size); break;
167 |       case 32: reed_sol_galois_w32_region_multby_2(coding_ptrs[1], size); break;
168 |       default: return 0;
169 |     }
170 | 
171 |     galois_region_xor(data_ptrs[i], coding_ptrs[1], size);
172 |   }
173 |   return 1;
174 | }
175 | 
176 | int *reed_sol_extended_vandermonde_matrix(int rows, int cols, int w)
177 | {
178 |   int *vdm;
179 |   int i, j, k;
180 | 
181 |   if (w < 30 && (1 << w) < rows) return NULL;
182 |   if (w < 30 && (1 << w) < cols) return NULL;
183 | 
184 |   vdm = talloc(int, rows*cols);
185 |   if (vdm == NULL) { return NULL; }
186 |   
187 |   vdm[0] = 1;
188 |   for (j = 1; j < cols; j++) vdm[j] = 0;
189 |   if (rows == 1) return vdm;
190 | 
191 |   i=(rows-1)*cols;
192 |   for (j = 0; j < cols-1; j++) vdm[i+j] = 0;
193 |   vdm[i+j] = 1;
194 |   if (rows == 2) return vdm;
195 | 
196 |   for (i = 1; i < rows-1; i++) {
197 |     k = 1;
198 |     for (j = 0; j < cols; j++) {
199 |       vdm[i*cols+j] = k;
200 |       k = galois_single_multiply(k, i, w);
201 |     }
202 |   }
203 |   return vdm;
204 | }
205 | 
206 | int *reed_sol_big_vandermonde_distribution_matrix(int rows, int cols, int w)
207 | {
208 |   int *dist;
209 |   int i, j, k;
210 |   int sindex, srindex, siindex, tmp;
211 | 
212 |   if (cols >= rows) return NULL;
213 |   
214 |   dist = reed_sol_extended_vandermonde_matrix(rows, cols, w);
215 |   if (dist == NULL) return NULL;
216 | 
217 |   sindex = 0;
218 |   for (i = 1; i < cols; i++) {
219 |     sindex += cols;
220 | 
221 |     /* Find an appropriate row -- where i,i != 0 */
222 |     srindex = sindex+i;
223 |     for (j = i; j < rows && dist[srindex] == 0; j++) srindex += cols;
224 |     if (j >= rows) {   /* This should never happen if rows/w are correct */
225 |       fprintf(stderr, "reed_sol_big_vandermonde_distribution_matrix(%d,%d,%d) - couldn't make matrix\n", 
226 |              rows, cols, w);
227 |       assert(0);
228 |     }
229 |  
230 |     /* If necessary, swap rows */
231 |     if (j != i) {
232 |       srindex -= i;
233 |       for (k = 0; k < cols; k++) {
234 |         tmp = dist[srindex+k];
235 |         dist[srindex+k] = dist[sindex+k];
236 |         dist[sindex+k] = tmp;
237 |       }
238 |     }
239 |   
240 |     /* If Element i,i is not equal to 1, multiply the column by 1/i */
241 | 
242 |     if (dist[sindex+i] != 1) {
243 |       tmp = galois_single_divide(1, dist[sindex+i], w);
244 |       srindex = i;
245 |       for (j = 0; j < rows; j++) {
246 |         dist[srindex] = galois_single_multiply(tmp, dist[srindex], w);
247 |         srindex += cols;
248 |       }
249 |     }
250 |  
251 |     /* Now, for each element in row i that is not in column 1, you need
252 |        to make it zero.  Suppose that this is column j, and the element
253 |        at i,j = e.  Then you want to replace all of column j with 
254 |        (col-j + col-i*e).   Note, that in row i, col-i = 1 and col-j = e.
255 |        So (e + 1e) = 0, which is indeed what we want. */
256 | 
257 |     for (j = 0; j < cols; j++) {
258 |       tmp = dist[sindex+j];
259 |       if (j != i && tmp != 0) {
260 |         srindex = j;
261 |         siindex = i;
262 |         for (k = 0; k < rows; k++) {
263 |           dist[srindex] = dist[srindex] ^ galois_single_multiply(tmp, dist[siindex], w);
264 |           srindex += cols;
265 |           siindex += cols;
266 |         }
267 |       }
268 |     }
269 |   }
270 |   /* We desire to have row k be all ones.  To do that, multiply
271 |      the entire column j by 1/dist[k,j].  Then row j by 1/dist[j,j]. */
272 | 
273 |   sindex = cols*cols;
274 |   for (j = 0; j < cols; j++) {
275 |     tmp = dist[sindex];
276 |     if (tmp != 1) { 
277 |       tmp = galois_single_divide(1, tmp, w);
278 |       srindex = sindex;
279 |       for (i = cols; i < rows; i++) {
280 |         dist[srindex] = galois_single_multiply(tmp, dist[srindex], w);
281 |         srindex += cols;
282 |       }
283 |     }
284 |     sindex++;
285 |   }
286 | 
287 |   /* Finally, we'd like the first column of each row to be all ones.  To
288 |      do that, we multiply the row by the inverse of the first element. */
289 | 
290 |   sindex = cols*(cols+1);
291 |   for (i = cols+1; i < rows; i++) {
292 |     tmp = dist[sindex];
293 |     if (tmp != 1) { 
294 |       tmp = galois_single_divide(1, tmp, w);
295 |       for (j = 0; j < cols; j++) dist[sindex+j] = galois_single_multiply(dist[sindex+j], tmp, w);
296 |     }
297 |     sindex += cols;
298 |   }
299 | 
300 |   return dist;
301 | }
302 | 
303 | 


--------------------------------------------------------------------------------
/Examples/cauchy_04.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 |  
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan.
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank.
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | #include "cauchy.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: cauchy_04 k m w seed - CRS coding example improving the matrix.\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "k+m must be <= 2^w\n");
 62 |   fprintf(stderr, "This sets up a generator matrix (G^T) in GF(2^w) whose last m rows are\n");
 63 |   fprintf(stderr, "a 'good' matrix, created with cauchy_good_general_coding_matrix().\n");
 64 |   fprintf(stderr, "It converts this matrix to a bitmatrix.\n");
 65 |   fprintf(stderr, "\n");
 66 |   fprintf(stderr, "Then, it encodes w packets from each of k disks (simulated) onto w packets on\n");
 67 |   fprintf(stderr, "on each of m disks.  Packets are longs.  Then, it deletes m random disks, and decodes.\n");
 68 |   fprintf(stderr, "\n");
 69 |   fprintf(stderr, "The encoding and decoding are done twice, first, with jerasure_bitmatrix_encode()\n");
 70 |   fprintf(stderr, "and jerasure_bitmatrix_decode(), and second using 'smart' scheduling with\n");
 71 |   fprintf(stderr, "jerasure_schedule_encode() and jerasure_schedule_decode_lazy().\n");
 72 | 
 73 |   fprintf(stderr, "\n");
 74 |   fprintf(stderr, "This demonstrates: cauchy_good_general_coding_matrix()\n");
 75 |   fprintf(stderr, "                   jerasure_bitmatrix_encode()\n");
 76 |   fprintf(stderr, "                   jerasure_bitmatrix_decode()\n");
 77 |   fprintf(stderr, "                   cauchy_n_ones()\n");
 78 |   fprintf(stderr, "                   jerasure_smart_bitmatrix_to_schedule()\n");
 79 |   fprintf(stderr, "                   jerasure_schedule_encode()\n");
 80 |   fprintf(stderr, "                   jerasure_schedule_decode_lazy()\n");
 81 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 82 |   fprintf(stderr, "                   jerasure_print_bitmatrix()\n");
 83 |   fprintf(stderr, "                   jerasure_get_stats()\n");
 84 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 85 |   exit(1);
 86 | }
 87 | 
 88 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 89 | {
 90 |   int i, j, x;
 91 |   unsigned char *up;
 92 | 
 93 |   printf("
\n");
 94 |   
 95 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 96 |   printf("\n");
 97 |   printf("\n");
100 |   for (i = 0; i < ndevices; i++) {
101 |     printf("\n");
111 |   }
112 |   printf("
%s%x
");
 98 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
 99 |   printf("
");
102 |     up = (unsigned char *) ptrs[i];
103 |     for (j = 0; j < size/packetsize; j++) {
104 |       for (x = 0; x < packetsize; x++) {
105 |         if (x > 0 && x%4 == 0) printf(" ");
106 |         printf("%02x", up[j*packetsize+x]);
107 |       }
108 |       printf("\n");
109 |     }
110 |     printf("
\n");
113 | }
114 | 
115 | int main(int argc, char **argv)
116 | {
117 |   int k, w, i, m;
118 |   int *matrix, *bitmatrix, **schedule;
119 |   char **data, **coding, **dcopy, **ccopy;
120 |   int no;
121 |   int *erasures, *erased;
122 |   double mstats[3], sstats[3];
123 |   uint32_t seed;
124 |   
125 |   if (argc != 5) usage(NULL);
126 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
127 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
128 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
129 |   if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
130 |   if (w < 30 && (k+m) > (1 << w)) usage("k + m is too big");
131 | 
132 |   matrix = cauchy_good_general_coding_matrix(k, m, w);
133 |   if (matrix == NULL) {
134 |     usage("couldn't make coding matrix");
135 |   }
136 | 
137 |   /* Print out header information to the output file. */
138 |   printf("\n");
139 |   printf("Jerasure Example Output: cauchy_04 %d %d %d %d\n", k, m, w, seed);
140 |   printf("
Jerasure Example Output: cauchy_04 %d %d %d %d
\n", k, m, w, seed);
141 | 
142 |   printf("
\n");
143 |   printf("Parameters:\n");
144 |   printf("
  •  Number of data disks (k): %d\n", k);
145 |   printf("
  •  Number of coding disks (m): %d\n", m);
146 |   printf("
  •  Word size of the Galois Field: (w): %d\n", w);
147 |   printf("
  •  Seed for the random number generator: %d\n", seed);
148 |   printf("
  •  Number of bytes stored per disk: %ld\n", sizeof(long)*w);
149 |   printf("
  •  Number of packets stored per disk: %d\n", w);
150 |   printf("
  •  Number of bytes per packet: %ld\n", sizeof(long));
151 |   printf("
\n");
152 | 
153 |   /* Print out the matrix and the bitmatrix */
154 |   printf("
\n");
155 |   printf("Here is the matrix, which was created with cauchy_good_general_coding_matrix().\n");
156 | 
157 |   printf("
\n");
158 |   jerasure_print_matrix(matrix, m, k, w);
159 |   printf("
\n");
160 | 
161 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
162 | 
163 |   no = 0;
164 |   for (i = 0; i < k*m; i++) {
165 |     no += cauchy_n_ones(matrix[i], w);
166 |   }
167 | 
168 |   printf("The bitmatrix, which has %d one%s:
\n", no, (no == 1) ? "" : "s");
169 |   jerasure_print_bitmatrix(bitmatrix, m*w, k*w, w);
170 |   printf("
\n");
171 |   printf("
\n");
172 | 
173 |   MOA_Seed(seed);
174 | 
175 |   data = talloc(char *, k);
176 |   dcopy = talloc(char *, k);
177 |   for (i = 0; i < k; i++) {
178 |     data[i] = talloc(char, sizeof(long)*w);
179 |     dcopy[i] = talloc(char, sizeof(long)*w);
180 |     MOA_Fill_Random_Region(data[i], sizeof(long)*w);
181 |     memcpy(dcopy[i], data[i], sizeof(long)*w);
182 |   }
183 | 
184 |   printf("Here are the packets on the data disks:
\n");
185 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
186 | 
187 |   coding = talloc(char *, m);
188 |   ccopy = talloc(char *, m);
189 |   for (i = 0; i < m; i++) {
190 |     coding[i] = talloc(char, sizeof(long)*w);
191 |     ccopy[i] = talloc(char, sizeof(long)*w);
192 |   }
193 | 
194 |   jerasure_bitmatrix_encode(k, m, w, bitmatrix, data, coding, w*sizeof(long), sizeof(long));
195 |   jerasure_get_stats(mstats);
196 | 
197 |   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
198 |   jerasure_schedule_encode(k, m, w, schedule, data, ccopy, w*sizeof(long), sizeof(long));
199 |   jerasure_get_stats(sstats);
200 | 
201 |   printf("
Encoding with jerasure_bitmatrix_encode() - Bytes XOR'd: %.0lf.
\n", mstats[0]);
202 |   printf("Encoding with jerasure_schedule_encode() - Bytes XOR'd: %.0lf.
\n", sstats[0]);
203 | 
204 |   for (i = 0; i < m; i++) {
205 |     if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
206 |       printf("Problem: the two encodings don't match on disk C%x\n", i);
207 |       exit(0);
208 |     }
209 |   }
210 | 
211 |   printf("Here are the packets on the coding disks.
\n");
212 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
213 |   printf("
\n");
214 | 
215 |   erasures = talloc(int, (m+1));
216 |   erased = talloc(int, (k+m));
217 |   for (i = 0; i < m+k; i++) erased[i] = 0;
218 |   for (i = 0; i < m; ) {
219 |     erasures[i] = MOA_Random_W(31, 1)%(k+m);
220 |     if (erased[erasures[i]] == 0) {
221 |       erased[erasures[i]] = 1;
222 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
223 |       i++;
224 |     }
225 |   }
226 |   erasures[i] = -1;
227 |   printf("Erasures on the following devices:");
228 |   for (i = 0; erasures[i] != -1; i++) {
229 |     printf(" %c%x", ((erasures[i] < k) ? 'D' : 'C'), (erasures[i] < k ? erasures[i] : erasures[i]-k));
230 |   }
231 |   printf("
\nHere is the state of the system:\n
\n");
232 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
233 |   printf("
\n");
234 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
235 |   printf("
\n");
236 | 
237 |   jerasure_bitmatrix_decode(k, m, w, bitmatrix, 0, erasures, data, coding, w*sizeof(long), sizeof(long));
238 |   jerasure_get_stats(mstats);
239 | 
240 |   printf("
Decoded with jerasure_bitmatrix_decode - Bytes XOR'd: %.0lf.
\n", mstats[0]);
241 | 
242 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)*w) != 0) {
243 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
244 |   }
245 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
246 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
247 |   }
248 | 
249 |   for (i = 0; erasures[i] != -1; i++) {
250 |     bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
251 |   }
252 | 
253 |   jerasure_schedule_decode_lazy(k, m, w, bitmatrix, erasures, data, coding, w*sizeof(long), sizeof(long), 1);
254 |   jerasure_get_stats(sstats);
255 | 
256 |   printf("jerasure_schedule_decode_lazy - Bytes XOR'd: %.0lf.
\n", sstats[0]);
257 | 
258 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)*w) != 0) {
259 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
260 |   }
261 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
262 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
263 |   }
264 | 
265 |   printf("Here is the state of the system:\n
\n");
266 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
267 |   printf("
\n");
268 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
269 |   printf("
\n");
270 | 
271 |   return 0;
272 | }
273 | 


--------------------------------------------------------------------------------
/src/galois.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 | 
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | 
 53 | #include "galois.h"
 54 | 
 55 | #define MAX_GF_INSTANCES 64
 56 | gf_t *gfp_array[MAX_GF_INSTANCES] = { 0 };
 57 | int  gfp_is_composite[MAX_GF_INSTANCES] = { 0 };
 58 | 
 59 | gf_t *galois_get_field_ptr(int w)
 60 | {
 61 |   if (gfp_array[w] != NULL) {
 62 |     return gfp_array[w];
 63 |   }
 64 | 
 65 |   return NULL;
 66 | }
 67 | 
 68 | gf_t* galois_init_field(int w,
 69 |                         int mult_type,
 70 |                         int region_type,
 71 |                         int divide_type,
 72 |                         uint64_t prim_poly,
 73 |                         int arg1,
 74 |                         int arg2)
 75 | {
 76 |   int scratch_size;
 77 |   void *scratch_memory;
 78 |   gf_t *gfp;
 79 | 
 80 |   if (w <= 0 || w > 32) {
 81 |     fprintf(stderr, "ERROR -- cannot init default Galois field for w=%d\n", w);
 82 |     assert(0);
 83 |   }
 84 | 
 85 |   gfp = (gf_t *) malloc(sizeof(gf_t));
 86 |   if (!gfp) {
 87 |     fprintf(stderr, "ERROR -- cannot allocate memory for Galois field w=%d\n", w);
 88 |     assert(0);
 89 |   }
 90 | 
 91 |   scratch_size = gf_scratch_size(w, mult_type, region_type, divide_type, arg1, arg2);
 92 |   if (!scratch_size) {
 93 |     fprintf(stderr, "ERROR -- cannot get scratch size for base field w=%d\n", w);
 94 |     assert(0);
 95 |   }
 96 | 
 97 |   scratch_memory = malloc(scratch_size);
 98 |   if (!scratch_memory) {
 99 |     fprintf(stderr, "ERROR -- cannot get scratch memory for base field w=%d\n", w);
100 |     assert(0);
101 |   }
102 | 
103 |   if(!gf_init_hard(gfp,
104 |                    w, 
105 |                    mult_type, 
106 |                    region_type, 
107 |                    divide_type, 
108 |                    prim_poly, 
109 |                    arg1, 
110 |                    arg2, 
111 |                    NULL, 
112 |                    scratch_memory))
113 |   {
114 |     fprintf(stderr, "ERROR -- cannot init default Galois field for w=%d\n", w);
115 |     assert(0);
116 |   }
117 | 
118 |   gfp_is_composite[w] = 0;
119 |   return gfp;
120 | }
121 | 
122 | gf_t* galois_init_composite_field(int w,
123 |                                 int region_type,
124 |                                 int divide_type,
125 |                                 int degree,
126 |                                 gf_t* base_gf)
127 | {
128 |   int scratch_size;
129 |   void *scratch_memory;
130 |   gf_t *gfp;
131 |   
132 |   if (w <= 0 || w > 32) {
133 |     fprintf(stderr, "ERROR -- cannot init composite field for w=%d\n", w);
134 |     assert(0);
135 |   }
136 |   
137 |   gfp = (gf_t *) malloc(sizeof(gf_t));
138 |   if (!gfp) {
139 |     fprintf(stderr, "ERROR -- cannot allocate memory for Galois field w=%d\n", w);
140 |     assert(0);
141 |   }
142 | 
143 |   scratch_size = gf_scratch_size(w, GF_MULT_COMPOSITE, region_type, divide_type, degree, 0);
144 |   if (!scratch_size) {
145 |     fprintf(stderr, "ERROR -- cannot get scratch size for composite field w=%d\n", w);
146 |     assert(0);
147 |   }
148 | 
149 |   scratch_memory = malloc(scratch_size);
150 |   if (!scratch_memory) {
151 |     fprintf(stderr, "ERROR -- cannot get scratch memory for composite field w=%d\n", w);
152 |     assert(0);
153 |   }
154 | 
155 |   if(!gf_init_hard(gfp,
156 |                    w,
157 |                    GF_MULT_COMPOSITE,
158 |                    region_type,
159 |                    divide_type,
160 |                    0, 
161 |                    degree, 
162 |                    0, 
163 |                    base_gf,
164 |                    scratch_memory))
165 |   {
166 |     fprintf(stderr, "ERROR -- cannot init default composite field for w=%d\n", w);
167 |     assert(0);
168 |   }
169 |   gfp_is_composite[w] = 1;
170 |   return gfp;
171 | }
172 | 
173 | int galois_init_default_field(int w)
174 | {
175 |   if (gfp_array[w] == NULL) {
176 |     gfp_array[w] = (gf_t*)malloc(sizeof(gf_t));
177 |     if(gfp_array[w] == NULL)
178 |       return ENOMEM;
179 |     if (!gf_init_easy(gfp_array[w], w))
180 |       return EINVAL;
181 |   }
182 |   return 0;
183 | }
184 | 
185 | int galois_uninit_field(int w)
186 | {
187 |   int ret = 0;
188 |   if (gfp_array[w] != NULL) {
189 |     int recursive = 1;
190 |     ret = gf_free(gfp_array[w], recursive);
191 |     free(gfp_array[w]);
192 |     gfp_array[w] = NULL;
193 |   }
194 |   return ret;
195 | }
196 | 
197 | static void galois_init(int w)
198 | {
199 |   if (w <= 0 || w > 32) {
200 |     fprintf(stderr, "ERROR -- cannot init default Galois field for w=%d\n", w);
201 |     assert(0);
202 |   }
203 | 
204 |   switch (galois_init_default_field(w)) {
205 |   case ENOMEM:
206 |     fprintf(stderr, "ERROR -- cannot allocate memory for Galois field w=%d\n", w);
207 |     assert(0);
208 |     break;
209 |   case EINVAL:
210 |     fprintf(stderr, "ERROR -- cannot init default Galois field for w=%d\n", w);
211 |     assert(0);
212 |     break;
213 |   }
214 | }
215 | 
216 | 
217 | static int is_valid_gf(gf_t *gf, int w)
218 | {
219 |   // TODO: I assume we may eventually
220 |   // want to do w=64 and 128, so w
221 |   // will be needed to perform this check
222 |   (void)w;
223 | 
224 |   if (gf == NULL) {
225 |     return 0;
226 |   }
227 |   if (gf->multiply.w32 == NULL) {
228 |     return 0;
229 |   }
230 |   if (gf->multiply_region.w32 == NULL) {
231 |     return 0;
232 |   }
233 |   if (gf->divide.w32 == NULL) {
234 |     return 0;
235 |   }
236 |   if (gf->inverse.w32 == NULL) {
237 |     return 0;
238 |   }
239 |   if (gf->extract_word.w32 == NULL) {
240 |     return 0;
241 |   }
242 | 
243 |   return 1;
244 | }
245 | 
246 | void galois_change_technique(gf_t *gf, int w)
247 | {
248 |   if (w <= 0 || w > 32) {
249 |     fprintf(stderr, "ERROR -- cannot support Galois field for w=%d\n", w);
250 |     assert(0);
251 |   }
252 | 
253 |   if (!is_valid_gf(gf, w)) {
254 |     fprintf(stderr, "ERROR -- overriding with invalid Galois field for w=%d\n", w);
255 |     assert(0);
256 |   }
257 | 
258 |   if (gfp_array[w] != NULL) {
259 |     gf_free(gfp_array[w], gfp_is_composite[w]);
260 |   }
261 | 
262 |   gfp_array[w] = gf;
263 | }
264 | 
265 | int galois_single_multiply(int x, int y, int w)
266 | {
267 |   if (x == 0 || y == 0) return 0;
268 |   
269 |   if (gfp_array[w] == NULL) {
270 |     galois_init(w);
271 |   }
272 | 
273 |   if (w <= 32) {
274 |     return gfp_array[w]->multiply.w32(gfp_array[w], x, y);
275 |   } else {
276 |     fprintf(stderr, "ERROR -- Galois field not implemented for w=%d\n", w);
277 |     return 0;
278 |   }
279 | }
280 | 
281 | int galois_single_divide(int x, int y, int w)
282 | {
283 |   if (x == 0) return 0;
284 |   if (y == 0) return -1;
285 | 
286 |   if (gfp_array[w] == NULL) {
287 |     galois_init(w);
288 |   }
289 | 
290 |   if (w <= 32) {
291 |     return gfp_array[w]->divide.w32(gfp_array[w], x, y);
292 |   } else {
293 |     fprintf(stderr, "ERROR -- Galois field not implemented for w=%d\n", w);
294 |     return 0;
295 |   }
296 | }
297 | 
298 | void galois_w08_region_multiply(char *region,      /* Region to multiply */
299 |                                   int multby,       /* Number to multiply by */
300 |                                   int nbytes,        /* Number of bytes in region */
301 |                                   char *r2,          /* If r2 != NULL, products go here */
302 |                                   int add)
303 | {
304 |   if (gfp_array[8] == NULL) {
305 |     galois_init(8);
306 |   }
307 |   gfp_array[8]->multiply_region.w32(gfp_array[8], region, r2, multby, nbytes, add);
308 | }
309 | 
310 | void galois_w16_region_multiply(char *region,      /* Region to multiply */
311 |                                   int multby,       /* Number to multiply by */
312 |                                   int nbytes,        /* Number of bytes in region */
313 |                                   char *r2,          /* If r2 != NULL, products go here */
314 |                                   int add)
315 | {
316 |   if (gfp_array[16] == NULL) {
317 |     galois_init(16);
318 |   }
319 |   gfp_array[16]->multiply_region.w32(gfp_array[16], region, r2, multby, nbytes, add);
320 | }
321 | 
322 | 
323 | void galois_w32_region_multiply(char *region,      /* Region to multiply */
324 |                                   int multby,       /* Number to multiply by */
325 |                                   int nbytes,        /* Number of bytes in region */
326 |                                   char *r2,          /* If r2 != NULL, products go here */
327 |                                   int add)
328 | {
329 |   if (gfp_array[32] == NULL) {
330 |     galois_init(32);
331 |   }
332 |   gfp_array[32]->multiply_region.w32(gfp_array[32], region, r2, multby, nbytes, add);
333 | }
334 | 
335 | void galois_w8_region_xor(void *src, void *dest, int nbytes)
336 | {
337 |   if (gfp_array[8] == NULL) {
338 |     galois_init(8);
339 |   }
340 |   gfp_array[8]->multiply_region.w32(gfp_array[32], src, dest, 1, nbytes, 1);
341 | }
342 | 
343 | void galois_w16_region_xor(void *src, void *dest, int nbytes)
344 | {
345 |   if (gfp_array[16] == NULL) {
346 |     galois_init(16);
347 |   }
348 |   gfp_array[16]->multiply_region.w32(gfp_array[16], src, dest, 1, nbytes, 1);
349 | }
350 | 
351 | void galois_w32_region_xor(void *src, void *dest, int nbytes)
352 | {
353 |   if (gfp_array[32] == NULL) {
354 |     galois_init(32);
355 |   }
356 |   gfp_array[32]->multiply_region.w32(gfp_array[32], src, dest, 1, nbytes, 1);
357 | }
358 | 
359 | void galois_region_xor(char *src, char *dest, int nbytes)
360 | {
361 |   if (nbytes >= 16) {
362 |     galois_w32_region_xor(src, dest, nbytes);
363 |   } else {
364 |     int i = 0;
365 |     for (i = 0; i < nbytes; i++) {
366 |       *dest ^= *src;
367 |       dest++;
368 |       src++;
369 |     } 
370 |   }
371 | }
372 | 
373 | int galois_inverse(int y, int w)
374 | {
375 |   if (y == 0) return -1;
376 |   return galois_single_divide(1, y, w);
377 | }
378 | 


--------------------------------------------------------------------------------
/Examples/cauchy_02.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 |  
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | #include "cauchy.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: cauchy_02 k m w seed - CRS coding example using Bloemer's original matrix.\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "k+m must be <= 2^w\n");
 62 |   fprintf(stderr, "This sets up a generator matrix (G^T) in GF(2^w) whose last m rows are\n");
 63 |   fprintf(stderr, "created from a Cauchy matrix, using the original definition from [Bloemer95].\n");
 64 |   fprintf(stderr, "It converts this matrix to a bitmatrix, and then it encodes w packets from\n");
 65 |   fprintf(stderr, "each of k disks (simulated) onto w packets on each of m disks.  Packets are \n");
 66 |   fprintf(stderr, "simply longs.  Then, it deletes m random disks, and decodes.  \n");
 67 |   fprintf(stderr, "\n");
 68 |   fprintf(stderr, "The encoding and decoding are done twice, first, with jerasure_bitmatrix_encode()\n");
 69 |   fprintf(stderr, "and jerasure_bitmatrix_decode(), and second using 'smart' scheduling with\n");
 70 |   fprintf(stderr, "jerasure_schedule_encode() and jerasure_schedule_decode_lazy().\n");
 71 | 
 72 |   fprintf(stderr, "\n");
 73 |   fprintf(stderr, "This demonstrates: cauchy_original_coding_matrix()\n");
 74 |   fprintf(stderr, "                   jerasure_bitmatrix_encode()\n");
 75 |   fprintf(stderr, "                   jerasure_bitmatrix_decode()\n");
 76 |   fprintf(stderr, "                   cauchy_n_ones()\n");
 77 |   fprintf(stderr, "                   jerasure_smart_bitmatrix_to_schedule()\n");
 78 |   fprintf(stderr, "                   jerasure_schedule_encode()\n");
 79 |   fprintf(stderr, "                   jerasure_schedule_decode_lazy()\n");
 80 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 81 |   fprintf(stderr, "                   jerasure_print_bitmatrix()\n");
 82 |   fprintf(stderr, "                   jerasure_get_stats()\n");
 83 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 84 |   exit(1);
 85 | }
 86 | 
 87 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 88 | {
 89 |   int i, j, x;
 90 |   unsigned char *up;
 91 | 
 92 |   printf("
\n");
 93 |   
 94 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 95 |   printf("\n");
 96 |   printf("\n");
 99 |   for (i = 0; i < ndevices; i++) {
100 |     printf("\n");
110 |   }
111 |   printf("
%s%x
");
 97 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
 98 |   printf("
");
101 |     up = (unsigned char *) ptrs[i];
102 |     for (j = 0; j < size/packetsize; j++) {
103 |       for (x = 0; x < packetsize; x++) {
104 |         if (x > 0 && x%4 == 0) printf(" ");
105 |         printf("%02x", up[j*packetsize+x]);
106 |       }
107 |       printf("\n");
108 |     }
109 |     printf("
\n");
112 | }
113 | 
114 | int main(int argc, char **argv)
115 | {
116 |   int k, w, i, m;
117 |   int *matrix, *bitmatrix, **schedule;
118 |   char **data, **coding, **dcopy, **ccopy;
119 |   int no;
120 |   int *erasures, *erased;
121 |   double mstats[3], sstats[3];
122 |   uint32_t seed;
123 |   
124 |   if (argc != 5) usage(NULL);
125 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
126 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
127 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
128 |   if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
129 |   if (w < 30 && (k+m) > (1 << w)) usage("k + m is too big");
130 | 
131 |   matrix = cauchy_original_coding_matrix(k, m, w);
132 |   if (matrix == NULL) {
133 |     usage("couldn't make coding matrix");
134 |   }
135 | 
136 |   /* Print out header information to the output file. */
137 |   printf("\n");
138 |   printf("Jerasure Example Output: cauchy_02 %d %d %d %d\n", k, m, w, seed);
139 |   printf("
Jerasure Example Output: cauchy_02 %d %d %d %d
\n", k, m, w, seed);
140 | 
141 |   printf("
\n");
142 |   printf("Parameters:\n");
143 |   printf("
  •  Number of data disks (k): %d\n", k);
144 |   printf("
  •  Number of coding disks (m): %d\n", m);
145 |   printf("
  •  Word size of the Galois Field: (w): %d\n", w);
146 |   printf("
  •  Seed for the random number generator: %d\n", seed);
147 |   printf("
  •  Number of bytes stored per disk: %ld\n", sizeof(long)*w);
148 |   printf("
  •  Number of packets stored per disk: %d\n", w);
149 |   printf("
  •  Number of bytes per packet: %ld\n", sizeof(long));
150 |   printf("
\n");
151 | 
152 |   /* Print out the matrix and the bitmatrix */
153 |   printf("
\n");
154 |   printf("Here is the matrix, which was created with cauchy_original_coding_matrix().\n");
155 |   printf("This is not the best matrix to use, but we include it to show an example\n");
156 |   printf("of cauchy_original_coding_matrix().  For the best matrix and encoding/decoding\n");
157 |   printf("methodology, see cauchy_04.
\n");
158 | 
159 |   jerasure_print_matrix(matrix, m, k, w);
160 |   printf("
\n");
161 | 
162 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
163 | 
164 |   no = 0;
165 |   for (i = 0; i < k*m; i++) {
166 |     no += cauchy_n_ones(matrix[i], w);
167 |   }
168 | 
169 |   printf("The bitmatrix, which has %d one%s:
\n", no, (no == 1) ? "" : "s");
170 |   jerasure_print_bitmatrix(bitmatrix, m*w, k*w, w);
171 |   printf("
\n");
172 |   printf("
\n");
173 |   MOA_Seed(seed);
174 | 
175 |   data = talloc(char *, k);
176 |   dcopy = talloc(char *, k);
177 |   for (i = 0; i < k; i++) {
178 |     data[i] = talloc(char, sizeof(long)*w);
179 |     dcopy[i] = talloc(char, sizeof(long)*w);
180 |     MOA_Fill_Random_Region(data[i], sizeof(long)*w);
181 |     memcpy(dcopy[i], data[i], sizeof(long)*w);
182 |   }
183 | 
184 |   printf("Here are the packets on the data disks:
\n");
185 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
186 | 
187 |   coding = talloc(char *, m);
188 |   ccopy = talloc(char *, m);
189 |   for (i = 0; i < m; i++) {
190 |     coding[i] = talloc(char, sizeof(long)*w);
191 |     ccopy[i] = talloc(char, sizeof(long)*w);
192 |   }
193 | 
194 |   jerasure_bitmatrix_encode(k, m, w, bitmatrix, data, coding, w*sizeof(long), sizeof(long));
195 |   jerasure_get_stats(mstats);
196 | 
197 |   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
198 |   jerasure_schedule_encode(k, m, w, schedule, data, ccopy, w*sizeof(long), sizeof(long));
199 |   jerasure_get_stats(sstats);
200 | 
201 |   printf("
Encoding with jerasure_bitmatrix_encode() - Bytes XOR'd: %.0lf.
\n", mstats[0]);
202 |   printf("Encoding with jerasure_schedule_encode() - Bytes XOR'd: %.0lf.
\n", sstats[0]);
203 | 
204 |   for (i = 0; i < m; i++) {
205 |     if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
206 |       printf("Problem: the two encodings don't match on disk C%x\n", i);
207 |       exit(0);
208 |     }
209 |   }
210 | 
211 |   printf("Here are the packets on the coding disks.
\n");
212 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
213 |   printf("
\n");
214 | 
215 |   erasures = talloc(int, (m+1));
216 |   erased = talloc(int, (k+m));
217 |   for (i = 0; i < m+k; i++) erased[i] = 0;
218 |   for (i = 0; i < m; ) {
219 |     erasures[i] = MOA_Random_W(31, 1)%(k+m);
220 |     if (erased[erasures[i]] == 0) {
221 |       erased[erasures[i]] = 1;
222 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
223 |       i++;
224 |     }
225 |   }
226 |   erasures[i] = -1;
227 |   printf("Erasures on the following devices:");
228 |   for (i = 0; erasures[i] != -1; i++) {
229 |     printf(" %c%x", ((erasures[i] < k) ? 'D' : 'C'), (erasures[i] < k ? erasures[i] : erasures[i]-k));
230 |   }
231 |   printf("
\nHere is the state of the system:\n
\n");
232 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
233 |   printf("
\n");
234 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
235 |   printf("
\n");
236 | 
237 |   jerasure_bitmatrix_decode(k, m, w, bitmatrix, 0, erasures, data, coding, w*sizeof(long), sizeof(long));
238 |   jerasure_get_stats(mstats);
239 | 
240 |   printf("
Decoded with jerasure_bitmatrix_decode - Bytes XOR'd: %.0lf.
\n", mstats[0]);
241 | 
242 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)*w) != 0) {
243 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
244 |   }
245 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
246 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
247 |   }
248 | 
249 |   for (i = 0; erasures[i] != -1; i++) {
250 |     bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
251 |   }
252 | 
253 |   jerasure_schedule_decode_lazy(k, m, w, bitmatrix, erasures, data, coding, w*sizeof(long), sizeof(long), 1);
254 |   jerasure_get_stats(sstats);
255 | 
256 |   printf("jerasure_schedule_decode_lazy - Bytes XOR'd: %.0lf.
\n", sstats[0]);
257 | 
258 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)*w) != 0) {
259 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
260 |   }
261 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
262 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
263 |   }
264 | 
265 |   printf("Here is the state of the system:\n
\n");
266 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
267 |   printf("
\n");
268 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
269 |   printf("
\n");
270 | 
271 |   return 0;
272 | }
273 | 


--------------------------------------------------------------------------------
/Examples/cauchy_03.c:
--------------------------------------------------------------------------------
  1 | /* *
  2 |  * Copyright (c) 2014, James S. Plank and Kevin Greenan
  3 |  * All rights reserved.
  4 |  *
  5 |  * Jerasure - A C/C++ Library for a Variety of Reed-Solomon and RAID-6 Erasure
  6 |  * Coding Techniques
  7 |  *
  8 |  * Revision 2.0: Galois Field backend now links to GF-Complete
  9 |  *
 10 |  * Redistribution and use in source and binary forms, with or without
 11 |  * modification, are permitted provided that the following conditions
 12 |  * are met:
 13 |  *
 14 |  *  - Redistributions of source code must retain the above copyright
 15 |  *    notice, this list of conditions and the following disclaimer.
 16 |  *
 17 |  *  - Redistributions in binary form must reproduce the above copyright
 18 |  *    notice, this list of conditions and the following disclaimer in
 19 |  *    the documentation and/or other materials provided with the
 20 |  *    distribution.
 21 |  *
 22 |  *  - Neither the name of the University of Tennessee nor the names of its
 23 |  *    contributors may be used to endorse or promote products derived
 24 |  *    from this software without specific prior written permission.
 25 |  *
 26 |  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 27 |  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 28 |  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 29 |  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 30 |  * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 31 |  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 32 |  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 33 |  * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 34 |  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 35 |  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
 36 |  * WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 37 |  * POSSIBILITY OF SUCH DAMAGE.
 38 |  */
 39 | 
 40 | /* Jerasure's authors:
 41 |  
 42 |    Revision 2.x - 2014: James S. Plank and Kevin M. Greenan
 43 |    Revision 1.2 - 2008: James S. Plank, Scott Simmerman and Catherine D. Schuman.
 44 |    Revision 1.0 - 2007: James S. Plank
 45 |  */
 46 | 
 47 | #include 
 48 | #include 
 49 | #include 
 50 | #include 
 51 | #include 
 52 | #include "jerasure.h"
 53 | #include "cauchy.h"
 54 | 
 55 | #define talloc(type, num) (type *) malloc(sizeof(type)*(num))
 56 | 
 57 | static void usage(char *s)
 58 | {
 59 |   fprintf(stderr, "usage: cauchy_03 k m w seed - CRS coding example improving the matrix.\n");
 60 |   fprintf(stderr, "       \n");
 61 |   fprintf(stderr, "k+m must be <= 2^w\n");
 62 |   fprintf(stderr, "This sets up a generator matrix (G^T) in GF(2^w) whose last m rows are\n");
 63 |   fprintf(stderr, "created from a Cauchy matrix, using the original definition from [Bloemer95].\n");
 64 |   fprintf(stderr, "This is done with cauchy_xy_coding_matrix().\n");
 65 |   fprintf(stderr, "\n");
 66 |   fprintf(stderr, "It then it improves the matrix, which yields a different bitmatrix that is\n");
 67 |   fprintf(stderr, "MDS like the original bitmatrix, but it will yield a bitmatrix with fewer ones.\n");
 68 |   fprintf(stderr, "Then, it encodes w packets from each of k disks (simulated) onto w packets on\n");
 69 |   fprintf(stderr, "on each of m disks.  Packets are longs.  Then, it deletes m random disks, and decodes.\n");
 70 |   fprintf(stderr, "\n");
 71 |   fprintf(stderr, "The encoding and decoding are done twice, first, with jerasure_bitmatrix_encode()\n");
 72 |   fprintf(stderr, "and jerasure_bitmatrix_decode(), and second using 'smart' scheduling with\n");
 73 |   fprintf(stderr, "jerasure_schedule_encode() and jerasure_schedule_decode_lazy().\n");
 74 | 
 75 |   fprintf(stderr, "\n");
 76 |   fprintf(stderr, "This demonstrates: cauchy_xy_coding_matrix()\n");
 77 |   fprintf(stderr, "                   cauchy_improve_coding_matrix()\n");
 78 |   fprintf(stderr, "                   jerasure_bitmatrix_encode()\n");
 79 |   fprintf(stderr, "                   jerasure_bitmatrix_decode()\n");
 80 |   fprintf(stderr, "                   cauchy_n_ones()\n");
 81 |   fprintf(stderr, "                   jerasure_smart_bitmatrix_to_schedule()\n");
 82 |   fprintf(stderr, "                   jerasure_schedule_encode()\n");
 83 |   fprintf(stderr, "                   jerasure_schedule_decode_lazy()\n");
 84 |   fprintf(stderr, "                   jerasure_print_matrix()\n");
 85 |   fprintf(stderr, "                   jerasure_print_bitmatrix()\n");
 86 |   fprintf(stderr, "                   jerasure_get_stats()\n");
 87 |   if (s != NULL) fprintf(stderr, "%s\n", s);
 88 |   exit(1);
 89 | }
 90 | 
 91 | static void print_array(char **ptrs, int ndevices, int size, int packetsize, char *label)
 92 | {
 93 |   int i, j, x;
 94 |   unsigned char *up;
 95 | 
 96 |   printf("
\n");
 97 |   
 98 |   for (i = 0; i < ndevices; i++) printf("\n", label, i);
 99 |   printf("\n");
100 |   printf("\n");
103 |   for (i = 0; i < ndevices; i++) {
104 |     printf("\n");
114 |   }
115 |   printf("
%s%x
");
101 |   for (j = 0; j < size/packetsize; j++) printf("Packet %d\n", j);
102 |   printf("
");
105 |     up = (unsigned char *) ptrs[i];
106 |     for (j = 0; j < size/packetsize; j++) {
107 |       for (x = 0; x < packetsize; x++) {
108 |         if (x > 0 && x%4 == 0) printf(" ");
109 |         printf("%02x", up[j*packetsize+x]);
110 |       }
111 |       printf("\n");
112 |     }
113 |     printf("
\n");
116 | }
117 | 
118 | int main(int argc, char **argv)
119 | {
120 |   int k, w, i, m;
121 |   int *matrix, *bitmatrix, **schedule;
122 |   char **data, **coding, **dcopy, **ccopy;
123 |   int no;
124 |   int *erasures, *erased;
125 |   double mstats[3], sstats[3];
126 |   uint32_t seed;
127 |   int *X, *Y;
128 |   
129 |   if (argc != 5) usage(NULL);
130 |   if (sscanf(argv[1], "%d", &k) == 0 || k <= 0) usage("Bad k");
131 |   if (sscanf(argv[2], "%d", &m) == 0 || m <= 0) usage("Bad m");
132 |   if (sscanf(argv[3], "%d", &w) == 0 || w <= 0 || w > 32) usage("Bad w");
133 |   if (sscanf(argv[4], "%d", &seed) == 0) usage("Bad seed");
134 |   if (w < 30 && (k+m) > (1 << w)) usage("k + m is too big");
135 | 
136 |   X = talloc(int, m);
137 |   Y = talloc(int, k);
138 |   for (i = 0; i < m; i++) X[i] = i;
139 |   for (i = 0; i < k; i++) Y[i] = m+i;
140 | 
141 |   matrix = cauchy_xy_coding_matrix(k, m, w, X, Y);
142 |   if (matrix == NULL) {
143 |     usage("couldn't make coding matrix");
144 |   }
145 | 
146 |   /* Print out header information to the output file. */
147 |   printf("\n");
148 |   printf("Jerasure Example Output: cauchy_03 %d %d %d %d\n", k, m, w, seed);
149 |   printf("
Jerasure Example Output: cauchy_03 %d %d %d %d
\n", k, m, w, seed);
150 | 
151 |   printf("
\n");
152 |   printf("Parameters:\n");
153 |   printf("
  •  Number of data disks (k): %d\n", k);
154 |   printf("
  •  Number of coding disks (m): %d\n", m);
155 |   printf("
  •  Word size of the Galois Field: (w): %d\n", w);
156 |   printf("
  •  Seed for the random number generator: %d\n", seed);
157 |   printf("
  •  Number of bytes stored per disk: %ld\n", sizeof(long)*w);
158 |   printf("
  •  Number of packets stored per disk: %d\n", w);
159 |   printf("
  •  Number of bytes per packet: %ld\n", sizeof(long));
160 |   printf("
\n");
161 | 
162 |   /* Print out the matrix and the bitmatrix */
163 |   printf("
\n");
164 |   printf("Here is the matrix, which was created with cauchy_xy_coding_matrix().\n");
165 | 
166 |   printf("
\n");
167 |   jerasure_print_matrix(matrix, m, k, w);
168 |   printf("
\n");
169 | 
170 |   cauchy_improve_coding_matrix(k, m, w, matrix);
171 | 
172 |   printf("
\n");
173 |   printf("Here is the matrix improved with cauchy_improve_coding_matrix().\n");
174 | 
175 |   printf("
\n");
176 |   jerasure_print_matrix(matrix, m, k, w);
177 |   printf("
\n");
178 | 
179 |   bitmatrix = jerasure_matrix_to_bitmatrix(k, m, w, matrix);
180 | 
181 |   no = 0;
182 |   for (i = 0; i < k*m; i++) {
183 |     no += cauchy_n_ones(matrix[i], w);
184 |   }
185 | 
186 |   printf("The bitmatrix, which has %d one%s:
\n", no, (no == 1) ? "" : "s");
187 |   jerasure_print_bitmatrix(bitmatrix, m*w, k*w, w);
188 |   printf("
\n");
189 |   printf("
\n");
190 | 
191 |   MOA_Seed(seed);
192 | 
193 |   data = talloc(char *, k);
194 |   dcopy = talloc(char *, k);
195 |   for (i = 0; i < k; i++) {
196 |     data[i] = talloc(char, sizeof(long)*w);
197 |     dcopy[i] = talloc(char, sizeof(long)*w);
198 |     MOA_Fill_Random_Region(data[i], sizeof(long)*w);
199 |     memcpy(dcopy[i], data[i], sizeof(long)*w);
200 |   }
201 | 
202 |   printf("Here are the packets on the data disks:
\n");
203 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
204 | 
205 |   coding = talloc(char *, m);
206 |   ccopy = talloc(char *, m);
207 |   for (i = 0; i < m; i++) {
208 |     coding[i] = talloc(char, sizeof(long)*w);
209 |     ccopy[i] = talloc(char, sizeof(long)*w);
210 |   }
211 | 
212 |   jerasure_bitmatrix_encode(k, m, w, bitmatrix, data, coding, w*sizeof(long), sizeof(long));
213 |   jerasure_get_stats(mstats);
214 | 
215 |   schedule = jerasure_smart_bitmatrix_to_schedule(k, m, w, bitmatrix);
216 |   jerasure_schedule_encode(k, m, w, schedule, data, ccopy, w*sizeof(long), sizeof(long));
217 |   jerasure_get_stats(sstats);
218 | 
219 |   printf("
Encoding with jerasure_bitmatrix_encode() - Bytes XOR'd: %.0lf.
\n", mstats[0]);
220 |   printf("Encoding with jerasure_schedule_encode() - Bytes XOR'd: %.0lf.
\n", sstats[0]);
221 | 
222 |   for (i = 0; i < m; i++) {
223 |     if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
224 |       printf("Problem: the two encodings don't match on disk C%x\n", i);
225 |       exit(0);
226 |     }
227 |   }
228 | 
229 |   printf("Here are the packets on the coding disks.
\n");
230 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
231 |   printf("
\n");
232 | 
233 |   erasures = talloc(int, (m+1));
234 |   erased = talloc(int, (k+m));
235 |   for (i = 0; i < m+k; i++) erased[i] = 0;
236 |   for (i = 0; i < m; ) {
237 |     erasures[i] = MOA_Random_W(31, 1)%(k+m);
238 |     if (erased[erasures[i]] == 0) {
239 |       erased[erasures[i]] = 1;
240 |       bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
241 |       i++;
242 |     }
243 |   }
244 |   erasures[i] = -1;
245 |   printf("Erasures on the following devices:");
246 |   for (i = 0; erasures[i] != -1; i++) {
247 |     printf(" %c%x", ((erasures[i] < k) ? 'D' : 'C'), (erasures[i] < k ? erasures[i] : erasures[i]-k));
248 |   }
249 |   printf("
\nHere is the state of the system:\n
\n");
250 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
251 |   printf("
\n");
252 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
253 |   printf("
\n");
254 | 
255 |   jerasure_bitmatrix_decode(k, m, w, bitmatrix, 0, erasures, data, coding, w*sizeof(long), sizeof(long));
256 |   jerasure_get_stats(mstats);
257 | 
258 |   printf("
Decoded with jerasure_bitmatrix_decode - Bytes XOR'd: %.0lf.
\n", mstats[0]);
259 | 
260 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)*w) != 0) {
261 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
262 |   }
263 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
264 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
265 |   }
266 | 
267 |   for (i = 0; erasures[i] != -1; i++) {
268 |     bzero((erasures[i] < k) ? data[erasures[i]] : coding[erasures[i]-k], sizeof(long)*w);
269 |   }
270 | 
271 |   jerasure_schedule_decode_lazy(k, m, w, bitmatrix, erasures, data, coding, w*sizeof(long), sizeof(long), 1);
272 |   jerasure_get_stats(sstats);
273 | 
274 |   printf("jerasure_schedule_decode_lazy - Bytes XOR'd: %.0lf.
\n", sstats[0]);
275 | 
276 |   for (i = 0; i < k; i++) if (memcmp(data[i], dcopy[i], sizeof(long)*w) != 0) {
277 |     printf("ERROR: D%x after decoding does not match its state before decoding!
\n", i);
278 |   }
279 |   for (i = 0; i < m; i++) if (memcmp(coding[i], ccopy[i], sizeof(long)*w) != 0) {
280 |     printf("ERROR: C%x after decoding does not match its state before decoding!
\n", i);
281 |   }
282 | 
283 |   printf("Here is the state of the system:\n
\n");
284 |   print_array(data, k, sizeof(long)*w, sizeof(long), "D");
285 |   printf("
\n");
286 |   print_array(coding, m, sizeof(long)*w, sizeof(long), "C");
287 |   printf("
\n");
288 | 
289 |   return 0;
290 | }
291 | 


--------------------------------------------------------------------------------