Fibonacci Example

#include <stdio.h>
#include <sleep.h>
#include <stdlib.h>
#include <hthread.h>
#include <config.h>
#include <xparameters.h>
#include <xuartns550_l.h>

#define FIBMAX 7
#define HWTI_BASEADDR (void*)(0x63000000)

hthread_mutex_t hwtiMutex;

struct fibonacci {
        Huint fibNum;
        Huint fibVal;
};

void* findFibHWTI(void * arg) {
        //This is the code software would normally be
        //running. Instead this is executed in hardware.
        struct fibonacci * fib;
        fib = (struct fibonacci *) arg;
        fib->fibVal = 1;

        return NULL;
}

void* findFibonacci(void * arg) {
        hthread_attr_t attrBase;
        hthread_t threadBase;
        hthread_t threadOne;
        hthread_t threadTwo;
        struct fibonacci * fib;
        struct fibonacci fibOne;
        struct fibonacci fibTwo;

        fib = (struct fibonacci *) arg;

        if (fib->fibNum == 0 || fib->fibNum == 1) {
                //Set up the attr for a HW thread
                hthread_attr_init( &attrBase );
                hthread_attr_sethardware( &attrBase, HWTI_BASEADDR );

                //Since there is only one HWTI, perform a mutex lock
                //on it, then create the HW thread
                hthread_mutex_lock( &hwtiMutex );
                hthread_create(&threadBase, &attrBase, NULL, (void*)fib);

                //Clean up the attr
                hthread_attr_destroy( &attrBase );

                //Wait for HW thread to finish ... and unlock mutex
                hthread_join(threadBase, NULL);
                hthread_mutex_unlock( &hwtiMutex );
        } else {
                fibOne.fibNum = fib->fibNum - 1;
                fibTwo.fibNum = fib->fibNum - 2;

                //Create two software thread to calculate the two previous Fibonacci numbers.
                hthread_create(&threadOne, NULL, findFibonacci, (void*)&fibOne);
                hthread_create(&threadTwo, NULL, findFibonacci, (void*)&fibTwo);

                //Wait for the child threads to finish
                hthread_join(threadOne, NULL);
                hthread_join(threadTwo, NULL);

                fib->fibVal = fibOne.fibVal + fibTwo.fibVal;
        }

        return NULL;
}

int main (int argc, char *argv[]) {
        hthread_t thread;
        struct fibonacci fib;
        Huint fibArray[FIBMAX];
        Huint i;

        //Initialize the hthreads system
        hthread_init();
        hthread_mutex_init( &hwtiMutex, NULL );

        //Calculate the Fibonacci sequence
        for( i=0; i<FIBMAX; i++ ) {
                fib.fibNum = i;
                fib.fibVal = 0;

                printf( "Creating Thread for Fibonacci %d\n", i );
                hthread_create(&thread, NULL, findFibonacci, (void*)&fib);
                hthread_join(thread, NULL);
                fibArray[i] = fib.fibVal;
        }

        for( i=0; i<FIBMAX; i++ ) {
                printf( "Fibonacci %d is %d\n", i, fibArray[i] );
        }
        return 1 ;
}

library IEEE;
use IEEE.std_logic_1164.all;
use IEEE.std_logic_arith.all;
use IEEE.std_logic_unsigned.all;
use IEEE.std_logic_misc.all;

library Unisim;
use Unisim.all;

---------------------------------------------------------------------------
-- Thread Manager Entity section
---------------------------------------------------------------------------

entity user_logic_hwtul is
  port (
    clock : in std_logic;

    intrfc2thrd_status : in std_logic_vector(0 to 3);
    intrfc2thrd_result : in std_logic_vector(0 to 31);

    thrd2intrfc_opcode : out std_logic_vector(0 to 7);
    thrd2intrfc_argument_one : out std_logic_vector(0 to 31);
    thrd2intrfc_argument_two : out std_logic_vector(0 to 31)
  );
end entity user_logic_hwtul;

---------------------------------------------------------------------------
-- Architecture section
---------------------------------------------------------------------------

architecture IMP of user_logic_hwtul is

---------------------------------------------------------------------------
-- Signal declarations
---------------------------------------------------------------------------

  type hwtul_state is (
    START,
    IDLE,
    WRITE_MEMORY_1,
    WRITE_MEMORY_2,
    WRITE_MEMORY_3,
    WRITE_MEMORY_4,
    EXIT_INIT, 
    EXIT_WAIT
  );

  signal current_state, next_state : hwtul_state := START;
  signal argument, argument_next : std_logic_vector(0 to 31);
  signal threadID, threadID_next : std_logic_vector(0 to 31);
  signal argVal, argVal_next : std_logic_vector(0 to 31);

  signal opcode, opcode_next : std_logic_vector(0 to 7);
  signal argOne, argOne_next : std_logic_vector(0 to 31);
  signal argTwo, argTwo_next : std_logic_vector(0 to 31);

  -- user_status Constants
  constant USER_STATUS_RESET : std_logic_vector(0 to 3) := x"1";
  constant USER_STATUS_RUN : std_logic_vector(0 to 3) := x"2";
  constant USER_STATUS_ACK : std_logic_vector(0 to 3) := x"4";
  constant USER_STATUS_PAUSE : std_logic_vector(0 to 3) := x"8";

  -- user_opcode Constants
  constant OPCODE_NOOP : std_logic_vector(0 to 7) := x"00";
  constant OPCODE_HTHREAD_EXIT : std_logic_vector(0 to 7) := x"01";
  constant OPCODE_READ : std_logic_vector(0 to 7) := x"02";
  constant OPCODE_WRITE : std_logic_vector(0 to 7) := x"03";
  constant OPCODE_HTHREAD_SELF : std_logic_vector(0 to 7) := x"04";
  constant OPCODE_HTHREAD_YIELD : std_logic_vector(0 to 7) := x"05";
  constant OPCODE_HTHREAD_MUTEX_LOCK : std_logic_vector(0 to 7) := x"06";
  constant OPCODE_HTHREAD_MUTEX_UNLOCK : std_logic_vector(0 to 7) := x"07";
  constant OPCODE_HTHREAD_INTRASSOC : std_logic_vector(0 to 7) := x"08";

  -- misc constants
  constant Z32 : std_logic_vector(0 to 31) := (others => '0');
  constant H32 : std_logic_vector(0 to 31) := (others => '1');

---------------------------------------------------------------------------
-- Begin architecture
---------------------------------------------------------------------------

begin -- architecture IMP

  HWTUL_STATE_PROCESS : process (clock, argument_next, 
                                                        opcode_next, argOne_next, 
                                                        argTwo_next) is
  begin

    if (clock'event and (clock = '1')) then
      argument <= argument_next;
      opcode <= opcode_next;
      argOne <= argOne_next;
      argTwo <= argTwo_next;
      argVal <= argVal_next;
      threadID <= threadID_next;
      thrd2intrfc_opcode <= opcode_next;
      thrd2intrfc_argument_one <= argOne_next;
      thrd2intrfc_argument_two <= argTwo_next;

      if ( intrfc2thrd_status = USER_STATUS_RESET ) then
        current_state <= IDLE;
      else
        current_state <= next_state;
      end if;

    end if;
  end process HWTUL_STATE_PROCESS;

  HWTUL_STATE_MACHINE : process (clock) is
  begin

    -- Default register assignments
    next_state <= current_state;
    opcode_next <= opcode;
    argOne_next <= argOne;
    argTwo_next <= argTwo;
    argument_next <= argument;
    threadID_next <= threadID;
    argVal_next <= argVal;

    -- The state machine
    case current_state is
      when START =>
        --Set default values
        opcode_next <= OPCODE_NOOP;
        argOne_next <= Z32;
        argTwo_next <= Z32;
        next_state <= IDLE;

      when IDLE =>
        case intrfc2thrd_status is
          when USER_STATUS_RUN =>
            argument_next <= intrfc2thrd_result;
            next_state <= WRITE_MEMORY_1;
          when others =>
            next_state <= IDLE;
        end case;
      ---------------------------------------------------------
      -- Write a zero value at argument + 4
      ---------------------------------------------------------
      when WRITE_MEMORY_1 =>
        --Prepare the data to write, and the address to write too
        argTwo_next <= x"00000001";
        argOne_next <= (argument + 4);
        next_state <= WRITE_MEMORY_2;

      when WRITE_MEMORY_2 =>
        --Tell the HWTI to do the write
        opcode_next <= OPCODE_WRITE;
        next_state <= WRITE_MEMORY_3;

      when WRITE_MEMORY_3 =>
        --Wait for the HWTI to ACK the write request
        if ( intrfc2thrd_status = USER_STATUS_ACK ) then
          opcode_next <= OPCODE_NOOP;
          next_state <= WRITE_MEMORY_4;
        else
          next_state <= WRITE_MEMORY_3;
        end if;

      when WRITE_MEMORY_4 =>
        --Wait for the HWTI to tell us to RUN again
        if ( intrfc2thrd_status = USER_STATUS_RUN ) then
          next_state <= EXIT_INIT;
        else
          next_state <= WRITE_MEMORY_4;
        end if;

      ---------------------------------------------------------
      -- Exit
      -- Initiate the call to the Thread Manager to indicate
      -- this thread is done doing its work.
      ---------------------------------------------------------
      when EXIT_INIT =>
        argOne_next <= argVal;
        opcode_next <= OPCODE_HTHREAD_EXIT;
        next_state <= EXIT_WAIT_ACK;

      when EXIT_WAIT_ACK =>
        case intrfc2thrd_status is
          when USER_STATUS_ACK =>
            opcode_next <= OPCODE_NOOP;
            next_state <= EXIT_WAIT;
          when others =>
            next_state <= EXIT_WAIT_ACK;
        end case;

      when EXIT_WAIT =>
        next_state <= EXIT_WAIT;

      when others =>
        next_state <= IDLE;

    end case;
  end process HWTUL_STATE_MACHINE;
end architecture IMP;