M3_cache.c

#include <stdlib.h>
#include <stdio.h>

#include "M3.h"
#include "M3_cache.h"
#include "M3_otfs.h"
#include "M3_gcp.h"

#ifdef USE_MPI
#include "mpi.h"
#include "M3_mpi.h"
#endif

int M3_RunConfigStruct_GetTODcache( M3_RunConfigStruct *runConfig, M3_TODcacheStruct **todCache )
{
  *todCache = &(runConfig->todCache);
  return( M3_EFLAG_NONE );
}

int M3_TODcacheStruct_SetCacheAll( M3_TODcacheStruct *todCache )
{
  todCache->useGCPcache = 1;
  todCache->useScanMapCache = 1;
  return( M3_EFLAG_NONE );
}

int M3_TODcacheStruct_SetCacheNone( M3_TODcacheStruct *todCache )
{
  todCache->useGCPcache = 0;
  todCache->useScanMapCache = 0;
  return( M3_EFLAG_NONE );
}

int M3_TODcacheStruct_SetCacheGCPdata( M3_TODcacheStruct *todCache, int useGCPcache )
{
  todCache->useGCPcache = useGCPcache;
  return( M3_EFLAG_NONE );
}

int M3_TODcacheStruct_SetCacheScanMapData( M3_TODcacheStruct *todCache, int useScanMapCache )
{
  todCache->useScanMapCache = useScanMapCache;
  return( M3_EFLAG_NONE );
}

int M3_TODcacheStruct_AppendRequest( M3_TODcacheStruct *todCache, M3_DataSetLL *dataSet, M3_Interval requestInterval)
{
  M3_TODrequestLL *thisRequest;
  /* Check to be sure that caching is turned on.  */
  if( todCache->useGCPcache || todCache->useScanMapCache )
  {     
    /* Add an empty node to the list. */
    if( todCache->todRequestList == NULL )
    {
      M3_MallocRecordLL_AppendToList( &(todCache->mallocRecordList), sizeof(M3_TODrequestLL), (void **)&(todCache->todRequestList ));
      thisRequest = todCache->todRequestList;
    }
    else
    {
      for( thisRequest = todCache->todRequestList;
           thisRequest->next;
           thisRequest = thisRequest->next );
      M3_MallocRecordLL_AppendToList( &(todCache->mallocRecordList), sizeof(M3_TODrequestLL), (void **)&(thisRequest->next));
      thisRequest = thisRequest->next;
    }
  
    /* Fill in the request values. */
    thisRequest->dataSetNode = dataSet;
    thisRequest->sampleInterval = requestInterval;
    thisRequest->next = NULL;
  }
  return( M3_EFLAG_NONE );
}

int M3_MallocRecordLL_AppendToList( M3_MallocRecordLL **recordList, size_t size, void **space )
{
  M3_MallocRecordLL *record;

  if( size == 0 )
    return( M3_EFLAG_NONE );

  /* Add an empty node to the list.  */
  if( *recordList )
  {
    for( record = *recordList; record->next; record = record->next );
    record->next = calloc(1,sizeof(M3_MallocRecordLL));
    record = record->next;
  }
  else
  {
    *recordList = calloc(1,sizeof(M3_MallocRecordLL));
    record = *recordList;
  }
  M3_ErrorCheck(-1, "M3_MallocRecordLL_AppendToList()", (record ? 1:0), M3_EFLAG_MALLOC_FSTRING );
  /* Set the size and allocate the space. */
  record->size = size;
  record->space = calloc(size, 1);
  M3_ErrorCheck(-1, "M3_MallocRecordLL_AppendToList()", (record->space ? 1:0), M3_EFLAG_MALLOC_FSTRING );

  /* Set the output pointer */
  *space = record->space;

  return( M3_EFLAG_NONE );
}


int M3_MallocRecordLL_Destroy( M3_MallocRecordLL *recordList )
{
  M3_MallocRecordLL *thisRecord, *tempRecord;

  thisRecord = recordList;
  while( thisRecord )
  {
    tempRecord = thisRecord->next;
    if( thisRecord->space )
      free( thisRecord->space );
    free(thisRecord);
    thisRecord = tempRecord;
  }

  return( M3_EFLAG_NONE );
}


int M3_TODcacheStruct_Initialize( M3_TODcacheStruct *todCache, M3_RunConfigStruct *runConfig, size_t *storeSize )
{
  int32_t i, j, k, cacheMap;
  int64_t numHitPixel;
  M3_BitArray bitArray = {0};
  M3_PixelConvertStruct *pixelConvert;
  M3_TimeIntervalLL *timeIntervalList;
  M3_GCPointingGroupLL *thisGCPgroup, *thatGCPgroup;
  M3_TODrequestLL *thisRequest;
  M3_TimeInterval thisTimeInterval;
  M3_IntervalLL requestInterval;
  M3_PixelClassLL *thisPixelClass;
  M3_MallocRecordLL *thisRecord;
  M3_MapEl *mapPtr;
  M3_DataSetLL *thisDataSet;
  M3_ComponentLL *thisComponent;
  M3_SubcomponentLL *thisSubcomponent;

  size_t thisStoreSize;
  void *storeSpace;
  static int64_t diskBufferSize = -1;
  char *tempPtr;

  if( diskBufferSize == -1 )
  {
    tempPtr = getenv("M3_DISK_BUFFER_SIZE");
    if( tempPtr )
      diskBufferSize = strtoll( tempPtr, NULL, 10);
    else
      diskBufferSize = M3_DISK_BUFFER_SIZE;
  }

  /* Initialize the storeSize to zero.  */
  todCache->storeSize = 0;
  *storeSize = 0;

  /* Initialize the GCP cache from the request interval list. */
  if( todCache->useGCPcache )
  {
    timeIntervalList = NULL;
    for( thisGCPgroup = runConfig->GCPointingGroupList; 
         thisGCPgroup;
         thisGCPgroup = thisGCPgroup->next )
    {
      /* Go through the request intervals.  */  
      for( thisRequest = todCache->todRequestList; thisRequest; thisRequest = thisRequest->next )
      {
        M3_DataSetLL_GetGCPointingGroupNode( thisRequest->dataSetNode, &thatGCPgroup );
        if( thisGCPgroup == thatGCPgroup )
        {
          /* Convert the sample interval list into a time interval list for gcp initilization. */
          M3_DataSetLL_SampleIntervalToTimeInterval(thisRequest->dataSetNode, thisRequest->sampleInterval, &(thisTimeInterval));
          M3_TimeIntervalLL_InsertInterval( &timeIntervalList, thisTimeInterval);
        }
      }
      if( timeIntervalList )
      {
        /* Initialize GCP with the list just generated. */
        M3_GCPointingGroupLL_GetStoreSize( thisGCPgroup, timeIntervalList, &thisStoreSize );
        
        /* Allocate memory in the cache structure, and use it for GCP init.  */
        M3_MallocRecordLL_AppendToList(&(todCache->mallocRecordList), thisStoreSize, &storeSpace );
        M3_GCPointingGroupLL_InitializeStore( thisGCPgroup, timeIntervalList, storeSpace );
    
        M3_TimeIntervalLL_DestroyList( timeIntervalList );
        timeIntervalList = NULL;
      }
    }
  }
  
  /* Initialize scan map cache. */
  /* Make sure that simulated data exists*/
  cacheMap = 0;
  for( thisDataSet = runConfig->dataSetList; thisDataSet; thisDataSet = thisDataSet->next )
    for( thisComponent = thisDataSet->componentList; thisComponent; thisComponent = thisComponent->next )
      for( thisSubcomponent = thisComponent->subcomponentList; thisSubcomponent; thisSubcomponent = thisSubcomponent->next )
        if( thisSubcomponent->simType == M3_MAPSCAN_SIM_TYPE )
        {
          cacheMap = 1;
          break;
        }

  if( todCache->useScanMapCache && cacheMap )
  {
    /* Create a short cut to the pixel conversion structure.  */
    pixelConvert = &(runConfig->pixelConvert);

    /* Figure out the total number of pixels in all of the classes (not just those that were observed) */
    /* We will create a bit array which will keep track of which pixels are observed.  */
    M3_RunConfigStruct_SumNumClassPixels( runConfig, &i );
    bitArray.numEl = i;
    pixelConvert->numGlobalPix = i; 

    /* Determine if the total number of pixels is small enough that we should 
       store an indexed lookup table rather than requiring a binary search 
       to convert from global pixel index to observed pixel index.  
       This uses M3_DISK_BUFFER_SIZE as the measureing stick for determining 
       what is "small enough".  This may not be the best solution.  */
    if(pixelConvert->numGlobalPix*sizeof(int32_t) < diskBufferSize )
      pixelConvert->useFullLookup = 1;
    else
      pixelConvert->useFullLookup = 0;
  
    /* Allocate the bit array of length the number of global pixles 
       for deteriming observed pixels.  */
    bitArray.array = (unsigned char *)calloc(bitArray.numEl/8 + ( bitArray.numEl%8 ? 1 : 0 ), 1 );
    M3_ErrorCheck(-1, "M3_TODcacheStruct_GetSize() bit array of global pixels", (bitArray.array?1:0), M3_EFLAG_MALLOC_FSTRING );

    /* Now that we have initialized the GCP we can figure out which pixels were observed.*/
    /* requestInterval will be a list with only one element, so set next to NULL. */
    requestInterval.next = NULL;
    for( thisRequest = todCache->todRequestList; thisRequest; thisRequest = thisRequest->next )
    {    
      /* Flip bits of observed pixels. */
      requestInterval.interval = thisRequest->sampleInterval;
      M3_DataSetLL_AugmentHitBits( thisRequest->dataSetNode, runConfig->pixelClassList, &requestInterval, &bitArray, 0);
    }

    /* Figure out the total number of observed pixels.  */
    M3_BitArray_SumBits( &bitArray, &numHitPixel );
    pixelConvert->myNumPix = numHitPixel;
    
    /* Allocate space for the index array for the map that will be scanned.  */
    M3_MallocRecordLL_AppendToList( &(todCache->mallocRecordList), sizeof(int32_t)*numHitPixel, (void **)(&(pixelConvert->myPixToGlobalPix)) );
    M3_ErrorCheck(-1, "M3_TODcacheStruct_Initialize()", (pixelConvert->myPixToGlobalPix ? 1:0), M3_EFLAG_MALLOC_FSTRING );

    if( pixelConvert->useFullLookup )
    {
      M3_MallocRecordLL_AppendToList( &(todCache->mallocRecordList), sizeof(int32_t)*pixelConvert->numGlobalPix, (void **)(&(pixelConvert->globalPixToMyPix)) );
      M3_ErrorCheck(-1, "M3_TODcacheStruct_Initialize()", (pixelConvert->globalPixToMyPix ? 1:0), M3_EFLAG_MALLOC_FSTRING );  
    }

    /* Create lookup table from bit array.  */
    j = 0;
    for( i = 0; i < pixelConvert->numGlobalPix; i++ )
      if( M3_BitArray_GetBit( &bitArray, i ) )
      {
        pixelConvert->myPixToGlobalPix[j] = i;
        if( pixelConvert->useFullLookup )
          pixelConvert->globalPixToMyPix[i] = j;
        j++;
      }
    /* Free the bitArray, we no longer need it.  */
    free(bitArray.array);

    /* Find the largest pixel class index for classOffset array size */
    for( i = 0, M3_RunConfigStruct_GetPixelClassRoot( runConfig, &thisPixelClass );
         thisPixelClass;
         i++, M3_PixelClassLL_GetNextNodeInList(&thisPixelClass));
    pixelConvert->numPixelClass = i;

    /* Allocate classOffset array */
    M3_MallocRecordLL_AppendToList( &(todCache->mallocRecordList), sizeof(int32_t)*(pixelConvert->numPixelClass+1), (void **)(&(pixelConvert->classOffset)) );
    M3_ErrorCheck(-1, "M3_TODcacheStruct_Initialize()", (pixelConvert->classOffset ? 1 : 0), M3_EFLAG_MALLOC_FSTRING );

    i = 0;
    for( j = 0, M3_RunConfigStruct_GetPixelClassRoot( runConfig, &thisPixelClass );
         thisPixelClass;
         j++, M3_PixelClassLL_GetNextNodeInList(&thisPixelClass))
    {
      pixelConvert->classOffset[j] = i;
      M3_PixelClassLL_GetNumPixelInClass( thisPixelClass,&k );
      i += k;
    }
    pixelConvert->classOffset[j] = i;

    /* Allocate space for scan map.  */
    M3_MallocRecordLL_AppendToList( &(todCache->mallocRecordList), sizeof(M3_MapEl)*pixelConvert->myNumPix, (void **)(&(pixelConvert->mapSimStore)));
    M3_ErrorCheck(-1, "M3_TODcacheStruct_Initialize()", (pixelConvert->mapSimStore ? 1:0),M3_EFLAG_DEFAULT ); 

    /* Read the partial maps into memory.  */
    mapPtr = pixelConvert->mapSimStore;
    /* i is the index for the pixel classes.  */
    /* j is the index for myPixels */
    /* k keeps track of the number of observed pixels in each class.  */
    j = 0;
    for( i = 0, M3_RunConfigStruct_GetPixelClassRoot( runConfig, &thisPixelClass );
         thisPixelClass;
         i++, M3_PixelClassLL_GetNextNodeInList(&thisPixelClass))
    {
      k = 0;
      while( j < pixelConvert->myNumPix && pixelConvert->myPixToGlobalPix[j] < pixelConvert->classOffset[i+1] )
      {
        pixelConvert->mapSimStore[j].pixel = pixelConvert->myPixToGlobalPix[j] - pixelConvert->classOffset[i];
        j++;
        k++;
      }
      M3_ProfileStart( 193, "Map reading inside cache initialization");
#ifdef USE_MPI
      M3_File_ReadDataMPI( thisPixelClass->mapFile, &k, mapPtr, MPI_COMM_WORLD );
#else
      M3_PixelClassLL_GetIndexedMap( thisPixelClass, k, mapPtr );
#endif
      M3_ProfileStop( 193 );
      mapPtr += k;
    }

    for( j = 0; j < pixelConvert->myNumPix; j++ )
      pixelConvert->mapSimStore[j].pixel = pixelConvert->myPixToGlobalPix[j];
  }

  /* Calculate the size of the cache. */
  todCache->storeSize = 0;
  for( thisRecord = todCache->mallocRecordList; 
       thisRecord;
       thisRecord = thisRecord->next )
    todCache->storeSize += thisRecord->size;

  *storeSize = todCache->storeSize;

  return(M3_EFLAG_NONE);
}

int M3_TODcacheStruct_Destroy( M3_TODcacheStruct *todCache )
{
  M3_TODrequestLL *thisRequest, *thatRequest;
  M3_PointingClassLL *thisPointingClass;

  if( todCache == NULL )
    return( M3_EFLAG_NONE );

  if( todCache->todRequestList == NULL )
    return(M3_EFLAG_NONE);
  
  if( todCache->useScanMapCache )
  {
    memset( &(todCache->todRequestList->dataSetNode->runConfigNode->pixelConvert), 0, sizeof(M3_PixelConvertStruct));
  }

  if( todCache->useGCPcache )
  {
    thisRequest = todCache->todRequestList;
    while( thisRequest )
    {
      for( thisPointingClass = thisRequest->dataSetNode->pointingClassList; thisPointingClass; thisPointingClass = thisPointingClass->next )
        if( thisPointingClass->subclassList )
          if( thisPointingClass->subclassList->GCPointingGroupNode )
          {
            thisPointingClass->subclassList->GCPointingGroupNode->GCPointingStoreList = NULL;
            thisPointingClass->subclassList->GCPointingGroupNode->auxStore = NULL;
          }
            
      thisRequest = thisRequest->next; 
    }
  }

  M3_MallocRecordLL_Destroy( todCache->mallocRecordList );
  todCache->todRequestList = NULL;
  todCache->mallocRecordList = NULL;
 
  return( M3_EFLAG_NONE );
}
 

---