CordicXilinx Class Reference

#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

anonymous enum

private

Enumerator
Pi
HalfPi
NHalfPi

Definition at line 29 of file CordicXilinx.h.

{ Pi, HalfPi, NHalfPi };

Constructor & Destructor Documentation

CordicXilinx()

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_, dqm-mbProfile::log, M_PI, NHalfPi, Pi, funct::pow(), idealTransformation::rotation, rotations_, 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

encodeAngle()

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;
}

operator()()

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(), simKBmtfDigis_cfi::aPhi, cms::cuda::assert(), gather_cfg::cout, debug_, encodedAngles_, HalfPi, mps_fire::i, inputBits_, internalBits_, iterations_, NHalfPi, outputBits_, Pi, funct::pow(), idealTransformation::rotation, rotations_, scaleFactor_, Validation_hcalonly_cfi::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_);
}

Member Data Documentation

debug_

const bool CordicXilinx::debug_

private

Definition at line 24 of file CordicXilinx.h.

Referenced by CordicXilinx(), and operator()().

encodedAngles_

std::array<int, 3> CordicXilinx::encodedAngles_

private

Definition at line 28 of file CordicXilinx.h.

Referenced by CordicXilinx(), and operator()().

inputBits_

const int CordicXilinx::inputBits_

private

Definition at line 22 of file CordicXilinx.h.

Referenced by operator()().

internalBits_

int CordicXilinx::internalBits_

private

Definition at line 31 of file CordicXilinx.h.

Referenced by CordicXilinx(), encodeAngle(), and operator()().

iterations_

int CordicXilinx::iterations_

private

Definition at line 30 of file CordicXilinx.h.

Referenced by CordicXilinx(), and operator()().

outputBits_

const int CordicXilinx::outputBits_

private

Definition at line 23 of file CordicXilinx.h.

Referenced by operator()().

rotations_

std::vector<int> CordicXilinx::rotations_

private

Definition at line 26 of file CordicXilinx.h.

Referenced by CordicXilinx(), and operator()().

scaleFactor_

int CordicXilinx::scaleFactor_

private

Definition at line 32 of file CordicXilinx.h.

Referenced by CordicXilinx(), and operator()().