Reorganize and commit all the modified TACLeBench code and run scripts

3 files changed, 1723 insertions, 0 deletions

diff --git a/baseline/source/huff_enc/ChangeLog.txt b/baseline/source/huff_enc/ChangeLog.txt
new file mode 100644
index 0000000..020dc4f
--- /dev/null
+++ b/baseline/source/huff_enc/ChangeLog.txt
@@ -0,0 +1,27 @@
+File: huff_enc.c
+Original provenience: David Bourgin (David.Bourgin@ufrima.imag.fr)
+
+2017-04-18:
+- Annotated huff_enc_main as entry-point for timing analysis
+
+2016-03-24:
+- Replaced dynamic memory allocation by a fixed array with 514 entries
+- Replaced memset() with loops
+- Added source code for a special qsort() implementation without
+  function pointer
+- Replaced file I/O by reading and writing to char arrays
+- Added huff_dec_main(), huff_dec_init() and huff_dec_return()
+- Added huff_dec_ prefix to all functions, types and global variables
+- Changed function arguments to ANSI style
+- Replaced macro definitions
+- Added forward declarations of all functions
+- Added generic TACLeBench header replacing previous header
+- Included license from compress.txt
+- Applied code formatting with astyle
+
+2016-05-24:
+- Changed type of j to unsigned to avoid warning
+- Removed static declarations
+
+2016-05-25:
+- Precise types to avoid gcc++ warnings
diff --git a/baseline/source/huff_enc/compress.txt b/baseline/source/huff_enc/compress.txt
new file mode 100644
index 0000000..5966bcf
--- /dev/null
+++ b/baseline/source/huff_enc/compress.txt
@@ -0,0 +1,1107 @@
++===========================================================+
+|     Introduction to the losslessy compression schemes     |
+|           Description of the codec source codes           |
++-----------------------------------------------------------+
+| From David Bourgin (E-mail: david.bourgin@ufrima.imag.fr) |
+| Date: 22/9/94                                             |
++===========================================================+
+
+                          ------ BE CARE ------
+This file (compress.txt) is copyrighted. (c) David Bourgin - 1994
+Permission to use this documentation for any purpose other than
+its incorporation into a commercial product is hereby granted without fee.
+Permission to copy and distribute this documentation only for non-commercial use
+is also granted without fee, provided, however, that the above copyright notice
+appears in all copies, that both that copyright notice and this permission notice appear in supporting documentation. The author makes no representations about
+the suitability of this documentation for any purpose. It is provided "as is"
+without express or implied warranty. 
+
+The source codes you obtain with this file are *NOT* covered by the same
+copyright, because you can include them for both commercial and non-commercial
+use. See below for more infos.
+
+The source code files (codrl1.c, dcodrl1.c, codrle2.c, dcodrle2.c, codrle3.c,
+dcodrle3.c, codrle4.c, dcodrle4.c, codhuff.c, dcodhuff.c) are copyrighted.
+They have been uploaded on ftp in turing.imag.fr (129.88.31.7):/pub/compression
+on 22/5/94 and have been modified on 22/9/94.
+(c) David Bourgin - 1994
+The source codes I provide have no buggs (!) but being that I make them
+available for free I have some notes to make. They can change at any time
+without notice. I assume no responsability or liability for any errors or
+inaccurracies, make no warranty of any kind (express, implied or statutory)
+with respect to this publication and expressly disclaim any and all warranties
+of merchantability, fitness for particular purposes. Of course, if you have
+some problems to use the information presented here, I will try to help you if
+I can.
+
+If you include the source codes in your application, here are the conditions:
+- You have to put my name in the header of your source file (not in the
+excutable program if you don't want) (this item is a must)
+- I would like to see your resulting application, if possible (this item is not
+a must, because some applications must remain secret)
+- Whenever you gain money with your application, I would like to receive a very
+little part in order to be encouraged to update my source codes and to develop
+new schemes (this item is not a must)
+                          ---------------------
+
+There are several means to compress data. Here, we are only going to deal with
+the losslessy schemes. These schemes are also called non-destructive because
+you always recover the initial data you had, and this, as soon as you need them.
+With losslessy schemes, you won't never lose any informations (except perhaps
+when you store or transmit your data but this is another problem...).
+
+In this introduction, we are going to see:
+- The RLE scheme (with different possible algorithms)
+- The Huffman schemes (dynamical scheme)
+- And the LZW scheme
+
+For the novice, a compresser is a program able to read several data (e.g. bytes)
+in input and to write several data in output. The data you obtain from the
+output (also called compressed data) will - of course - take less space than
+the the input data. This is true in most of cases, if the compresser works
+and if the type of the data is correct to be compressed with the given scheme.
+The codec (coder-decoder) enables you to save space on your hard disk and/or
+to save the communication costs because you always store/transmit the compressed
+data. You'll use the decompresser as soon as you need to recover your initial
+useful data. Note that the compressed data are useless if you have not
+the decoder...
+
+You are doubtless asking "How can I reduce the data size without losing some
+informations?". It's easy to answer to this question. I'll only take an example.
+I'm sure you have heard about the morse. This system established in the 19th
+century use a scheme very close to the huffman one. In the morse you encode
+the letters to transmit with two kinds of signs. If you encode these two sign
+possibilities in one bit, the symbol 'e' is transmitted in a single bit and
+the symbols 'y' and 'z' need four bits. Look at the symbols in the text you are
+reading, you'll fast understand the compression ratio...
+
+Important: The source codes associated to the algorithms I present are
+completely adaptative on what you need to compress. They all use basical
+macros on the top of the file. Usually the macros to change are:
+
+- beginning_of_data
+- end_of_data
+- read_byte
+- read_block
+- write_byte
+- write_block
+
+These allow the programmer to modify only a little part of the header
+of the source codes in order to compress as well memory as files.
+
+beginning_of_data(): Macro used to set the program so that the next read_byte()
+call will read the first byte to compress.
+end_of_data(): Returns a boolean to know whether there is no more bytes to read
+from the input stream. Return 0 if there is no more byte to compress, another
+non-zero value otherwise.
+read_byte(): Returns a byte read from the input stream if available.
+write_byte(x): Writes the byte 'x' to the output stream.
+read_block(...) and write_block(...): Same use as read_byte and write_byte(x)
+but these macros work on blocks of bytes and not only on a single byte.
+
+If you want to compress *from* the memory, before entering in a xxxcoding
+procedure ('xxx' is the actual extension to replace with a given codec), you
+have to add a pointer set up to the beginning of the zone to compress. Note
+that the following pointer 'source_memory_base' is not to add, it is just given
+here to specify a name to the address of the memory zone you are going to
+encode or decode. That is the same about source_memory_end which can be either
+a pointer to create or an existing pointer.
+
+unsigned char *source_memory_base, /* Base of the source memory */
+              *source_memory_end,  /* Last address to read.
+           source_memory_end=source_memory_base+source_zone_length-1 */
+              *source_ptr;         /* Used in the xxxcoding procedure */
+void pre_start()
+{ source_ptr=source_memory_base;
+  xxxcoding();
+}
+
+end_of_data() and read_byte() are also to modify to compress *from* memory:
+
+#define end_of_data()  (source_ptr>source_memory_end)
+#define read_byte()  (*(source_ptr++))
+
+If you want to compress *to* memory, before entering in a xxxcoding procedure
+('xxx' is the actual extension to replace with a given codec), you have to add
+a pointer. Note that the pointer 'dest_memory_base' is not to add, it is just
+given there to specify the address of the destination memory zone you are
+going to encode or decode.
+
+unsigned char *dest_memory_base, /* Base of the destination memory */
+              *dest_ptr;         /* Used in the xxxcoding procedure */
+void pre_start()
+{ dest_ptr=dest_memory_base;
+  xxxcoding();
+}
+
+Of course, you can combine both from and to memory in the pre_start() procedure.
+The files dest_file and source_file handled in the main() function are
+to remove...
+
+void pre_start()
+{ source_ptr=source_memory_base;
+  dest_ptr=dest_memory_base;
+  xxxcoding();
+}
+
+In fact, to write to memory, the problem is in the write_byte(x) procedure.
+This problem exists because your destination zone can either be a static
+zone or a dynamically allocated zone. In the two cases, you have to check
+if there is no overflow, especially if the coder is not efficient and must
+produce more bytes than you reserved in memory.
+
+In the first case, with a *static* zone, write_byte(x) macro should look like