#include <L1Trigger/L1TCalorimeter/src/firmware/CordicXilinx.cc>

Public Member Functions
	CordicXilinx (int inputBits, int outputBits, bool debug=false)

int	encodeAngle (const double angleFloat) const

void	operator() (int32_t xInput, int32_t yInput, int32_t &aPhi, uint32_t &aMagnitude) const

Private Types
enum	{ Pi, HalfPi, NHalfPi }

Private Attributes
const bool	debug_

std::array< int, 3 >	encodedAngles_

const int	inputBits_

int	internalBits_

int	iterations_

const int	outputBits_

std::vector< int >	rotations_

int	scaleFactor_

Detailed Description

Description: Emulates parts of the Xilinx DSP IP CORDIC routine, as described in http://www.xilinx.com/support/documentation/ip_documentation/cordic/v6_0/pg105-cordic.pdf This class only implements the vector translation, returning magnitude and phase, given signed x and y inputs. The inputs and outputs are not packed, so that normal signed integer arithmetic works as expected. They can easily be packed into a fixed width by abs() and placing a sign bit at the appropriate offset. The applicable configuration parameters that are being emulated are the following:

Functional Selection: Translate
Phase Format: Radians
Round Mode: Truncate
Advanced Configuration Parameters: Iterations=0, Precision=0, Coarse Rotation, Compensation Scaling = Embedded Multiplier In addition, an arbitrary input and output width can be specified, HOWEVER, only in=24, out=19 has been rigorously tested against the Xilinx proprietary emulator.

Tests: Full circle at various magnitudes, including maximum; a few billion random inputs Limited hardware comparisons have shown agreement as well. Test framework: https://github.com/nsmith-/cordic_test

Original Author: Nick Smith ( nick..nosp@m.smit.nosp@m.h@cer.nosp@m.n.ch )

Definition at line 8 of file CordicXilinx.h.

Member Enumeration Documentation

anonymous enum

private

Enumerator
Pi
HalfPi
NHalfPi

Definition at line 29 of file CordicXilinx.h.

29 { Pi, HalfPi, NHalfPi };

CordicXilinx::HalfPi

Definition: CordicXilinx.h:29

CordicXilinx::Pi

Definition: CordicXilinx.h:29

CordicXilinx::NHalfPi

Definition: CordicXilinx.h:29

Constructor & Destructor Documentation

CordicXilinx::CordicXilinx	(	int	inputBits,
		int	outputBits,
		bool	debug = `false`
	)

Definition at line 34 of file CordicXilinx.cc.

References reco::ceil(), debug_, encodeAngle(), encodedAngles_, HalfPi, mps_fire::i, internalBits_, iterations_, log, M_PI, NHalfPi, Pi, funct::pow(), gpuVertexFinder::printf(), idealTransformation::rotation, rotations_, HLT_FULL_cff::scaleFactor, and scaleFactor_.

     : inputBits_(inputBits), outputBits_(outputBits), debug_(debug) {
   // Coarse rotation lowers necessary iterations by 2
   iterations_ = outputBits - 2;
   // Internal precision is by default this value (when set to 0 in xilinx config)
   internalBits_ = outputBits + ceil(log((float)iterations_) / log(2.));
 
   double scaleFactor = 1.;
   for (int i = 1; i <= iterations_; ++i) {
     int rotation = encodeAngle(atan(pow(2., -i)));
     rotations_.push_back(rotation);
     scaleFactor *= pow(1 + pow(2., -2 * i), -0.5);
   }
   scaleFactor_ = scaleFactor * pow(2., internalBits_ - 1) + 0.5;
 
   // Precompute angles table for speed
   encodedAngles_[Pi] = encodeAngle(M_PI);
   encodedAngles_[HalfPi] = encodeAngle(M_PI / 2);
   encodedAngles_[NHalfPi] = encodeAngle(-M_PI / 2);
 
   if (debug_)
     printf(
         "Cordic setup: %d iterations, %d internal bits, scale factor = %d\n", iterations_, internalBits_, scaleFactor_);
 }

Member Function Documentation

int CordicXilinx::encodeAngle ( const double angleFloat ) const

Definition at line 59 of file CordicXilinx.cc.

References cms::cuda::assert(), internalBits_, M_PI, and funct::pow().

Referenced by CordicXilinx().

                                                            {
   assert(fabs(angleFloat) <= M_PI);
   // Xilinx seems to store rounded rotation table
   return angleFloat * pow(2., internalBits_ - 3) + 0.5;
 }

void CordicXilinx::operator()	(	int32_t	xInput,
		int32_t	yInput,
		int32_t &	aPhi,
		uint32_t &	aMagnitude
	)		const

Definition at line 65 of file CordicXilinx.cc.

References funct::abs(), cms::cuda::assert(), gather_cfg::cout, debug_, encodedAngles_, HalfPi, mps_fire::i, inputBits_, internalBits_, iterations_, NHalfPi, outputBits_, Pi, funct::pow(), gpuVertexFinder::printf(), idealTransformation::rotation, rotations_, scaleFactor_, jetcorrextractor::sign(), x, and y.

                                                                                                        {
   // Assumption in algorithm is that arithmetic shifts are used for ints (as opposed to logical shifts)
   static_assert(((int)-1) >> 3 == (int)-1,
                 "Signed ints need to use arithmetic shifts for this algorithm to work properly!");
 
   // Input checks
   // Input is in 2QN format, and for xilinx
   // the max is +- 1.0000...
   assert(abs(xInput) <= (1 << (inputBits_ - 1)));
   assert(abs(yInput) <= (1 << (inputBits_ - 1)));
 
   // Rotation to get from current vector to origin
   // must invert to get aPhi
   int rotation(0);
   int x, y;
 
   // Debug tool
   auto printVals = [&x, &y, &rotation, this] {
     printf("x: % 8d y: % 8d phi: % 8d outphi: % 8d float phi = % f\n",
            x,
            y,
            rotation,
            (abs(rotation) >> (internalBits_ - outputBits_)) * ((rotation > 0) ? -1 : 1),
            rotation / pow(2., internalBits_ - 3));
   };
 
   // Convert to internal precision
   if (internalBits_ > inputBits_) {
     x = xInput << (internalBits_ - inputBits_);
     y = yInput << (internalBits_ - inputBits_);
   } else {
     x = xInput >> (inputBits_ - internalBits_);
     y = yInput >> (inputBits_ - internalBits_);
   }
   if (debug_)
     printVals();
 
   // Coarse rotate to [-pi/4,pi/4)
   if (x - y >= 0) {
     if (x + y >= 0) {
       // East (Correct) quadrant
     } else {
       // South, rotate by +pi/2
       int xtmp = -y;
       int ytmp = x;
       x = xtmp;
       y = ytmp;
       rotation += encodedAngles_[HalfPi];
     }
   } else {
     if (x + y >= 0) {
       // North, rotate by -pi/2
       int xtmp = y;
       int ytmp = -x;
       x = xtmp;
       y = ytmp;
       rotation += encodedAngles_[NHalfPi];
     } else {
       // West, rotate by pi
       x = -x;
       y = -y;
       rotation += encodedAngles_[Pi];
     }
   }
   if (debug_)
     std::cout << "Coarse rotate" << std::endl;
   if (debug_)
     printVals();
 
   if (debug_)
     std::cout << "Starting iterations" << std::endl;
   for (int i = 1; i <= iterations_; ++i) {
     int sign = (y >= 0) ? -1 : 1;
     int xtmp = x - sign * (y >> i);
     int ytmp = y + sign * (x >> i);
     x = xtmp;
     y = ytmp;
     rotation += sign * rotations_[i - 1];
     if (debug_)
       printVals();
   }
 
   // need a little extra room for the last multiplication
   aMagnitude = ((long)x * (long)scaleFactor_) >> (2 * internalBits_ - outputBits_ - 1);
 
   // Xilinx seems to just mod to [-pi,pi]
   if (rotation > encodedAngles_[Pi])
     rotation -= 2 * encodedAngles_[Pi] + 1;
   aPhi = (-rotation) >> (internalBits_ - outputBits_);
 }