int Virtex6::getIntNAdderCost(int wIn, int n)
{
int chunkSize, lastChunkSize, nr, a, b, cost;
suggestSubaddSize(chunkSize, wIn);
lastChunkSize = wIn%chunkSize;
nr = ceil((double) wIn/chunkSize);
// IntAdder
a = (nr-1)*nr*chunkSize/2 + (nr-1)*lastChunkSize;
b = nr*lastChunkSize + (nr-1)*nr*chunkSize/2;
if (nr > 2) // carry
{
a += (nr-1)*(nr-2)/2;
}
if (nr == 3) // SRL16E
{
a += chunkSize;
}
else if (nr > 3) // SRL16E, FDE
{
a += (nr-3)*chunkSize + 1;
b += (nr-3)*chunkSize + 1;
}
// IntNAdder
if (n >= 3)
{
a += (2*n-4)*wIn + 1;
b += (2*n-5)*wIn;
}
cost = a+b*0.25;
return cost;
}
int Virtex6::getIntMultiplierCost(int wInX, int wInY){
int cost = 0;
int halfLut = lutInputs_/2;
int cx = int(ceil((double) wInX/halfLut)); // number of chunks on X
int cy = int(ceil((double) wInY/halfLut)); // number of chunks on Y
int padX = cx*halfLut - wInX; // zero padding of X input
int padY = cy*halfLut - wInY; // zero padding of Y input
if (cx > cy) // set cx as the min and cy as the max
{
int tmp = cx;
cx = cy;
cy = tmp;
tmp = padX;
padX = padY;
padY = tmp;
}
float p = (double)cy/(double)halfLut; // number of chunks concatenated per operand
float r = p - floor(p); // relative error; used for detecting how many operands have ceil(p) chunks concatenated
int chunkSize, aux;
suggestSubaddSize(chunkSize, wInX+wInY);
// int lastChunkSize = (wInX+wInY)%chunkSize;
// int nr = ceil((double) (wInX+wInY)/chunkSize);
if (r == 0.0) // all IntNAdder operands have p concatenated partial products
{
aux = halfLut*cx; // number of operands having p concatenated chunks
if (aux <= 4)
cost = p*lutInputs_*(aux-2)*(aux-1)/2-(padX*cx*(cx+1)+padY*aux*(aux+1))/2; // registered partial products without zero paddings
else
cost = p*lutInputs_*3 + p*lutInputs_*(aux-4)-(padX*(cx+1)+padY*(aux+1)); // registered partial products without zero paddings including SRLs
}
else if (r > 0.5) // 2/3 of the IntNAdder operands have p concatenated partial products
{
aux = (halfLut-1)*cx; // number of operands having p concatenated chunks
if (halfLut*cx <= 4)
cost = ceil(p)*lutInputs_*(aux-2)*(aux-1)/2 + floor(p)*lutInputs_*((aux*cx)+(cx-2)*(cx-1)/2);// registered partial products without zero paddings
else
{
if (aux - 4 > 0)
{
cost = ceil(p)*lutInputs_*3 - padY - 2*padX + // registered partial products without zero paddings
(ceil(p)*lutInputs_-padY) * (aux-4) + // SRLs for long concatenations
(floor(p)*lutInputs_*cx - cx*padY); // SRLs for shorter concatenations
}
else
{
cost = ceil(p)*lutInputs_*(aux-2)*(aux-1)/2 + floor(p)*lutInputs_*((aux*cx)+(cx+aux-6)*(cx+aux-5)/2); // registered partial products without zero paddings
cost += (floor(p)*lutInputs_-padY) * (aux+cx-4); // SRLs for shorter concatenations
}
}
}
else if (r > 0) // 1/3 of the IntNAdder operands have p concatenated partial products
{
aux = (halfLut-1)*cx; // number of operands having p concatenated chunks
if (halfLut*cx <= 4)
cost = ceil(p)*lutInputs_*(cx-2)*(cx-1)/2 + floor(p)*lutInputs_*((aux*cx)+(aux-2)*(aux-1)/2);// registered partial products without zero paddings
else
{
cost = ceil(p)*lutInputs_*(cx-2)*(cx-1)/2 + floor(p)*lutInputs_*((aux*cx)+(aux-2)*(aux-1)/2);// registered partial products without zero paddings
if (cx - 4 > 0)
{
cost = ceil(p)*lutInputs_*3 - padY - 2*padX; // registered partial products without zero paddings
cost += ceil(p)*lutInputs_*(cx-4) - (cx-4)*padY; // SRLs for long concatenations
cost += floor(p)*lutInputs_*aux - aux*padY; // SRLs for shorter concatenations
}
else
{
cost = ceil(p)*lutInputs_*(cx-2)*(cx-1)/2 + floor(p)*lutInputs_*((aux*cx)+(cx+aux-6)*(cx+aux-5)/2); // registered partial products without zero paddings
cost += (floor(p)*lutInputs_-padY) * (aux+cx-4); // SRLs for shorter concatenations
}
}
}
aux = halfLut*cx;
cost += p*lutInputs_*aux + halfLut*(aux-1)*aux/2; // registered addition results on each pipeline stage of the IntNAdder
if (padX+padY > 0)
cost += (cx-1)*(cy-1)*lutInputs_ + cx*(lutInputs_-padY) + cy*(lutInputs_-padX);
else
cost += cx*cy*lutInputs_; // LUT cost for small multiplications
return cost*5/8;
};
int Virtex5::getIntNAdderCost(int wIn, int n)
{
/* compressor tree cost */
int p = n, q = 0;
int levels = 0;
do{
while (p - 6 > 0){
p-=6;
q+=3;
}
while (p - 5 > 0){
p-=5;
q+=3;
}
while (p - 4 > 0){
p-=4;
q+=3;
}
while (p - 3 > 0){
p-=3;
q+=2;
}
levels++;
p=q;
q=0;
}while (p>2);
/* at this point levels holds the number of lut levels*/
int alpha, beta, k, intAdderCost;
suggestSubaddSize(alpha, wIn);
beta = (wIn % alpha == 0? alpha: wIn % alpha);
k = (wIn % alpha ==0? wIn/alpha: wIn/alpha + 1);
intAdderCost = (4*k-7)*alpha + 3*beta;
return (intAdderCost + levels*wIn);
/*
int chunkSize, lastChunkSize, nr, a, b, cost;
suggestSubaddSize(chunkSize, wIn);
lastChunkSize = wIn%chunkSize;
nr = ceil((double) wIn/chunkSize);
// IntAdder
a = (nr-1)*nr*chunkSize/2 + (nr-1)*lastChunkSize;
b = nr*lastChunkSize + (nr-1)*nr*chunkSize/2;
if (nr > 2) // carry
{
a += (nr-1)*(nr-2)/2;
}
if (nr == 3) // SRL16E
{
a += chunkSize;
}
else if (nr > 3) // SRL16E, FDE
{
a += (nr-3)*chunkSize + 1;
b += (nr-3)*chunkSize + 1;
}
// IntNAdder
if (n >= 3)
{
a += (2*n-4)*wIn + 1;
b += (2*n-5)*wIn;
}
cost = a+b*0.25;
return cost;
*/
}
