graphcreate.c

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

#include "graphcreate.h"
#define DBG_LVL 0


int getGraph(int index, graphs *graph, int *gap, int **iphi)
   {
   int Gnum, i, j, k, node, socket;

   if ( ( index <= 0 ) ){
     PR_DBG( 0, "Don't know about code %i\n", index );
     return -1;
   }
   if ( graph->vnodenum % BITSPERLEFTCHECKNODE != 0 ){
     PR_DBG( 0, "vnodenmum (%i) is not a multiple of BITSPERLEFTCHECKNODE (%i).\n"
	     "Giving up!\n", graph->vnodenum, BITSPERLEFTCHECKNODE );
     return -1;
   }

   Gnum=index-1;

   i=0;
   
   (*graph).vnodenum=codes[Gnum][i];
   i++;
   (*graph).cnodenum=codes[Gnum][i];
   i++;
   (*graph).rate=1.0-((double)(*graph).cnodenum)/((double)(*graph).vnodenum);
   
   (*graph).vdegreesnum=codes[Gnum][i];
   i++;
   (*graph).cdegreesnum=codes[Gnum][i];
   i++;
   (*graph).vmaxdegree=codes[Gnum][i];
   i++;
   (*graph).cmaxdegree=codes[Gnum][i];
   i++;

   /* allocate memory for nodes */
   PR_DBG( 3 , "allocating nodelists and degreelists\n");
   (*graph).vnodelist=(vnode *)swr_malloc(sizeof(vnode)*(*graph).vnodenum);
   (*graph).cnodelist=(cnode *)swr_malloc(sizeof(cnode)*(*graph).cnodenum);
   
   /* enter the degreelist */
   (*graph).vdegreelist=(degreelist *)swr_malloc(sizeof(degreelist));
   (*graph).cdegreelist=(degreelist *)swr_malloc(sizeof(degreelist));
   
   /* assign vnodelist */
   for (j=0; j<(*graph).vdegreesnum; j++)
      {
      (*(*graph).vdegreelist).degree[j]=codes[Gnum][i];
      i++;
      (*(*graph).vdegreelist).numofnodes[j]=codes[Gnum][i];
      i++;
      }
   
   /* assign cnodelist */
   for (j=0; j<(*graph).cdegreesnum; j++)
      {
      (*(*graph).cdegreelist).degree[j]=codes[Gnum][i];
      i++;
      (*(*graph).cdegreelist).numofnodes[j]=codes[Gnum][i];
      i++;
      }

   /* assign vnodes */
   PR_DBG( 3 , "allocating vnodeedgelists\n")
   for (node=0; node<(*graph).vnodenum; node++)
      {
      vnodedegree=codes[Gnum][i];
      i++;

      vnodeedgelist=(edge *)swr_malloc(sizeof(edge)*vnodedegree);

      for (socket=0; socket<vnodedegree; socket++)
         {
         vnodeedge.dest=codes[Gnum][i];
	 i++;
	 vnodeedge.socket=codes[Gnum][i];
	 i++;
	 }
      }
	   
   /* assign cnodes */
   PR_DBG( 3 , "allocating cnodeedgelists\n")
   for (node=0; node<(*graph).cnodenum; node++)
      {
      cnodedegree=codes[Gnum][i];
      i++;

      cnodeedgelist=(edge *)swr_malloc(sizeof(edge)*cnodedegree);

      for (socket=0; socket<cnodedegree; socket++)
         {
         cnodeedge.dest=codes[Gnum][i];
	 i++;
	 cnodeedge.socket=codes[Gnum][i];
	 i++;
	 }
      }

   //assign encoder preprocessed data
   (*gap)=codes[Gnum][i];
   i++;

   *iphi=(int *)swr_malloc((*gap)*(*gap)*sizeof(int));

   for (j=0; j<(*gap); j++)
      {
      for (k=0; k<(*gap); k++)
         {
         *(*iphi+j*(*gap)+k)=codes[Gnum][i];
	 i++;
         }
      }   

   // Assign the memory for the f's
   if ( graph->f ){
     swr_free( graph->f );
   }
   graph->f = swr_malloc( graph->vnodenum / BITSPERLEFTCHECKNODE *
			  ( 1 << BITSPERLEFTCHECKNODE ) * sizeof( double ) );

   return(0);
   }
   


/****************************************/
/** Free most of the memory of a graph **/
/****************************************/
void freeGraph(graphs *graph,int *iphi)
   {
   int node;

   /* deallocate memory for edges */
   PR_DBG( 3 , "freeing vnodeedgelists\n");
   for (node=0; node<(*graph).vnodenum; node++)
      swr_free((*((*graph).vnodelist+node)).edgelist);//swr_free(vnodeedgelist);

   PR_DBG( 3 , "freeing cnodeedgelists\n");
   for (node=0; node<(*graph).cnodenum; node++)
   swr_free((*((*graph).cnodelist+node)).edgelist);//swr_free(cnodeedgelist);
  
   /* deallocate memory for nodes */
   PR_DBG( 3 , "freeing nodelists and degreelists\n");
   swr_free((*graph).vnodelist);
   swr_free((*graph).cnodelist);

   /* deallocate memory for degreelist */
   swr_free((*graph).vdegreelist);
   swr_free((*graph).cdegreelist);

   /* deallocate memory for iphi */
   PR_DBG( 3 , "freeing iphi\n");
   swr_free(iphi);

   // deallocate memory for the f's
   swr_free( graph->f );
   }