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 % graph->bits_per_left_checknode != 0 ){
     PR_DBG( 0, "vnodenmum (%i) is not a multiple of bits_per_left_checknode (%i).\n"
	     "Giving up!\n", graph->vnodenum, graph->bits_per_left_checknode );
     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 / graph->bits_per_left_checknode *
			  ( 1 << graph->bits_per_left_checknode ) * 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 );
   graph->f = NULL;
   }