---

binarysave.c

Go to the documentation of this file.

#include <stdio.h>     
#include <time.h>
#include <sys/types.h> /* for clock routines */

#include "binarysave.h"
#include "ipc.h"
#include "cmdparam.h"
#include "globals.h"
#include "kernel.h"
#define NO_ANALYZE



/******************************************************************************/
/* Static variables                                                           */
/******************************************************************************/

Tristate LISSOMBinaryStateSaver::save_afferent_weights_only=False;
Tristate LISSOMBinaryStateSaver::save_all_lateral_weights=False;
Tristate LISSOMBinaryStateSaver::load_afferent_weights_only=False;



/******************************************************************************/
/* Defines and typedefs                                                       */
/******************************************************************************/

/* Enable faster file reads by assuming order of data stored in file
   matches the current configuration of PEs
*/
/* #define ASSUME_FIXED_PE_CONFIGURATION */

/* Turns on file debugging messages when defined */
/* #define LF_DEBUG_FILE */

#define LF_BUFFER_VERIFY



typedef f32 LFFloatType;
#define LF_FLOAT_SIZE sizeof(LFFloatType)


/* Binary file tokens */
#define SMALLEST_LFTOK            1
#define LFTOK_NO_TOKEN            0
#define LFTOK_SNAPSHOT_HEADER     1
#define LFTOK_ROW_HEADER          2
#define LFTOK_NEURON_HEADER_ORIG  3
#define LFTOK_AFF_WEIGHTS         4
#define LFTOK_LEXC_WEIGHTS_OLD    5
#define LFTOK_LINH_WEIGHT_CHUNK   6
#define LFTOK_NEURON_TRAILER      7
#define LFTOK_SNAPSHOT_TRAILER    8
#define LFTOK_LEXC_WEIGHTS        9
#define LFTOK_NEURON_HEADER_BUG  10 /* So named because some files using it reported an incorrect token length, confusing printTokens */
#define LARGEST_LFTOK            10

#define LF_UNUSED   0x00

#define LF_ALL_EYES   99



#define LF_FLOAT_TOLERANCE 0.0000001

/* Error handling */
#define LF_NO_ERROR 0
#define LF_ERROR   -1

#define LF_MAXWARNINGS 5


/******************************************************************************/
/* Initialization hook                                                        */
/******************************************************************************/


void  LISSOMBinaryStateSaver::binarysave_init_hook( void )
{
  PARAM_I(PARAM_3BOOL,  load_afferent_weights_only,False,True,
          "If true, when loading weights, load only the afferent ones. This allows\n"
          "a machine with little memory to read in a file created on a much larger one,\n"
          "though all it can do is compute initial activations and map values which\n"
          "depend on them.");
  
  PARAM_I(PARAM_3BOOL,  save_afferent_weights_only,False,True,
          "If true, when saving weights, save only the afferent ones. This results\n"
          "in a much smaller file, but the resulting network is of only limited use.");

  PARAM_I(PARAM_3BOOL,  save_all_lateral_weights,False,True,
          "If true, when saving weights, save all lateral weights whether\n"
          "they are negative or not.");
}



/******************************************************************************/
/* File processing routines                                                   */
/******************************************************************************/


int LISSOMBinaryStateSaver::binaryWeightsFileWrite( FILE *file )
{ 
  int current_local_row;
  int part_of_row;
  time_t start_time, end_time;

  /* reset everything */
  tokensWritten = 0;
  status = 0;
  errorsEncountered = 0;
  
  /* The last PE is in charge of writing */
  if (AMYOUNGESTPE) {
    start_time = time(NULL);
    ipc_notify(IPC_ALL,IPC_STD,"Weight file saving started %.24s", ctime(&start_time));

    /* write LFTOK_SNAPSHOT_HEADER */
    writeToken(   file, makeToken( LFTOK_SNAPSHOT_HEADER, 2+1, lm.N, lm.perows));
    writeInteger( file, iteration);
  }

  /* dump data for each row */
  for (current_local_row=0; current_local_row <lm.perows; current_local_row++) {
    for (part_of_row=0; part_of_row <parts_per_row; part_of_row++) {
    
      const int current_map_row = MAPROW(current_local_row);
      LFBufferClear( &binaryBuffer );
      binaryWeightsBufferFill( &binaryBuffer, current_map_row, current_local_row, part_of_row );
      if (status != 0) return status;
      
      /* verify contents of buffer */
#ifdef LF_BUFFER_VERIFY
        tokensRead = 0;
        binaryWeightsBufferProcess( &binaryBuffer, True);
        if(status != 0) return status;
#endif

      /* synchronize all processors before writing each PE's part-row of data */
      ipc_barrier();
      
      /* The last PE writes this part-row from all of the PEs */
      if (AMYOUNGESTPE) {
        int pe;
        
        for(pe=(NPEs-1); pe>=0; pe--){
          
          if (!PEISME(pe))
            LFBufferGet(&binaryBuffer, pe);
          
          /* determine and write row number and length */
          writeToken(  file, makeToken( LFTOK_ROW_HEADER, 2 + 1, 
                                        ARBITRARY_MAPROW(current_local_row,pe), LF_UNUSED));
          writeInteger(file, LFBufferLength(&binaryBuffer));
          
          /* dump part-row in buffer to file */
          LFBufferWrite(&binaryBuffer,file);
        }
      }
    
      /* synchronize all processors before computing the next part-row of data */
      ipc_barrier();
    }
  }

  if (AMYOUNGESTPE) {
    
    /* write LFTOK_SNAPSHOT_TRAILER */
    writeToken(  file, makeToken( LFTOK_SNAPSHOT_TRAILER, 2 + 1, LF_UNUSED, LF_UNUSED));
    writeInteger(file, iteration);

    end_time = time(NULL);  
  
    /* Show elapsed time */
    ipc_notify(IPC_ALL,IPC_STD,"Weight saving took %g seconds, completing %.24s",
               (double)difftime(end_time, start_time),
               ctime(&end_time));
  }

  if (errorsEncountered != 0) {
    ipc_notify(IPC_ALL,IPC_ERROR,"There were %d non-fatal errors during saving",errorsEncountered);
    ipc_notify(IPC_ALL,IPC_ERROR,"Consult the log file for more information");
  }

  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::binaryWeightsBufferFill( LFBuffer *buffer, int current_map_row, 
                            int current_local_row, int part_of_row )
{ 
  int current_j;
  int which_eye;
  
  int start_j =  part_of_row      * (lm.N/parts_per_row);
  int end_j   = (part_of_row + 1) * (lm.N/parts_per_row);

  /* Check that N is evenly divisible by parts_per_row) */
  if (lm.N%parts_per_row != 0){
    ipc_notify(IPC_ALL,IPC_ERROR,"N must be divisible by parts_per_row: %d%%%d != 0",
              (int)lm.N, (int)parts_per_row);
    return LF_ERROR;
    /* ipc_notify(IPC_ALL,IPC_STD,"After"); */
  }
  
  /* write data for each neuron in this part of row */
  for (current_j =start_j; current_j <end_j; current_j++){
    
    if(status != 0) return status;

    /* write LFTOK_NEURON_HEADER */
    LFBufferWriteToken(buffer, 
                       makeToken( LFTOK_NEURON_HEADER_ORIG, 2 + 2, current_map_row, current_j));
    
    LFBufferWriteInteger(buffer, lm.cortex_map[current_map_row][current_j].centerx);
    LFBufferWriteInteger(buffer, lm.cortex_map[current_map_row][current_j].centery);
    
    /* write LFTOK_AFF_WEIGHTS */
    {
      const int rf_width = 1 + 2*lm.rf_radius;  /* always odd */

      /* Wts in file are always scaled for num_eyes=2, regardless of num_eyes */
      const double wt_scale = lm.num_aff_inputs()/2.0;

      int x,y;
      
      /* writes all afferent weights, even those which may be outside the 
         retina boundaries for this receptive field.  Assuming a reasonable 
         lm.rf_radius (e.g. 5), this should not waste a significant amount of space. 
         */
      
      /* write one afferent weight token for each eye */
      for (which_eye = 0; which_eye < lm.num_aff_inputs(); which_eye++) {
        LFBufferWriteToken(buffer, makeToken( LFTOK_AFF_WEIGHTS, 
                                              2 + rf_width*rf_width,
                                              rf_width, which_eye)); 
        
        for (x=0; x<rf_width; x++)
          for (y=0; y<rf_width; y++)
            LFBufferWriteFloat(buffer, wt_scale * 
                               lm.wts[current_local_row][current_j].weights[which_eye][x][y]);
        
      }
    }
    

    /* Save lateral weights if needed */
    if (!save_afferent_weights_only) {
      
      /* write LFTOK_LEXC_WEIGHTS */
      binaryWeightsBufferWriteLatWeights( buffer, LFTOK_LEXC_WEIGHTS,
                                          current_map_row, current_j,
                                          lm.exc_rad, lm.exc_array_width,
                                          &(lm.wts[current_local_row][current_j].lat_exc_wts[0]));
      
      /* write LFTOK_LINH_WEIGHT_CHUNKs */
      {
        int start_index=0, end_index=-1, i;
        int dynamic_lat_inh_dimension = (2*lm.inh_rad + 1)*(2*lm.inh_rad + 1);
        f64 live_threshold = 1.5 * DEATH_FLAG;

        if (save_all_lateral_weights)
                live_threshold = -1.0E30;

        if (dynamic_lat_inh_dimension != lm.lat_inh_dimension)
          ipc_notify(IPC_ONE,IPC_ERROR,"Lateral inhibitory radius changed; not supported by binarysave.c");

        /* infinite loop -- find and write each chunk of live weights */
        /* this is ugly, but I can't figure out a better way */
        for (;;) {
            /* Looks at all lateral inhibitory weights, even those which may be 
               outside the cortex boundaries for this neuron.  This is fine 
               as long as the weights outside were initialized to zero or 
               DEATH_FLAG, since they will not be considered alive anyway.  
               */

            /* skip over empty connections to find start of chunk */
            for (start_index = end_index+1; 
                 ((start_index <= dynamic_lat_inh_dimension-1) &&
                  (lm.wts[current_local_row][current_j].lat_inh_wts[start_index]   < live_threshold));
                 start_index++);
          
            /* done if at end of array */
            if (start_index >= dynamic_lat_inh_dimension) 
              break;
          
            /* chunk lasts until two or three dead connections found in a row */
            /* skips by two, so might end up with one dead connection included */
            for (end_index=start_index; 
                 ((end_index < dynamic_lat_inh_dimension - 2)  &&
                  !((lm.wts[current_local_row][current_j].lat_inh_wts[end_index+1] < live_threshold) &&
                    (lm.wts[current_local_row][current_j].lat_inh_wts[end_index+2] < live_threshold)));
                 end_index +=2);
          
            /* ensure that array bounds are respected and last few connections are saved */
            if (end_index >= (dynamic_lat_inh_dimension-2))
              end_index = dynamic_lat_inh_dimension - 1;
          
          
            /* remove last dead connection, if any */
            /* delete this statement if 8-byte multiples are needed */
            if (lm.wts[current_local_row][current_j].lat_inh_wts[end_index] < live_threshold)
              end_index--;

            /* make and write token for this chunk */
            LFBufferWriteToken(buffer, makeToken( LFTOK_LINH_WEIGHT_CHUNK, 
                                                        2 + (end_index - start_index + 1), 
                                                        start_index, end_index));
          
            /* write weights */
            for (i=start_index; i<=end_index; i++)
              LFBufferWriteFloat(buffer, lm.wts[current_local_row][current_j].lat_inh_wts[i]);
          
          };
      }
    }

    /* write LFTOK_NEURON_TRAILER */
    LFBufferWriteToken(buffer, makeToken( LFTOK_NEURON_TRAILER, 2, current_map_row, current_j));
    
  }

  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::binaryWeightsFileRead( FILE *file )
{ 
  LFTokenType thisToken; /* most recently read token */

  time_t start_time, end_time;

  /* reset everything */
  tokensRead = 0;
  status = 0;
  errorsEncountered = 0;
  LFBufferClear( &binaryBuffer );

  /* The first PE does the actual file reading */
  if (AMPARENTPE){
    
    start_time = time(NULL);
    ipc_notify(IPC_ALL,IPC_STD,"Weight file loading started %.24s", ctime(&start_time));

    /* read LFTOK_SNAPSHOT_HEADER */
    thisToken = readTokenExpecting(LFTOK_SNAPSHOT_HEADER, file);
    compareParameter(tokenInfoa(thisToken), lm.N,     "N"    );
#ifdef ASSUME_FIXED_PE_CONFIGURATION
    compareParameter(tokenInfob(thisToken), lm.perows, "perows");
#endif
    
    /* Read iteration to PE0; value won't propagate to other PEs until later */
    iteration = readInteger(file);
  }

#ifdef ASSUME_FIXED_PE_CONFIGURATION
  ipc_notify(IPC_ONE,IPC_VERBOSE,"Assuming fixed order of rows in binary weights file");
  binaryWeightsFileReadInFixedOrder(file, &binaryBuffer);
#else
  binaryWeightsFileReadInArbitraryOrder(file, &binaryBuffer);
#endif
  
  /* read LFTOK_SNAPSHOT_TRAILER */
  if (AMPARENTPE){
    thisToken = readTokenExpecting(LFTOK_SNAPSHOT_TRAILER, file);
    if (readInteger(file) != iteration)
      ipc_notify(IPC_ALL,IPC_ERROR,"File truncated: End of SNAPSHOT_TRAILER missing");

    end_time = time(NULL);  

    /* Show elapsed time */
    ipc_notify(IPC_ALL,IPC_STD,"Weight loading took %g seconds, completing %.24s",
               (double)(difftime(end_time, start_time)),
               ctime(&end_time));

  }

  if (errorsEncountered != 0) {
    ipc_notify(IPC_ALL,IPC_ERROR,"There were %d non-fatal errors during loading",errorsEncountered);
    ipc_notify(IPC_ALL,IPC_ERROR,"Consult the runfile for more information");
  }
  
  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::binaryWeightsBufferWriteLatWeights( LFBuffer *buffer, int token_name,
                                        int i, int j, int radius, int array_width,
                                        l_weight *weights)
{
  const int lowk  = MAX(i-radius,0     );
  const int highk = MIN(i+radius,lm.N-1);
  const int lowl  = MAX(j-radius,0     );
  const int highl = MIN(j+radius,lm.N-1);
  const int num   = (highk-lowk+1)*(highl-lowl+1);
    
  int k,l;
  
  LFBufferWriteToken(buffer, makeToken( token_name, 2+num, num, 0));
  
  for(k=lowk; k<= highk; k++) {
    const int partial_idx = PARTIAL_LAT_INDEX(i,j,k,radius,array_width);
    for (l=lowl; l<=highl; l++) {
      const int idx = FULL_LAT_INDEX(partial_idx,l);
      
      LFBufferWriteFloat(buffer, weights[idx]);
    }
  }
  
  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::binaryWeightsBufferReadLatWeights(  LFBuffer *buffer, LFTokenType token,
                                        int i, int j, int radius, int array_width,
                                        l_weight *weights, int verify, const char *description)
{
  const int lowk  = MAX(i-radius,0     );
  const int highk = MIN(i+radius,lm.N-1);
  const int lowl  = MAX(j-radius,0     );
  const int highl = MIN(j+radius,lm.N-1);
  const int num   = (highk-lowk+1)*(highl-lowl+1);
  
  int k,l;

  if (load_afferent_weights_only) {
    /* Discard lateral weights */
    int idx;
    for(idx=0; idx<tokenInfoa(token); idx++) 
      LFBufferReadFloat(buffer);
    return LF_NO_ERROR;
  }

  /* Discard data if bogus */
  if (num != tokenInfoa(token)) {
    const  int maxwarnings=10;
    static int warnings = 0;
    /* ipc_abort(IPC_EXIT_FILE_PROBLEM, */
    warnings++;
    if (warnings < maxwarnings) {
      ipc_notify(IPC_ALL,IPC_ERROR,
                 "Problem with lateral weight encoding (at neuron (%d,%d): file %d != computed %d); current parameters may not match file",
                 i,j,tokenInfoa(token),num);
    }
    else if (warnings == maxwarnings)
      ipc_notify(IPC_ALL,IPC_ERROR,
                 "Maximum number of lateral weight warnings reached (%d); the rest will be discarded",
                 maxwarnings);
    
    for (k=tokenInfoa(token); k>0; k--)
      LFBufferReadFloat(buffer);
  } else
    
  for(k=lowk; k<= highk; k++) {
    const int partial_idx = PARTIAL_LAT_INDEX(i,j,k,radius,array_width);
    for (l=lowl; l<=highl; l++) {
      const int idx = FULL_LAT_INDEX(partial_idx,l);
      const l_weight aFloat = LFBufferReadFloat(buffer);
      
      compareOrSet_l_weight(&weights[idx], aFloat, verify, description);
    }
  }

  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::binaryWeightsFileReadInFixedOrder(FILE *file, LFBuffer *buffer)
{
  int current_map_row;
  int current_local_row;
  int part_of_row;
  int row_length;
  LFTokenType thisToken; /* most recently read token */
  
  /* read data for each pe, one part of one row at a time */
  for (current_local_row =0; current_local_row <lm.perows; current_local_row++) {
    for (part_of_row=0; part_of_row <parts_per_row; part_of_row++) {

      if (AMPARENTPE){
        int pe; 
        int rowsRead = 0;
        
        /* Read LFTOK_ROW_HEADERs and data for each part-row until data is found for this PE */
        do
          {
            thisToken = readTokenExpecting(LFTOK_ROW_HEADER, file);
            
            current_map_row  = tokenInfoa(thisToken);
            row_length = readInteger(file);
            LFBufferClear( buffer );
            LFBufferRead(  buffer, file, row_length);
            
            if ( current_local_row != LOCALROW(current_map_row)) {
                status = LF_ERROR;
                ipc_notify(IPC_ALL,IPC_ERROR,"Rows are not in the correct major order in file");
            }
            pe = PEFORROW(current_map_row);
            if (!PEISME(pe))
              LFBufferPut( buffer, pe);

            rowsRead++;
            
          }  while (!PEISME(pe));
        
        if ( rowsRead != NPEs) {
          status = LF_ERROR;
          ipc_notify(IPC_ALL,IPC_ERROR,"Rows are not in the correct minor order in file");
        }
      }

      
      /* ensure that every pe that had data in the file has gotten it */
      ipc_barrier();

#ifdef CRAY      
#pragma _CRI suppress (buffer) /* Force data to be loaded from memory   */
#endif
      
      /* process the tokens in this PE's buffer */
      binaryWeightsBufferProcess( buffer, False);
      
      /* ensure that every pe is done with its data before continuing */
      ipc_barrier();

      if(status != 0) return status;
    }
  }

  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::binaryWeightsFileReadInArbitraryOrder(FILE *file, LFBuffer *buffer)
{
  static int done;
  done=0;
  
  while (!done) {

    /* Ensure all PEs are ready to receive any data that might be sent to them */
    ipc_barrier();
    
    /* One PE reads all data initially, then moves it to appropriate PE
       for processing. */
    if (AMPARENTPE) {
      LFTokenType nextToken;
      int i, ownerpe, pe_has_data[NPES];
      
      /* Initially, no PE's buffer contains data, since all have read theirs */
      for (i=0; i<NPEs; i++)
        pe_has_data[i]=False;

      /* Determine what the next batch of data will be */
      nextToken  = peekToken(file);
      ownerpe    = PEFORROW(tokenInfoa(nextToken));
      done       = (tokenName(nextToken) !=  LFTOK_ROW_HEADER);

      /* Read rows, if any, until one found that would overwrite a full buffer */
      while (!done && !pe_has_data[ownerpe]) {
        int row_length;
        
        readTokenExpecting(LFTOK_ROW_HEADER,file); /* Discard known token */
        row_length = readInteger(file);
        
        LFBufferRead(  buffer, file, row_length);
        pe_has_data[ownerpe]=True;
        
        if (!PEISME(ownerpe)) {
          LFBufferPut( buffer, ownerpe);
          LFBufferClear( buffer );
        }

        nextToken  = peekToken(file);
        ownerpe    = PEFORROW(tokenInfoa(nextToken));
        done       = (tokenName(nextToken) !=  LFTOK_ROW_HEADER);
      }
    }
    
    /* ensure that data is ready at parent PE before continuing */
    ipc_barrier();
    ipc_get( &done, IPC_INT, 1, PARENTPE);
    
    /* process any tokens that may be in this PEs buffer */
#ifdef CRAY
#pragma _CRI suppress (buffer) /* Force data to be loaded from memory   */
#endif
    if (LFBufferLength(buffer)!=0)
      binaryWeightsBufferProcess(buffer, False);
  }

  if(status != 0) return status;
  return LF_NO_ERROR;
}



#define MAKE_SURE_NEURON_HEADER_INFO_AVAILABLE                          \
  if (current_map_row == Uninitialized || current_j == Uninitialized) {  \
    ipc_notify(IPC_ALL,IPC_ERROR,"Missing neuron header");                           \
    return LF_ERROR;                                                       \
  }



int LISSOMBinaryStateSaver::binaryWeightsBufferProcess( LFBuffer *buffer, int verify)
{ 
  LFTokenType thisToken; /* most recently read token */
  int max_eye_data_found=-1;

#ifdef LF_DEBUG_FILE
  int offset;
#endif

  int current_local_row = Uninitialized;
  int current_map_row   = Uninitialized;
  int current_j         = Uninitialized;

  /* Snapshot buffer at start for later restoration if just verifying */
  /* (Slight encapsulation violation, but...) */
  int bufferStart = buffer->start;
  int bufferEnd   = buffer->end;

  /* process each token in this buffer */
  do
    {
      if(status != LF_NO_ERROR) return status;

#ifdef LF_DEBUG_FILE
      offset = buffer->start;
#endif      
      thisToken = LFBufferReadToken(buffer);
#ifdef LF_DEBUG_FILE
        printToken( thisToken, offset );      
#endif
      
      switch(tokenName(thisToken)){
        
      case LFTOK_NEURON_HEADER_ORIG:
      case LFTOK_NEURON_HEADER_BUG:
        
        if (current_map_row != Uninitialized || current_j != Uninitialized) {
          ipc_notify(IPC_ALL,IPC_ERROR,"Missing neuron trailer");
          return LF_ERROR;
        }
        
        current_map_row   = tokenInfoa(thisToken);
        current_j         = tokenInfob(thisToken);
        current_local_row = LOCALROW(current_map_row);
        
        compareOrSetInt(&lm.cortex_map[current_map_row][current_j].centerx, 
                        LFBufferReadInteger(buffer),
                        verify, "centerx");
        compareOrSetInt(&lm.cortex_map[current_map_row][current_j].centery, 
                        LFBufferReadInteger(buffer),
                        verify, "centery");

        max_eye_data_found=-1;

        if (tokenName(thisToken)==LFTOK_NEURON_HEADER_BUG) {
          int which_eye;
          for (which_eye = 0; which_eye < lm.num_aff_inputs(); which_eye++) {
#ifdef NO_ANALYZE      
            LFBufferReadInteger(buffer);
#else
            compareOrSetInt(&or_pref[which_eye][current_map_row][current_j], 
                            LFBufferReadInteger(buffer),
                            verify, "orientation preference");
#endif
          }
        }
          
        break;
      
      case LFTOK_AFF_WEIGHTS:         
        {
          int x,y,eye;
          const int rf_width  = tokenInfoa(thisToken);  /* always odd */
          const int which_eye = tokenInfob(thisToken);
          const int eye_start = (which_eye==LF_ALL_EYES ?        0 : which_eye);
          const int eye_bound = (which_eye==LF_ALL_EYES ? lm.num_aff_inputs() : which_eye+1);
          const double wt_scale = 2.0/lm.num_aff_inputs(); /* Wts in file are always scaled as if num_eyes=2 */

          if (which_eye!=LF_ALL_EYES)
            max_eye_data_found = MAX(max_eye_data_found,which_eye);
          
          compareParameter((rf_width-1)/2, lm.rf_radius,     "rf_radius"    );
          
          MAKE_SURE_NEURON_HEADER_INFO_AVAILABLE;
          
          for (x=0; x<rf_width; x++)
            for (y=0; y<rf_width; y++) {
              a_weight aFloat = wt_scale * LFBufferReadFloat(buffer);
              
              for (eye=eye_start; eye<eye_bound; eye++)
                compareOrSet_a_weight(&lm.wts[current_local_row][current_j].weights[eye][x][y],
                                      aFloat, verify, "afferent weight");
            }
        }
        break;
        
        
      case LFTOK_LEXC_WEIGHTS:
        MAKE_SURE_NEURON_HEADER_INFO_AVAILABLE;   
        binaryWeightsBufferReadLatWeights( buffer, thisToken,
                                           current_map_row, current_j,
                                           lm.exc_rad, lm.exc_array_width,
                                           &(lm.wts[current_local_row][current_j].lat_exc_wts[0]),
                                           verify,"lateral excitatory weight");
        break;
        
      case LFTOK_LEXC_WEIGHTS_OLD:
        {
          int start_index, end_index, i;
          static int ignoring_weights = False;
          
          start_index  = tokenInfoa(thisToken);
          end_index    = tokenInfob(thisToken);
          
          MAKE_SURE_NEURON_HEADER_INFO_AVAILABLE;        
          
          for (i=start_index; i<=end_index; i++) {
            l_weight aFloat = LFBufferReadFloat(buffer);
            
            if (!ignoring_weights && (end_index > lm.lat_exc_dimension)) {
              if (!load_afferent_weights_only)
                ipc_notify(IPC_ALL,IPC_WARNING,"Not enough space for the lateral excitatory weights; ignoring them");
              ignoring_weights = True;
            }

            if (!ignoring_weights && !load_afferent_weights_only)
              compareOrSet_l_weight(&lm.wts[current_local_row][current_j].lat_exc_wts[i],
                                    aFloat, verify, "lateral excitatory weight");
          }
        }
        break;
        
        
      case LFTOK_LINH_WEIGHT_CHUNK:   
        {
          int i;
          int start_index, end_index;
          static int ignoring_weights = False;
          
          start_index  = tokenInfoa(thisToken);  /* first index (from left to right) */
          end_index    = tokenInfob(thisToken);  /* last index */
          
          MAKE_SURE_NEURON_HEADER_INFO_AVAILABLE;
          
          for (i=start_index; i<=end_index; i++) {
            l_weight aFloat = LFBufferReadFloat(buffer);
            
            if (!ignoring_weights && (end_index > lm.lat_inh_dimension)) {
              if (!load_afferent_weights_only)
                ipc_notify(IPC_ALL,IPC_WARNING,"Not enough space for the lateral inhibitory weights; ignoring them");
              ignoring_weights = True;
            }
            
            if (!ignoring_weights && !load_afferent_weights_only)
              compareOrSet_l_weight(&lm.wts[current_local_row][current_j].lat_inh_wts[i],
                                    aFloat, verify, "lateral inhibitory weight");
          }
        }
        break;
        
        
      case LFTOK_NEURON_TRAILER:
        if ((tokenInfoa(thisToken) != current_map_row) ||
            (tokenInfob(thisToken) != current_j)) {
          status = LF_ERROR;
          ipc_notify(IPC_ALL,IPC_ERROR,"File format error -- neuron trailer");
        }

        /* If there are currently more eyes than were defined in the file,
           copy data to remaining eyes */
        if (max_eye_data_found >= 0 && lm.num_aff_inputs() < max_eye_data_found+1) {
          static int warned=False;
          if (!warned) {
            ipc_notify(IPC_ONE,IPC_CAUTION,"Data in file was for %d eyes; ignoring eyes larger than %d",
                       max_eye_data_found+1,lm.num_aff_inputs()-1);
            warned=True;
          }
        }
        
        if (max_eye_data_found >= 0 && lm.num_aff_inputs() > max_eye_data_found+1) {
          int x,y,eye;
          static int warned=False;
          
          if (!warned) {
            ipc_notify(IPC_ONE,IPC_CAUTION,"Data in file was for %d eyes; extending to %d eyes",
                       max_eye_data_found+1,lm.num_aff_inputs());
            warned=True;
          }
          
          for (x=0; x<1+lm.rf_radius*2; x++)
            for (y=0; y<1+lm.rf_radius*2; y++)
              for (eye=max_eye_data_found+1; eye<lm.num_aff_inputs(); eye++)
                lm.wts[current_local_row][current_j].weights[eye][x][y] =
                  lm.wts[current_local_row][current_j].weights[max_eye_data_found][x][y];
        }
        
        current_map_row   = Uninitialized;
        current_local_row = Uninitialized;
        current_j         = Uninitialized;
        break;
        
        
      default:
        status = LF_ERROR;
        ipc_notify(IPC_ALL,IPC_ERROR,"Error in input file -- unknown token: %ld",
                  (long)tokenName(thisToken));
      }
    } while (LFBufferLength(buffer) > 0);

  /* Reset buffer to start and end at the beginning, since circular buffer hasn't been implemented */
  LFBufferClear( buffer ); 
  
  /* restore buffer to previous state */
  if (verify){
    buffer->start = bufferStart;
    buffer->end   = bufferEnd;
  }

  return LF_NO_ERROR;
}



void LISSOMBinaryStateSaver::printTokens( FILE *file )
{
  int offset;
  LFTokenType token;
  f32 float32;
  i32 int32;
  int i;

  /* The first PE does the actual file reading */
  if (AMPARENTPE)
    do {
      offset = ftell(file);
  
      token = readToken(file);
  
      printToken( token, offset );
  
      if ( (tokenName(token) >= SMALLEST_LFTOK) && (tokenName(token) <= LARGEST_LFTOK) )
        for(i=2; i<tokenLength(token); i++) {
          offset = ftell(file);
          int32 = (i32)readInteger(file);
          fseek(file, offset, SEEK_SET); /* Reset file offset */
          float32 = (f32)readFloat(file);
          
          ipc_notify(IPC_ALL,IPC_STD,"Offset: %#6x     Hex: %10x  Int: %11d  Float: %e",
                     (int)offset,(int)int32,(int)int32,(double)float32);
        }
    }
  while (tokenName(token) != LFTOK_SNAPSHOT_TRAILER);
}



void LISSOMBinaryStateSaver::printTokensInBuffer( LFBuffer *buffer )
{
  int offset;
  LFTokenType token;
  f32 float32;
  i32 int32;
  int i;
  int bufferStart = buffer->start;
  int bufferEnd = buffer->end;

  /* The first PE does the actual file reading */
  if (AMPARENTPE)
    do {
      offset = buffer->start;
  
      token = LFBufferReadToken(buffer);
  
      printToken( token, offset );
  
      if ( (tokenName(token) >= SMALLEST_LFTOK) && (tokenName(token) <= LARGEST_LFTOK) )
        for(i=2; i<tokenLength(token); i++) {
          offset = buffer->start;
          int32 = (i32)LFBufferReadInteger(buffer);
          buffer->start = offset; /* Reset buffer offset */
          float32 = (f32)LFBufferReadFloat(buffer);
          
          ipc_notify(IPC_ALL,IPC_STD,"Offset: %#6x     Hex: %10x  Int: %11d  Float: %e",
                     (int)offset,(int)int32,(int)int32,(double)float32);
        }
    }
  while (LFBufferLength(buffer)>0);

  buffer->start = bufferStart;
  buffer->end   = bufferEnd;
}



/******************************************************************************/
/* Token handling primitives                                                  */
/******************************************************************************/

LISSOMBinaryStateSaver::LFTokenType LISSOMBinaryStateSaver::makeToken(int name, int length, int infoa, int infob )
{
  LFTokenType temp;
  temp.right=
    ( ((i32)infob   & 0xFFFF)      ) |
    ( ((i32)infoa   & 0xFFFF) << 16);
  
  temp.left=
    ( ((i32)length  & 0xFFFF)      ) |
    ( ((i32)name    & 0xFFFF) << 16);

  return temp;
}



/* Return the indicated field of the given token. */
int LISSOMBinaryStateSaver::tokenName(   LFTokenType token )   {  return (int)((token.left  >> 16)         );  }
int LISSOMBinaryStateSaver::tokenLength( LFTokenType token )   {  return (int)((token.left       ) & 0xFFFF);  }
int LISSOMBinaryStateSaver::tokenInfoa(  LFTokenType token )   {  return (int)((token.right >> 16) & 0xFFFF);  }
int LISSOMBinaryStateSaver::tokenInfob(  LFTokenType token )   {  return (int)((token.right      ) & 0xFFFF);  }



const char* LISSOMBinaryStateSaver::tokenNameString(LFTokenType token)
{
  static char buf[20];
    
  switch (tokenName(token)) {
  case LFTOK_SNAPSHOT_HEADER:   return("SNAPSHOT_HEADER");    
  case LFTOK_ROW_HEADER:        return("ROW_HEADER");         
  case LFTOK_NEURON_HEADER_ORIG:return("NEURON_HEADER_ORIG");
  case LFTOK_NEURON_HEADER_BUG: return("NEURON_HEADER_BUG");
  case LFTOK_AFF_WEIGHTS:       return("AFF_WEIGHTS");        
  case LFTOK_LEXC_WEIGHTS_OLD:  return("LEXC_WEIGHTS_OLD");
  case LFTOK_LEXC_WEIGHTS:      return("LEXC_WEIGHTS");       
  case LFTOK_LINH_WEIGHT_CHUNK: return("LINH_WEIGHT_CHUNK");  
  case LFTOK_NEURON_TRAILER:    return("NEURON_TRAILER");     
  case LFTOK_SNAPSHOT_TRAILER:  return("SNAPSHOT_TRAILER");       
  default:
    sprintf(buf,"Token: %4d", (int)tokenName(token));
    return buf;
  }
}  



void LISSOMBinaryStateSaver::printToken( LFTokenType token, int offset )
{
  ipc_notify(IPC_ALL,IPC_STD,"Offset: %#6x  %-18s  Length: %3d  Infoa: %3d  Infob: %3d",
             offset,tokenNameString(token),(int)tokenLength(token),
             (int)tokenInfoa(token),(int)tokenInfob(token));
}



/******************************************************************************/
/* Buffer handling primitives                                                 */
/******************************************************************************/

void LISSOMBinaryStateSaver::LFBufferGet( LFBuffer *buffer, int pe )
{
  ipc_get64(&(buffer->start),   1, pe);
  ipc_get64(&(buffer->end),     1, pe);
  ipc_get32(&(buffer->data[0]), buffer->end + 1, pe);
}



void LISSOMBinaryStateSaver::LFBufferPut( LFBuffer *buffer, int pe )
{  
  /* Should fix this; would need to provide a static area for copying data
     or at least broadcasting the addresses */
  /* Warning is here because this is the most dangerous spot, but LFBufferGet
     will also retrieve trash. */
#if (NPES>1)
  ipc_notify(IPC_ONE,IPC_ERROR,
             "Binary file saving is currently not supported on multi-PE architectures"),
#else    
  ipc_put64(&(buffer->start),   1, pe);
  ipc_put64(&(buffer->end),     1, pe);
  ipc_put32(&(buffer->data[0]), buffer->end + 1, pe);
#endif  
}



void LISSOMBinaryStateSaver::LFBufferClear( LFBuffer *buffer )
{  
  buffer->start =  0;  
  buffer->end   = -1;  
}



int LISSOMBinaryStateSaver::LFBufferLength( LFBuffer *buffer )
{ return buffer->length(); }



int LISSOMBinaryStateSaver::LFBufferWrite( LFBuffer *buffer, FILE *file )
{
  buffer->start += fwrite(&(buffer->data[buffer->start]), sizeof(buffer->data[0]),
                          LFBufferLength(buffer), file);

  if ((buffer->end - buffer->start + 1) !=0){
    ipc_notify(IPC_ALL,IPC_ERROR,"Cannot write buffer to file -- Disk or quota full?");
    return LF_ERROR;
  }
  
  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::LFBufferRead( LFBuffer *buffer, FILE *file, int length)
{
  buffer->ensure_space_available(length);
  buffer->end += fread( &buffer->data[buffer->end + 1], 
                        sizeof(buffer->data[0]), length, file);  

  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::LFBufferWriteToken(LFBuffer *buffer, LFTokenType token )
{
  i32 words[2];
  words[0] = token.left;
  words[1] = token.right;

  if (!bigendian) {
    words[0] = i32_swap_endian(words[0]);
    words[1] = i32_swap_endian(words[1]);
  }

  buffer->ensure_space_available(3);
  buffer->data[++buffer->end] = words[0];
  buffer->data[++buffer->end] = words[1];

  tokensWritten++;

  return LF_NO_ERROR;
}



LISSOMBinaryStateSaver::LFTokenType LISSOMBinaryStateSaver::LFBufferReadToken(LFBuffer *buffer )
{
  LFTokenType token;
  i32 words[2];
  
  /*  ipc_notify(IPC_ALL,IPC_STD,"Buffer start:%08x  end:%08x",
      buffer->start, buffer->end); */

  if ((buffer->end - buffer-> start) < 1)
    ipc_notify(IPC_ALL,IPC_ERROR,"Buffer is empty -- cannot read token");

  words[0] = buffer->data[buffer->start++];
  words[1] = buffer->data[buffer->start++];
  if (!bigendian) {
    words[0] = i32_swap_endian(words[0]);
    words[1] = i32_swap_endian(words[1]);
  }
  
  token.left  = words[0];
  token.right = words[1];

  tokensRead++;

  if ( (tokenName(token) < SMALLEST_LFTOK) || (tokenName(token) > LARGEST_LFTOK) )
    ipc_notify(IPC_ALL,IPC_WARNING,"Unknown token: %08x %08x", (int)token.left, (int)token.right); 
  
  return token;
}


int LISSOMBinaryStateSaver::LFBufferWriteItem(LFBuffer *buffer, void *itemptr)
{
  /* Get item */
  LFBufferDataType item = *(LFBufferDataType *)itemptr;
  if (!bigendian)
    item = LFBufferDataType_swap_endian(item);

  /* Put item in buffer */
  buffer->ensure_space_available(1);
  buffer->data[++buffer->end] = item;
  return LF_NO_ERROR;
}

     

LISSOMBinaryStateSaver::LFBufferDataType LISSOMBinaryStateSaver::LFBufferReadItem(LFBuffer *buffer)
{
  LFBufferDataType item;

  /* Check for data available */
  if ((buffer->end - buffer->start) < 0){
    ipc_notify(IPC_ALL,IPC_ERROR,"Buffer is empty -- cannot read integer");
    return 0;    
  }

  /* Get item */
  item = buffer->data[buffer->start++];
  if (!bigendian)
    item = LFBufferDataType_swap_endian(item);

  /* Return item */
  return item;
}



int LISSOMBinaryStateSaver::LFBufferWriteFloat(LFBuffer *buffer, f32 aFloat )
{
  assert(sizeof(f32)==sizeof(LFBufferDataType));
  return LFBufferWriteItem(buffer,&aFloat);
}



f32 LISSOMBinaryStateSaver::LFBufferReadFloat(LFBuffer *buffer)
{
  LFBufferDataType item = LFBufferReadItem(buffer);
  assert(sizeof(f32)==sizeof(LFBufferDataType));
  return *(f32 * )(void *)(&item);
}



int LISSOMBinaryStateSaver::LFBufferWriteInteger(LFBuffer *buffer, int anInteger )
{
  i32 output=(i32)anInteger;
  assert(sizeof(i32)==sizeof(LFBufferDataType));
  return LFBufferWriteItem(buffer,&output);
}



int LISSOMBinaryStateSaver::LFBufferReadInteger(LFBuffer *buffer)
{  return (int) LFBufferReadItem(buffer);  }



/******************************************************************************/
/* Direct file handling primitives                                            */
/******************************************************************************/

int LISSOMBinaryStateSaver::writeToken(FILE *file, LFTokenType token )
{
  i32 words[2];
  words[0] = token.left;
  words[1] = token.right;

  if (!bigendian) {
    words[0] = i32_swap_endian(words[0]);
    words[1] = i32_swap_endian(words[1]);
  }

  if (2 != fwrite( &words, sizeof(words[0]), 2, file)){
    ipc_notify(IPC_ALL,IPC_ERROR,"Cannot write to file");
    return LF_ERROR;
  }
  tokensWritten++;

  return LF_NO_ERROR;
}



LISSOMBinaryStateSaver::LFTokenType LISSOMBinaryStateSaver::readToken(FILE *file )
{
  LFTokenType token;
  i32 words[2];

  if (2 != fread( &words, sizeof(words[0]),    2, file))
    ipc_notify(IPC_ALL,IPC_ERROR,"Cannot read token from file");

  tokensRead++;

  if (!bigendian) {
    words[0] = i32_swap_endian(words[0]);
    words[1] = i32_swap_endian(words[1]);
  }
  
  token.left  = words[0];
  token.right = words[1];

  if ( (tokenName(token) < SMALLEST_LFTOK) || (tokenName(token) > LARGEST_LFTOK) )
    ipc_notify(IPC_ALL,IPC_WARNING,"Unknown token: %08x %08x", (int)token.left, (int)token.right); 
  
  return token;
}



LISSOMBinaryStateSaver::LFTokenType LISSOMBinaryStateSaver::peekToken(FILE *file )
{
  LFTokenType token;
  i32 words[2];
  long position = ftell(file);

  if (2 != fread( &words, sizeof(words[0]),    2, file))
    ipc_notify(IPC_ALL,IPC_ERROR,"Cannot read token from file");

  fseek(file, position, SEEK_SET); /* Reset file offset */

  if (!bigendian) {
    words[0] = i32_swap_endian(words[0]);
    words[1] = i32_swap_endian(words[1]);
  }
  
  token.left  = words[0];
  token.right = words[1];

  if ( (tokenName(token) < SMALLEST_LFTOK) || (tokenName(token) > LARGEST_LFTOK) )
    ipc_notify(IPC_ALL,IPC_WARNING,"Unknown token: %08x %08x", (int)token.left, (int)token.right); 

  return token;
}



LISSOMBinaryStateSaver::LFTokenType
LISSOMBinaryStateSaver::readTokenExpecting(int tokenNameExpected, FILE *file)
{
  int offset = ftell(file);
  LFTokenType token;
  token=readToken(file);

#ifdef LF_DEBUG_FILE
  printToken( token, offset );
#endif
  
  if (tokenName(token) != tokenNameExpected)
    ipc_notify(IPC_ALL,IPC_ERROR,"Expected token %s at offset %d but found %d. (Full token: 0x%08x %08x)", 
              tokenNameString(makeToken(tokenNameExpected,0,0,0)), offset, (int)tokenName(token),
              (int)token.left, (int)token.right);
  
  return token;
}



int LISSOMBinaryStateSaver::writeItem(FILE *file, void *itemptr)
{
  static int warningprinted = False;
  LFBufferDataType item = *(LFBufferDataType *)itemptr;

  if (!bigendian)
    item = LFBufferDataType_swap_endian(item);

  if (1 != fwrite( &item, sizeof(item), 1, file))
    if (!warningprinted) {
      ipc_notify(IPC_ALL,IPC_ERROR,"Cannot write to file");
      warningprinted=True;
    }

  return LF_NO_ERROR;
}

     

LISSOMBinaryStateSaver::LFBufferDataType
LISSOMBinaryStateSaver::readItem(FILE* file)
{
  LFBufferDataType item;
  static int warningprinted = False;
  
  if (1 != fread( &item, sizeof(item), 1, file))
    if (!warningprinted) {
      ipc_notify(IPC_ALL,IPC_ERROR,"Cannot read from file");
      warningprinted=True;
    }
  
  if (!bigendian)
    item = LFBufferDataType_swap_endian(item);
  
  return item;
}



int LISSOMBinaryStateSaver::writeFloat(FILE *file, f32 aFloat )
{
  assert(sizeof(f32)==sizeof(LFBufferDataType));
  return writeItem(file,&aFloat);
}



f32 LISSOMBinaryStateSaver::readFloat(FILE *file)
{
  LFBufferDataType item = readItem(file);
  assert(sizeof(f32)==sizeof(LFBufferDataType));
  return *(f32 * )(void *)(&item);
}



int LISSOMBinaryStateSaver::writeInteger(FILE *file, int anInteger )
{
  i32 output=(i32)anInteger;
  assert(sizeof(i32)==sizeof(LFBufferDataType));
  return writeItem(file,&output);
}



int LISSOMBinaryStateSaver::readInteger(FILE *file)
{  return (int)readItem(file);  }



/******************************************************************************/
/* Other utility routines                                                     */
/******************************************************************************/


int LISSOMBinaryStateSaver::compareParameter(int weight_file_parameter, int param_file_parameter, const char *description)
{
  if (weight_file_parameter != param_file_parameter) {
    ipc_notify(IPC_ALL,IPC_ERROR,"Value for %s in weight file (%d) differs from value in param file (%d)", 
              description, (int)weight_file_parameter, (int)param_file_parameter);
    return LF_ERROR;
  }

  return LF_NO_ERROR;
}



int LISSOMBinaryStateSaver::compareOrSetInt(int *destination, int value, int verify, const char *description)
{
  if (!verify) 
    *destination = value;
  else if (*destination != value) {
    static int warnings=0;
    warnings++;
    if (warnings < LF_MAXWARNINGS) 
      ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSetInt: Value for %s stored in buffer (%d) differs from value in memory (%d)", 
                description, (int)value, (int)*destination);
    else if (warnings == LF_MAXWARNINGS) 
      ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSetInt: Maximum number of warnings reached (%d)",warnings);
  }

  return *destination;
}



#define compareOrSet_proc(type)                                                                 \
LISSOMBinaryStateSaver::type LISSOMBinaryStateSaver::compareOrSet_ ## type (type *destination, type value, int verify, const char *description) \
{                                                                                               \
  if (!verify)                                                                                  \
    *destination = value;                                                                       \
  else                                                                                          \
    /* ensure that the number is "pretty close" to real value, even if zero */                  \
    if ((*destination == 0 && ((*destination - value)                 > LF_FLOAT_TOLERANCE ))|| \
        (*destination != 0 && ((*destination - value)/(*destination)) > LF_FLOAT_TOLERANCE ) ) {\
      static int warnings=0;                                                                    \
      warnings++;                                                                               \
      if (warnings < LF_MAXWARNINGS)                                                            \
        ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSet_" #type ": Value for %s stored in buffer (%e) differs from value in memory (%e)",    \
                  description, (double)value, (double)(*destination));                          \
      else if (warnings == LF_MAXWARNINGS)                                                      \
        ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSet_" #type ": Maximum number of warnings reached (%d)",warnings);       \
    }                                                                                           \
                                                                                                \
  return *destination;                                                                          \
}



compareOrSet_proc(a_weight)
compareOrSet_proc(l_weight)

     

/* For debugging, the routines below are what the macros above currently expand to 

//a_weight LISSOMBinaryStateSaver::compareOrSet_a_weight ( a_weight *destination, a_weight value, int verify, const char *description)
//{
//  if (!verify)
//    *destination = value;
//  else if ((*destination == 0 && ((*destination - value) > 0.0000001 ))
//           || (*destination != 0 && ((*destination - value)/(*destination)) > 0.0000001 ) ) {
//    static int warnings=0;
//    warnings++;
//    if (warnings < 5 )
//      ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSet_" "a_weight" ": Value for %s stored in buffer (%e) differs from value in memory (%e)",
//                description, (double)value, (double)(*destination));
//    else if (warnings == 5 )
//      ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSet_" "a_weight" ": Maximum number of warnings reached (%d)",warnings);
//  }
// 
//  return *destination;
//} 
// 
//l_weight LISSOMBinaryStateSaver::compareOrSet_l_weight ( l_weight *destination, l_weight value, int verify, const char *description)
//{
//  if (!verify)
//    *destination = value;
//  else if ((*destination == 0 && ((*destination - value) > 0.0000001 )) ||
//           (*destination != 0 && ((*destination - value)/(*destination)) > 0.0000001 ) ) {
//    static int warnings=0;
//    warnings++;
//    if (warnings < 5 )
//      ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSet_" "l_weight" ": Value for %s stored in buffer (%e) differs from value in memory (%e)",
//                description, (double)value, (double)(*destination));
//    else if (warnings == 5 )
//      ipc_notify(IPC_ALL,IPC_ERROR,"compareOrSet_" "l_weight" ": Maximum number of warnings reached (%d)",warnings);
//  }
// 
//  return *destination;
//}

*/

---