decodehelpers.c

This a framework to test new ideas in transmission technology. Actual development is a LDPC-coder in

#include "decodehelpers.h"
#include "sse2mmx.h"
#include "lookup.h"
//#include <sys/time.h>
#define DBG_LVL 3

#define MAXMESSAGE 50



/************************************
* copy the received values into the *
* appropriate places in the graph   *
************************************/
void initializegraph(graphstemp *graph, double *received) {
  int node, socket;
  int degindex,dispindex;
  int temp=0;
  for (node=0; node<(*graph).vnodenum; node++) {
    degindex = (*graph).vdegreelookup[(*graph).vdegrees[node]];
    dispindex = (*graph).vdegreedisp[node];
    vnodevalue =(int) (*(received + node)*T/MAX_VALUE);
  }
  for (degindex=0; degindex<(*graph).vdegreesnum; degindex++)
    for(dispindex=0;dispindex<(*(*graph).vdegreelist).numofnodes[degindex];dispindex++)
      for (socket=0; socket<(*(*graph).vdegreelist).degree[degindex]; socket++) {
        vmessage = 0;
      }
  for (degindex=0; degindex<(*graph).cdegreesnum; degindex++)
    for(dispindex=0;dispindex<(*(*graph).cdegreelist).numofnodes[degindex];dispindex++)
      for (socket=0; socket<(*(*graph).cdegreelist).degree[degindex]; socket++) {
        cmessage = 0;
      }
}


/**********************************
* make decisions on current graph *
**********************************/
void makedecisions(graphstemp *graph, int *decisions) {
  int socket,degindex,dispindex,node,numnode;
  short int sum[8],i=0;
  int temp1,temp2;
  int lim;
  for (degindex=0; degindex<(*graph).vdegreesnum; degindex++) {
    numnode = (*(*graph).vdegreelist).numofnodes[degindex];
    temp1=numnode/8;
    temp2=numnode%8;
    if(temp1>0)
      lim=8;
    else
      lim = temp2;
    for(dispindex=0;dispindex<numnode;) {
      /* take sum over all inputs */
      load7(&vnodevalue);
      node=vvalue;
      for (socket=0; socket<vnodedeg; socket++)
        add
          (&vmessage);
      retrieve7(sum);
      for(i=0;i<lim;i++) {
        node = vvalue;
        dispindex++;
        if(sum[i]>0)
          *(decisions+node)=0;
        else
          *(decisions+node)=1;
      }
      if(temp1>1) {
        temp1--;
      } else
        // This is the case when the number of nodes left are
        // less than 8.
        lim=temp2;

    }
  }
}

/************************************
* message map at the variable nodes *
* schedule can be used if we want   *
* the decoder to be time variant    *
* currently it is not used          *
************************************/
void variablemessagemap(graphstemp *graph) {
  int  socket;
  int degindex,dispindex,numnode,deg;
  int lim,temp1,temp2,temp=0;
  short int newmessage[8];
  init(T);
  for (degindex=0; degindex<(*graph).vdegreesnum; degindex++) {
    deg = (*(*graph).vdegreelist).degree[degindex];
    numnode = (*(*graph).vdegreelist).numofnodes[degindex];
    temp1 = numnode / 8;
    temp2 = numnode % 8;
    if(temp1>0)
      lim = 8;
    else
      lim=temp2;
    //printf("The value of temp1 and temp2 are %d , %d \n",temp1,temp2);
    for(dispindex=0;dispindex<numnode;) {
      load7(&vnodevalue);
      for (socket=0; socket<deg; socket++) {
        /* take sum over all inputs */
        add
          (&vmessage);

      }

      /* now determine all the outgoing messages */
      for (socket=0; socket<deg; socket++) {
        temp=0;
        sub(&vmessage);
        limit();
        retrieve0(newmessage);
        for(;temp<lim;temp++) {
          ctomessage=newmessage[temp];
        }
      }
      dispindex+=lim;
      if(temp1>1) {
        temp1--;
      } else
        // This is the case when the number of
        // nodes left are less than 8
      {
        //	    printf("The number of nodes left are less than 8 \n");
        lim = temp2;
      }

    }
  }
}

/*********************************
* message map at the check nodes *
*********************************/
void checkmessagemap(graphstemp *graph) {
  int socket;
  int degindex,dispindex,numnode,deg;
  int ernum1[8],ernum2[8],error;
  extern short int * prod;
  extern float **lower, ** higher;
  int temp1,temp2,lim;
  int temp=0;
  load2TA();
  for (degindex=0; degindex<(*graph).cdegreesnum; degindex++) {
    deg = (*(*graph).cdegreelist).degree[degindex];
    numnode = (*(*graph).cdegreelist).numofnodes[degindex];
    temp1=numnode/8;
    temp2=numnode%8;
    if(temp1>0)
      lim=8;
    else
      lim = temp2;
    for(dispindex=0;dispindex<numnode;) {
      init67TA();
      error=-1;
      for(temp=0;temp<lim;temp++) {
        ernum1[temp]=-1;
        ernum2[temp]=-1;
      }
      for (socket=0; socket<deg; socket++) {
        /* combine all non-erasure inputs */
        for(temp=0;temp<lim;temp++) {
          if (cmessage!=0) {
            cmessage = lookup_tanh(cmessage);
          } else {
            // error specifies if there is
            // any error in the entire
            // block of deg x 8
            // we have considered
            error=1;
            cmessage = 1;
            if(ernum1[temp]<0)
              ernum1[temp]=socket;
            else
              ernum2[temp]++;
          }
        }
        temp=0;
        load45data(&cmessage);
        save45temp(lower[socket],higher[socket]);
        mulfloat();
      }
      if(error==-1) {
        // This means there is no error in the block
        // of deg x 8 which we have considered
        temp=0;
        for(socket=0;socket<deg;socket++) {
          divide(lower[socket],higher[socket]);
          loadmessage45(&prod[0]);
          for(temp=0;temp<lim;temp++) {
            vtomessage=lookup_atanh(prod[temp]);
          }
        }
      } else {
        loadmessage67(&prod[0]);
        for(temp=0;temp<lim;temp++) {
          if(ernum1[temp]==-1) {
            /* now determine all outgoing messages */
            for (socket=0; socket<deg; socket++)									                       {
              if(cmessage !=0) {
                vtomessage=lookup_atanh(prod[temp] * TA / cmessage);
              } else {
                vtomessage=0;
              }
            }
          } else {
            if(ernum2[temp]==-1) {
              /* if there is exactly on erasure input then */
              /* then all but one output is an erasure     */
              for (socket=0; socket<deg; socket++) {
                vtomessage = 0;
              }
              socket=ernum1[temp];
              vtomessage=lookup_atanh(prod[temp]);
            } else {
              /* if we have two or more erasure inputs */
              /* then all outputs are erasures         */
              for (socket=0; socket<deg; socket++) {
                vtomessage=0;
              }
            }
          }
        }
      }
      dispindex+=lim;
      if(temp1>1)
        temp1--;
      else
        // This is the case when the number of nodes
        // left are less than 8
        lim=temp2;
    }
  }
}

int gettime() {
  struct timeval t;
  gettimeofday(&t,NULL);
  return t.tv_usec + 1000000* t.tv_sec;
}