<?xml version="1.0" encoding="utf-8" standalone="no"?>
<!DOCTYPE document PUBLIC "-//CNX//DTD CNXML 0.5 plus MathML//EN" "http://cnx.rice.edu/cnxml/0.5/DTD/cnxml_mathml.dtd">
<document xmlns="http://cnx.rice.edu/cnxml" xmlns:md="http://cnx.rice.edu/mdml/0.4" xmlns:m="http://www.w3.org/1998/Math/MathML" xmlns:bib="http://bibtexml.sf.net/" id="m10659"> 
  <name>Spectrum Analyzer: Optimization Exercise</name>
  <metadata>
  <md:version>1.3</md:version>
  <md:created>2004/09/13 10:34:55.424 GMT-5</md:created>
  <md:revised>2004/09/22 22:48:29.901 GMT-5</md:revised>
  <md:authorlist>
      <md:author id="rlmorris">
      <md:firstname>Robert</md:firstname>
      <md:othername>L.</md:othername>
      <md:surname>Morrison</md:surname>
      <md:email>rlmorris@uiuc.edu</md:email>
    </md:author>
      <md:author id="kleffner">
      <md:firstname>Matt</md:firstname>
      
      <md:surname>Kleffner</md:surname>
      <md:email>kleffner@uiuc.edu</md:email>
    </md:author>
      <md:author id="frutiger">
      <md:firstname>Michael</md:firstname>
      
      <md:surname>Frutiger</md:surname>
      <md:email>frutiger@uiuc.edu</md:email>
    </md:author>
  </md:authorlist>

  <md:maintainerlist>
    <md:maintainer id="kleffner">
      <md:firstname>Matt</md:firstname>
      
      <md:surname>Kleffner</md:surname>
      <md:email>kleffner@uiuc.edu</md:email>
    </md:maintainer>
  </md:maintainerlist>
  
  <md:keywordlist>
    <md:keyword>processor</md:keyword>
    <md:keyword>C</md:keyword>
    <md:keyword>assembly</md:keyword>
    <md:keyword>optimization</md:keyword>
    <md:keyword>pseudo-noise</md:keyword>
    <md:keyword>digital signal processing</md:keyword>
    <md:keyword>autocorrelation</md:keyword>
    <md:keyword>IIR filter</md:keyword>
    <md:keyword>power spectral density</md:keyword>
    <md:keyword>PSD</md:keyword>
  </md:keywordlist>

  <md:abstract>Students are to implement and optimize a power spectral density estimator, a pseudo-noise (PN) sequence generator, and an IIR filter.</md:abstract>
</metadata>


<content>

  <para id="para1">
    In this lab you are to implement and optimize the
    a pseudo-noise (PN)
    sequence generator, IIR filter, and autocorrelation routines that are
    part of the previous lab's PSD estimator.
    For the lab grade, you will be judged on the execution time of
    your system (memory usage need not be minimized).
  </para>

  <section id="s1">
    <name>Reference Implementation</name>

    <para id="s1p4">
      After taking a look at the source code of the PSD estimator
      reference implementation, you
      will likely discover inefficiencies. This implementation is provided as
      the "reference implementation" of the optimization process and to
      define the expected input and output of the application. The computational
      efficiency of your code will be judged against this implementation.
      While the given code might serve as a starting point, you should do
      whatever you need to do to make your code as efficient
      as possible, while operating in an equivalent manner as the given code.
    </para>

    <para id="s1p5">
      The exact portion of the code to be optimized is defined below. 
      You may write in C, assembly, or any combination of the two; choose
      whatever will allow you to write the fastest code. The optimization
      process will be smoother if you plan for optimization before
      you begin any programming.
    </para>

  </section>

  <section id="s3">
    <name>Optimization</name>
    <para id="s3p1">
      Since a primary purpose of this lab is to learn optimization and
      efficient code techniques, <emphasis>your lab grade will be based
      primarily on the total execution time of your system.</emphasis>
      You are not required to optimize memory use.  Note that by execution
      time we mean cycle count, not the number of instructions in
      your program. Remember that several of the TMS320C54xx
      instructions take more than one cycle. The multicycle
      instructions are primarily the multi-word instructions,
      including instructions that take immediates, like
      <code>stm</code>, and instructions using direct addressing
      of memory (such as <code>ld *(temp),A</code>). Branch and
      repeat statements also require several cycles to execute.
      Most C instructions take more than one cycle. The debugger
      can be used to determine the exact number of cycles used by
      your code; ask your TA to demonstrate. However, since the
      number of execution cycles used by an instruction is usually
      determined by the number of words in its encoding, the
      easiest way to estimate the number of cycles used by your
      code is to count the number of instruction words in the
      <code>.lst</code> file or the disassembly window in the
      debugger.
    </para>

    <para id="s3p2">
      We will grade you based on the number of cycles used between
      the <code>input_full = 0;</code> and <code>bit_rev_fft();</code>
      statements. Note that some instructions, like <code>RPT</code>, are
      <emphasis>non-repeatable instructions</emphasis>; their use may cause
      unnecessary glitches in I/O. For grading simplicity, your final
      code should not have modifications except between these two instructions,
      and <code>M</code> should be set to <code>31</code>.
      If the number of cycles between the two points is variable, the maximum
      possible number of cycles will be counted. You must use the
      <code>core.asm</code> file in
      <code>v:\ece320\54x\dsplib\core.asm</code> or the C core
      file in <code>v:\ece320\54x\dspclib\core.asm</code> as
      provided by the TAs; <emphasis>these files may not be
      modified</emphasis>. We reserve the right to test your code by
      modifying the inputs.
    </para>
  </section>

  <section id="s4">
    <name>Routine-Specific Optimization Tips</name>

    <para id="s4p1">
      If you are programming the PN generator in assembly, you may wish
      to refer to the description of assembly instructions for
      logical operations in <cite>Section 2-2</cite> of the
      <cite>C54x Mnemonic Instruction Set</cite> reference.
      Initialize the shift register to one. You can debug the PN output by
      comparing it to the output of the MATLAB code. Be prepared to
      prove to a TA that your PN generator works properly as part of your quiz.
    </para>

    <para id="s4p2">
      Your IIR filtering routine can debugged by writing an impulse followed
      by zeros in <code>autocorr_in</code> instead of <code>randsample</code>.
    </para>

    <para id="s4p3">
      Your autocorrelation routine can be debugged by commenting out the
      IIR-filtering routine and writing the maximum DC value into
      <code>autocorr_in</code> in a similar manner as described the
      IIR-debugging step. Note that each of these tips is the most helpful if
      the output is inspected in memory.
    </para>
  </section>

  <section id="s5">
    <name>Grading</name>

    <para id="s5p1">
      This lab is to be completed in one week.
      Grading for this lab will be a bit different from past labs:

      <list id="list2" type="bulleted">
        <item> 1 point: Prelab</item>
        <item> 2 points: Working code, implemented from scratch in assembly
   language or C. </item>
        <item> 5 points: Optimization. These points will be assigned based
   on your cycle counts and the optimizations you have made. </item>
        <item> 2 points: Oral quiz. </item>
      </list>
    </para>
  </section>

</content>
  
</document>
