void equalizer_chain_seq(LTE_PHY_PARAMS *lte_phy_params)
{
int i;
double tstart, tend, ttime;
int h;
geneDMRS(lte_phy_params->DMRS, lte_phy_params->N_tx_ant, lte_phy_params->N_dft_sz);
// SubCarrierMapping(lte_phy_params, lte_phy_params->resm_in, lte_phy_params->resm_out);
// ofmodulating(lte_phy_params, lte_phy_params->resm_out, lte_phy_params->ofmod_out);
ttime = 0.0;
// rapl_power_start();
tstart = dtime();
ofdemodulating(lte_phy_params, lte_phy_params->ofdemod_in, lte_phy_params->ofdemod_out);
tend = dtime();
ttime = ttime + (tend - tstart);
printf("time_ofdm %.3f s\n", ttime / 1000.0);
for (h = 0; h < 100; h++) {
// tstart = dtime();
SubCarrierDemapping(lte_phy_params, lte_phy_params->ofdemod_out, lte_phy_params->resdm_out);
// tend = dtime();
// ttime = ttime + (tend - tstart);
// tstart = dtime();
Equalizing(lte_phy_params, lte_phy_params->resdm_out, lte_phy_params->eq_out);
// tend = dtime();
// ttime = ttime + (tend - tstart);
// rapl_power_stop();
// printf("%.3fms\n", ttime);
}
}
void LSFreqDomain(float pInpData[/*N_EQ_IN_MAX*/N_EQ_IN * 2], float pOutData[/*N_EQ_OUT_MAX*/N_EQ_OUT * 2], int MDFT, int NumLayer, int NumRxAntenna)
{
// float pDMRS[2 * LTE_PHY_N_ANT_MAX * LTE_PHY_DFT_SIZE_MAX * 2];
float pDMRS[2 * NUM_LAYER * NUM_DFT * 2];
// printf("LSFreqDomain: %d %d %d\n", MDFT, NumLayer, NumRxAntenna);
// pDMRS = (*VpUser).GetpDMRS();
geneDMRS(pDMRS, NumLayer, MDFT);
for (int m = 0; m < /*MDFT*/ NUM_DFT; m++)
{
//#pragma HLS PIPELINE II=20
//#pragma HLS DEPENDENCE array inter false
float pXt[2 * LTE_PHY_N_ANT_MAX * 2];
float pXtDagger[LTE_PHY_N_ANT_MAX * 2 * 2];
for (int slot = 0; slot < 2; slot++)
{
for (int layer = 0; layer < /*NumLayer*/NUM_LAYER; layer++)
{
//#pragma HLS PIPELINE
//#pragma HLS DEPENDENCE array inter false
// pXt[slot * NumLayer + layer] = pDMRS[(slot * NumLayer + layer) * MDFT + m];
pXt[2 * (slot * NumLayer + layer) + 0] = pDMRS[2 * ((slot * NumLayer + layer) * MDFT + m) + 0];
pXt[2 * (slot * NumLayer + layer) + 1] = pDMRS[2 * ((slot * NumLayer + layer) * MDFT + m) + 1];
// pXtDagger[layer * 2 + slot] = conj(pDMRS[(slot * NumLayer + layer) * MDFT + m]);
pXtDagger[2 * (layer * 2 + slot) + 0] = pDMRS[2 * ((slot * NumLayer + layer) * MDFT + m) + 0];
pXtDagger[2 * (layer * 2 + slot) + 1] = (-1.0) * pDMRS[2 * ((slot * NumLayer + layer) * MDFT + m) + 1];
}
}
// float pYt[2 * LTE_PHY_N_ANT_MAX * 2];
float pYt[2 * NUM_RX_ANTENNA * 2];
for (int slot = 0; slot < 2; slot++)
{
for (int nrx = 0; nrx < /*NumRxAntenna*/ NUM_RX_ANTENNA; nrx++)
{
//#pragma HLS PIPELINE
//#pragma HLS DEPENDENCE array inter false
// pYt[slot * NumRxAntenna + nrx] = pInpData[(nrx * 2 + slot) * MDFT + m];
pYt[2 * (slot * NumRxAntenna + nrx) + 0] = pInpData[2 * ((nrx * 2 + slot) * MDFT + m) + 0];
pYt[2 * (slot * NumRxAntenna + nrx) + 1] = pInpData[2 * ((nrx * 2 + slot) * MDFT + m) + 1];
}
}
// float pHTranspose[LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX * 2];
float pHTranspose[NUM_LAYER * NUM_RX_ANTENNA * 2];
FDLSEstimation(pXt, pXtDagger, pYt, pHTranspose, NumLayer, NumRxAntenna);
FDLSEqualization(pInpData, pHTranspose, m, NumLayer, NumRxAntenna, MDFT, pOutData);
}
}
inline void LSFreqDomain(float *pInpData, float *pOutData, int MDFT, int NumLayer, int NumRxAntenna, int NumULSymbSF)
{
int inp_len = NumLayer * NumULSymbSF * MDFT;
int out_len = NumLayer * (NumULSymbSF - 2) * MDFT;
int dmrs_len = NumLayer * MDFT * 2;
float *pDMRS = (float *)malloc(2 * dmrs_len * sizeof(float));
geneDMRS(pDMRS, NumLayer, MDFT);
for (int m = 0; m < MDFT; m++)
{
int xt_len = 2 * NumLayer;
float pXt[2 * (2 * LTE_PHY_N_ANT_MAX)];
float pXtDagger[2 * (LTE_PHY_N_ANT_MAX * 2)];
for (int slot = 0; slot < 2; slot++)
{
for (int layer = 0; layer < NumLayer; layer++)
{
// pXt[slot * NumLayer + layer] = pDMRS[(slot * NumLayer + layer) * MDFT + m];
pXt[slot * NumLayer + layer] = pDMRS[(slot * NumLayer + layer) * MDFT + m];
pXt[slot * NumLayer + layer + xt_len] = pDMRS[(slot * NumLayer + layer) * MDFT + m + dmrs_len];
// pXtDagger[layer * 2 + slot] = conj(pDMRS[(slot * NumLayer + layer) * MDFT + m]);
pXtDagger[layer * 2 + slot] = pDMRS[(slot * NumLayer + layer) * MDFT + m];
pXtDagger[layer * 2 + slot + xt_len] = (-1.0) * pDMRS[(slot * NumLayer + layer) * MDFT + m + dmrs_len];
}
}
int yt_len = NumRxAntenna * 2;
float pYt[2 * (2 * LTE_PHY_N_ANT_MAX)];
for (int slot = 0; slot < 2; slot++)
{
for (int nrx = 0; nrx < NumRxAntenna; nrx++)
{
// pYt[slot * NumRxAntenna + nrx] = pInpData[(nrx * 2 + slot) * MDFT + m];
pYt[slot * NumRxAntenna + nrx] = pInpData[(nrx * 2 + slot) * MDFT + m];
pYt[slot * NumRxAntenna + nrx + yt_len] = pInpData[(nrx * 2 + slot) * MDFT + m + inp_len];
}
}
float pHTranspose[2 * (LTE_PHY_N_ANT_MAX * LTE_PHY_N_ANT_MAX)];
FDLSEstimation(pXt, pXtDagger, pYt, pHTranspose, NumLayer, NumRxAntenna);
FDLSEqualization(pInpData, pHTranspose, m, NumLayer, NumRxAntenna, MDFT, NumULSymbSF, pOutData);
}
free(pDMRS);
}
void UserPara::initUserPara()
{
NIFFT=(*VpBS).NIFFT;
CPLen=(*VpBS).CPLen;
NumULSymbSF=14;
RSu=(*VpBS).RSU;
RSv=(*VpBS).RSV;
MQAM=(*VpBS).MQAMPerUser;
MDFT=(*VpBS).MDFTPerUser;
NumLayer=(*VpBS).NumLayerPerUser;
SCLoc=(*VpBS).SCLocPattern;
DataLength=(*VpBS).DataLengthPerUser;
DMRSSymbPos[0]=(*VpBS).DMRSSymbPos[0];
DMRSSymbPos[1]=(*VpBS).DMRSSymbPos[1];
ProcessingStatusFlag=(*VpBS).ProcessingStatusFlag;
BufferSizeFlag = (*VpBS).BufferSizeFlag;
NInfoBits = MDFT*(NumULSymbSF-2)*((int)((log((double)MQAM))/(log(2.0))));
QAMLen = MDFT*(NumULSymbSF-2);
ncs[0]=3;ncs[1]=11;
pDMRS = new complex<float>**[2];
for(int slot=0;slot<2;slot++){*(pDMRS+slot)=new complex<float>*[NumLayer];}
for(int slot=0;slot<2;slot++)
{
for(int layer=0;layer<NumLayer;layer++)
{*(*(pDMRS+slot)+layer)=new complex<float>[MDFT];}
}
bool zcFlag=true;
int idx=0;
while(zcFlag)
{
if(pPrimeTable[idx][0]==MDFT)
{
Nzc=pPrimeTable[idx][1];
zcFlag=false;
}
else
{idx++;}
}
geneDMRS();
}
void SubCarrierMapping(/*LTE_PHY_PARAMS *lte_phy_params, */
float pInpData[N_RESMAPPER_IN_MAX * 2],
float pOutData[N_RESMAPPER_OUT_MAX * 2],
int dmrs_symb_pos[2],
int NumLayer,
int SCLoc,
int NIFFT,
int MDFT)
{
// int NumLayer = lte_phy_params->N_tx_ant;
int NumULSymbSF = LTE_PHY_N_SYMB_PER_SUBFR;
// int SCLoc = lte_phy_params->sc_loc;
// int NIFFT = lte_phy_params->N_fft_sz;
// int MDFT = lte_phy_params->N_dft_sz;
float DMRS[2 * LTE_PHY_N_ANT_MAX * LTE_PHY_DFT_SIZE_MAX * 2];
geneDMRS(DMRS, NumLayer, MDFT);
for (int nlayer = 0; nlayer < NumLayer; nlayer++)
{
for (int nsym = 0; nsym < NumULSymbSF; nsym++)
{
int SymIdx = nlayer * NumULSymbSF + nsym;
for (int n = 0; n < NIFFT; n++)
{
// pOutData[SymIdx * NIFFT + n] = std::complex<float>(1.0, 0.0);
pOutData[2 * (SymIdx * NIFFT + n) + 0] = 1.0;
pOutData[2 * (SymIdx * NIFFT + n) + 1] = 0.0;
}
}
}
for (int nlayer = 0; nlayer < NumLayer; nlayer++)
{
int DMRSslot = 0;
for (int nsym = 0; nsym < NumULSymbSF; nsym++)
{
int SymIdx = nlayer * NumULSymbSF + nsym;
if (nsym == /*lte_phy_params->*/dmrs_symb_pos[DMRSslot])
{
for (int n = SCLoc; n < SCLoc + MDFT; n++)
{
// pOutData[SymIdx * NIFFT + n] = *(*(*(VpDMRS + DMRSslot) + nlayer) + n - SCLoc);
// pOutData[SymIdx * NIFFT + n] = DMRS[(DMRSslot * NumLayer + nlayer) * MDFT + (n - SCLoc)];
pOutData[2 * (SymIdx * NIFFT + n) + 0] = DMRS[2 * ((DMRSslot * NumLayer + nlayer) * MDFT + (n - SCLoc)) + 0];
pOutData[2 * (SymIdx * NIFFT + n) + 1] = DMRS[2 * ((DMRSslot * NumLayer + nlayer) * MDFT + (n - SCLoc)) + 1];
}
DMRSslot++;
}
else
{
for (int n = SCLoc; n < SCLoc + MDFT; n++)
{
// *(*(pOutData+SymIdx)+n)=*(*(pInpData+nlayer*(NumULSymbSF-2)+nsym-DMRSslot)+n-SCLoc);
// pOutData[SymIdx * NIFFT + n] = pInpData[nlayer * (NumULSymbSF - 2) * MDFT + (nsym - DMRSslot) * MDFT + n - SCLoc];
pOutData[2 * (SymIdx * NIFFT + n) + 0] = pInpData[2 * (nlayer * (NumULSymbSF - 2) * MDFT + (nsym - DMRSslot) * MDFT + n - SCLoc) + 0];
pOutData[2 * (SymIdx * NIFFT + n) + 1] = pInpData[2 * (nlayer * (NumULSymbSF - 2) * MDFT + (nsym - DMRSslot) * MDFT + n - SCLoc) + 1];
}
}
}
}
}
