Merge lp:~rengolin/linaro-toolchain-benchmarks/clang into lp:linaro-toolchain-benchmarks

[Renato Golin]

Adding Clang Toolchain files

Adding Clang Toolchain files

Unmerged revisions

29. By Renato Golin on 2013-10-07

Adding Clang toolchain files

28. By Michael Hope on 2012-08-07

Add a new target for PGO builds.

27. By Michael Hope on 2012-08-06

Add support for setting -flto via .

26. By Michael Hope on 2012-07-04

Always set CC so CROSS_COMPILE works. Delete tarball reference.

25. By Michael Hope on 2012-05-15

Added a note on cross running.

24. By Michael Hope on 2012-04-23

Remove the extra call when building to prevent thlite related build
errors.
Add an explicit NOTPARALLEL to this level. Let the invoking -jx pass
through to the sub makes. Run tests at -j1.

23. By Michael Hope on 2012-04-23

Add LDADD with -lm and -lrt to the end of the linker command line.
Change THOBJS for THLIB in the target dependancies to fix an error
where THLIB hasn't been generated yet.

22. By Michael Hope on 2012-01-31

Add documentation and a wrapper for cross compiling and running over SSH.

21. By Michael Hope on 2011-08-29

Switch to high resolution timers. Remove a lot of the cruft from copying the example harness.

20. By Michael Hope on 2011-08-29

Change a left over reference to x86 to linux32l

=== added file '.bzrignore'
--- .bzrignore	1970-01-01 00:00:00 +0000
+++ .bzrignore	2013-10-07 11:04:13 +0000
@@ -0,0 +1,5 @@
+automotive/gcc
+telecom/gcc
+*.log
+consumer/gcc
+th/gcc/harness.mak

=== added file 'GNUmakefile'
--- GNUmakefile	1970-01-01 00:00:00 +0000
+++ GNUmakefile	2013-10-07 11:04:13 +0000
@@ -0,0 +1,97 @@
+# Linaro specific Makefile that overrides some of the standard EEMBC
+# targets.
+#
+# Uses GNU make's search rules to appear before the standard EEMBC
+# makefile.
+#
+
+# Cross compiler prefix such as arm-linux-gnueabi-
+CROSS_COMPILE ?=
+
+# Use gcc instead of /usr/bin/gcc so that you can put your new
+# compiler in the path.  Also consider running 'make
+# CC=/path/to/your/gcc'
+CC = $(CROSS_COMPILE)gcc
+# Use the same GCC as the linker driver
+LD = $(CC)
+
+# How to run tests.  By default, all tests are run natively.  Try
+# 'RUN="$PWD/sshrun hostname"' to use SSH to run tests on $hostname.
+# Use a separate `ssh -M` session to speed things up.
+RUN ?=
+
+# Default platform is a Linux 32 bit little endian host with
+# iterations that give a ~10 s run on a Cortex-A9
+PLATFORM ?= linux32l
+
+# Only build for GCC, not VC
+TOOLCHAIN ?= gcc
+
+# Default configuration is -O3 with the vectoriser.  Take the tuning
+# and architecture from the compiler itself
+COMPILER_FLAGS ?= -O3 -DNDEBUG
+# LTO and similar need to pass through to the linker
+LINKER_FLAGS ?= $(COMPILER_FLAGS)
+
+# All of the apps to check if they exist
+APPS ?= 8_16-bit automotive consumer networking office telecom voip
+VER ?=
+
+# Allow local customisation
+-include local.mk
+
+# Nothing to change beneath here
+
+ROOT = ..
+TCDIR = util/make
+# All of the 'dirs.mak' files from all possible apps
+DIRS = $(wildcard $(APPS:%=%/dirs*.mak)))
+# All of the apps that are present
+PRESENT = $(sort $(subst /,,$(dir $(DIRS))))
+
+# Build and run the suite
+all: build rerun
+
+# Do a complete PGO build including the instrument build, run, and
+# final build.  Always starts from clean.
+pgo-build:
+	$(MAKE) clean
+	$(MAKE) build PROFILE_FLAGS="-fprofile-generate"
+	$(MAKE) rerun
+	$(MAKE) clean
+	$(MAKE) build PROFILE_FLAGS="-fprofile-use"
+
+build: $(PRESENT:%=build-%)
+
+build-%:
+	$(MAKE) -C $* TCDIR=$(ROOT)/$(TCDIR) VER=$(VER) \
+	CC="$(CC)" \
+	LD="$(LD)" \
+	PLATFORM=$(PLATFORM) \
+	TOOLCHAIN=$(TOOLCHAIN) \
+	COMPILER_FLAGS="$(COMPILER_FLAGS) $(PROFILE_FLAGS)" \
+	LINKER_FLAGS="$(LINKER_FLAGS) $(PROFILE_FLAGS)" \
+	targets
+
+rerun: $(PRESENT:%=rerun-%)
+
+rerun-%: build-%
+	$(MAKE) -C $* TCDIR=$(ROOT)/$(TCDIR) VER=$(VER) \
+	CC="$(CC)" \
+	LD="$(LD)" \
+	PLATFORM=$(PLATFORM) \
+	TOOLCHAIN=$(TOOLCHAIN) \
+	COMPILER_FLAGS="$(COMPILER_FLAGS) $(PROFILE_FLAGS)" \
+	LINKER_FLAGS="$(LINKER_FLAGS) $(PROFILE_FLAGS)" \
+	RUN="$(RUN)" \
+	-j1 \
+	rerun
+
+clean:
+	$(MAKE) -f makefile clean
+
+# Make a tarball archive of this repo
+archive:
+	bzr export ../eembc-linaro-v1+bzr$(shell bzr revno).tar.bz2 --root=eembc-linaro-v1+bzr$(shell bzr revno)
+
+.NOTPARALLEL:

=== added file 'README.linaro'
--- README.linaro	1970-01-01 00:00:00 +0000
+++ README.linaro	2013-10-07 11:04:13 +0000
@@ -0,0 +1,54 @@
+EEMBC for Linaro
+================
+Michael Hope <[e-mail]> 2011
+
+This directory contains all of the EEMBC v1 benchmarks that Linaro has
+licenses for along with a good set of iterations and helper scripts to
+make running the benchmarks easier.
+
+All benchmarks were calibrated on a PandaBoard against
+gcc-linaro-4.5-2011.05 at `-O3 -mfpu=neon`.  The iterations in
+foo/iterationslinux32l.mak are set for a 10 s run on such a board.
+
+The Linaro specific rules are stored in `GNUmakefile`.  GNU make will
+choose this over the standard EEMBC makefile.
+
+Usage
+-----
+`make`:
+ Build and run all of the benchmarks, summarising to ./gcc_*.log
+
+`make build`:
+ Build all of the benchmarks in parallel
+
+`make rerun`:
+ Re-run all of the benchmarks without rebuilding, summarising to ./gcc_*.log
+
+You can also build or run individual benchmarks using `make build-foo`
+or `make rerun-foo` where `foo` is the benchmark name such as
+automotive, consumer, or telecom.  Note that the results for an
+individual benchmark are saved as foo/gcc_*.log and not summarised to
+the top level directory.
+
+Cross-running
+-------------
+make CROSS_COMPILE=arm-linux-gnueabi- RUN="$PWD/sshrun toolchain@ursa3"
+
+Customising
+-----------
+See `GNUmakefile`.  You might want to set `CC`, `COMPILER_FLAGS`, or
+`APPS`.  Set these from the command line using:
+
+ `make COMPILER_FLAGS="-Os -mtune=cortex-a5"`
+
+or by creating a file called `local.mk` and adding:
+
+ `COMPILER_FLAGS = -Os -mtune=cortex-a5`
+
+References
+----------
+These files are stored in a bzr repository at:
+ bzr+ssh://people.linaro.org/~toolchain/public_html/restricted/repos/eembc-linaro-v1
+
+The licenses are documented at:
+ https://wiki.linaro.org/Internal/ToolChain

=== added directory 'automotive'
=== added directory 'automotive/a2time01'
=== added file 'automotive/a2time01/algo.h'
--- automotive/a2time01/algo.h	1970-01-01 00:00:00 +0000
+++ automotive/a2time01/algo.h	2013-10-07 11:04:13 +0000
@@ -0,0 +1,166 @@
+/*==============================================================================
+ *$RCSfile: algo.h,v $
+ *
+ *   DESC : Angle-to-Time Conversion - a2time00
+ *
+ * AUTHOR : dt
+ *
+ *  EEMBC : Automotive Subcommittee 
+ *
+ *    CVS : $Revision: 1.2 $
+ *          $Date: 2002/04/19 18:31:37 $
+ *          $Author: rick $
+ *          $Source: d:/cvs/eembc2/automotive/a2time01/algo.h,v $
+ *          
+ * NOTE   :
+ *
+ *------------------------------------------------------------------------------
+ *
+ * HISTORY :
+ *
+ * $Log: algo.h,v $
+ * Revision 1.2  2002/04/19 18:31:37  rick
+ * Bug #146: global tablecount uninitialized
+ *
+ *
+ *------------------------------------------------------------------------------
+ * Copyright (c) 1998-2002 by the EDN Embedded Microprocessor 
+ * Benchmark Consortium (EEMBC), Inc. 
+ * 
+ * All Rights Reserved. This is licensed program product and 
+ * is owned by EEMBC. The Licensee understands and agrees that the 
+ * Benchmarks licensed by EEMBC hereunder (including methods or concepts 
+ * utilized therein) contain certain information that is confidential 
+ * and proprietary which the Licensee expressly agrees to retain in the 
+ * strictest confidence and to use only in conjunction with the Benchmarks 
+ * pursuant to the terms of this Agreement. The Licensee further agrees 
+ * to keep the source code and all related documentation confidential and 
+ * not to disclose such source code and/or related documentation to any 
+ * third party. The Licensee and any READER of this code is subject to 
+ * either the EEMBC Member License Agreement and/or the EEMBC Licensee 
+ * Agreement. 
+ * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, EEMBC DISCLAIMS ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
+ * PURPOSE, WITH REGARD TO THE BENCHMARKS AND THE ACCOMPANYING 
+ * DOCUMENTATION. LICENSEE ACKNOWLEDGES AND AGREES THAT THERE ARE NO 
+ * WARRANTIES, GUARANTIES, CONDITIONS, COVENANTS, OR REPRESENTATIONS BY 
+ * EEMBC AS TO MARKETABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR OTHER 
+ * ATTRIBUTES, WHETHER EXPRESS OR IMPLIED (IN LAW OR IN FACT), ORAL OR 
+ * WRITTEN. 
+ * 
+ * Licensee hereby agrees by accessing this source code that all benchmark 
+ * scores related to this code must be certified by ECL prior to publication 
+ * in any media, form, distribution, or other means of conveyance of 
+ * information subject to the terms of the EEMBC Member License Agreement 
+ * and/or EEMBC Licensee Agreement. 
+ * 
+ * Other Copyright Notice (if any): 
+ * 
+ * For conditions of distribution and use, see the accompanying README file.
+ * ===========================================================================*/
+
+#ifndef __ALGO_H
+#define __ALGO_H
+
+/*******************************************************************************
+    Includes (thlib includes eembc_dt.h)                                                                     
+*******************************************************************************/
+
+#include "thlib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* Compilation switches to be defined( or not )based on application follow */
+
+/* Define (=1) when compiling for DOUBLE variables */
+#define DATA_SIZE   1       
+/* ..or( =0 )when compiling for FLOAT variables */
+#if DATA_SIZE == 0           /* SHORT variables */
+typedef n_short varsize ;    /* Data and variables are 16 bits */
+#define MAX_VARIABLE 0x7FFF  /* Must match sim. real-time ctr in test data */
+#else                        /* Else, LONG variables */
+typedef n_long varsize;      /* Data and variables are 32 bits */
+#define MAX_VARIABLE 0x7FFF  /* Must match sim. real-time ctr in test data */
+#endif /* DATA_SIZE */
+
+#define RAM_OUT 0   /* Define (=1)to direct debug text to RAM file */
+                    /* or( =0 )to direct debug text to console */
+
+/*******************************************************************************
+    Defines                                                                     
+*******************************************************************************/
+
+#define false           0
+#define true            !false
+
+#if (BMDEBUG && RAM_OUT == 1)	/* Debug buffer size == 32K */ 
+#define MAX_FILESIZE    8192    /* Maximum size of output file */
+#else
+#define MAX_FILESIZE    256     /* Maximum size of output file */
+#endif 
+#define NUM_TESTS       500     /* Number of sets of input test data stimuli */
+#define VAR_COUNT       1       /* Number of variables which must be allocated */
+#define HEADER_SIZE     100     /* Approx size of text title and header messages */
+
+#define CYLINDERS       8       /* We're simulating an eight cylinder engine */
+#define TENTH_DEGREES   3600    /* Number of 1/10-degrees in a circle */
+
+/* Cylinder #1 firing angle (*10) */
+#define FIRE1_ANGLE (TENTH_DEGREES/CYLINDERS*1)
+/* Cylinder #2 firing angle (*10) */
+#define FIRE2_ANGLE (TENTH_DEGREES/CYLINDERS*2)
+/* Cylinder #3 firing angle (*10) */
+#define FIRE3_ANGLE (TENTH_DEGREES/CYLINDERS*3)   
+/* Cylinder #4 firing angle (*10) */
+#define FIRE4_ANGLE (TENTH_DEGREES/CYLINDERS*4)  
+/* Cylinder #5 firing angle (*10) */
+#define FIRE5_ANGLE (TENTH_DEGREES/CYLINDERS*5)   
+/* Cylinder #6 firing angle (*10) */
+#define FIRE6_ANGLE (TENTH_DEGREES/CYLINDERS*6)   
+/* Cylinder #7 firing angle (*10) */
+#define FIRE7_ANGLE (TENTH_DEGREES/CYLINDERS*7)   
+/* Cylinder #8 firing angle (*10) */
+#define FIRE8_ANGLE (TENTH_DEGREES/CYLINDERS*8)   
+
+#define CYL1            1       /* Cylinder #1 firing window */
+#define CYL2            2       /* Cylinder #2 firing window */
+#define CYL3            3       /* Cylinder #3 firing window */
+#define CYL4            4       /* Cylinder #4 firing window */
+#define CYL5            5       /* Cylinder #5 firing window */
+#define CYL6            6       /* Cylinder #6 firing window */
+#define CYL7            7       /* Cylinder #7 firing window */
+#define CYL8            8       /* Cylinder #8 firing window */
+
+#define TDC_TEETH       2       /* Number of missing teeth (=1) at TDC */
+#define TDC_MARGIN      0.9     /* Discrimination window for TDC teeth */
+#define NUM_TEETH       60      /* Number of teeth on tonewheel */
+
+/* Arbitrary scale factor for computing internal RPM */
+#define RPM_SCALE_FACTOR        3600000 
+
+/*******************************************************************************
+    Global Variables                                                            
+*******************************************************************************/
+
+#ifndef ALGO_GLOBALS            /* Don't define these twice! */
+
+extern n_int   tableCount ;     /* Number of passes through table */
+extern varsize angleCounter ;   /* Current 'angleCounter' pulled from  data */
+extern varsize *inpAngleCount ; /* Array of 'angleCounter' test data values */
+extern varsize tonewheelTeeth ; /* Number of teeth on the tonewheel */
+/*extern n_int isTopDeadCenter ;  * TRUE/FALSE flag when TDC occurs */
+
+#endif /* ALGO_GLOBALS */       
+
+/*******************************************************************************
+    Function Prototypes                                                         
+*******************************************************************************/
+
+n_int  GetTestData( n_void ) ;
+n_int  GetInputValues( n_void ) ;
+n_void DebugOut( n_char * ) ;
+n_void WriteOut( varsize ) ;
+
+#endif /* __ALGO_H */

=== added file 'automotive/a2time01/algotst.c'
--- automotive/a2time01/algotst.c	1970-01-01 00:00:00 +0000
+++ automotive/a2time01/algotst.c	2013-10-07 11:04:13 +0000
@@ -0,0 +1,1140 @@
+/*==============================================================================
+ *$RCSfile: algotst.c,v $
+ *
+ *   DESC : Angle-to-Time Conversion - a2time00
+ *
+ * AUTHOR : dt
+ *
+ *  EEMBC : Automotive Subcommittee 
+ *
+ *    CVS : $Revision: 1.3 $
+ *          $Date: 2002/04/19 18:31:37 $
+ *          $Author: rick $
+ *          $Source: d:/cvs/eembc2/automotive/a2time01/algotst.c,v $
+ *          
+ * NOTE   :
+ *
+ *------------------------------------------------------------------------------
+ *
+ * HISTORY :
+ *
+ * $Log: algotst.c,v $
+ * Revision 1.3  2002/04/19 18:31:37  rick
+ * Bug #146: global tablecount uninitialized
+ *
+ *
+ *------------------------------------------------------------------------------
+ * Copyright (c) 1998-2002 by the EDN Embedded Microprocessor 
+ * Benchmark Consortium (EEMBC), Inc. 
+ * 
+ * All Rights Reserved. This is licensed program product and 
+ * is owned by EEMBC. The Licensee understands and agrees that the 
+ * Benchmarks licensed by EEMBC hereunder (including methods or concepts 
+ * utilized therein) contain certain information that is confidential 
+ * and proprietary which the Licensee expressly agrees to retain in the 
+ * strictest confidence and to use only in conjunction with the Benchmarks 
+ * pursuant to the terms of this Agreement. The Licensee further agrees 
+ * to keep the source code and all related documentation confidential and 
+ * not to disclose such source code and/or related documentation to any 
+ * third party. The Licensee and any READER of this code is subject to 
+ * either the EEMBC Member License Agreement and/or the EEMBC Licensee 
+ * Agreement. 
+ * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, EEMBC DISCLAIMS ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
+ * PURPOSE, WITH REGARD TO THE BENCHMARKS AND THE ACCOMPANYING 
+ * DOCUMENTATION. LICENSEE ACKNOWLEDGES AND AGREES THAT THERE ARE NO 
+ * WARRANTIES, GUARANTIES, CONDITIONS, COVENANTS, OR REPRESENTATIONS BY 
+ * EEMBC AS TO MARKETABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR OTHER 
+ * ATTRIBUTES, WHETHER EXPRESS OR IMPLIED (IN LAW OR IN FACT), ORAL OR 
+ * WRITTEN. 
+ * 
+ * Licensee hereby agrees by accessing this source code that all benchmark 
+ * scores related to this code must be certified by ECL prior to publication 
+ * in any media, form, distribution, or other means of conveyance of 
+ * information subject to the terms of the EEMBC Member License Agreement 
+ * and/or EEMBC Licensee Agreement. 
+ * 
+ * Other Copyright Notice (if any): 
+ * 
+ * For conditions of distribution and use, see the accompanying README file.
+ * ===========================================================================*/
+
+/*******************************************************************************
+    Includes                                                                    
+*******************************************************************************/
+
+#include "algo.h"
+
+/*  DECLARATIONS  */    
+
+/*
+ * The following test data represents values read from a realtime clock
+ * which is captured( in hardware )on each rising edge of the ring-gear
+ * tooth.  The counter is expected to roll over at maximum count, and
+ * it is presumed to be an "up" counter.
+ *
+ */    
+
+const varsize inpAngleROM[] = 
+{        
+    123, 
+
+    456, 
+
+    796, 
+
+    1143, 
+
+    1497, 
+
+    1858, 
+
+    2226, 
+
+    2601, 
+
+    3358, 
+
+    3743, 
+
+    4136, 
+
+    4535, 
+
+    4942, 
+
+    5355, 
+
+    5776, 
+
+    6203, 
+
+    6638, 
+
+    7079, 
+
+    7528, 
+
+    7983, 
+
+    8446, 
+
+    8915, 
+
+    9392, 
+
+    9875, 
+
+    10366, 
+
+    10863, 
+
+    11368, 
+
+    11879, 
+
+    12398, 
+
+    12923, 
+
+    13456, 
+
+    13995, 
+
+    14542, 
+
+    15095, 
+
+    15656, 
+
+    16223, 
+
+    16798, 
+
+    17379, 
+
+    17968, 
+
+    18563, 
+
+    19166, 
+
+    19775, 
+
+    20392, 
+
+    21015, 
+
+    21646, 
+
+    22283, 
+
+    22928, 
+
+    23579, 
+
+    24238, 
+
+    24903, 
+
+    25576, 
+
+    26255, 
+
+    26942, 
+
+    27635, 
+
+    28336, 
+
+    29043, 
+
+    29758, 
+
+    30479, 
+
+    31208, 
+
+    31943, 
+
+    32686, 
+
+    668, 
+
+    1425, 
+
+    2189, 
+
+    2960, 
+
+    3738, 
+
+    4523, 
+
+    5315, 
+
+    6906, 
+
+    7708, 
+
+    8518, 
+
+    9334, 
+
+    10158, 
+
+    10988, 
+
+    11826, 
+
+    12670, 
+
+    13522, 
+
+    14380, 
+
+    15246, 
+
+    16118, 
+
+    16998, 
+
+    17884, 
+
+    18778, 
+
+    19678, 
+
+    20586, 
+
+    21500, 
+
+    22422, 
+
+    23350, 
+
+    24286, 
+
+    25228, 
+
+    26178, 
+
+    27134, 
+
+    28098, 
+
+    29068, 
+
+    30046, 
+
+    31030, 
+
+    32022, 
+
+    250, 
+
+    1253, 
+
+    2263, 
+
+    3280, 
+
+    4304, 
+
+    5335, 
+
+    6373, 
+
+    7418, 
+
+    8470, 
+
+    9529, 
+
+    10595, 
+
+    11668, 
+
+    12748, 
+
+    13835, 
+
+    14929, 
+
+    16030, 
+
+    17138, 
+
+    18253, 
+
+    19375, 
+
+    20504, 
+
+    21640, 
+
+    22783, 
+
+    23933, 
+
+    25090, 
+
+    26254, 
+
+    27425, 
+
+    28603, 
+
+    29788, 
+
+    30980, 
+
+    32179, 
+
+    620, 
+
+    3045, 
+
+    4264, 
+
+    5491, 
+
+    6724, 
+
+    7965, 
+
+    9212, 
+
+    10467, 
+
+    11728, 
+
+    12997, 
+
+    14272, 
+
+    15555, 
+
+    16844, 
+
+    18141, 
+
+    19444, 
+
+    20755, 
+
+    22072, 
+
+    23397, 
+
+    24728, 
+
+    26067, 
+
+    27412, 
+
+    28765, 
+
+    30124, 
+
+    31491, 
+
+    100, 
+
+    1484, 
+
+    2875, 
+
+    4273, 
+
+    5678, 
+
+    7090, 
+
+    8509, 
+
+    9935, 
+
+    11368, 
+
+    12808, 
+
+    14255, 
+
+    15709, 
+
+    17170, 
+
+    18638, 
+
+    20113, 
+
+    21595, 
+
+    23084, 
+
+    24580, 
+
+    26083, 
+
+    27593, 
+
+    29110, 
+
+    30634, 
+
+    32165, 
+
+    930, 
+
+    2470, 
+
+    4017, 
+
+    5571, 
+
+    7132, 
+
+    8700, 
+
+    10275, 
+
+    11857, 
+
+    13446, 
+
+    15042, 
+
+    16645, 
+
+    18255, 
+
+    19872, 
+
+    21496, 
+
+    24751, 
+
+    26385, 
+
+    28027, 
+
+    29675, 
+
+    31331, 
+
+    230, 
+
+    1904, 
+
+    3585, 
+
+    5273, 
+
+    6968, 
+
+    8670, 
+
+    10379, 
+
+    12095, 
+
+    13818, 
+
+    15548, 
+
+    17285, 
+
+    19029, 
+
+    20780, 
+
+    22538, 
+
+    24303, 
+
+    26075, 
+
+    27854, 
+
+    29640, 
+
+    31433, 
+
+    460, 
+
+    2262, 
+
+    4071, 
+
+    5887, 
+
+    7710, 
+
+    9540, 
+
+    11377, 
+
+    13221, 
+
+    15072, 
+
+    16930, 
+
+    18795, 
+
+    20667, 
+
+    22546, 
+
+    24432, 
+
+    26325, 
+
+    28225, 
+
+    30132, 
+
+    32046, 
+
+    1200, 
+
+    3129, 
+
+    5065, 
+
+    7008, 
+
+    8958, 
+
+    10915, 
+
+    12879, 
+
+    14850, 
+
+    16828, 
+
+    18813, 
+
+    20805, 
+
+    22804, 
+
+    24810, 
+
+    26823, 
+
+    28843, 
+
+    30870, 
+
+    130, 
+
+    2165, 
+
+    6242, 
+
+    8287, 
+
+    10340, 
+
+    12399, 
+
+    14466, 
+
+    16539, 
+
+    18620, 
+
+    20707, 
+
+    22802, 
+
+    24903, 
+
+    27012, 
+
+    29127, 
+
+    31250, 
+
+    610, 
+
+    2745, 
+
+    4887, 
+
+    7036, 
+
+    9192, 
+
+    11355, 
+
+    13525, 
+
+    15702, 
+
+    17886, 
+
+    20077, 
+
+    22275, 
+
+    24480, 
+
+    26692, 
+
+    28911, 
+
+    31137, 
+
+    600, 
+
+    2838, 
+
+    5083, 
+
+    7335, 
+
+    9594, 
+
+    11860, 
+
+    14133, 
+
+    16413, 
+
+    18700, 
+
+    20994, 
+
+    23295, 
+
+    25603, 
+
+    27918, 
+
+    30240, 
+
+    32569, 
+
+    2140, 
+
+    4486, 
+
+    6812, 
+
+    9118, 
+
+    11404, 
+
+    13670, 
+
+    15916, 
+
+    18142, 
+
+    20348, 
+
+    22534, 
+
+    24700, 
+
+    26846, 
+
+    28972, 
+
+    31078, 
+
+    430, 
+
+    2530, 
+
+    4610, 
+
+    8777, 
+
+    10867, 
+
+    12938, 
+
+    14988, 
+
+    17019, 
+
+    19029, 
+
+    21020, 
+
+    22990, 
+
+    24941, 
+
+    26871, 
+
+    28782, 
+
+    30672, 
+
+    32543, 
+
+    1650, 
+
+    3505, 
+
+    5340, 
+
+    7155, 
+
+    8950, 
+
+    10725, 
+
+    12480, 
+
+    14215, 
+
+    15930, 
+
+    17625, 
+
+    19300, 
+
+    20955, 
+
+    22590, 
+
+    24205, 
+
+    25800, 
+
+    27375, 
+
+    28930, 
+
+    30465, 
+
+    31980, 
+
+    720, 
+
+    2208, 
+
+    3676, 
+
+    5124, 
+
+    6552, 
+
+    7960, 
+
+    9371, 
+
+    10785, 
+
+    12202, 
+
+    13622, 
+
+    15045, 
+
+    16471, 
+
+    17900, 
+
+    19332, 
+
+    20767, 
+
+    22205, 
+
+    23646, 
+
+    25090, 
+
+    26537, 
+
+    27987, 
+
+    29440, 
+
+    30896, 
+
+    32355, 
+
+    1050, 
+
+    2516, 
+
+    3985, 
+
+    5457, 
+
+    6932, 
+
+    9889, 
+
+    11374, 
+
+    12863, 
+
+    14354, 
+
+    15849, 
+
+    17346, 
+
+    18847, 
+
+    20350, 
+
+    21857, 
+
+    23366, 
+
+    24879, 
+
+    26394, 
+
+    27913, 
+
+    29434, 
+
+    30959, 
+
+    32486, 
+
+    1250, 
+
+    2784, 
+
+    4322, 
+
+    5862, 
+
+    7406, 
+
+    8952, 
+
+    10502, 
+
+    12054, 
+
+    13610, 
+
+    15168, 
+
+    16730, 
+
+    18294, 
+
+    19862, 
+
+    21432, 
+
+    23006, 
+
+    24582, 
+
+    26162, 
+
+    27744, 
+
+    29330, 
+
+    30918, 
+
+    32510, 
+
+    1340, 
+
+    2941, 
+
+    4545, 
+
+    6152, 
+
+    7762, 
+
+    9375, 
+
+    10991, 
+
+    12610, 
+
+    14232, 
+
+    15857, 
+
+    17485, 
+
+    19116, 
+
+    20750, 
+
+    22387, 
+
+    24027, 
+
+    25670, 
+
+    27316, 
+
+    28965, 
+
+    30617, 
+
+    32272, 
+
+    1160, 
+
+    2819, 
+
+    4481, 
+
+    7812, 
+
+    9484, 
+
+    11160, 
+
+    12838, 
+
+    14520, 
+
+    16204, 
+
+    17892, 
+
+    19582, 
+
+    21276, 
+
+    22972, 
+
+    24672, 
+
+    26374, 
+
+    28080, 
+
+    29788, 
+
+    31500, 
+
+    450, 
+
+    2171, 
+
+    3895, 
+
+    5622, 
+
+    7352, 
+
+    9085, 
+
+    10821, 
+
+    12560, 
+
+    14302, 
+
+    16047, 
+
+    17795, 
+
+    19546, 
+
+    21300, 
+
+    23057, 
+
+    24817, 
+
+    26580, 
+
+    28346, 
+
+    30115, 
+
+    31887, 
+
+    900, 
+
+    2684, 
+
+    4471, 
+
+    6261, 
+
+    8054, 
+
+    9850, 
+
+    11649, 
+
+    13451, 
+
+    15256, 
+
+    17064, 
+
+    18875, 
+
+    20689, 
+
+    22503, 
+
+    24317, 
+
+    26131, 
+
+    27945, 
+
+    29759, 
+
+    31573, 
+
+    620, 
+
+    2435, 
+
+    4250, 
+
+    6065, 
+
+    7880, 
+
+    9695, 
+
+    11510, 
+
+    13325, 
+
+    16962, 
+
+    18787, 
+
+    20613, 
+
+    22438, 
+
+    24264, 
+
+    26089, 
+
+    27915, 
+
+    29740, 
+
+    31566, 
+
+    620, 
+
+    2442, 
+
+    4264
+
+} ; /* End of test values :  inpAngleROM[] */
+
+/*******************************************************************************
+    Functions                                                                   
+*******************************************************************************/
+
+/*
+*  Function :  GetTestData
+*
+*    Builds the table of input data which represents 'angle' input 
+*    from the mag input on the ring gear.  This is the "real world" data stream which
+*    drives the algorithm.  This data is installed in RAM prior to execution of the
+*    algorithm.
+*
+*/    
+n_int 
+GetTestData( n_void )
+{        
+    n_int i ; 
+
+    tonewheelTeeth = NUM_TEETH ; 
+    inpAngleCount = (varsize *)th_malloc( ( NUM_TESTS + 1 ) * sizeof(varsize) ) ; 
+
+    if( inpAngleCount == NULL )
+    {
+        return false ; 
+    }
+
+    /* Copy the test values from ROM to RAM  */    
+    for( i = 0 ; i < NUM_TESTS ; i++ )
+    {
+        inpAngleCount[i] = inpAngleROM[i] ; 
+    }
+
+    return true ; 
+} /* End of function 'GetTestData' */
+
+/*
+*  Function :  GetInputValues
+*
+*    On each pass of the table lookup, a value must be input for 'angleCount.
+*    Each time this function is called, the next input value is
+*    pulled from the table in RAM.  The table wraps around, so that input data is
+*    continuous.     A flag is returned TRUE whenever the table wraps around.
+*
+*/    
+
+n_int 
+GetInputValues( n_void )
+{        
+    angleCounter = inpAngleCount[tableCount] ; 
+
+    if( ++tableCount < NUM_TESTS )
+    {
+        return false ; 
+    }
+
+    tableCount = 0 ; 
+    return true ; 
+} /* End of function 'GetInputValues' */

=== added file 'automotive/a2time01/bmark.c'
--- automotive/a2time01/bmark.c	1970-01-01 00:00:00 +0000
+++ automotive/a2time01/bmark.c	2013-10-07 11:04:13 +0000
@@ -0,0 +1,1076 @@
+/*==============================================================================
+ *$RCSfile: bmark.c,v $
+ *
+ *   DESC : This file contains the Test Main and other TH support functions
+ *
+ * AUTHOR : ARM, Ltd., ECL, LLP
+ *
+ *  EEMBC : Automotive Subcommittee 
+ *
+ *    CVS : $Revision: 1.7 $
+ *          $Date: 2002/08/07 22:20:25 $
+ *          $Author: rick $
+ *          $Source: d:/cvs/eembc2/automotive/a2time01/bmark.c,v $
+ *          
+ * NOTE   :
+ *
+ *------------------------------------------------------------------------------
+ *
+ * HISTORY :
+ *
+ * $Log: bmark.c,v $
+ * Revision 1.7  2002/08/07 22:20:25  rick
+ * Add NI CRC to TH Regular
+ *
+ * Revision 1.6  2002/07/22 16:09:49  rick
+ * Fix iteration dependant NI CRC
+ *
+ * Revision 1.5  2002/05/29 22:24:45  rick
+ * Set recommended iterations with make
+ *
+ * Revision 1.4  2002/04/25 20:10:43  rick
+ * sprintf to th_sprintf
+ *
+ * Revision 1.3  2002/04/19 18:31:37  rick
+ * Bug #146: global tablecount uninitialized
+ *
+ * Revision 1.2  2002/03/08 00:58:51  rick
+ * Repair Iterations and CRC ifdef logic
+ *
+ * Revision 1.4  2002/02/25 17:15:31  rick
+ * Add comment blocks, fix atime th_report call.
+ *
+ *
+ *------------------------------------------------------------------------------
+ * Copyright (c) 1998-2002 by the EDN Embedded Microprocessor 
+ * Benchmark Consortium (EEMBC), Inc. 
+ * 
+ * All Rights Reserved. This is licensed program product and 
+ * is owned by EEMBC. The Licensee understands and agrees that the 
+ * Benchmarks licensed by EEMBC hereunder (including methods or concepts 
+ * utilized therein) contain certain information that is confidential 
+ * and proprietary which the Licensee expressly agrees to retain in the 
+ * strictest confidence and to use only in conjunction with the Benchmarks 
+ * pursuant to the terms of this Agreement. The Licensee further agrees 
+ * to keep the source code and all related documentation confidential and 
+ * not to disclose such source code and/or related documentation to any 
+ * third party. The Licensee and any READER of this code is subject to 
+ * either the EEMBC Member License Agreement and/or the EEMBC Licensee 
+ * Agreement. 
+ * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, EEMBC DISCLAIMS ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
+ * PURPOSE, WITH REGARD TO THE BENCHMARKS AND THE ACCOMPANYING 
+ * DOCUMENTATION. LICENSEE ACKNOWLEDGES AND AGREES THAT THERE ARE NO 
+ * WARRANTIES, GUARANTIES, CONDITIONS, COVENANTS, OR REPRESENTATIONS BY 
+ * EEMBC AS TO MARKETABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR OTHER 
+ * ATTRIBUTES, WHETHER EXPRESS OR IMPLIED (IN LAW OR IN FACT), ORAL OR 
+ * WRITTEN. 
+ * 
+ * Licensee hereby agrees by accessing this source code that all benchmark 
+ * scores related to this code must be certified by ECL prior to publication 
+ * in any media, form, distribution, or other means of conveyance of 
+ * information subject to the terms of the EEMBC Member License Agreement 
+ * and/or EEMBC Licensee Agreement. 
+ * 
+ * Other Copyright Notice (if any): 
+ * 
+ * For conditions of distribution and use, see the accompanying README file.
+ * ===========================================================================*/
+
+#define ALGO_GLOBALS    1   /* Next time, we'll skip these */
+#include "algo.h"
+
+/* Estimate of allocation for NUM_TESTS*( debug test + 2 variables )*/
+#define T_BSIZE (MAX_FILESIZE+((NUM_TESTS+1)*VAR_COUNT*4))
+
+int t_run_test( size_t iterations, int argc, const char *argv[] ) ; 
+int test_main( struct TCDef **tcdef, int argc, const char *argv[] ) ; 
+
+/* Define iterations */
+#if !defined(ITERATIONS) || CRC_CHECK || ITERATIONS==DEFAULT
+#undef ITERATIONS
+#if CRC_CHECK
+#define ITERATIONS 50000	/* required iterations for crc */
+#else
+#define ITERATIONS 50000	/* recommended iterations for benchmark */
+#endif
+#endif
+
+/* Pre-caclculated CRC values */
+#if	CRC_CHECK
+#define EXPECTED_CRC 0x0000
+#elif NON_INTRUSIVE_CRC_CHECK
+#define EXPECTED_CRC 0xc74a
+#else
+#define EXPECTED_CRC 0x0000
+#endif
+
+static TCDef the_tcdef = 
+{        
+    "AUT a2time01   ",
+    EEMBC_MEMBER_COMPANY, 
+    EEMBC_PROCESSOR, 
+    EEMBC_TARGET, 
+    "Algorithm #2 -- Angle-To-Time Conversion V1.0E0 - a2time00", 
+    TCDEF_REVISION, 
+    NULL,   /* Pointer to the next TCDef */
+    /* TH Version Number Required */
+    { EEMBC_TH_MAJOR, EEMBC_TH_MINOR, EEMBC_TH_STEP, EEMBC_TH_REVISION }, 
+    /* Target Hardware Version Number Required( make all zeros to ignore ) */ 
+    { 0, 0, 0, 0 }, 
+    /* The Version number of this Benchmark */
+    { 1, 0, 'E', 0 }, 
+    ITERATIONS,
+    &t_run_test, 
+    &test_main, 
+    NULL,   /* There is no main funciton in this implimentation */
+    NULL    /* There is no entry function in this implimentation */
+} ; 
+
+n_int   *RAMfile ;          /* Pointer to test output RAM file */
+n_int   *RAMfilePtr ;       /* Pointer to position in output RAM file */
+n_int   RAMfileSize ;       /* Size of the debug output RAM file */
+n_int   tableCount;        /* Number of passes through table */
+n_int   *RAMfileEOF;        /* points to end of RAM file */
+n_int   RAMfile_increment;  /* difference between varsize and n_int */
+
+varsize angleCounter ;      /* Current 'angleCounter' pulled from test data */
+varsize *inpAngleCount ;    /* Array of 'angleCounter' test data values */
+varsize tonewheelTeeth ;    /* Number of teeth on the tonewheel */
+
+/* >> IMPORTANT NOTE << 
+*
+* Since benchmarks can be entered( run )multiple times, the benchmark
+* MUST NOT depend on global data being initialized.  E.g. it must
+* complelty initialize itself EVERY TIME its t_run_test()function
+* is called.
+* 
+*/    
+
+/*
+* FUNC   : t_run_test
+*
+* DESC   : called to run the test
+*
+*          This function is called to start the test.  It does not return
+*          until after the test is completed( finished ).  Note, th_finished()
+*          and th_report_results()MUST be called before this function
+*          returns if results are to be report.  If these are not called
+*          then no results will be reported for the test.
+*         
+* NOTE   : after this function returns, no other functions in the test
+*          will be called.  EG, returning from this function is equivelent
+*          to returning from a main()or calling th_exit()
+*
+* RETURNS : Success if the test ran fine.  If th_finished()and
+*          th_report_results()were not called, then the test finished
+*          successfully, but there were no results and the host will
+*          not be able to measure the test's duration.
+*/    
+
+int
+t_run_test( size_t iterations, int argc, const char *argv[] )
+{        
+    size_t loop_cnt ; 
+    THTestResults results ; 
+
+#if BMDEBUG
+    char *szTitle = 
+        "\nEEMBC Automotive/Industrial Subcommittee Benchmarks ( c )1998-1999\n"
+        "Algorithm 2 : Angle-to-Time Conversion  Rev. 1.0E0 a2time00 \n" ; 
+    char *szHeader = 
+        "\n\n   angle  pulse          tdc   engine "
+        "tooth  delta        fire   test\n"
+        "   Count, DeltaT, TDC,   Time, Speed, "
+        "Count, TimeAvg,     Time   counter\n" ; 
+    char szDebug[100] ; 
+#else
+    varsize i ;
+#endif /* BMDEBUG */
+
+    static n_char szDataSize[40] ; 
+    n_int isTableLooped = false ;    /* Input test data table looped */
+    varsize window ; 
+    static varsize pulseDeltaTime1 ;
+    static varsize pulseDeltaTime2 ;
+    static varsize pulseDeltaTime3 ;
+    static varsize angle1 ;
+    static varsize angle2 ;
+    static varsize angle3 ; 
+    static varsize angleCounterLast1 ;
+    static varsize angleCounterLast2 ;
+    static varsize angleCounterLast3 ; 
+    static varsize toothCount1 ;
+    static varsize toothCount2 ;
+    static varsize toothCount3 ; 
+    static varsize deltaTimeAccum1 ;
+    static varsize deltaTimeAccum2 ;
+    static varsize deltaTimeAccum3 ; 
+    static varsize deltaTimeAvg1 ;
+    static varsize deltaTimeAvg2 ;
+    static varsize deltaTimeAvg3 ; 
+    static varsize firingTime1 ;
+    static varsize firingTime2 ;
+    static varsize firingTime3 ; 
+    static n_ulong tdcTime1 ;
+    static n_ulong tdcTime2 ;
+    static n_ulong tdcTime3 ; 
+    static n_ulong engineSpeed1 ;
+    static n_ulong engineSpeed2 ;
+    static n_ulong engineSpeed3 ; 
+    static n_ulong rotationTime1 ;
+    static n_ulong rotationTime2 ;
+    static n_ulong rotationTime3 ; 
+    static n_int isTopDeadCenter1 ; /* TRUE/FALSE flag when TDC occurs */
+    static n_int isTopDeadCenter2 ; /* TRUE/FALSE flag when TDC occurs */
+    static n_int isTopDeadCenter3 ; /* TRUE/FALSE flag when TDC occurs */
+
+    /* Unused */
+    argc = argc ;
+    argv = argv ;
+    
+    /*
+     * First, initialize the data structures we need for the test
+     * and allocate memory as needed.  Report an error if we can't.
+     *
+     */    
+
+    /* Variable initializations at t=0 */    
+    toothCount1 = 0 ;       /* Don't know which pulse we start on */
+    toothCount2 = 0 ; 
+    toothCount3 = 0 ; 
+    deltaTimeAccum1 = 0 ;   /* ...and haven't accumulated for filter... */
+    deltaTimeAccum2 = 0 ; 
+    deltaTimeAccum3 = 0 ; 
+    deltaTimeAvg1 = 32767 ; /* ...and not gotten an average... */
+    deltaTimeAvg2 = 32767 ; 
+    deltaTimeAvg3 = 32767 ; 
+    tdcTime1 = 0 ;          /* ...and don't know when TDC occurs */
+    tdcTime2 = 0 ; 
+    tdcTime3 = 0 ; 
+    angleCounterLast1 = 0 ; 
+    angleCounterLast2 = 0 ; 
+    angleCounterLast3 = 0 ; 
+    engineSpeed1 = 0 ; 
+    engineSpeed2 = 0 ; 
+    engineSpeed3 = 0 ; 
+    rotationTime1 = 0 ; 
+    rotationTime2 = 0 ; 
+    rotationTime3 = 0 ; 
+    firingTime1 = 0 ; 
+    firingTime2 = 0 ; 
+    firingTime3 = 0 ; 
+/* ALGO_GLOBALS */
+    tableCount		= 0;
+	angleCounter	= 0;   /* Current 'angleCounter' pulled from  data */
+	inpAngleCount	= NULL; /* Array of 'angleCounter' test data values */
+	tonewheelTeeth	= 0; /* Number of teeth on the tonewheel */
+
+    /* Set size of output file (1K) */    
+    RAMfileSize = MAX_FILESIZE ;
+
+    /* Allocate some RAM for output file */   
+	RAMfile         = (n_int *)th_malloc( RAMfileSize * sizeof(n_int) + sizeof (varsize) ) ;
+    if ( RAMfile == NULL )
+          th_exit( THE_OUT_OF_MEMORY, "Cannot Allocate Memory %s:%d", __FILE__,__LINE__ );
+ 
+	/* align it to varsize boundary */ 
+	RAMfile       = ((n_int *)ROUNDUP(RAMfile, sizeof (varsize) ));
+    RAMfilePtr    = RAMfile; /* Point to beginning of test output file */
+    RAMfileEOF    = RAMfile + RAMfileSize;  /* should be OK ANSI C */
+
+    if (sizeof(varsize) > sizeof(n_int)) {    /* this is a floating point benchmark! */
+        RAMfile_increment = sizeof(varsize) / sizeof(n_int);
+        if (sizeof(varsize) % sizeof(n_int)) RAMfile_increment += 1;  /* should never happen, but ... */
+    }
+    else{
+        RAMfile_increment = 1;
+    }
+  
+    /* Tell us the compiled data size */    
+#if BMDEBUG
+    th_sprintf( szDataSize, "Data size = %s\n\n", 
+        ( DATA_SIZE ? "LONG" : "SHORT" ) ) ; 
+#else
+    szDataSize[0] = (n_char)( '0' + DATA_SIZE ) ; 
+    szDataSize[1] = '\0' ; 
+#endif /* BMDEBUG */
+
+    /* Initialize the test data -- stimuli for the algorithm. */    
+    /* Allocate for the test input data table */
+    if( !GetTestData() ) 
+    {
+        th_exit( THE_OUT_OF_MEMORY, "Cannot Allocate Memory %s : %d", 
+            __FILE__, __LINE__ ) ; 
+    }
+
+    th_signal_start() ;    /* Tell the host that the test has begun */
+
+#if BMDEBUG
+    DebugOut( szTitle ) ;    /* Print the title message in RAM file */
+    DebugOut( szDataSize ) ; /*  and the data size */
+    DebugOut( szHeader ) ;   /* Print the test output file header in RAM file */
+#endif     /* BMDEBUG */
+
+    window = TENTH_DEGREES / tonewheelTeeth ; /* Only need to do this once */
+
+    /* This is the actual benchmark algorithm. */    
+
+    for( loop_cnt = 0 ; loop_cnt < iterations ; loop_cnt++ ) /* no stopping! */
+    {
+
+#if BMDEBUG
+        if( isTableLooped )
+        {
+            DebugOut( "END--END--END\n" ) ;    /* Flag end-of-testfile */
+        }
+#endif /* BMDEBUG */
+
+        /***********************************************************************
+            First Pass                                                          
+        ***********************************************************************/
+
+        /* Gets 'angleCounter' value from test data*/
+        isTableLooped = GetInputValues() ;
+
+#if BMDEBUG
+        th_sprintf( szDebug, "%8ld", (n_long)angleCounter ) ;
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute 'pulseDeltaTime' -- the difference in counter 
+         * readings from the last pulse to the current one.  Note that
+         * the realtime counter may roll over, so the elapsed time may
+         * need to be corrected when this occurs.
+         *
+         */    
+        if( angleCounterLast1 > angleCounter ) 
+        {
+            pulseDeltaTime1 = angleCounter + 
+                ( (varsize)MAX_VARIABLE - angleCounterLast1 + 1 ) ; 
+        }
+        else
+        {
+            pulseDeltaTime1 = angleCounter - angleCounterLast1 ; 
+        }
+
+        /* Update timer history... */
+        angleCounterLast1 = angleCounter ;
+        /* ...and elapsed time for a revolution */
+        rotationTime1 += pulseDeltaTime1 ; 
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4ld", (n_long)pulseDeltaTime1 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Must detect TDC reference by noticing that the period between this
+         * pulse and the last one is two or three times normal.  We'll set a
+         * flag when TDC reference occurs, and clear it on all other pulses.
+         * We also keep count of which pulse we're on relative to TDC reference.
+         *
+         */    
+
+        if( pulseDeltaTime1 > ( TDC_TEETH *deltaTimeAvg1 *TDC_MARGIN ) )
+        {
+            isTopDeadCenter1 = true ; 
+            pulseDeltaTime1 /= TDC_TEETH ; 
+    
+            /*
+             * Compute engine speed every TDC.  Engine speed will be
+             * the inverse of 'tdcTime', which is the period( in CPU
+             * time )between TDC's.  Engine speed is also scaled by
+             * an arbitrary constant to make it useful elsewhere in
+             * the engine controller.
+             *
+             */    
+            tdcTime1 = rotationTime1 ; 
+            rotationTime1 = 0 ; 
+            engineSpeed1 = RPM_SCALE_FACTOR / tdcTime1 ; 
+            toothCount1 = 0 ; 
+        }
+        else 
+        {
+            toothCount1++ ; 
+            isTopDeadCenter1 = false ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4d, %8ld, %5ld, %4ld", ( isTopDeadCenter1 & 1 ),
+            (n_long)tdcTime1, (n_long)engineSpeed1, (n_long)toothCount1 ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)engineSpeed1 ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute an average delta-T for TDC pulse discrimination.
+         * The delta-T will be filtered by averaging over the period
+         * of one cylinder( several pulses ).
+         *
+         */    
+
+        deltaTimeAccum1 += pulseDeltaTime1 ; 
+        if( ( toothCount1 > 0 ) && 
+            ( toothCount1 %( tonewheelTeeth / CYLINDERS ) == 0 ) )
+        {        
+            deltaTimeAvg1 = deltaTimeAccum1 / ( tonewheelTeeth / CYLINDERS ) ; 
+            deltaTimeAccum1 = 0 ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %6ld, ", (n_long)deltaTimeAvg1 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        angle1 = ( TENTH_DEGREES * toothCount1 / tonewheelTeeth ) ; 
+
+        /*
+         * Now, output a value for the firing angle timer( a one-shot )
+         * only if we're on the tooth which precedes the firing
+         * angle for one of the cylinders.  We presume that there is
+         * always a tooth which precedes each cylinder's firing angle.
+         * The value which is output presumably goes to a "capture/compare"
+         * timer which generates an interrupt used to fire that cylinder.
+         * Note the special treatment for the last cylinder( #4, #6, or #8 ), 
+         * we don't subtract the 'angle' because the 360th degree of rotation
+         * is the same as the 0th degree of the next rotation.
+         *
+         */    
+
+        /* CYLINDER 1 */    
+        if( ( angle1 >= ( ( CYL1 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL1 * TENTH_DEGREES / CYLINDERS ) ) )
+        {
+            firingTime1 = 
+                ( ( FIRE1_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 2 */    
+        if( ( angle1 >= ( ( CYL2 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL2 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE2_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 3 */    
+        if( ( angle1 >= ( ( CYL3 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL3 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE3_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 4 */    
+        if( ( angle1 >= ( ( CYL4 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL4 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE4_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 4 )
+
+        /* CYLINDER 5 */    
+        if( ( angle1 >= ( ( CYL5 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL5 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE5_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 6 */    
+        if( ( angle1 >= ( ( CYL6 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL6 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE6_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 6 )
+
+        /* CYLINDER 7 */    
+        if( ( angle1 >= ( ( CYL7 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL7 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE7_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 8 */    
+        if( ( angle1 >= ( ( CYL8 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL8 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE8_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#endif /* 6 cylinders */
+#endif /* 4 cylinders */
+
+        if( firingTime1 > MAX_VARIABLE )
+        {
+            firingTime1 -= MAX_VARIABLE ; 
+        }
+
+        /* Output the 'firingTime result */    
+
+#if BMDEBUG
+        th_sprintf( szDebug, " %10ld\n", (n_long)firingTime1 ) ; 
+        DebugOut( szDebug ) ; 
+#else      
+        WriteOut( (varsize)firingTime1 ) ; 
+#endif /* BMDEBUG */
+
+        /***********************************************************************
+            Second Pass                                                         
+        ***********************************************************************/
+        /* Gets 'angleCounter' value from test data*/
+        isTableLooped += GetInputValues() ;
+
+#if BMDEBUG
+        /* Output some debug info, if needed */
+        th_sprintf( szDebug, "%8ld", (n_long)angleCounter ) ;
+        DebugOut( szDebug ) ; 
+#endif     /* BMDEBUG */
+
+
+        /*
+         * Compute 'pulseDeltaTime' -- the difference in counter 
+         * readings from the last pulse to the current one.  Note that
+         * the realtime counter may roll over, so the elapsed time may
+         * need to be corrected when this occurs.
+         *
+         */    
+
+        if( angleCounterLast2 > angleCounter )
+        {
+            pulseDeltaTime2 = angleCounter +
+                ( (varsize)MAX_VARIABLE - angleCounterLast2 + 2 ) ; 
+        }
+        else
+        {
+            pulseDeltaTime2 = angleCounter - angleCounterLast2 ; 
+        }
+
+        /* Update timer history... */
+        angleCounterLast2 = angleCounter ;    
+        /* ...and elapsed time for a revolution */
+        rotationTime2 += pulseDeltaTime2 ;    
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4ld", (n_long)pulseDeltaTime2 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Must detect TDC reference by noticing that the period between this
+         * pulse and the last one is two or three times normal.  We'll set a
+         * flag when TDC reference occurs, and clear it on all other pulses.
+         * We also keep count of which pulse we're on relative to TDC reference.
+         *
+         */    
+
+        if( pulseDeltaTime2 > ( TDC_TEETH * deltaTimeAvg2 * TDC_MARGIN ) )
+        {        
+            isTopDeadCenter2 = true ; 
+            pulseDeltaTime2 /= TDC_TEETH ; 
+
+            /*
+             * Compute engine speed every TDC.  Engine speed will be
+             * the inverse of 'tdcTime', which is the period( in CPU
+             * time )between TDC's.  Engine speed is also scaled by
+             * an arbitrary constant to make it useful elsewhere in
+             * the engine controller.
+             *
+             */    
+
+
+            tdcTime2 = rotationTime2 ; 
+            rotationTime2 = 0 ; 
+            engineSpeed2 = RPM_SCALE_FACTOR / tdcTime2 ; 
+            toothCount2 = 0 ; 
+        }
+        else {        
+            toothCount2++ ; 
+            isTopDeadCenter2 = false ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4d, %8ld, %5ld, %4ld", ( isTopDeadCenter2 & 1 ),
+            (n_long)tdcTime2, (n_long)engineSpeed2, (n_long)toothCount2 ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)engineSpeed2 ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute an average delta-T for TDC pulse discrimination.
+         * The delta-T will be filtered by averaging over the period
+         * of one cylinder( several pulses ).
+         *
+         */    
+        deltaTimeAccum2 += pulseDeltaTime2 ; 
+
+        if( ( toothCount2 > 0 ) && 
+            ( toothCount2 % ( tonewheelTeeth / CYLINDERS ) == 0 ) )
+        {        
+            deltaTimeAvg2 = deltaTimeAccum2 / ( tonewheelTeeth / CYLINDERS ) ; 
+            deltaTimeAccum2 = 0 ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %6ld, ", (n_long)deltaTimeAvg2 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        angle2 = ( TENTH_DEGREES * toothCount2 / tonewheelTeeth ) ; 
+
+        /*
+         * Now, output a value for the firing angle timer( a one-shot )
+         * only if we're on the tooth which precedes the firing
+         * angle for one of the cylinders.  We presume that there is
+         * always a tooth which precedes each cylinder's firing angle.
+         * The value which is output presumably goes to a "capture/compare"
+         * timer which generates an interrupt used to fire that cylinder.
+         * Note the special treatment for the last cylinder( #4, #6, or #8 ), 
+         * we don't subtract the 'angle' because the 360th degree of rotation
+         * is the same as the 0th degree of the next rotation.
+         *
+         */    
+
+        /* CYLINDER 1 */    
+        if( ( angle2 >= ( ( CYL1 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle2 < ( CYL1 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE1_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 2 */    
+        if( ( angle2 >= ( ( CYL2 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL2 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE2_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 3 */    
+        if( ( angle2 >= ( ( CYL3 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL3 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE3_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 4 */    
+        if( ( angle2 >= ( ( CYL4 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL4 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE4_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 4 )
+
+        /* CYLINDER 5 */    
+        if( ( angle2 >= ( ( CYL5 * TENTH_DEGREES / CYLINDERS )- window ) ) &&
+            ( angle2 < ( CYL5 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE5_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 6 */    
+        if( ( angle2 >= ( ( CYL6 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL6 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE6_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 6 )
+
+        /* CYLINDER 7 */    
+        if( ( angle2 >= ( ( CYL7 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL7 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE7_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 8 */    
+        if( ( angle2 >= ( ( CYL8 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL8 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE8_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+#endif /* 6 cylinders */
+#endif /* 4 cylinders */
+
+        if( firingTime2 > MAX_VARIABLE )
+        {
+            firingTime2 -= MAX_VARIABLE ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, " %10ld\n", (n_long)firingTime2 ) ; 
+        DebugOut( szDebug ) ; 
+#else 
+        WriteOut( (varsize)firingTime2 ) ; 
+#endif /* BMDEBUG */
+
+        /***********************************************************************
+            Third Pass                                                          
+        ***********************************************************************/
+        /* Gets 'angleCounter' value from test data*/
+        isTableLooped += GetInputValues() ;
+
+#if BMDEBUG
+        th_sprintf( szDebug, "%8ld", (n_long)angleCounter ) ;
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute 'pulseDeltaTime' -- the difference in counter 
+         * readings from the last pulse to the current one.  Note that
+         * the realtime counter may roll over, so the elapsed time may
+         * need to be corrected when this occurs.
+         *
+         */    
+
+        if( angleCounterLast3 > angleCounter )
+        {
+            pulseDeltaTime3 = angleCounter +
+                ( (varsize)MAX_VARIABLE - angleCounterLast3 + 3 ) ; 
+        }
+        else
+        {
+            pulseDeltaTime3 = angleCounter - angleCounterLast3 ; 
+        }
+        /* Update timer history */
+        angleCounterLast3 = angleCounter ;    
+        /* and elapsed time for a revolution */
+        rotationTime3 += pulseDeltaTime3 ;    
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4ld", (n_long)pulseDeltaTime3 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Must detect TDC reference by noticing that the period between this
+         * pulse and the last one is two or three times normal.  We'll set a
+         * flag when TDC reference occurs, and clear it on all other pulses.
+         * We also keep count of which pulse we're on relative to TDC reference.
+         *
+         */    
+
+        if( pulseDeltaTime3 > ( TDC_TEETH * deltaTimeAvg3 * TDC_MARGIN ) )
+        {        
+            isTopDeadCenter3 = true ; 
+            pulseDeltaTime3 /= TDC_TEETH ; 
+
+            /*
+             * Compute engine speed every TDC.  Engine speed will be
+             * the inverse of 'tdcTime', which is the period( in CPU
+             * time )between TDC's.  Engine speed is also scaled by
+             * an arbitrary constant to make it useful elsewhere in
+             * the engine controller.
+             *
+             */    
+
+            tdcTime3 = rotationTime3 ; 
+            rotationTime3 = 0 ; 
+            engineSpeed3 = RPM_SCALE_FACTOR / tdcTime3 ; 
+            toothCount3 = 0 ; 
+        }
+        else 
+        {        
+            toothCount3++ ; 
+            isTopDeadCenter3 = false ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4d, %8ld, %5ld, %4ld", ( isTopDeadCenter3 & 1 ),
+            (n_long)tdcTime3, (n_long)engineSpeed3, (n_long)toothCount3 ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)engineSpeed3 ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute an average delta-T for TDC pulse discrimination.
+         * The delta-T will be filtered by averaging over the period
+         * of one cylinder( several pulses ).
+         *
+         */    
+
+        deltaTimeAccum3 += pulseDeltaTime3 ; 
+
+        if( ( toothCount3 > 0 ) && 
+            ( toothCount3 % ( tonewheelTeeth / CYLINDERS ) == 0 ) )
+        {        
+            deltaTimeAvg3 = deltaTimeAccum3 / ( tonewheelTeeth / CYLINDERS ) ; 
+            deltaTimeAccum3 = 0 ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %6ld, ", (n_long)deltaTimeAvg3 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        angle3 = ( TENTH_DEGREES * toothCount3 / tonewheelTeeth ) ; 
+
+        /*
+         * Now, output a value for the firing angle timer( a one-shot )
+         * only if we're on the tooth which precedes the firing
+         * angle for one of the cylinders.  We presume that there is
+         * always a tooth which precedes each cylinder's firing angle.
+         * The value which is output presumably goes to a "capture/compare"
+         * timer which generates an interrupt used to fire that cylinder.
+         * Note the special treatment for the last cylinder( #4, #6, or #8 ), 
+         * we don't subtract the 'angle' because the 360th degree of rotation
+         * is the same as the 0th degree of the next rotation.
+         *
+         */    
+
+        /* CYLINDER 1 */    
+        if( ( angle3 >= ( ( CYL1 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL1 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE1_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 2 */    
+        if( ( angle3 >= ( ( CYL2 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL2 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE2_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 3 */    
+        if( ( angle3 >= ( ( CYL3 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 <( CYL3 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE3_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 4 */    
+        if( ( angle3 >= ( ( CYL4 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL4 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE4_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 4 )
+
+        /* CYLINDER 5 */    
+        if( ( angle3 >= ( ( CYL5 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL5 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE5_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 6 */    
+        if( ( angle3 >= ( ( CYL6 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL6 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE6_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 6 )
+
+        /* CYLINDER 7 */    
+        if( ( angle3 >= ( ( CYL7 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL7 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE7_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 8 */    
+        if( ( angle3 >= ( ( CYL8 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 <( CYL8 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE8_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES  )+ 
+                angleCounter ; 
+        }
+
+#endif /* 6 cylinders */
+#endif /* 4 cylinders */
+
+        if( firingTime3 > MAX_VARIABLE )
+        {
+            firingTime3 -= MAX_VARIABLE ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, " %10ld", (n_long)firingTime3 ) ; 
+        DebugOut( szDebug ) ; 
+        th_sprintf( szDebug, ", %08lX\n", ( n_ulong )loop_cnt ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)firingTime3 ) ; 
+
+#if DATA_SIZE == 0 /* Might break up the loop counter */
+        i = (varsize)( loop_cnt &0x0000FFFF ) ; 
+        WriteOut( i ) ; /*  ...in the output file */
+        i = (varsize)( loop_cnt >> 16 ) ; 
+        WriteOut( i ) ; 
+#else
+        WriteOut( (varsize)loop_cnt ) ; 
+#endif
+        i = (varsize)0xAAAA ; 
+        WriteOut( i ) ; /* Flag the end of data-block */
+#endif /* BMDEBUG */
+
+#if BMDEBUG
+        if( !th_harness_poll() )
+        {
+            break ; 
+        }
+#endif
+    }
+
+    /* Signal that we are finished */
+    results.duration = th_signal_finished() ;    
+
+    results.iterations = loop_cnt ; 
+    results.v1 = 0 ; 
+    results.v2 = 0 ; 
+    results.v3 = 0 ; 
+    results.v4 = 0 ; 
+    results.info = szDataSize ; 
+
+#if NON_INTRUSIVE_CRC_CHECK
+	results.CRC=0;
+/* varsize is n_short or n_long, calc crc based on e_u32 */
+/* final answers are iteration dependant */
+	results.CRC = Calc_crc32((e_u32)*inpAngleCount,results.CRC ) ; 
+	results.CRC = Calc_crc32((e_u32)tonewheelTeeth,results.CRC ) ; 
+#elif	CRC_CHECK
+	results.CRC=0;
+#else
+	results.CRC=0;
+#endif
+
+    return th_report_results( &results,EXPECTED_CRC);
+
+} /* End of function 't_run_test' */
+
+/*
+ * FUNC   : test_main
+ *
+ * DESC   : the test( or bench mark )main entry point
+ *
+ * RETURNS : Any error value defined in th_error.h
+ */    
+
+int
+test_main( struct TCDef **tcdef, int argc, const char *argv[] )
+{        
+    /* Unused */
+    argc = argc ;
+    argv = argv ;
+    
+    /* Point the test harness at our test defintion struction */    
+    *tcdef = &the_tcdef ; 
+
+    /* Now do any other low level, or basic initialization here */    
+    return Success ; 
+}
+
+/*
+*    Function :  DebugOut
+*
+*    Outputs test data for debug purposes.  Can direct output to console
+*    in PC application.  Builds a test data image in RAM for embedded use.
+*    In either case, the output is text.  Re-use the same RAMfile as for
+*    WriteOut().
+*
+*/    
+
+#if BMDEBUG
+
+n_void 
+DebugOut( n_char *szSrc )
+{        
+#if RAM_OUT == 1
+    n_int i ;
+    n_int length ; 
+
+    /* Make sure we don't overwrite the end of the RAM file */    
+    length = (n_int)strlen( szSrc ) ; 
+
+    for( i = 0 ; i < length ; i++ )
+    {        
+        *RAMfilePtr++ = szSrc[i] ; 
+
+        if ( RAMfilePtr >= RAMfileEOF )
+            RAMfilePtr = RAMfile;
+    }
+#else
+    th_printf( szSrc ) ; 
+#endif /* RAM_OUT */
+
+} /* End of function 'DebugOut' */
+
+#endif /* BMDEBUG */
+
+/*
+*    Function :  WriteOut
+*
+*    Outputs results to the RAM file so that it can be downloaded to host for
+*  verification.  Also serves to defeat optimization which would remove the
+*  code used to develop the results when not in DEBUG mode.
+*
+*/    
+
+n_void
+WriteOut( varsize value )
+{
+if (( RAMfilePtr+RAMfile_increment) > RAMfileEOF )
+    RAMfilePtr = RAMfile;
+
+    *(varsize *)RAMfilePtr = value;
+     RAMfilePtr += RAMfile_increment; /* this might need to be casted back to (n_int *) ??*/
+
+} /* End of function 'WriteOut' */
+

=== added file 'automotive/a2time01/bmark_lite.c'
--- automotive/a2time01/bmark_lite.c	1970-01-01 00:00:00 +0000
+++ automotive/a2time01/bmark_lite.c	2013-10-07 11:04:13 +0000
@@ -0,0 +1,1073 @@
+/*==============================================================================
+ *$RCSfile: bmark_lite.c,v $
+ *
+ *   DESC : This file contains the Test Main and other TH support functions
+ *
+ * AUTHOR : ARM, Ltd., ECL, LLC
+ *
+ *  EEMBC : Automotive/Industrial Subcommittee 
+ *
+ *    CVS : $Revision: 1.18 $
+ *          $Date: 2002/08/07 22:20:25 $
+ *          $Author: rick $
+ *          $Source: d:/cvs/eembc2/automotive/a2time01/bmark_lite.c,v $
+ *          
+ * NOTE   :
+ *
+ *------------------------------------------------------------------------------
+ *
+ * HISTORY :
+ *
+ * $Log: bmark_lite.c,v $
+ * Revision 1.18  2002/08/07 22:20:25  rick
+ * Add NI CRC to TH Regular
+ *
+ * Revision 1.17  2002/07/22 21:58:53  rick
+ * General cleanup Beta 2b
+ *
+ * Revision 1.16  2002/07/22 16:09:49  rick
+ * Fix iteration dependant NI CRC
+ *
+ * Revision 1.15  2002/07/18 23:33:45  rick
+ * Fix iteration dependencies in NI CRC
+ *
+ * Revision 1.14  2002/07/11 22:13:26  rick
+ * Initialize tcdef results
+ *
+ * Revision 1.13  2002/07/10 19:00:42  rick
+ * Always initialize tcdef->CRC
+ *
+ * Revision 1.12  2002/05/29 22:24:46  rick
+ * Set recommended iterations with make
+ *
+ * Revision 1.11  2002/05/10 23:57:44  rick
+ * Fix missing shifts in 16, and 32 bit CRC calculations
+ *
+ * Revision 1.10  2002/05/10 17:20:36  rick
+ * Add al_main to API
+ *
+ * Revision 1.9  2002/04/25 20:10:43  rick
+ * sprintf to th_sprintf
+ *
+ * Revision 1.8  2002/04/19 18:31:37  rick
+ * Bug #146: global tablecount uninitialized
+ *
+ * Revision 1.7  2002/03/12 18:31:04  rick
+ * ITERATIONS, CRC_CHECK, NON_INTRUSIVE_CRC_CHECK, add standards headers
+ *
+ * Revision 1.6  2002/03/11 22:11:47  rick
+ * ITERATIONS, CRC_CHECK, NON_INTRUSIVE TCDef Usage
+ *
+ * Revision 1.5  2002/03/08 00:58:51  rick
+ * Repair Iterations and CRC ifdef logic
+ *
+ * Revision 1.4  2002/02/25 17:15:31  rick
+ * Add comment blocks, fix atime th_report call.
+ *
+ *
+ *------------------------------------------------------------------------------
+ * Copyright (c) 1998-2002 by the EDN Embedded Microprocessor 
+ * Benchmark Consortium (EEMBC), Inc. 
+ * 
+ * All Rights Reserved. This is licensed program product and 
+ * is owned by EEMBC. The Licensee understands and agrees that the 
+ * Benchmarks licensed by EEMBC hereunder (including methods or concepts 
+ * utilized therein) contain certain information that is confidential 
+ * and proprietary which the Licensee expressly agrees to retain in the 
+ * strictest confidence and to use only in conjunction with the Benchmarks 
+ * pursuant to the terms of this Agreement. The Licensee further agrees 
+ * to keep the source code and all related documentation confidential and 
+ * not to disclose such source code and/or related documentation to any 
+ * third party. The Licensee and any READER of this code is subject to 
+ * either the EEMBC Member License Agreement and/or the EEMBC Licensee 
+ * Agreement. 
+ * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, EEMBC DISCLAIMS ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
+ * PURPOSE, WITH REGARD TO THE BENCHMARKS AND THE ACCOMPANYING 
+ * DOCUMENTATION. LICENSEE ACKNOWLEDGES AND AGREES THAT THERE ARE NO 
+ * WARRANTIES, GUARANTIES, CONDITIONS, COVENANTS, OR REPRESENTATIONS BY 
+ * EEMBC AS TO MARKETABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR OTHER 
+ * ATTRIBUTES, WHETHER EXPRESS OR IMPLIED (IN LAW OR IN FACT), ORAL OR 
+ * WRITTEN. 
+ * 
+ * Licensee hereby agrees by accessing this source code that all benchmark 
+ * scores related to this code must be certified by ECL prior to publication 
+ * in any media, form, distribution, or other means of conveyance of 
+ * information subject to the terms of the EEMBC Member License Agreement 
+ * and/or EEMBC Licensee Agreement. 
+ * 
+ * Other Copyright Notice (if any): 
+ * 
+ * For conditions of distribution and use, see the accompanying README file.
+ * ===========================================================================*/
+
+/*******************************************************************************
+    Includes                                                                    
+*******************************************************************************/
+#define ALGO_GLOBALS    1   /* Next time, we'll skip these */
+#include "algo.h"
+
+/* Estimate of allocation for NUM_TESTS*( debug test + 2 variables )*/
+#define T_BSIZE (MAX_FILESIZE+((NUM_TESTS+1)*VAR_COUNT*4))
+
+
+/* ======================================================================== */
+/*         F U N C T I O N   P R O T O T Y P E S                            */
+/* ======================================================================== */
+int main(int argc, const char* argv[] );
+int t_run_test(struct TCDef *tcdef, int argc, const char* argv[]);
+
+/* Define iterations */
+#if !defined(ITERATIONS) || CRC_CHECK || ITERATIONS==DEFAULT
+#undef ITERATIONS
+#if CRC_CHECK
+#define ITERATIONS 50000	/* required iterations for crc */
+#else
+#define ITERATIONS 50000	/* recommended iterations for benchmark */
+#endif
+#endif
+
+/* Pre-caclculated CRC values */
+#if	CRC_CHECK
+#define EXPECTED_CRC 0x0000
+#elif NON_INTRUSIVE_CRC_CHECK
+#define EXPECTED_CRC 0xc74a
+#else
+#define EXPECTED_CRC 0x0000
+#endif
+
+TCDef the_tcdef = 
+{
+    "AUT a2time01   ",
+    EEMBC_MEMBER_COMPANY, 
+    EEMBC_PROCESSOR, 
+    EEMBC_TARGET, 
+    "Algorithm #2 -- Angle-To-Time Conversion V1.0E0 - a2time00",
+    TCDEF_REVISION, 
+    { EEMBC_TH_MAJOR, EEMBC_TH_MINOR, EEMBC_TH_STEP, EEMBC_TH_REVISION }, 
+    { 0, 0, 0, 0 },   /* Target Hardware Version Number Required( make all zeros to ignore )*/
+    { 1, 0, 'C', 0 }, /* The Version number of this Benchmark */
+	ITERATIONS,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0,
+	0
+} ; 
+
+/*  DECLARATIONS */    
+n_int   *RAMfile ;          /* Pointer to test output RAM file */
+n_int   *RAMfilePtr ;       /* Pointer to position in output RAM file */
+n_int   RAMfileSize ;       /* Size of the debug output RAM file */
+n_int   tableCount ;        /* Number of passes through table */
+n_int   *RAMfileEOF;        /* points to end of RAM file */
+n_int   RAMfile_increment;  /* difference between varsize and n_int */
+
+varsize angleCounter ;      /* Current 'angleCounter' pulled from test data */
+varsize *inpAngleCount ;    /* Array of 'angleCounter' test data values */
+varsize tonewheelTeeth ;    /* Number of teeth on the tonewheel */
+
+
+/*********************************************************************************
+* FUNC	: int t_run_test( struct TCDef *tcdef,int argc, const char *argv[] )
+* DESC  : This is the functions that carries out the algorithm. This function
+*         is called from the main.  Same algorithm is called three times. Input
+*         data for the algorithm is stored in 'algotst'c'.  All variables declared
+*         and initialized in 'init.c'.  When 'BMDEBUG' and 'WINDOWS_EXAMPLE_CODE' 
+*         defined in 'thcfg.h' it will write bunch of debug message in the RAM.  
+*         All debug routines are in 'debug.c'. It calculates CRC using intermediate
+*         values from the algorithms.  CRC is used to check if algorithm carried out
+*         correctly.
+* ARGUMENT: arc - not used
+*           argv - not used
+*           tcdef - structure defined in 'thlib.h'.  Following members of tcdef
+*     			rec_iterations- recommend number of times algorithm should be carried out
+*   			iterations  - actual number of times algorithm was carried
+*                             most cases same as 'rec_iterations'
+*               duration	- Total time to carry out the algorithm
+*               CRC			- calculated CRC
+*
+* RETURNS : Success if the the CRC matches. 
+*****************************************************************************************/    
+int t_run_test( struct TCDef *tcdef,int argc, const char *argv[] )
+{    
+    size_t		loop_cnt = tcdef->rec_iterations;
+
+
+#if BMDEBUG
+    char *szTitle = 
+        "\nEEMBC Automotive/Industrial Subcommittee Benchmarks ( c )1998-1999\n"
+        "Algorithm 2 : Angle-to-Time Conversion  Rev. 1.0E0 a2time00 \n" ; 
+    char *szHeader = 
+        "\n\n   angle  pulse          tdc   engine "
+        "tooth  delta        fire   test\n"
+        "   Count, DeltaT, TDC,   Time, Speed, "
+        "Count, TimeAvg,     Time   counter\n" ; 
+    char szDebug[100] ; 
+#else
+    varsize i ;
+#endif /* BMDEBUG */
+
+    static n_char szDataSize[40] ; 
+    n_int isTableLooped = false ;    /* Input test data table looped */
+    varsize window ; 
+    static varsize pulseDeltaTime1 ;
+    static varsize pulseDeltaTime2 ;
+    static varsize pulseDeltaTime3 ;
+    static varsize angle1 ;
+    static varsize angle2 ;
+    static varsize angle3 ; 
+    static varsize angleCounterLast1 ;
+    static varsize angleCounterLast2 ;
+    static varsize angleCounterLast3 ; 
+    static varsize toothCount1 ;
+    static varsize toothCount2 ;
+    static varsize toothCount3 ; 
+    static varsize deltaTimeAccum1 ;
+    static varsize deltaTimeAccum2 ;
+    static varsize deltaTimeAccum3 ; 
+    static varsize deltaTimeAvg1 ;
+    static varsize deltaTimeAvg2 ;
+    static varsize deltaTimeAvg3 ; 
+    static varsize firingTime1 ;
+    static varsize firingTime2 ;
+    static varsize firingTime3 ; 
+    static n_ulong tdcTime1 ;
+    static n_ulong tdcTime2 ;
+    static n_ulong tdcTime3 ; 
+    static n_ulong engineSpeed1 ;
+    static n_ulong engineSpeed2 ;
+    static n_ulong engineSpeed3 ; 
+    static n_ulong rotationTime1 ;
+    static n_ulong rotationTime2 ;
+    static n_ulong rotationTime3 ; 
+    static n_int isTopDeadCenter1 ; /* TRUE/FALSE flag when TDC occurs */
+    static n_int isTopDeadCenter2 ; /* TRUE/FALSE flag when TDC occurs */
+    static n_int isTopDeadCenter3 ; /* TRUE/FALSE flag when TDC occurs */
+
+    /* Unused */
+    argc = argc ;
+    argv = argv ;
+    
+    /*
+     * First, initialize the data structures we need for the test
+     * and allocate memory as needed.  Report an error if we can't.
+     *
+     */    
+
+    /* Variable initializations at t=0 */    
+    toothCount1 = 0 ;       /* Don't know which pulse we start on */
+    toothCount2 = 0 ; 
+    toothCount3 = 0 ; 
+    deltaTimeAccum1 = 0 ;   /* ...and haven't accumulated for filter... */
+    deltaTimeAccum2 = 0 ; 
+    deltaTimeAccum3 = 0 ; 
+    deltaTimeAvg1 = 32767 ; /* ...and not gotten an average... */
+    deltaTimeAvg2 = 32767 ; 
+    deltaTimeAvg3 = 32767 ; 
+    tdcTime1 = 0 ;          /* ...and don't know when TDC occurs */
+    tdcTime2 = 0 ; 
+    tdcTime3 = 0 ; 
+    angleCounterLast1 = 0 ; 
+    angleCounterLast2 = 0 ; 
+    angleCounterLast3 = 0 ; 
+    engineSpeed1 = 0 ; 
+    engineSpeed2 = 0 ; 
+    engineSpeed3 = 0 ; 
+    rotationTime1 = 0 ; 
+    rotationTime2 = 0 ; 
+    rotationTime3 = 0 ; 
+    firingTime1 = 0 ; 
+    firingTime2 = 0 ; 
+    firingTime3 = 0 ; 
+/* ALGO_GLOBALS */
+    tableCount		= 0;
+	angleCounter	= 0;   /* Current 'angleCounter' pulled from  data */
+	inpAngleCount	= NULL; /* Array of 'angleCounter' test data values */
+	tonewheelTeeth	= 0; /* Number of teeth on the tonewheel */
+
+    /* Set size of output file (1K) */    
+    RAMfileSize = MAX_FILESIZE ;
+
+    /* Allocate some RAM for output file */   
+	RAMfile         = (n_int *)th_malloc( RAMfileSize * sizeof(n_int) + sizeof (varsize) ) ;
+    if ( RAMfile == NULL )
+          th_exit( THE_OUT_OF_MEMORY, "Cannot Allocate Memory %s:%d", __FILE__,__LINE__ );
+ 
+	/* align it to varsize boundary */ 
+	RAMfile       = ((n_int *)ROUNDUP(RAMfile, sizeof (varsize) ));
+    RAMfilePtr    = RAMfile; /* Point to beginning of test output file */
+    RAMfileEOF    = RAMfile + RAMfileSize;  /* should be OK ANSI C */
+
+    if (sizeof(varsize) > sizeof(n_int)) {    /* this is a floating point benchmark! */
+        RAMfile_increment = sizeof(varsize) / sizeof(n_int);
+        if (sizeof(varsize) % sizeof(n_int)) RAMfile_increment += 1;  /* should never happen, but ... */
+    }
+    else{
+        RAMfile_increment = 1;
+    }
+  
+    /* Tell us the compiled data size */    
+#if BMDEBUG
+    th_sprintf( szDataSize, "Data size = %s\n\n", 
+        ( DATA_SIZE ? "LONG" : "SHORT" ) ) ; 
+#else
+    szDataSize[0] = (n_char)( '0' + DATA_SIZE ) ; 
+    szDataSize[1] = '\0' ; 
+#endif /* BMDEBUG */
+
+    /* Initialize the test data -- stimuli for the algorithm. */    
+    /* Allocate for the test input data table */
+    if( !GetTestData() ) 
+    {
+        th_exit( THE_OUT_OF_MEMORY, "Cannot Allocate Memory %s : %d", 
+            __FILE__, __LINE__ ) ; 
+    }
+
+    th_signal_start() ;    /* Tell the host that the test has begun */
+
+#if BMDEBUG
+    DebugOut( szTitle ) ;    /* Print the title message in RAM file */
+    DebugOut( szDataSize ) ; /*  and the data size */
+    DebugOut( szHeader ) ;   /* Print the test output file header in RAM file */
+#endif     /* BMDEBUG */
+
+    window = TENTH_DEGREES / tonewheelTeeth ; /* Only need to do this once */
+
+    /* This is the actual benchmark algorithm. */    
+
+    for( loop_cnt = 0 ; loop_cnt < tcdef->rec_iterations ; loop_cnt++ ) /* no stopping! */
+    {
+
+#if BMDEBUG
+        if( isTableLooped )
+        {
+            DebugOut( "END--END--END\n" ) ;    /* Flag end-of-testfile */
+        }
+#endif /* BMDEBUG */
+
+        /***********************************************************************
+            First Pass                                                          
+        ***********************************************************************/
+
+        /* Gets 'angleCounter' value from test data */
+        isTableLooped = GetInputValues() ;
+
+#if BMDEBUG
+        th_sprintf( szDebug, "%8ld", (n_long)angleCounter ) ;
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute 'pulseDeltaTime' -- the difference in counter 
+         * readings from the last pulse to the current one.  Note that
+         * the realtime counter may roll over, so the elapsed time may
+         * need to be corrected when this occurs.
+         *
+         */    
+        if( angleCounterLast1 > angleCounter ) 
+        {
+            pulseDeltaTime1 = angleCounter + 
+                ( (varsize)MAX_VARIABLE - angleCounterLast1 + 1 ) ; 
+        }
+        else
+        {
+            pulseDeltaTime1 = angleCounter - angleCounterLast1 ; 
+        }
+
+        /* Update timer history... */
+        angleCounterLast1 = angleCounter ;
+        /* ...and elapsed time for a revolution */
+        rotationTime1 += pulseDeltaTime1 ; 
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4ld", (n_long)pulseDeltaTime1 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Must detect TDC reference by noticing that the period between this
+         * pulse and the last one is two or three times normal.  We'll set a
+         * flag when TDC reference occurs, and clear it on all other pulses.
+         * We also keep count of which pulse we're on relative to TDC reference.
+         *
+         */    
+
+        if( pulseDeltaTime1 > ( TDC_TEETH *deltaTimeAvg1 *TDC_MARGIN ) )
+        {
+            isTopDeadCenter1 = true ; 
+            pulseDeltaTime1 /= TDC_TEETH ; 
+    
+            /*
+             * Compute engine speed every TDC.  Engine speed will be
+             * the inverse of 'tdcTime', which is the period( in CPU
+             * time )between TDC's.  Engine speed is also scaled by
+             * an arbitrary constant to make it useful elsewhere in
+             * the engine controller.
+             *
+             */    
+            tdcTime1 = rotationTime1 ; 
+            rotationTime1 = 0 ; 
+            engineSpeed1 = RPM_SCALE_FACTOR / tdcTime1 ; 
+            toothCount1 = 0 ; 
+        }
+        else 
+        {
+            toothCount1++ ; 
+            isTopDeadCenter1 = false ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4d, %8ld, %5ld, %4ld", ( isTopDeadCenter1 & 1 ),
+            (n_long)tdcTime1, (n_long)engineSpeed1, (n_long)toothCount1 ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)engineSpeed1 ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute an average delta-T for TDC pulse discrimination.
+         * The delta-T will be filtered by averaging over the period
+         * of one cylinder( several pulses ).
+         *
+         */    
+
+        deltaTimeAccum1 += pulseDeltaTime1 ; 
+        if( ( toothCount1 > 0 ) && 
+            ( toothCount1 %( tonewheelTeeth / CYLINDERS ) == 0 ) )
+        {        
+            deltaTimeAvg1 = deltaTimeAccum1 / ( tonewheelTeeth / CYLINDERS ) ; 
+            deltaTimeAccum1 = 0 ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %6ld, ", (n_long)deltaTimeAvg1 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        angle1 = ( TENTH_DEGREES * toothCount1 / tonewheelTeeth ) ; 
+
+        /*
+         * Now, output a value for the firing angle timer( a one-shot )
+         * only if we're on the tooth which precedes the firing
+         * angle for one of the cylinders.  We presume that there is
+         * always a tooth which precedes each cylinder's firing angle.
+         * The value which is output presumably goes to a "capture/compare"
+         * timer which generates an interrupt used to fire that cylinder.
+         * Note the special treatment for the last cylinder( #4, #6, or #8 ), 
+         * we don't subtract the 'angle' because the 360th degree of rotation
+         * is the same as the 0th degree of the next rotation.
+         *
+         */    
+
+        /* CYLINDER 1 */    
+        if( ( angle1 >= ( ( CYL1 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL1 * TENTH_DEGREES / CYLINDERS ) ) )
+        {
+            firingTime1 = 
+                ( ( FIRE1_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 2 */    
+        if( ( angle1 >= ( ( CYL2 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL2 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE2_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 3 */    
+        if( ( angle1 >= ( ( CYL3 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL3 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE3_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 4 */    
+        if( ( angle1 >= ( ( CYL4 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle1 < ( CYL4 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE4_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 4 )
+
+        /* CYLINDER 5 */    
+        if( ( angle1 >= ( ( CYL5 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL5 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE5_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 6 */    
+        if( ( angle1 >= ( ( CYL6 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL6 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE6_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 6 )
+
+        /* CYLINDER 7 */    
+        if( ( angle1 >= ( ( CYL7 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL7 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE7_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 8 */    
+        if( ( angle1 >= ( ( CYL8 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle1 < ( CYL8 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime1 = 
+                ( ( FIRE8_ANGLE - angle1 ) * tdcTime1 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#endif /* 6 cylinders */
+#endif /* 4 cylinders */
+
+        if( firingTime1 > MAX_VARIABLE )
+        {
+            firingTime1 -= MAX_VARIABLE ; 
+        }
+
+        /* Output the 'firingTime result */    
+
+#if BMDEBUG
+        th_sprintf( szDebug, " %10ld\n", (n_long)firingTime1 ) ; 
+        DebugOut( szDebug ) ; 
+#else      
+        WriteOut( (varsize)firingTime1 ) ; 
+#endif /* BMDEBUG */
+
+        /***********************************************************************
+            Second Pass                                                         
+        ***********************************************************************/
+        /* Gets 'angleCounter' value from test data*/
+        isTableLooped += GetInputValues() ;
+
+#if BMDEBUG
+        /* Output some debug info, if needed */
+        th_sprintf( szDebug, "%8ld", (n_long)angleCounter ) ;
+        DebugOut( szDebug ) ; 
+#endif     /* BMDEBUG */
+
+
+        /*
+         * Compute 'pulseDeltaTime' -- the difference in counter 
+         * readings from the last pulse to the current one.  Note that
+         * the realtime counter may roll over, so the elapsed time may
+         * need to be corrected when this occurs.
+         *
+         */    
+
+        if( angleCounterLast2 > angleCounter )
+        {
+            pulseDeltaTime2 = angleCounter +
+                ( (varsize)MAX_VARIABLE - angleCounterLast2 + 2 ) ; 
+        }
+        else
+        {
+            pulseDeltaTime2 = angleCounter - angleCounterLast2 ; 
+        }
+
+        /* Update timer history... */
+        angleCounterLast2 = angleCounter ;    
+        /* ...and elapsed time for a revolution */
+        rotationTime2 += pulseDeltaTime2 ;    
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4ld", (n_long)pulseDeltaTime2 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Must detect TDC reference by noticing that the period between this
+         * pulse and the last one is two or three times normal.  We'll set a
+         * flag when TDC reference occurs, and clear it on all other pulses.
+         * We also keep count of which pulse we're on relative to TDC reference.
+         *
+         */    
+
+        if( pulseDeltaTime2 > ( TDC_TEETH * deltaTimeAvg2 * TDC_MARGIN ) )
+        {        
+            isTopDeadCenter2 = true ; 
+            pulseDeltaTime2 /= TDC_TEETH ; 
+
+            /*
+             * Compute engine speed every TDC.  Engine speed will be
+             * the inverse of 'tdcTime', which is the period( in CPU
+             * time )between TDC's.  Engine speed is also scaled by
+             * an arbitrary constant to make it useful elsewhere in
+             * the engine controller.
+             *
+             */    
+
+
+            tdcTime2 = rotationTime2 ; 
+            rotationTime2 = 0 ; 
+            engineSpeed2 = RPM_SCALE_FACTOR / tdcTime2 ; 
+            toothCount2 = 0 ; 
+        }
+        else {        
+            toothCount2++ ; 
+            isTopDeadCenter2 = false ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4d, %8ld, %5ld, %4ld", ( isTopDeadCenter2 & 1 ),
+            (n_long)tdcTime2, (n_long)engineSpeed2, (n_long)toothCount2 ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)engineSpeed2 ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute an average delta-T for TDC pulse discrimination.
+         * The delta-T will be filtered by averaging over the period
+         * of one cylinder( several pulses ).
+         *
+         */    
+        deltaTimeAccum2 += pulseDeltaTime2 ; 
+
+        if( ( toothCount2 > 0 ) && 
+            ( toothCount2 % ( tonewheelTeeth / CYLINDERS ) == 0 ) )
+        {        
+            deltaTimeAvg2 = deltaTimeAccum2 / ( tonewheelTeeth / CYLINDERS ) ; 
+            deltaTimeAccum2 = 0 ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %6ld, ", (n_long)deltaTimeAvg2 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        angle2 = ( TENTH_DEGREES * toothCount2 / tonewheelTeeth ) ; 
+
+        /*
+         * Now, output a value for the firing angle timer( a one-shot )
+         * only if we're on the tooth which precedes the firing
+         * angle for one of the cylinders.  We presume that there is
+         * always a tooth which precedes each cylinder's firing angle.
+         * The value which is output presumably goes to a "capture/compare"
+         * timer which generates an interrupt used to fire that cylinder.
+         * Note the special treatment for the last cylinder( #4, #6, or #8 ), 
+         * we don't subtract the 'angle' because the 360th degree of rotation
+         * is the same as the 0th degree of the next rotation.
+         *
+         */    
+
+        /* CYLINDER 1 */    
+        if( ( angle2 >= ( ( CYL1 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle2 < ( CYL1 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE1_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 2 */    
+        if( ( angle2 >= ( ( CYL2 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL2 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE2_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 3 */    
+        if( ( angle2 >= ( ( CYL3 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL3 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE3_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 4 */    
+        if( ( angle2 >= ( ( CYL4 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL4 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE4_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 4 )
+
+        /* CYLINDER 5 */    
+        if( ( angle2 >= ( ( CYL5 * TENTH_DEGREES / CYLINDERS )- window ) ) &&
+            ( angle2 < ( CYL5 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE5_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 6 */    
+        if( ( angle2 >= ( ( CYL6 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL6 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE6_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 6 )
+
+        /* CYLINDER 7 */    
+        if( ( angle2 >= ( ( CYL7 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL7 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE7_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+        /* CYLINDER 8 */    
+        if( ( angle2 >= ( ( CYL8 * TENTH_DEGREES / CYLINDERS ) - window ) ) &&
+            ( angle2 < ( CYL8 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime2 = 
+                ( ( FIRE8_ANGLE - angle2 ) * tdcTime2 / TENTH_DEGREES ) +
+                angleCounter ; 
+        }
+
+#endif /* 6 cylinders */
+#endif /* 4 cylinders */
+
+        if( firingTime2 > MAX_VARIABLE )
+        {
+            firingTime2 -= MAX_VARIABLE ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, " %10ld\n", (n_long)firingTime2 ) ; 
+        DebugOut( szDebug ) ; 
+#else 
+        WriteOut( (varsize)firingTime2 ) ; 
+#endif /* BMDEBUG */
+
+        /***********************************************************************
+            Third Pass                                                          
+        ***********************************************************************/
+        /* Gets 'angleCounter' value from test data*/
+        isTableLooped += GetInputValues() ;
+
+#if BMDEBUG
+        th_sprintf( szDebug, "%8ld", (n_long)angleCounter ) ;
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute 'pulseDeltaTime' -- the difference in counter 
+         * readings from the last pulse to the current one.  Note that
+         * the realtime counter may roll over, so the elapsed time may
+         * need to be corrected when this occurs.
+         *
+         */    
+
+        if( angleCounterLast3 > angleCounter )
+        {
+            pulseDeltaTime3 = angleCounter +
+                ( (varsize)MAX_VARIABLE - angleCounterLast3 + 3 ) ; 
+        }
+        else
+        {
+            pulseDeltaTime3 = angleCounter - angleCounterLast3 ; 
+        }
+        /* Update timer history */
+        angleCounterLast3 = angleCounter ;    
+        /* and elapsed time for a revolution */
+        rotationTime3 += pulseDeltaTime3 ;    
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4ld", (n_long)pulseDeltaTime3 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Must detect TDC reference by noticing that the period between this
+         * pulse and the last one is two or three times normal.  We'll set a
+         * flag when TDC reference occurs, and clear it on all other pulses.
+         * We also keep count of which pulse we're on relative to TDC reference.
+         *
+         */    
+
+        if( pulseDeltaTime3 > ( TDC_TEETH * deltaTimeAvg3 * TDC_MARGIN ) )
+        {        
+            isTopDeadCenter3 = true ; 
+            pulseDeltaTime3 /= TDC_TEETH ; 
+
+            /*
+             * Compute engine speed every TDC.  Engine speed will be
+             * the inverse of 'tdcTime', which is the period( in CPU
+             * time )between TDC's.  Engine speed is also scaled by
+             * an arbitrary constant to make it useful elsewhere in
+             * the engine controller.
+             *
+             */    
+
+            tdcTime3 = rotationTime3 ; 
+            rotationTime3 = 0 ; 
+            engineSpeed3 = RPM_SCALE_FACTOR / tdcTime3 ; 
+            toothCount3 = 0 ; 
+        }
+        else 
+        {        
+            toothCount3++ ; 
+            isTopDeadCenter3 = false ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %4d, %8ld, %5ld, %4ld", ( isTopDeadCenter3 & 1 ),
+            (n_long)tdcTime3, (n_long)engineSpeed3, (n_long)toothCount3 ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)engineSpeed3 ) ; 
+#endif /* BMDEBUG */
+
+        /*
+         * Compute an average delta-T for TDC pulse discrimination.
+         * The delta-T will be filtered by averaging over the period
+         * of one cylinder( several pulses ).
+         *
+         */    
+
+        deltaTimeAccum3 += pulseDeltaTime3 ; 
+
+        if( ( toothCount3 > 0 ) && 
+            ( toothCount3 % ( tonewheelTeeth / CYLINDERS ) == 0 ) )
+        {        
+            deltaTimeAvg3 = deltaTimeAccum3 / ( tonewheelTeeth / CYLINDERS ) ; 
+            deltaTimeAccum3 = 0 ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, ", %6ld, ", (n_long)deltaTimeAvg3 ) ; 
+        DebugOut( szDebug ) ; 
+#endif /* BMDEBUG */
+
+        angle3 = ( TENTH_DEGREES * toothCount3 / tonewheelTeeth ) ; 
+
+        /*
+         * Now, output a value for the firing angle timer( a one-shot )
+         * only if we're on the tooth which precedes the firing
+         * angle for one of the cylinders.  We presume that there is
+         * always a tooth which precedes each cylinder's firing angle.
+         * The value which is output presumably goes to a "capture/compare"
+         * timer which generates an interrupt used to fire that cylinder.
+         * Note the special treatment for the last cylinder( #4, #6, or #8 ), 
+         * we don't subtract the 'angle' because the 360th degree of rotation
+         * is the same as the 0th degree of the next rotation.
+         *
+         */    
+
+        /* CYLINDER 1 */    
+        if( ( angle3 >= ( ( CYL1 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL1 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE1_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 2 */    
+        if( ( angle3 >= ( ( CYL2 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL2 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE2_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 3 */    
+        if( ( angle3 >= ( ( CYL3 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 <( CYL3 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE3_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 4 */    
+        if( ( angle3 >= ( ( CYL4 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL4 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE4_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 4 )
+
+        /* CYLINDER 5 */    
+        if( ( angle3 >= ( ( CYL5 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL5 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE5_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 6 */    
+        if( ( angle3 >= ( ( CYL6 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL6 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE6_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+#if( CYLINDERS > 6 )
+
+        /* CYLINDER 7 */    
+        if( ( angle3 >= ( ( CYL7 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 < ( CYL7 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE7_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES ) + 
+                angleCounter ; 
+        }
+
+        /* CYLINDER 8 */    
+        if( ( angle3 >= ( ( CYL8 * TENTH_DEGREES / CYLINDERS ) - window ) ) && 
+            ( angle3 <( CYL8 * TENTH_DEGREES / CYLINDERS ) ) )
+        {        
+            firingTime3 = 
+                ( ( FIRE8_ANGLE - angle3 ) * tdcTime3 / TENTH_DEGREES  )+ 
+                angleCounter ; 
+        }
+
+#endif /* 6 cylinders */
+#endif /* 4 cylinders */
+
+        if( firingTime3 > MAX_VARIABLE )
+        {
+            firingTime3 -= MAX_VARIABLE ; 
+        }
+
+#if BMDEBUG
+        th_sprintf( szDebug, " %10ld", (n_long)firingTime3 ) ; 
+        DebugOut( szDebug ) ; 
+        th_sprintf( szDebug, ", %08lX\n", ( n_ulong )loop_cnt ) ; 
+        DebugOut( szDebug ) ; 
+#else
+        WriteOut( (varsize)firingTime3 ) ; 
+
+#if DATA_SIZE == 0 /* Might break up the loop counter */
+        i = (varsize)( loop_cnt &0x0000FFFF ) ; 
+        WriteOut( i ) ; /*  ...in the output file */
+        i = (varsize)( loop_cnt >> 16 ) ; 
+        WriteOut( i ) ; 
+#else
+        WriteOut( (varsize)loop_cnt ) ; 
+#endif
+        i = (varsize)0xAAAA ; 
+        WriteOut( i ) ; /* Flag the end of data-block */
+#endif /* BMDEBUG */
+
+#if BMDEBUG
+        if( !th_harness_poll() )
+        {
+            break ; 
+        }
+#endif
+    }
+
+    /* Signal that we are finished */
+	tcdef->duration = th_signal_finished() ;
+
+    tcdef->iterations = loop_cnt;
+    tcdef->v1 = 0 ; 
+    tcdef->v2 = 0 ; 
+    tcdef->v3 = 0 ; 
+    tcdef->v4 = 0 ; 
+
+
+#if NON_INTRUSIVE_CRC_CHECK
+	tcdef->CRC=0;
+/* varsize is n_short or n_long, calc crc based on e_u32 */
+/* final answers are iteration dependent */
+	tcdef->CRC = Calc_crc32((e_u32)*inpAngleCount,tcdef->CRC ) ; 
+	tcdef->CRC = Calc_crc32((e_u32)tonewheelTeeth,tcdef->CRC ) ; 
+#elif	CRC_CHECK
+	tcdef->CRC=0;
+#else
+	tcdef->CRC=0;
+#endif
+
+	return	th_report_results(tcdef,EXPECTED_CRC);
+} /* End of function 't_run_test' */
+
+
+/***************************************************************************/
+int main(int argc, const char* argv[] )
+{
+	/* target specific inititialization */
+	al_main(argc, argv);
+	/* Benchmark Execution */
+	return	t_run_test(&the_tcdef,argc,argv); 
+} 
+
+#if BMDEBUG
+
+n_void DebugOut( n_char *szSrc )
+{        
+#if RAM_OUT == 1
+    n_int i ;
+    n_int length ; 
+
+    /* Make sure we don't overwrite the end of the RAM file */    
+    length = (n_int)strlen( szSrc ) ; 
+
+    for( i = 0 ; i < length ; i++ )
+    {        
+        *RAMfilePtr++ = szSrc[i] ; 
+
+        if ( RAMfilePtr >= RAMfileEOF )
+            RAMfilePtr = RAMfile;
+    }
+#else
+    th_printf( szSrc ) ;
+#endif /* RAM_OUT */
+
+} /* End of function 'DebugOut' */
+
+#endif /* BMDEBUG */
+
+/*
+*    Function :  WriteOut
+*
+*    Outputs results to the RAM file so that it can be downloaded to host for
+*  verification.  Also serves to defeat optimization which would remove the
+*  code used to develop the results when not in DEBUG mode.
+*
+*/    
+
+n_void	WriteOut( varsize value )
+{
+if (( RAMfilePtr+RAMfile_increment) > RAMfileEOF )
+    RAMfilePtr = RAMfile;
+
+    *(varsize *)RAMfilePtr = value;
+     RAMfilePtr += RAMfile_increment; /* this might need to be casted back to (n_int *) ??*/
+
+} /* End of function 'WriteOut' */
+

=== added directory 'automotive/a2time01/win32'
=== added file 'automotive/a2time01/win32/a2time01.dsp'
--- automotive/a2time01/win32/a2time01.dsp	1970-01-01 00:00:00 +0000
+++ automotive/a2time01/win32/a2time01.dsp	2013-10-07 11:04:13 +0000
@@ -0,0 +1,168 @@
+# Microsoft Developer Studio Project File - Name="A2TIME01" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=A2TIME01 - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "A2TIME01.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "A2TIME01.mak" CFG="A2TIME01 - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "A2TIME01 - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "A2TIME01 - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "A2TIME01 - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\.." /I "..\..\..\th\x86\al" /I "..\..\..\th\src" /I "..\x86\al" /I "..\src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "A2TIME01 - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "A2TIME01___Win32_Debug"
+# PROP BASE Intermediate_Dir "A2TIME01___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\.." /I "..\..\..\th\x86\al" /I "..\..\..\th\src" /I "..\x86\al" /I "..\src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "A2TIME01 - Win32 Release"
+# Name "A2TIME01 - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\algotst.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\bmark.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\algo.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# Begin Group "AL"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\th\x86\al\eembc_dt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\x86\al\thal.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\x86\al\thcfg.h
+# End Source File
+# End Group
+# Begin Group "FL"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\th\src\anytoi.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\crc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\heap.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\memmgr.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\printfe.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\ssubs.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\therror.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\thfl.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\thlib.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th\src\uuencode.c
+# End Source File
+# End Group
+# End Target
+# End Project

=== added file 'automotive/a2time01/win32/a2time01_lite.dsp'
--- automotive/a2time01/win32/a2time01_lite.dsp	1970-01-01 00:00:00 +0000
+++ automotive/a2time01/win32/a2time01_lite.dsp	2013-10-07 11:04:13 +0000
@@ -0,0 +1,156 @@
+# Microsoft Developer Studio Project File - Name="A2TIME01_Lite" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=A2TIME01_Lite - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE 
+!MESSAGE NMAKE /f "A2TIME01_Lite.mak".
+!MESSAGE 
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE 
+!MESSAGE NMAKE /f "A2TIME01_Lite.mak" CFG="A2TIME01_Lite - Win32 Debug"
+!MESSAGE 
+!MESSAGE Possible choices for configuration are:
+!MESSAGE 
+!MESSAGE "A2TIME01_Lite - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "A2TIME01_Lite - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE 
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_ProjName ""
+# PROP Scc_LocalPath ""
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "A2TIME01_Lite - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release_Lite"
+# PROP Intermediate_Dir "Release_Lite"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\.." /I "..\..\..\th_Lite\x86\al" /I "..\..\..\th_Lite\src" /I "..\x86\al" /I "..\src" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x409 /d "NDEBUG"
+# ADD RSC /l 0x409 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+
+!ELSEIF  "$(CFG)" == "A2TIME01_Lite - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "A2TIME01_Lite___Win32_Debug"
+# PROP BASE Intermediate_Dir "A2TIME01_Lite___Win32_Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug_Lite"
+# PROP Intermediate_Dir "Debug_Lite"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\.." /I "..\..\..\th_Lite\x86\al" /I "..\..\..\th_Lite\src" /I "..\x86\al" /I "..\src" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /FR /YX /FD /GZ /c
+# ADD BASE RSC /l 0x409 /d "_DEBUG"
+# ADD RSC /l 0x409 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+
+!ENDIF 
+
+# Begin Target
+
+# Name "A2TIME01_Lite - Win32 Release"
+# Name "A2TIME01_Lite - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=..\algotst.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\bmark_lite.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=..\algo.h
+# End Source File
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# Begin Group "FL"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\crc.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\eembc_dt.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\heap.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\heap.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\thal.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\thlib.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_Lite\src\thlib.h
+# End Source File
+# End Group
+# Begin Group "AL"
+
+# PROP Default_Filter ""
+# Begin Source File
+
+SOURCE=..\..\..\th_lite\x86\al\heapport.h
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_lite\x86\al\thal.c
+# End Source File
+# Begin Source File
+
+SOURCE=..\..\..\th_lite\x86\al\thcfg.h
+# End Source File
+# End Group
+# End Target
+# End Project

=== added directory 'automotive/aifftr01'
=== added file 'automotive/aifftr01/algo.h'
--- automotive/aifftr01/algo.h	1970-01-01 00:00:00 +0000
+++ automotive/aifftr01/algo.h	2013-10-07 11:04:13 +0000
@@ -0,0 +1,153 @@
+/*==============================================================================
+ *$RCSfile: algo.h,v $
+ *
+ *   DESC : Fast Fourier Transform
+ *
+ * AUTHOR : dt
+ *
+ *  EEMBC : Automotive/Industrial Subcommittee 
+ *
+ *    CVS : $Revision: 1.2 $
+ *          $Date: 2002/04/25 20:10:43 $
+ *          $Author: rick $
+ *          $Source: d:/cvs/eembc2/automotive/aifftr01/algo.h,v $
+ *          
+ * NOTE   :
+ *
+ *------------------------------------------------------------------------------
+ *
+ * HISTORY :
+ *
+ * $Log: algo.h,v $
+ * Revision 1.2  2002/04/25 20:10:43  rick
+ * sprintf to th_sprintf
+ *
+ *
+ *------------------------------------------------------------------------------
+ * Copyright (c) 1998-2002 by the EDN Embedded Microprocessor 
+ * Benchmark Consortium (EEMBC), Inc. 
+ * 
+ * All Rights Reserved. This is licensed program product and 
+ * is owned by EEMBC. The Licensee understands and agrees that the 
+ * Benchmarks licensed by EEMBC hereunder (including methods or concepts 
+ * utilized therein) contain certain information that is confidential 
+ * and proprietary which the Licensee expressly agrees to retain in the 
+ * strictest confidence and to use only in conjunction with the Benchmarks 
+ * pursuant to the terms of this Agreement. The Licensee further agrees 
+ * to keep the source code and all related documentation confidential and 
+ * not to disclose such source code and/or related documentation to any 
+ * third party. The Licensee and any READER of this code is subject to 
+ * either the EEMBC Member License Agreement and/or the EEMBC Licensee 
+ * Agreement. 
+ * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, EEMBC DISCLAIMS ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
+ * PURPOSE, WITH REGARD TO THE BENCHMARKS AND THE ACCOMPANYING 
+ * DOCUMENTATION. LICENSEE ACKNOWLEDGES AND AGREES THAT THERE ARE NO 
+ * WARRANTIES, GUARANTIES, CONDITIONS, COVENANTS, OR REPRESENTATIONS BY 
+ * EEMBC AS TO MARKETABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR OTHER 
+ * ATTRIBUTES, WHETHER EXPRESS OR IMPLIED (IN LAW OR IN FACT), ORAL OR 
+ * WRITTEN. 
+ * 
+ * Licensee hereby agrees by accessing this source code that all benchmark 
+ * scores related to this code must be certified by ECL prior to publication 
+ * in any media, form, distribution, or other means of conveyance of 
+ * information subject to the terms of the EEMBC Member License Agreement 
+ * and/or EEMBC Licensee Agreement. 
+ * 
+ * Other Copyright Notice (if any): 
+ * 
+ * For conditions of distribution and use, see the accompanying README file.
+ * ===========================================================================*/
+
+#ifndef __ALGO_H
+#define __ALGO_H
+
+/*******************************************************************************
+    Includes (thlib.h provides eembc_dt.h for us)                                                                   
+*******************************************************************************/
+
+#include "thlib.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+/* PLATFORM-SPECIFIC DEFINITIONS  */    
+
+/* Compilation switches to be defined( or not )based on application follow */
+
+/* Define( =1 )when compiling for 32-bit variables */    
+
+/* ...or( =0 )when compiling for 16-bit variables */    
+
+#define DATA_SIZE 1 
+
+#if DATA_SIZE == 1          /* LONG variables */
+typedef n_long varsize ;      /* Data and variables are 32 bits */
+#else                       /* Else, SHORT variables */
+typedef n_short varsize ;     /* Data and variables are 16 bits */
+#endif /* DATA_SIZE */
+
+/* Define( =1 )to direct debug text to RAM file */    
+
+/* ...or( =0 )to direct debug text to console */    
+
+#define RAM_OUT 0        
+
+/*******************************************************************************
+    Defines                                                                     
+*******************************************************************************/
+
+#define false    0
+#define true    !false
+
+#if (BMDEBUG && RAM_OUT == 1)	/* Debug buffer size == 32K */ 
+#define MAX_FILESIZE    8192    /* Maximum size of output file */
+#else
+#define MAX_FILESIZE    256     /* Maximum size of output file */
+#endif 
+#define NUM_TESTS    4096  /* Number of sets of input test data stimuli */
+#define VAR_COUNT    3     /* Number of variables which must be allocated */
+#define HEADER_SIZE  100   /* Approximate size of title and header messages */
+
+#define NUM_POINTS   512   /* Number of points in FFT */
+#define FFT_LENGTH   9     /* length = log2( NUM_POINTS )*/
+
+#ifdef PI
+#undef PI
+#endif
+#define PI 3.141592654 
+
+/* TRIG_SCALE_FACTOR is used for greatest twiddle factor precision */    
+#define TRIG_SCALE_FACTOR       32768
+
+/* BUTTERFLY_SCALE_FACTOR = log2( TRIG_SCALE_FACTOR )is used to
+accomodate accumulator size limit of 32 bits */    
+#define BUTTERFLY_SCALE_FACTOR  15          /* Divide by 32768 */
+
+/* STAGE_SCALE_FACTOR is used to prevent overflow from
+accumulation at each processing stage */    
+#define STAGE_SCALE_FACTOR      1           /* Divide by 2 */
+
+/*******************************************************************************
+    Global Variables                                                            
+*******************************************************************************/
+
+#ifndef ALGO_GLOBALS         /* Don't define these twice! */
+
+extern n_int   tableCount ;  /* Number of passes through table */
+extern varsize *inpSignal ;  /* Pointer to array of input signal data values */
+
+#endif /* ALGO_GLOBALS */    
+
+/*******************************************************************************
+    Function Prototypes                                                         
+*******************************************************************************/
+
+n_int  GetTestData( n_void ) ; 
+n_int  GetInputValues( varsize *, varsize * ) ; 
+n_void DebugOut( n_char * ) ; 
+n_void WriteOut( varsize  ) ; 
+
+#endif /* __ALGO_H */

=== added file 'automotive/aifftr01/algotst.c'
--- automotive/aifftr01/algotst.c	1970-01-01 00:00:00 +0000
+++ automotive/aifftr01/algotst.c	2013-10-07 11:04:13 +0000
@@ -0,0 +1,8343 @@
+/*==============================================================================
+ *$RCSfile: algotst.c,v $
+ *
+ *   DESC : Algorithm #16 :  FFT - Fast Fourier Transform - aifftr01
+ *
+ *  EEMBC : Automotive/Industrial Subcommittee 
+ *
+ *    CVS : $Revision: 1.3 $
+ *          $Date: 2002/04/10 19:36:56 $
+ *          $Author: rick $
+ *          $Source: d:/cvs/eembc2/automotive/aifftr01/algotst.c,v $
+ *          
+ * NOTE   :
+ *
+ *------------------------------------------------------------------------------
+ *
+ * HISTORY :
+ *
+ * $Log: algotst.c,v $
+ * Revision 1.3  2002/04/10 19:36:56  rick
+ * Fixes to reduce Lite vs. Regular variances in timing
+ *
+ *
+ *------------------------------------------------------------------------------
+ * Copyright (c) 1998-2002 by the EDN Embedded Microprocessor 
+ * Benchmark Consortium (EEMBC), Inc. 
+ * 
+ * All Rights Reserved. This is licensed program product and 
+ * is owned by EEMBC. The Licensee understands and agrees that the 
+ * Benchmarks licensed by EEMBC hereunder (including methods or concepts 
+ * utilized therein) contain certain information that is confidential 
+ * and proprietary which the Licensee expressly agrees to retain in the 
+ * strictest confidence and to use only in conjunction with the Benchmarks 
+ * pursuant to the terms of this Agreement. The Licensee further agrees 
+ * to keep the source code and all related documentation confidential and 
+ * not to disclose such source code and/or related documentation to any 
+ * third party. The Licensee and any READER of this code is subject to 
+ * either the EEMBC Member License Agreement and/or the EEMBC Licensee 
+ * Agreement. 
+ * TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, EEMBC DISCLAIMS ALL 
+ * WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, 
+ * IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
+ * PURPOSE, WITH REGARD TO THE BENCHMARKS AND THE ACCOMPANYING 
+ * DOCUMENTATION. LICENSEE ACKNOWLEDGES AND AGREES THAT THERE ARE NO 
+ * WARRANTIES, GUARANTIES, CONDITIONS, COVENANTS, OR REPRESENTATIONS BY 
+ * EEMBC AS TO MARKETABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR OTHER 
+ * ATTRIBUTES, WHETHER EXPRESS OR IMPLIED (IN LAW OR IN FACT), ORAL OR 
+ * WRITTEN. 
+ * 
+ * Licensee hereby agrees by accessing this source code that all benchmark 
+ * scores related to this code must be certified by ECL prior to publication 
+ * in any media, form, distribution, or other means of conveyance of 
+ * information subject to the terms of the EEMBC Member License Agreement 
+ * and/or EEMBC Licensee Agreement. 
+ * 
+ * Other Copyright Notice (if any): 
+ * 
+ * For conditions of distribution and use, see the accompanying README file.
+ * ===========================================================================*/
+
+/*******************************************************************************
+    Includes                                                                    
+*******************************************************************************/
+
+#include "algo.h"
+
+/* DECLARATIONS  */    
+
+/*
+* The following test data represents the sampled signal input to the FFT.
+*
+*/    
+
+const varsize inpSignalROM[] = 
+{        
+
+    0, 
+
+    0,    /* xsine512_t.dat */
+
+    19260, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    19260, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    -19260, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -19260, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    19260, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    19260, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    -19260, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -19260, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    19260, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    19260, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    -19261, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -19260, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    19261, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19259, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    -19261, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19259, 
+
+    0, 
+
+    0, 
+
+    0, 
+
+    19261, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19259, 
+
+    0, 
+
+    -1, 
+
+    0, 
+
+    -19261, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19259, 
+
+    0, 
+
+    1, 
+
+    0, 
+
+    19261, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19259, 
+
+    0, 
+
+    -1, 
+
+    0, 
+
+    -19261, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19259, 
+
+    0, 
+
+    1, 
+
+    0, 
+
+    19261, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19259, 
+
+    0, 
+
+    -1, 
+
+    0, 
+
+    -19261, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19259, 
+
+    0, 
+
+    1, 
+
+    0, 
+
+    19261, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19259, 
+
+    0, 
+
+    -1, 
+
+    0, 
+
+    -19261, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19259, 
+
+    0, 
+
+    1, 
+
+    0, 
+
+    19262, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19258, 
+
+    0, 
+
+    -1, 
+
+    0, 
+
+    -19262, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19258, 
+
+    0, 
+
+    2, 
+
+    0, 
+
+    19262, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19258, 
+
+    0, 
+
+    -2, 
+
+    0, 
+
+    -19262, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19258, 
+
+    0, 
+
+    2, 
+
+    0, 
+
+    19262, 
+
+    0, 
+
+    31164, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19258, 
+
+    0, 
+
+    -2, 
+
+    0, 
+
+    -19262, 
+
+    0, 
+
+    -31164, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19258, 
+
+    0, 
+
+    2, 
+
+    0, 
+
+    19262, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19258, 
+
+    0, 
+
+    -2, 
+
+    0, 
+
+    -19262, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19258, 
+
+    0, 
+
+    2, 
+
+    0, 
+
+    19262, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19258, 
+
+    0, 
+
+    -2, 
+
+    0, 
+
+    -19262, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19258, 
+
+    0, 
+
+    3, 
+
+    0, 
+
+    19263, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19258, 
+
+    0, 
+
+    -3, 
+
+    0, 
+
+    -19263, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19257, 
+
+    0, 
+
+    3, 
+
+    0, 
+
+    19263, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19257, 
+
+    0, 
+
+    -3, 
+
+    0, 
+
+    -19263, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19257, 
+
+    0, 
+
+    3, 
+
+    0, 
+
+    19263, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19257, 
+
+    0, 
+
+    -3, 
+
+    0, 
+
+    -19263, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19257, 
+
+    0, 
+
+    3, 
+
+    0, 
+
+    19263, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31163, 
+
+    0, 
+
+    19257, 
+
+    0, 
+
+    -3, 
+
+    0, 
+
+    -19263, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31163, 
+
+    0, 
+
+    -19257, 
+
+    0, 
+
+    3, 
+
+    0, 
+
+    19263, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31162, 
+
+    0, 
+
+    19257, 
+
+    0, 
+
+    -4, 
+
+    0, 
+
+    -19263, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31162, 
+
+    0, 
+
+    -19257, 
+
+    0, 
+
+    4, 
+
+    0, 
+
+    19263, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31162, 
+
+    0, 
+
+    19257, 
+
+    0, 
+
+    -4, 
+
+    0, 
+
+    -19264, 
+
+    0, 
+
+    -31165, 
+
+    0, 
+
+    -31162, 
+
+    0, 
+
+    -19256, 
+
+    0, 
+
+    4, 
+
+    0, 
+
+    19264, 
+
+    0, 
+
+    31165, 
+
+    0, 
+
+    31162, 
+
+    0, 
+
+    19256, 
+