Reorganize and commit all the modified TACLeBench code and run scripts

1 files changed, 594 insertions, 0 deletions

diff --git a/baseline/source/audiobeam/audiobeam.c b/baseline/source/audiobeam/audiobeam.c
new file mode 100644
index 0000000..ed5d656
--- /dev/null
+++ b/baseline/source/audiobeam/audiobeam.c
@@ -0,0 +1,594 @@
+/*
+
+  This program is part of the TACLeBench benchmark suite.
+  Version V 2.0
+
+  Name: audiobeam
+
+  Author: Eugene Weinstein
+
+  Function: Audio beam former
+
+  Source: StreamIt
+          http://groups.csail.mit.edu/cag/streamit/
+
+  Changes: no functional changes
+
+  License: see license.txt
+
+*/
+
+
+/*
+  Include section
+*/
+
+#include "../extra.h"
+#include "audiobeamlibm.h"
+#include "audiobeamlibmalloc.h"
+#include "audiobeam.h"
+
+/*
+  Forward declaration of functions
+*/
+
+void audiobeam_init();
+int audiobeam_return();
+void audiobeam_main( void );
+//int main( void );
+void audiobeam_preprocess_delays( struct audiobeam_PreprocessedDelays
+                                  prep_delays[], float *delays );
+float *audiobeam_parse_line( float *float_arr, int num_mic );
+long int audiobeam_find_max_in_arr( float *arr, int size );
+long int audiobeam_find_min_in_arr( float *arr, int size );
+int audiobeam_wrapped_inc_offset( int i, int offset, int max_i );
+int audiobeam_wrapped_dec_offset( int i, int offset, int max_i );
+int audiobeam_wrapped_inc( int i, int max_i );
+int audiobeam_wrapped_dec( int i, int max_i );
+struct audiobeam_DataQueue *audiobeam_init_data_queue( int max_delay,
+    int num_mic );
+struct audiobeam_Delays *audiobeam_init_delays ( int num_angles, int num_mic );
+void audiobeam_calc_distances( float *source_location,
+                               float audiobeam_mic_locations[15][3],
+                               float *distances,
+                               int num_mic );
+void audiobeam_calc_delays( float *distances, float *delays, int sound_speed,
+                            int sampling_rate, int num_mic );
+void audiobeam_adjust_delays( float *delays, int num_mic );
+float *audiobeam_calc_weights_lr ( int num_mic );
+float *audiobeam_calc_weights_left_only ( int num_mic );
+float audiobeam_calculate_energy( float *samples, int num_samples );
+float audiobeam_do_beamforming( struct audiobeam_PreprocessedDelays
+                                preprocessed_delays[],
+                                float **sample_queue,
+                                int queue_head,
+                                long int max_delay,
+                                int num_mic,
+                                float *weights );
+int audiobeam_process_signal( struct audiobeam_Delays *delays, int num_mic,
+                              float sampling_rate, float **beamform_results,
+                              struct audiobeam_DataQueue *queue,
+                              int num_beams, int window, float *weights );
+int audiobeam_calc_beamforming_result( struct audiobeam_Delays *delays,
+                                       float **beamform_results,
+                                       float *energies,
+                                       struct audiobeam_DataQueue *queue,
+                                       int num_beams, int window,
+                                       int hamming );
+void audiobeam_calc_single_pos( float source_location[3],
+                                float audiobeam_mic_locations[15][3],
+                                int hamming );
+
+
+/*
+  Declaration of global variables
+*/
+
+extern float audiobeam_input[5760];
+extern float audiobeam_mic_locations[15][3];
+extern float audiobeam_source_location[3];
+extern float audiobeam_origin_location[3];
+int audiobeam_input_pos;
+int audiobeam_checksum;
+
+
+/*
+  Initialization- and return-value-related functions
+*/
+
+void audiobeam_init()
+{
+  audiobeam_input_pos = 0;
+  audiobeam_checksum = 0;
+
+  unsigned int i;
+  unsigned char *p;
+  volatile char bitmask = 0;
+
+  /*
+    Apply volatile XOR-bitmask to entire input array.
+  */
+  p = ( unsigned char * ) &audiobeam_input[ 0 ];
+  _Pragma( "loopbound min 23040 max 23040" )
+  for ( i = 0; i < sizeof( audiobeam_input ); ++i, ++p )
+    *p ^= bitmask;
+
+  p = ( unsigned char * ) &audiobeam_mic_locations[ 0 ];
+  _Pragma( "loopbound min 180 max 180" )
+  for ( i = 0; i < sizeof( audiobeam_mic_locations ); ++i, ++p )
+    *p ^= bitmask;
+
+  p = ( unsigned char * ) &audiobeam_source_location[ 0 ];
+  _Pragma( "loopbound min 12 max 12" )
+  for ( i = 0; i < sizeof( audiobeam_source_location ); ++i, ++p )
+    *p ^= bitmask;
+
+  p = ( unsigned char * ) &audiobeam_origin_location[ 0 ];
+  _Pragma( "loopbound min 12 max 12" )
+  for ( i = 0; i < sizeof( audiobeam_origin_location ); ++i, ++p )
+    *p ^= bitmask;
+}
+
+
+int audiobeam_return()
+{
+  return ( audiobeam_checksum +1!= 0 );
+}
+
+
+/*
+  Algorithm core functions
+*/
+
+void audiobeam_preprocess_delays( struct audiobeam_PreprocessedDelays
+                                  prep_delays[], float *delays )
+{
+  int i;
+
+  _Pragma( "loopbound min 15 max 15" )
+  for ( i = 0; i < 15; i++ ) {
+    prep_delays[i].delay = delays[i];
+    prep_delays[i].high = ( int ) audiobeam_ceil( delays[i] );
+    prep_delays[i].low = ( int ) audiobeam_floor( delays[i] );
+    prep_delays[i].offset = delays[i] - prep_delays[i].low;
+  }
+}
+
+
+float *audiobeam_parse_line( float *float_arr, int num_mic )
+{
+  int i;
+
+  _Pragma( "loopbound min 15 max 15" )
+  for ( i = 0; i < num_mic; i++ )
+    float_arr[i] = audiobeam_input[audiobeam_input_pos++];
+
+  return float_arr;
+}
+
+
+long int audiobeam_find_max_in_arr( float *arr, int size )
+{
+  int i;
+  float max = 0;
+
+  _Pragma( "loopbound min 15 max 15" )
+  for ( i = 0; i < size; i++ ) {
+    if ( arr[i] > max )
+      max = arr[i];
+  }
+
+  return audiobeam_ceil( max );
+}
+
+
+long int audiobeam_find_min_in_arr( float *arr, int size )
+{
+  int i;
+  float min = arr[0];
+
+  _Pragma( "loopbound min 15 max 15" )
+  for ( i = 0; i < size; i++ ) {
+    if ( arr[i] < min )
+      min = arr[i];
+  }
+
+  return audiobeam_floor( min );
+