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;
  }
  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++;
    }
  }
  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);
}