trklet::VarInv Class Reference

#include <imath.h>

Inheritance diagram for trklet::VarInv:

Public Types
enum	mode { pos, neg, both }

Public Member Functions
int	addr_to_ival (int addr)
int	gen_inv (int i)
void	initLUT (double offset)
double	Ioffset ()
int	ival_to_addr (int ival)
void	local_calculate () override
double	offset ()
void	print (std::ofstream &fs, Verilog, int l1=0, int l2=0, int l3=0) override
void	print (std::ofstream &fs, HLS, int l1=0, int l2=0, int l3=0) override
void	set_mode (mode m)
	VarInv (imathGlobals *globals, std::string name, VarBase *p1, double offset, int nbits, int n, unsigned int shift, mode m, int nbaddr=-1)
void	writeLUT (std::ofstream &fs) const
void	writeLUT (std::ofstream &fs, Verilog) const
void	writeLUT (std::ofstream &fs, HLS) const
	~VarInv () override
Public Member Functions inherited from trklet::VarBase
void	add_cut (VarCut *cut, const bool call_set_cut_var=true)
void	add_delay (int i)
void	add_latency (unsigned int l)
void	analyze ()
void	calcDebug (int debug_level, long int ival_prev, bool &all_ok)
bool	calculate (int debug_level=0)
VarBase *	cut_var ()
std::string	dump ()
void	dump_msg ()
double	fval () const
bool	has_delay (int i)
void	inputs (std::vector< VarBase *> *vd)
long int	ival () const
double	K () const
std::map< std::string, int >	Kmap () const
std::string	kstring () const
int	latency () const
bool	local_passes () const
void	makeready ()
double	maxval () const
double	minval () const
std::string	name () const
int	nbits () const
std::string	op () const
VarBase *	p1 () const
VarBase *	p2 () const
VarBase *	p3 () const
void	passes (std::map< const VarBase *, std::vector< bool > > &passes, const std::map< const VarBase *, std::vector< bool > > *const previous_passes=nullptr) const
int	pipe_counter ()
std::string	pipe_delays (const int step)
void	pipe_increment ()
void	print_all (std::ofstream &fs, Verilog)
void	print_all (std::ofstream &fs, HLS)
void	print_cuts (std::map< const VarBase *, std::set< std::string > > &cut_strings, const int step, Verilog, const std::map< const VarBase *, std::set< std::string > > *const previous_cut_strings=nullptr) const
void	print_cuts (std::map< const VarBase *, std::set< std::string > > &cut_strings, const int step, HLS, const std::map< const VarBase *, std::set< std::string > > *const previous_cut_strings=nullptr) const
void	print_step (int step, std::ofstream &fs, Verilog)
void	print_step (int step, std::ofstream &fs, HLS)
void	print_truncation (std::string &t, const std::string &o1, const int ps, Verilog) const
void	print_truncation (std::string &t, const std::string &o1, const int ps, HLS) const
double	range () const
void	reset ()
int	shift () const
int	step () const
	VarBase (imathGlobals *globals, std::string name, VarBase *p1, VarBase *p2, VarBase *p3, int l)
virtual	~VarBase ()

Protected Attributes
unsigned int	ashift_
int *	LUT
mode	m_
unsigned int	mask_
int	n_
int	nbaddr_
int	Nelements_
double	offset_
unsigned int	shift_
Protected Attributes inherited from trklet::VarBase
VarBase *	cut_var_
std::vector< VarBase * >	cuts_
double	fval_
imathGlobals *	globals_
long int	ival_
double	K_
std::map< std::string, int >	Kmap_
int	latency_
double	maxval_
double	minval_
std::string	name_
int	nbits_
std::string	op_
VarBase *	p1_
VarBase *	p2_
VarBase *	p3_
int	pipe_counter_
std::vector< int >	pipe_delays_
bool	readytoanalyze_
bool	readytoprint_
int	step_
bool	usedasinput_
double	val_

Additional Inherited Members
Static Public Member Functions inherited from trklet::VarBase
static void	design_print (const std::vector< VarBase *> &v, std::ofstream &fs, Verilog)
static void	design_print (const std::vector< VarBase *> &v, std::ofstream &fs, HLS)
static void	hls_print (const std::vector< VarBase *> &v, std::ofstream &fs)
static std::string	itos (int i)
static std::string	pipe_delay (VarBase *v, int nbits, int delay)
static std::string	pipe_delay_wire (VarBase *v, std::string name_delayed, int nbits, int delay)
static void	verilog_print (const std::vector< VarBase *> &v, std::ofstream &fs)
Static Public Attributes inherited from trklet::VarBase
static struct trklet::VarBase::HLS	hls
static struct trklet::VarBase::Verilog	verilog

Detailed Description

Definition at line 956 of file imath.h.

Member Enumeration Documentation

mode

enum trklet::VarInv::mode

Enumerator
pos
neg
both

Definition at line 958 of file imath.h.

{ pos, neg, both };

Constructor & Destructor Documentation

VarInv()

trklet::VarInv::VarInv ( imathGlobals *  globals, std::string  name, VarBase *  p1, double  offset, int  nbits, int  n, unsigned int  shift, mode  m, int  nbaddr = -1  )

inline

Definition at line 960 of file imath.h.

References addr_to_ival(), ashift_, reco::HaloData::both, gen_inv(), mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, createfilelist::int, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, trklet::VarBase::K(), trklet::VarBase::K_, trklet::VarBase::Kmap(), trklet::VarBase::Kmap_, visualization-live-secondInstance_cfg::m, m_, mask_, dqmiodumpmetadata::n, n_, nbaddr_, trklet::VarBase::nbits(), trklet::VarBase::nbits_, Nelements_, offset(), offset_, trklet::VarBase::op_, trklet::VarBase::p1(), trklet::VarBase::p1_, funct::pow(), trklet::VarBase::shift(), and shift_.

        : VarBase(globals, name, p1, nullptr, nullptr, LUT_LATENCY) {
      op_ = "inv";
      offset_ = offset;
      nbits_ = nbits;
      n_ = n;
      shift_ = shift;
      m_ = m;
      if (nbaddr < 0)
        nbaddr = p1->nbits();
      nbaddr_ = nbaddr - shift;
      if (m_ != mode::both)
        nbaddr_--;
      Nelements_ = 1 << nbaddr_;
      mask_ = Nelements_ - 1;
      ashift_ = sizeof(int) * 8 - nbaddr_;

      const std::map<std::string, int> map1 = p1->Kmap();
      for (const auto &it : map1)
        Kmap_[it.first] = -it.second;
      Kmap_["2"] = Kmap_["2"] - n;
      K_ = pow(2, -n) / p1->K();

      LUT = new int[Nelements_];
      double offsetI = lround(offset_ / p1_->K());
      for (int i = 0; i < Nelements_; ++i) {
        int i1 = addr_to_ival(i);
        LUT[i] = gen_inv(offsetI + i1);
      }
    }

~VarInv()

trklet::VarInv::~VarInv ( )

inlineoverride

Definition at line 998 of file imath.h.

References LUT.

{ delete[] LUT; }

Member Function Documentation

addr_to_ival()

int trklet::VarInv::addr_to_ival ( int  addr )

inline

Definition at line 1013 of file imath.h.

References generateTowerEtThresholdLUT::addr, ashift_, cms::cuda::assert(), l1t::bitShift(), reco::HaloData::both, m_, Nelements_, and shift_.

Referenced by initLUT(), and VarInv().

                               {
      switch (m_) {
        case mode::pos:
          return l1t::bitShift(addr, shift_);
        case mode::neg:
          return l1t::bitShift((addr - Nelements_), shift_);
        case mode::both:
          return l1t::bitShift(addr, ashift_) >> (ashift_ - shift_);
      }
      assert(0);
    }

gen_inv()

int trklet::VarInv::gen_inv ( int  i )

inline

Definition at line 1024 of file imath.h.

References mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, createfilelist::int, n_, trklet::VarBase::nbits_, and shift_.

Referenced by initLUT(), and VarInv().

                       {
      unsigned int ms = sizeof(int) * 8 - nbits_;
      int lut = 0;
      if (i > 0) {
        int i1 = i + (1 << shift_) - 1;
        int lut1 = (lround((1 << n_) / i) << ms) >> ms;
        int lut2 = (lround((1 << n_) / (i1)) << ms) >> ms;
        lut = 0.5 * (lut1 + lut2);
      } else if (i < -1) {
        int i1 = i + (1 << shift_) - 1;
        int i2 = i;
        int lut1 = (lround((1 << n_) / i1) << ms) >> ms;
        int lut2 = (lround((1 << n_) / i2) << ms) >> ms;
        lut = 0.5 * (lut1 + lut2);
      }
      return lut;
    }

initLUT()

void VarInv::initLUT

(

double

offset

)

Definition at line 142 of file imath.cc.

References addr_to_ival(), gen_inv(), mps_fire::i, testProducerWithPsetDescEmpty_cfi::i1, trklet::VarBase::K(), Nelements_, offset(), offset_, and trklet::VarBase::p1_.

Referenced by trklet::IMATH_TrackletCalculator::IMATH_TrackletCalculator(), trklet::IMATH_TrackletCalculatorDisk::IMATH_TrackletCalculatorDisk(), and trklet::IMATH_TrackletCalculatorOverlap::IMATH_TrackletCalculatorOverlap().

                                  {
  offset_ = offset;
  double offsetI = lround(offset_ / p1_->K());
  for (int i = 0; i < Nelements_; ++i) {
    int i1 = addr_to_ival(i);
    LUT[i] = gen_inv(offsetI + i1);
  }
}

Ioffset()

double trklet::VarInv::Ioffset ( )

inline

Definition at line 1003 of file imath.h.

References trklet::VarBase::K(), offset_, and trklet::VarBase::p1_.

{ return offset_ / p1_->K(); }

ival_to_addr()

int trklet::VarInv::ival_to_addr ( int  ival )

inline

Definition at line 1012 of file imath.h.

References trklet::VarBase::ival(), mask_, and shift_.

Referenced by local_calculate().

{ return ((ival >> shift_) & mask_); }

local_calculate()

void VarInv::local_calculate ( )

overridevirtual

Reimplemented from trklet::VarBase.

Definition at line 195 of file imath_calculate.cc.

References trklet::VarBase::fval(), trklet::VarBase::fval_, trklet::VarBase::ival(), trklet::VarBase::ival_, ival_to_addr(), offset_, and trklet::VarBase::p1_.

                             {
  fval_ = 1. / (offset_ + p1_->fval());
  ival_ = LUT[ival_to_addr(p1_->ival())];
}

offset()

double trklet::VarInv::offset ( )

inline

Definition at line 1002 of file imath.h.

References offset_.

Referenced by initLUT(), and VarInv().

{ return offset_; }

print() [1/2]

void VarInv::print ( std::ofstream &  fs, Verilog  , int  l1 = 0, int  l2 = 0, int  l3 = 0  )

overridevirtual

Reimplemented from trklet::VarBase.

Definition at line 287 of file imath_Verilog.cc.

References cms::cuda::assert(), compareTotals::fs, trklet::VarBase::itos(), mask_, trklet::VarBase::name(), trklet::VarBase::name_, nbaddr_, trklet::VarBase::nbits_, Nelements_, trklet::VarBase::p1_, shift_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, RandomServiceHelper::t1, and RandomServiceHelper::t2.

                                                                   {
  assert(p1_);
  assert(l2 == 0);
  assert(l3 == 0);
  std::string n1 = p1_->name();
  if (l1 > 0)
    n1 = n1 + "_delay" + itos(l1);
  //first calculate address
  std::string t1 = "addr_" + name_;
  std::string t = "wire [" + itos(nbaddr_ - 1) + ":0] " + t1 + ";\n";
  t = t + "assign " + t1 + " = ";
  if (shift_ > 0)
    t = t + "(" + n1 + ">>>" + itos(shift_) + ") & " + itos(mask_);
  else
    t = t + n1 + " & " + itos(mask_);
  fs << t << "; // address for the LUT\n";

  t = "wire signed [" + itos(nbits_ - 1) + ":0] " + name_ + ";\n";
  fs << t;

  std::string t2 = "LUT_" + name_;

  fs << "Memory #( \n";
  fs << "         .RAM_WIDTH(" << nbits_ << "),            // Specify RAM data width \n";
  fs << "         .RAM_DEPTH(" << Nelements_ << "),                     // Specify RAM depth (number of entries) \n";
  fs << "         .RAM_PERFORMANCE(\"HIGH_PERFORMANCE\"), // \"HIGH_PERFORMANCE\" = 2 clks latency \n";
  fs << "         .INIT_FILE() \n";
  fs << "       ) " << t2 << " ( \n";
  fs << "         .addra(" << itos(nbaddr_) << "\'b0),    // Write address bus, width determined from RAM_DEPTH  \n";
  fs << "         .addrb(" << t1 << " ),                   // Read address bus, width determined from RAM_DEPTH  \n";
  fs << "         .dina(" << itos(nbits_) << "\'b0),      // RAM input data, width determined from RAM_WIDTH   \n";
  fs << "         .clka(clk),      // Write clock \n";
  fs << "         .clkb(clk),      // Read clock  \n";
  fs << "         .wea(1\'b0),        // Write enable  \n";
  fs << "         .enb(1\'b1),        // Read Enable, for additional power savings, disable when not in use  \n";
  fs << "         .rstb(reset),      // Output reset (does not affect memory contents)                      \n";
  fs << "         .regceb(1\'b1),  // Output register enable                                                \n";
  fs << "         .doutb(" << name_ << ")     // RAM output data,                                                \n";
  fs << "     ); \n";
}

print() [2/2]

void VarInv::print ( std::ofstream &  fs, HLS  , int  l1 = 0, int  l2 = 0, int  l3 = 0  )

overridevirtual

Reimplemented from trklet::VarBase.

Definition at line 260 of file imath_HLS.cc.

References cms::cuda::assert(), compareTotals::fs, trklet::VarBase::itos(), mask_, trklet::VarBase::name(), trklet::VarBase::name_, nbaddr_, trklet::VarBase::nbits_, Nelements_, trklet::VarBase::p1_, shift_, AlCaHLTBitMon_QueryRunRegistry::string, submitPVValidationJobs::t, and RandomServiceHelper::t1.

                                                               {
  assert(p1_);
  assert(l1 == 0);
  assert(l2 == 0);
  assert(l3 == 0);

  fs << "static const ap_int<" << itos(nbits_) << "> LUT_" << name_ << "[" << Nelements_ << "] = {\n";
  fs << "#include \"LUT_" << name_ << ".h\"\n";
  fs << "};\n";

  std::string n1 = p1_->name();
  //first calculate address
  std::string t1 = "addr_" + name_;
  std::string t = "const ap_uint<" + itos(nbaddr_) + "> " + t1 + " = ";
  if (shift_ > 0)
    t = t + "(" + n1 + ">>" + itos(shift_) + ") & " + itos(mask_);
  else
    t = t + n1 + " & " + itos(mask_);
  fs << t << "; // address for the LUT\n";

  t = "const ap_int<" + itos(nbits_) + "> " + name_ + " = LUT_" + name_ + "[addr_" + name_ + "];\n";
  fs << t;
}

set_mode()

void trklet::VarInv::set_mode ( mode  m )

inline

Definition at line 1000 of file imath.h.

References visualization-live-secondInstance_cfg::m, and m_.

Referenced by trklet::IMATH_TrackletCalculatorDisk::IMATH_TrackletCalculatorDisk(), and trklet::IMATH_TrackletCalculatorOverlap::IMATH_TrackletCalculatorOverlap().

{ m_ = m; }

writeLUT() [1/3]

void trklet::VarInv::writeLUT ( std::ofstream &  fs ) const

inline

Definition at line 1008 of file imath.h.

References compareTotals::fs, trklet::VarBase::verilog, and writeLUT().

Referenced by writeLUT().

{ writeLUT(fs, verilog); }

writeLUT() [2/3]

void VarInv::writeLUT	(	std::ofstream &	fs,
		Verilog
	)		const

Definition at line 5 of file imath_Verilog.cc.

References TauDecayModes::dec, compareTotals::fs, mps_fire::i, trklet::VarBase::nbits_, and Nelements_.

                                                    {
  for (int i = 0; i < Nelements_; ++i)
    fs << std::hex << (LUT[i] & ((1 << nbits_) - 1)) << std::dec << "\n";
}

writeLUT() [3/3]

void VarInv::writeLUT	(	std::ofstream &	fs,
		HLS
	)		const

Definition at line 5 of file imath_HLS.cc.

References TauDecayModes::dec, compareTotals::fs, mps_fire::i, trklet::VarBase::nbits_, and Nelements_.

                                                {
  for (int i = 0; i < Nelements_ - 1; ++i)
    fs << "0x" << std::hex << (LUT[i] & ((1 << nbits_) - 1)) << std::dec << ",\n";
  fs << "0x" << std::hex << (LUT[Nelements_ - 1] & ((1 << nbits_) - 1)) << std::dec << "\n";
}

Member Data Documentation

ashift_

unsigned int trklet::VarInv::ashift_

protected

Definition at line 1048 of file imath.h.

Referenced by addr_to_ival(), and VarInv().

LUT

int* trklet::VarInv::LUT

protected

Definition at line 1052 of file imath.h.

Referenced by ~VarInv().

m_

mode trklet::VarInv::m_

protected

Definition at line 1045 of file imath.h.

Referenced by addr_to_ival(), set_mode(), and VarInv().

mask_

unsigned int trklet::VarInv::mask_

protected

Definition at line 1047 of file imath.h.

Referenced by ival_to_addr(), print(), and VarInv().

n_

int trklet::VarInv::n_

protected

Definition at line 1044 of file imath.h.

Referenced by gen_inv(), and VarInv().

nbaddr_

int trklet::VarInv::nbaddr_

protected

Definition at line 1050 of file imath.h.

Referenced by print(), and VarInv().

Nelements_

int trklet::VarInv::Nelements_

protected

Definition at line 1049 of file imath.h.

Referenced by addr_to_ival(), initLUT(), print(), VarInv(), and writeLUT().

offset_

double trklet::VarInv::offset_

protected

Definition at line 1043 of file imath.h.

Referenced by initLUT(), Ioffset(), local_calculate(), offset(), and VarInv().

shift_

unsigned int trklet::VarInv::shift_

protected

Definition at line 1046 of file imath.h.

Referenced by addr_to_ival(), gen_inv(), ival_to_addr(), print(), and VarInv().