mux.c

Go to the documentation of this file.

#include "standard.h"
#include <stdio.h>
#include <math.h>
#include "mux.h"
#include "al.h"
#include "al_sending.h"
#include "comb.h"
#include "muxstuff.h"


#define MIN(a, b) ({int _a=(a),_b=(b);(_a<_b)?_a:_b;})


extern int debug;

extern byte sync_8[1];
extern byte sync_16[2];
extern byte sync_2x16[2];
extern byte sync_24[3];
extern byte sync_32[4];


mux *new_mux(char *name)
{
  mux *bob;
  
  bob = malloc(sizeof(mux));
  if (bob != NULL) {
     bob->num_al_senders = 0;
     strcpy(bob->name, name);
     bob->wait_time=0;
  }

  bob->packetsSent = 0;
  return(bob);
}


static int bytes_ok(int mt_bytes[], int buffer_bytes[], int d, mux *m)
     /*
      * Returns 1 iff for i=0, i<d, mt_bytes[i] <= buffer_bytes[i]
      *           also, number of channels described in the MED must
      *           equal the number of channels.  Ie. if you only
      *           have LCN0 and LCN1, and your MED is 
      *           {LCN1 RC 10, LCN2 RC UCF} this function returns 0.
      *
      * Should be used like this:
      *
      * if (bytes_ok(mt_bytes, al_buffer, num_channels, m);
      */
{
  int ok = 1;
  int i;
  int tot_bytes = 0;

  for (i=0; i<d; i++) {
    tot_bytes += mt_bytes[i];
    if (buffer_bytes[i] < mt_bytes[i])
      ok = 0;
  }
  if (tot_bytes < m->params->info_field_length)
    ok = 0;
  return (ok);
}


float ratio_difference(float a[], float b[], int d)
     /* 
      * Computes the scalar difference between a[] and b[]
      * (i.e. sum(i=0, d-1, (abs(b[i] - a[i]))).
      *
      * Should be used like this:
      * 
      * diff = compute_difference(mt_ratios, al_ratios, num_channels);
      */
{
  float sum = 0.0;
  int i;
  for (i=0; i<d; i++) {
    sum += fabs(b[i] - a[i]);
  }
  return (sum);
}


static void print_int(int x)
{
  int i;
  for (i=31; i>=0; i--) {
    if (x & (1 << i))
      putchar('1');
    else
      putchar('0');
  }
  putchar('\n');
}


static void set_payload_size(mux *m)
{
  int x;
  double d;

  x = random();
  
  d = (double) x / 0x7FFFFFFF;

  m->params->info_field_length = 
    (int) (d * (m->params->payload_max - m->params->payload_min) + 
    m->params->payload_min + 0.5);
}


void multiplex(mux *m, int num_channels)
/*
 * mux function.  
 */
{
  int requested_sizes[MAX_AL_SENDERS];
  int al_bytes[MAX_AL_SENDERS];
  float al_ratios[MAX_AL_SENDERS];
  float best_diff;
  float diff;
  int best_mc;
  int num_arqs;
  combinations *arq_combs;
  int *arq_attempt;
  int total_bytes;
  int i, j, k, l, n, count;
  int MC=-1;
  int repeating;
  int fromwhere;
  int ok;
  byte larry;
  byte *header;
  byte *mplf;
  bytes *al_pdus[MAX_AL_SENDERS];
  int al_pdu_counters[MAX_AL_SENDERS];
  int als_requesting_arqs[MAX_AL_SENDERS];

#define SYNC_BYTES ((m->params->sync_flag_length)/8)
#define SYNC_BITS (m->params->sync_flag_length)

#define HEADER_BYTES ((code_length(m->params->header_code)+1)/8)
#define MPL_BYTES ((code_length(m->params->mpl_code)+1)/8)
#define INFO_BYTES (m->params->info_field_length)
#define PACKET_BYTES (SYNC_BYTES + HEADER_BYTES + INFO_BYTES)
#define AL (m->al_senders)
#define MT_SIZE (m->params->mux_table_size)
#define MT (m->params->mux_table)
#define MT_RATIOS (m->params->mt_ratios)
#define MT_BYTES (m->params->mt_bytes)

  /*
   * If it is time to make a packet, do so.  
   */
  
  if (channel_write_indication(m->output)) {
    
    /*
     * pick payload size randomly.
     */
    set_payload_size(m);
    
    MT_BYTES = make_mt_bytes(MT, MT_SIZE, num_channels, INFO_BYTES);
    MT_RATIOS = make_mt_ratios(MT_BYTES, MT_SIZE, num_channels, INFO_BYTES);
    
    if (debug) {
      printf("%s MUX [%s]: Payload field length = %d bytes\n", 
             print_time(), m->name, INFO_BYTES);
      printf("%s MUX [%s]: Buffer levels  : ", print_time(), m->name);
      for (i=0; i<num_channels; i++) {
        printf("%3d ", al_buffer_level(AL[i]));
      }
      printf("\n");
    }
    
    /*
     * Requested arq sizes 
     */
    if (debug >= 2) {
      printf("MUX [%s]: Requested sizes: ", m->name); 
    }
    num_arqs = 0;
    for (i=0; i<num_channels; i++) {
      if (al_request(AL[i]) == -1) {
        requested_sizes[i] = al_requested_size(AL[i]);
        als_requesting_arqs[num_arqs++] = i;
      }
      else {
        requested_sizes[i] = 0;
      }
      if (debug >= 2) {
        printf("%4d ", requested_sizes[i]);
      }
    }
    if (debug >= 2) {
      printf("\n");
    }
    
    if (debug >= 2) {
      printf("MUX : als requesting arq's: ");
      for (i=0; i<num_arqs; i++) 
        printf("%4d ", als_requesting_arqs[i]);
      printf("\n");
    }
    /*
     * Try to pick a multiplex code.  First try handling all or some of the ARQ's.
     */
    best_mc = -1;
    best_diff = -1;
    for (i = num_arqs; ((i >= 0) && (best_mc==-1)); i--) {
      if (debug >= 2) {
        printf("MUX : Trying to satisfy %d ARQ's.\n", i);
      }
      arq_combs = new_combinations(als_requesting_arqs, num_arqs, i);
      arq_attempt = next_combination(arq_combs);
      do {
        /*
         * Set up bytes per channel and ratios to check for this combination.
         */
        if (debug >= 3) {
          printf("MUX : ARQ combination: ");
          for (l=0; l<i; l++) 
            printf("%4d", arq_attempt[l]);
          printf("\n");
        }
        total_bytes = 0;
        for (j=0; j<num_channels; j++) {
          al_ratios[j] = 0.0;
          al_bytes[j] = 0;
        }
        for (j=0; j<i; j++) {
          al_bytes[arq_attempt[j]] = requested_sizes[arq_attempt[j]];
          al_ratios[arq_attempt[j]] = (float) al_bytes[arq_attempt[j]];
          total_bytes += al_bytes[arq_attempt[j]];
        }
        for (j=0; j<num_channels; j++) {
          if (al_bytes[j] == 0) {
            al_bytes[j] = al_buffer_level(AL[j]);
            al_ratios[j] = (int) al_bytes[j];
            total_bytes += al_bytes[j];
          }
        }
        if (total_bytes) {
          for (j=0; j<num_channels; j++) {
            al_ratios[j] = (float) al_ratios[j] / total_bytes;
          }
        }
        if (debug >= 2) {
          printf("MUX : AL Bytes per channel: ");
          for (l=0; l<num_channels; l++) 
            printf("%6d ", al_bytes[l]);
          printf("\n");
          printf("MUX : Byte ratios         : ");
          for (l=0; l<num_channels; l++)
            printf("%6.3f ", al_ratios[l]);
          printf("\n");   
        }
        /*
         * For each entry in the multiplex table, see if it handles the ARQ's we want.
         */
        for (j=0; j<MT_SIZE; j++) {
          if (debug >= 3) {
            printf("MUX : MC %2d ratios        : ", j);
            for (l=0; l<num_channels; l++) 
              printf("%6.3f ", MT_RATIOS[j][l]);
          }
          ok = 1;
          /* 
           * Make sure all ARQ's are handled (exactly for now) 
           */
          for (k=0; ((k<i) && (ok)); k++) {
            if (MT_BYTES[j][arq_attempt[k]] != requested_sizes[arq_attempt[k]])
              ok = 0;
          }
          /*
           * Check that bytes are ok.
           */
          if (ok) {
            if (!bytes_ok(MT_BYTES[j], al_bytes, num_channels,m))
              ok = 0;
          }
          /*
           * See if it's the best.
           */
          if (ok) {
            diff = ratio_difference(MT_RATIOS[j], al_ratios, num_channels);
            if (debug >= 3) {
              printf(" diff = %6.3f\n", diff);
            }
            if ((best_mc == -1) || (diff < best_diff)) {
              best_mc = j;
              best_diff = diff;
            }
          }
          else { 
            if (debug >= 3) {
              printf("\n");
            }
          }
        }
      } while ((arq_attempt = next_combination(arq_combs)) != NULL);
      close_combinations(arq_combs);
    }
    
    /*
     * If that didn't work, I don't know what will.
     */
    MC = best_mc;
    
    if (MC == -1) {
      if (debug) {
        printf("%s MUX [%s]: Doing nothing.\n", print_time(), m->name);
      }
      return;
    }
    else {
      if (debug) {
        printf("%s MUX [%s]: Making packet with MC %d, ", print_time(), m->name, MC);
        
        for (i=0; i<num_channels; i++)
          printf(" %3d", MT_BYTES[MC][i]);
        printf("\n");
      }
    }
    /************************************************************/
    /* Now form a packet based on the multiplex code chosen.    */
    /************************************************************/
    
    /* 
     * Get AL-PDU's.  Set counters to 0.
     */
    for (i=0; i<num_channels; i++) {
      if (MT_BYTES[MC][i] != 0) {
        al_pdus[i] = get_al_pdu(AL[i], MT_BYTES[MC][i]);
      }
      else {
        al_pdus[i] = NULL;
      }
      al_pdu_counters[i] = 0;
    }
    
    /*
     * Start sending packet 
     */
    n = 0;          /* Mux-pdu position counter */
    /*
     * Send SYNC field.
     */
    if (debug) {
      printf("%s MUX [%s]: Sending %d SYNC_BYTES.\n", print_time(),
             m->name, SYNC_BYTES);
    }
    for (count = 0; count < SYNC_BYTES; count++)  {
      if (m->params->use_double_flag) {
        larry = sync_2x16[count];
      }
      else if (SYNC_BITS == 32) {
        larry = sync_32[count];
      }
      else if (SYNC_BITS == 24) {
        larry = sync_24[count];
      }
      else if (SYNC_BITS == 16) {
        larry = sync_16[count];
      }
      else if (SYNC_BITS == 8) {
        larry = sync_8[count];
      }
      
      channel_write(m->output, larry);
      n++;
    }

    if (m->params->level == 2) {
      /* send HEADER and MPL concatenated, protected by 23,12 Golay code */
      header = construct_header_level2(MC,0,INFO_BYTES);
      for (count = 0; count < HEADER_BYTES; count++) {
        channel_write(m->output, header[count]);
      }
      if (debug) {
        printf("%s MUX [%s]: Sending %d HEADER_BYTES.\n", print_time(), 
               m->name,HEADER_BYTES);
      }
    } 
    else { /* level is 1 or 0 */
      /*
       * send HEADER field with BCH code
       */
      header = construct_header(MC, 0, m->params->header_code, m->params->level);
                              /* PM bit hard-coded to zero.  :-( */
      if (debug) {
        printf("%s MUX [%s]: Sending %d HEADER_BYTES.\n", print_time(),
               m->name, HEADER_BYTES);
      }
      for (count = 0; count < HEADER_BYTES; count++) {
        channel_write(m->output, header[count]);
        n++;
      }
    } 
    
    /*
     * Send INFO BYTES.
     */
    if (debug) {
        printf("%s MUX [%s]: Sending %d INFO_BYTES.\n", print_time(),
               m->name, INFO_BYTES);
    }

    for (count = 0; count < INFO_BYTES; count++) {
      fromwhere = mux_byte_source(&MT[MC], count);
      larry = get_byte(al_pdus[fromwhere], al_pdu_counters[fromwhere]++);

      channel_write(m->output, larry);
      n++;
    }

    /*
     * Don't need these anymore.
     */
    for (i=0; i<num_channels; i++) {
      if (al_pdus[i] != NULL) {
        free_bytes(al_pdus[i]);
      }
    }
    m->packetsSent++;
  }
  else {
    if (debug) {
      printf("%s MUX [%s] Not time to write yet.\n", print_time(), m->name);
    }
  }
}

void close_mux(mux *m)
{
  FILE *outf;
  printf("%s: %d Packets Sent\n",m->name,m->packetsSent);
  if (*m->params->stat_file!=0) {
    outf = fopen(m->params->stat_file,"a");
    assert(outf!=NULL);
    fprintf(outf,"%s: %d packets sent\n",m->name,m->packetsSent);
    fclose(outf);
  }
}

---