main.c

nios中自定义指令集实现三角函数的软件部分。

/*
  When building this software application, I recommend that you set the compiler
  optimizations to whatever you desire, -O3 for example.
  
  This application requires a "timestamp" timer and stdout.
*/
/*
These are the possible C flags that you may wish to compile with, if you have
the appropriate hardware for these instructions.  The opcode values shown are
the default opcode offset from the opcode base of the SPDP Floating Point
instructions.  If your instruction isn't based at ZERO, then you must alter
these values.

Required for Double Precision:

-mcustom-fwrx=0xF
-mcustom-fwry=0xE
-mcustom-frdxlo=0xC
-mcustom-frdxhi=0xD
-mcustom-frdy=0xB
-mcustom-faddd=0xA
-mcustom-fsubd=0x9
-mcustom-fmuld=0x8
-mcustom-fdivd=0x7

Required for Single Precision:

-mcustom-fadds=0x6
-mcustom-fsubs=0x5
-mcustom-fmuls=0x4
-mcustom-fdivs=0x3

This is what these things do:

double none write X none -mcustom-fwrx=N nios2_fwrx 
float none write Y none -mcustom-fwry=N nios2_fwry 
none none read low half of X float -mcustom-frdxlo=N nios2_frdxlo 
none none read high half of X float -mcustom-frdxhi=N nios2_frdxhi 
none none read Y float -mcustom-frdy=N nios2_frdy 

double double + double -mcustom-faddd=N __adddf3 
double double - double -mcustom-fsubd=N __subdf3 
double double * double -mcustom-fmuld=N __muldf3 
double double / double -mcustom-fdivd=N __divdf3 

single single + single -mcustom-fadds=N __addsf3 
single single - single -mcustom-fsubs=N __subsf3 
single single * single -mcustom-fmuls=N __mulsf3 
single single / single -mcustom-fdivs=N __divsf3 

*/

// These pragmas will prevent the custom instruction opcode from being used in
// this source file it forces the software libraries to be called instead.
#pragma no_custom_faddd
#pragma no_custom_fsubd
#pragma no_custom_fmuld
#pragma no_custom_fdivd
#pragma no_custom_fadds
#pragma no_custom_fsubs
#pragma no_custom_fmuls
#pragma no_custom_fdivs
#pragma no_custom_ftruncds
#pragma no_custom_fextsd
#pragma no_custom_fixdu
#pragma no_custom_fixdi
#pragma no_custom_floatud
#pragma no_custom_floatid
#pragma no_custom_fcmpned
#pragma no_custom_fcmpeqd
#pragma no_custom_fcmpged
#pragma no_custom_fcmpgtd
#pragma no_custom_fcmpled
#pragma no_custom_fcmpltd

#include <stdio.h>
#include "io.h"
#include "alt_types.h"
#include "system.h"
#include "dpfp_test.h"
#include <sys/alt_irq.h>
#include <sys/alt_cache.h>
#include <sys/alt_timestamp.h>
#include "float.h"
#include "math.h"

#define TEST_ENTRY  irq_context = alt_irq_disable_all(); \
                    alt_icache_flush_all(); \
                    alt_dcache_flush_all(); \
                    alt_timestamp_start();

#define TEST_EXIT(x)  x##_time = alt_timestamp(); \
                      alt_irq_enable_all(irq_context);

extern void dpfp_hw_addition(double *a, double *b, double *result);
extern void dpfp_hw_subtraction(double *a, double *b, double *result);
extern void dpfp_hw_multiplication(double *a, double *b, double *result);
extern void dpfp_hw_division(double *a, double *b, double *result);
extern void dpfp_sw_addition(double *a, double *b, double *result);
extern void dpfp_sw_subtraction(double *a, double *b, double *result);
extern void dpfp_sw_multiplication(double *a, double *b, double *result);
extern void dpfp_sw_division(double *a, double *b, double *result);
extern void dp_placebo(double *a, double *b, double *result);

extern void spfp_hw_addition(float *a, float *b, float *result);
extern void spfp_hw_subtraction(float *a, float *b, float *result);
extern void spfp_hw_multiplication(float *a, float *b, float *result);
extern void spfp_hw_division(float *a, float *b, float *result);
extern void spfp_sw_addition(float *a, float *b, float *result);
extern void spfp_sw_subtraction(float *a, float *b, float *result);
extern void spfp_sw_multiplication(float *a, float *b, float *result);
extern void spfp_sw_division(float *a, float *b, float *result);
extern void sp_placebo(float *a, float *b, float *result);

extern int dpfp_hw_compare(double a, double b);
extern float dpfp_hw_double_to_float(double a);
extern double dpfp_hw_float_to_double(float a);
extern double dpfp_hw_int_to_double(int a);
extern int dpfp_hw_double_to_int(double a);
extern double dpfp_hw_uint_to_double(unsigned int a);
extern unsigned int dpfp_hw_double_to_uint(double a);

extern int dpfp_sw_compare(double a, double b);
extern float dpfp_sw_double_to_float(double a);
extern double dpfp_sw_float_to_double(float a);
extern double dpfp_sw_int_to_double(int a);
extern int dpfp_sw_double_to_int(double a);
extern double dpfp_sw_uint_to_double(unsigned int a);
extern unsigned int dpfp_sw_double_to_uint(double a);

extern int non_arith_placebo(int a);

int main()
{
  int j;
  alt_irq_context irq_context;
  
  volatile alt_u32 dp_placebo_time;
  volatile alt_u32 dp_sw_add_time;
  volatile alt_u32 dp_hw_add_time;
  volatile alt_u32 dp_sw_sub_time;
  volatile alt_u32 dp_hw_sub_time;
  volatile alt_u32 dp_sw_mul_time;
  volatile alt_u32 dp_hw_mul_time;
  volatile alt_u32 dp_sw_div_time;
  volatile alt_u32 dp_hw_div_time;
  
  volatile alt_u32 dp_sw_compare_time;
  volatile alt_u32 dp_hw_compare_time;
  volatile alt_u32 dpfp_sw_float_to_double_time;
  volatile alt_u32 dpfp_hw_float_to_double_time;
  volatile alt_u32 dpfp_sw_double_to_float_time;
  volatile alt_u32 dpfp_hw_double_to_float_time;
  volatile alt_u32 dpfp_sw_int_to_double_time;
  volatile alt_u32 dpfp_hw_int_to_double_time;
  volatile alt_u32 dpfp_sw_uint_to_double_time;
  volatile alt_u32 dpfp_hw_uint_to_double_time;
  volatile alt_u32 dpfp_hw_double_to_uint_time;
  volatile alt_u32 dpfp_sw_double_to_uint_time;
  volatile alt_u32 dpfp_hw_double_to_int_time;
  volatile alt_u32 dpfp_sw_double_to_int_time;
  volatile alt_u32 non_arith_placebo_time;
  

  double *double_a_array;
  double *double_b_array;
  double *double_result_array;
  
  volatile alt_u32 sp_placebo_time;
  volatile alt_u32 sp_sw_add_time;
  volatile alt_u32 sp_hw_add_time;
  volatile alt_u32 sp_sw_sub_time;
  volatile alt_u32 sp_hw_sub_time;
  volatile alt_u32 sp_sw_mul_time;
  volatile alt_u32 sp_hw_mul_time;
  volatile alt_u32 sp_sw_div_time;
  volatile alt_u32 sp_hw_div_time;
  
  float *float_a_array;
  float *float_b_array;
  float *float_result_array;

  printf("Time tests starting...\n");
    
  int i;

  // negate and rotate the test array into negated array
  for(i=0;i<999;i++)
  {
    negated_double_array[(i*2)] = my_double_test_array[((i+1)*2)];
    negated_double_array[(i*2) + 1] = my_double_test_array[((i+1)*2) + 1] ^ 0x80000000;

    negated_single_array[i] = my_single_test_array[i+1] ^ 0x80000000;
  }
  negated_double_array[(i*2)] = my_double_test_array[(0)];
  negated_double_array[(i*2) + 1] = my_double_test_array[(0) + 1] ^ 0x80000000;

  negated_single_array[i] = my_single_test_array[0] ^ 0x80000000;

  // time the placebo
  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)calc_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dp_placebo(double_a_array++, double_b_array++, double_result_array++);
  }
  TEST_EXIT(dp_placebo)
    
  printf("\n Double Precision Addition Test...\n\n");
  
  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)calc_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_sw_addition(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_sw_add)

  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)cusp_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_hw_addition(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_hw_add)

  printf("\n Double Precision Subtraction Test...\n\n");
  
  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)calc_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_sw_subtraction(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_sw_sub)

  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)cusp_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_hw_subtraction(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_hw_sub)

  printf("\n Double Precision Multiplication Test...\n\n");
  
  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)calc_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_sw_multiplication(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_sw_mul)

  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)cusp_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_hw_multiplication(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_hw_mul)

  printf("\n Double Precision Division Test...\n\n");
  
  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)calc_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_sw_division(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_sw_div)

  double_a_array = (double*)my_double_test_array;
  double_b_array = (double*)negated_double_array;
  double_result_array = (double*)cusp_result_array;
  TEST_ENTRY
  for( j = 0 ; j < DOUBLE_TEST_ARRAY_SIZE_IN_DOUBLES ; j++)
  {
    dpfp_hw_division(double_a_array++, double_b_array++, double_result_array++);
  }        
  TEST_EXIT(dp_hw_div)

  // time the placebo
  float_a_array = (float*)my_single_test_array;
  float_b_array = (float*)negated_single_array;