#include <hidef.h>         /* common defines and macros */
#include <mc9s12c128.h>     /* derivative information */
#pragma LINK_INFO DERIVATIVE "mc9s12c128"

/*

  File:  prelab_5b_skeleton.c
  Course:  ECE348, Fall 2006
  Target processor:  MC9S12C128 using HC12 compiler
  Last modified:  09/14/2009
  
  This file serves as a starting point for lab 5b material
  on compiler optimizations.

*/

/* types */
typedef unsigned int   uint16;
typedef unsigned char  uint8;

/* prototypes */
uint16 ptr_add(uint16 *array, uint16 length);
uint16 ptr_add2(uint16 *array, uint16 length);
uint16 subscr_add(uint16 *array, uint16 length);

/* defines */
#define DATA_LEN 100


/* global variables */
uint16 myArray[DATA_LEN]; // stores data to be summed (static because defined at top level)

uint16 subscrResult;  // result of subscripted computation
uint16 ptrResult;     // result of slow pointer computation 
uint16 ptrResult2;    // result of faster pointer computation
uint8  flag_version1_good;
uint8  flag_version2_good;


/* 
  main function

  runs various subroutines and compares the results 
*/
void main(void) {
  uint16 i;
  EnableInterrupts;

  // initialize data array   
  for (i=0;i<DATA_LEN;i++) {
    myArray[i] = (i+1) * 3; // this can be changed by the TA to an arbitrary function
  }
  
  // time each of the below using the simulator
  subscrResult = subscr_add(myArray, DATA_LEN);
  ptrResult = ptr_add(myArray, DATA_LEN);
  ptrResult2 = ptr_add2(myArray, DATA_LEN);

  flag_version1_good =  (subscrResult == ptrResult);
  flag_version2_good =  (subscrResult == ptrResult2);
  
  for(;;) {} /* wait forever */
}


/*
  ptr_add
  Add an array of 16-bit values and return the result
  
  inputs:
   array - pointer to the first value in the array
   length - the number of consecutive array items to add
  outputs:
   return the 16-bit sum.  Do not detect overflow
  notes:
   optimized version 1 -- must be below 1560 clock cycles for full credit
   TODO: PUT YOUR SPEED HERE:    xxxx Clocks
*/
uint16 ptr_add(uint16 *array, uint16 length) {
  //TODO:  implement using pointer math
  //the target speed must be met with the base compiler options 
  return(0);    // just here so it will compile with TODO items undone
}


/*
  ptr_add2
  Add an array of 16-bit values and return the result
  
  inputs:
   array - pointer to the first value in the array
   length - the number of consecutive array items to add
  outputs:
   return the 16-bit sum.  Do not detect overflow
  notes:
   optimized version 2 -- must be below 960 clock cycles for full credit
   implementing this version is OPTIONAL
   TODO: PUT YOUR SPEED HERE:    xxxx Clocks
*/
uint16 ptr_add2(uint16 *array, uint16 length) {
  //TODO:  implement using pointer math
  //you will probably have to enable additional compiler options to meet the goal.
  return(0);  // just here so it will compile with TODO items undone
}



/*
  subscr_add
  Add an array of 16-bit values and return the result
  
  inputs:
   array - pointer to the first value in the array
   length - the number of consecutive array items to add
  outputs:
   return the 16-bit sum.  Do not detect overflow
  notes:
   base version start with this code; optimized versions must return the
   same value.  DO NOT MODIFY THIS FUNCTION!
*/
uint16 subscr_add(uint16 *array, uint16 length) {
  uint16 i;          // loop counter
  uint16 sum = 0;    // accumulates sum across array
  
  /* loop through the array and add each value to the running sum */
  for (i=0; i<length; i++) {
    sum = sum + array[i];
  }

  return sum;
}