memory_obj.c

来自「CA仿真模型中SLEUTH模型」· C语言 代码 · 共 987 行 · 第 1/2 页

          LOG_ERROR (msg_buf);
          EXIT (1);
        }
      }
    }
  }
  fprintf (fp, "MEMORY CHECK OK\n");
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_InvalidateCheckArray
** PURPOSE:       invalidate the check memory array elements
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_InvalidateCheckArray ()
{
  int i;
  for (i = 0; i < mem_check_count; i++)
  {
    *(mem_check_array[i]) = invalid_val;
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_CheckCheckArray
** PURPOSE:       memory check
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_CheckCheckArray ()
{
  char func[] = "mem_CheckCheckArray";
  int i;
  for (i = 0; i < mem_check_count; i++)
  {
    if (*(mem_check_array[i]) != invalid_val)
    {
      sprintf (msg_buf, "ptr = %d failed memory check", mem_check_array[i]);
      LOG_ERROR (msg_buf);
      sprintf (msg_buf, "i=%u *ptr=%X invalid_val=%X",
               i, *(mem_check_array[i]), invalid_val);
      LOG_ERROR (msg_buf);
      EXIT (1);
    }
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_partition
** PURPOSE:       partition the memory
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_partition (FILE * fp)
{
  int i;
  PIXEL *temp_ptr = (PIXEL *) mem_ptr;
  PIXEL *end_ptr;


  if (fp)
  {
    end_ptr = (temp_ptr + bytes2allocate / BYTES_PER_WORD);
    fprintf (fp, "\n\nMemory starts at %d and ends at %d\n",
             temp_ptr, end_ptr);
  }
  mem_check_count = 0;
  for (i = 0; i < igrid_GetIGridCount (); i++)
  {
    mem_check_array[mem_check_count++] = temp_ptr;
    temp_ptr += mem_check_size;
    igrid_array[i].ptr = (GRID_P) temp_ptr;
    temp_ptr += igrid_size;
    strcpy (igrid_array[i].current_owner, "");
    mem_igrid_push (i);
    if (fp)
    {
      fprintf (fp, "%d mem_check_array[%2u]\n",
               mem_check_array[mem_check_count - 1], mem_check_count - 1);
      fprintf (fp, "%d igrid_array[%2u]\n", igrid_array[i].ptr, i);
    }
  }

  for (i = 0; i < pgrid_GetPGridCount (); i++)
  {
    mem_check_array[mem_check_count++] = temp_ptr;
    temp_ptr += mem_check_size;
    pgrid_array[i].ptr = (GRID_P) temp_ptr;
    temp_ptr += pgrid_size;
    strcpy (pgrid_array[i].current_owner, "");
    mem_pgrid_push (i);
    if (fp)
    {
      fprintf (fp, "%d mem_check_array[%2u]\n",
               mem_check_array[mem_check_count - 1], mem_check_count - 1);
      fprintf (fp, "%d pgrid_array[%2u]\n", pgrid_array[i].ptr, i);
    }
  }

  for (i = 0; i < wgrid_GetWGridCount (); i++)
  {
    mem_check_array[mem_check_count++] = temp_ptr;
    temp_ptr += mem_check_size;
    wgrid_array[i].ptr = (GRID_P) temp_ptr;
    mem_InvalidateGrid (wgrid_array[i].ptr);
    temp_ptr += wgrid_size;
    strcpy (wgrid_array[i].current_owner, "");
    mem_wgrid_push (i);
    if (fp)
    {
      fprintf (fp, "%d mem_check_array[%2u]\n",
               mem_check_array[mem_check_count - 1], mem_check_count - 1);
      fprintf (fp, "%d wgrid_array[%2u]\n", wgrid_array[i].ptr, i);
    }
  }
  mem_check_array[mem_check_count++] = temp_ptr;
  if (fp)
  {
    fprintf (fp, "%d mem_check_array[%2u]\n",
             mem_check_array[mem_check_count - 1], mem_check_count - 1);
    fprintf (fp, "%d End of memory \n", end_ptr);
  }
  min_wgrid_free_tos = wgrid_free_tos;

}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_InvalidateGrid
** PURPOSE:       invalidate a grid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_InvalidateGrid (GRID_P ptr)
{
  int i;

  for (i = 0; i < total_pixels; i++)
  {
    ptr[i] = invalid_val;
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_CheckInvalidateGrid
** PURPOSE:       memory check a grid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_CheckInvalidateGrid (GRID_P ptr)
{
  char func[] = "mem_CheckInvalidateGrid";
  int i;

  for (i = 0; i < total_pixels; i++)
  {
    if (ptr[i] != invalid_val)
    {
      sprintf (msg_buf, "grid %d is not invalid", ptr);
      LOG_ERROR (msg_buf);
      EXIT (1);
    }
  }
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_allocate
** PURPOSE:       allocate memory
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_allocate ()
{
  char func[] = "mem_allocate";
  mem_ptr = malloc (bytes2allocate);
  if (mem_ptr == NULL)
  {
    sprintf (msg_buf, "Unable to allocate %u bytes of memory", bytes2allocate);
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  if (scen_GetLogFlag ())
  {
    scen_Append2Log ();
    fprintf (scen_GetLogFP (), "%s %u Allocated %u bytes of memory\n",
             __FILE__, __LINE__, bytes2allocate);
    scen_CloseLog ();
  }

  memset (mem_ptr, 0, bytes2allocate);
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_igrid_push
** PURPOSE:       push igrid onto a stack
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_igrid_push (int i)
{
  char func[] = "mem_igrid_push";
  if (igrid_free_tos >= 50)
  {
    sprintf (msg_buf, "igrid_free_tos >= 50");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  igrid_free[igrid_free_tos] = i;
  igrid_array[i].free = TRUE;
  igrid_free_tos++;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_igrid_pop
** PURPOSE:       pop an igrid from the stack
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static int
  mem_igrid_pop ()
{
  char func[] = "mem_igrid_pop";
  igrid_free_tos--;
  if (igrid_free_tos < 0)
  {
    sprintf (msg_buf, "igrid_free_tos < 0");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  igrid_array[igrid_free_tos].free = FALSE;
  return igrid_free[igrid_free_tos];
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_pgrid_push
** PURPOSE:       push a pgrid onto a stack
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_pgrid_push (int i)
{
  char func[] = "mem_pgrid_push";
  if (pgrid_free_tos >= 50)
  {
    sprintf (msg_buf, "pgrid_free_tos >= 50");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  pgrid_free[pgrid_free_tos] = i;
  pgrid_array[i].free = TRUE;
  pgrid_free_tos++;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_pgrid_pop
** PURPOSE:       pop a pgrid from the stack
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static int
  mem_pgrid_pop ()
{
  char func[] = "mem_pgrid_pop";
  pgrid_free_tos--;
  if (pgrid_free_tos < 0)
  {
    sprintf (msg_buf, "pgrid_free_tos < 0");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  pgrid_array[pgrid_free_tos].free = FALSE;
  return pgrid_free[pgrid_free_tos];
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_wgrid_push
** PURPOSE:       push a wgrid onto the stack
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static void
  mem_wgrid_push (int i)
{
  char func[] = "mem_wgrid_push";
  if (wgrid_free_tos >= 50)
  {
    sprintf (msg_buf, "wgrid_free_tos >= 50");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  wgrid_free[wgrid_free_tos] = i;
  wgrid_array[i].free = TRUE;
#ifdef MEMORY_CHECK_LEVEL3
  mem_InvalidateGrid (wgrid_array[i].ptr);
#endif
  wgrid_free_tos++;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_wgrid_pop
** PURPOSE:       pop a wgrid from the stack
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
static int
  mem_wgrid_pop ()
{
  char func[] = "mem_wgrid_pop";
  wgrid_free_tos--;
  if (wgrid_free_tos < 0)
  {
    sprintf (msg_buf, "wgrid_free_tos < 0");
    LOG_ERROR (msg_buf);
    sprintf (msg_buf, "Increase NUM_WORKING_GRIDS in scenario file");
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  wgrid_array[wgrid_free[wgrid_free_tos]].free = FALSE;
  min_wgrid_free_tos = MIN (min_wgrid_free_tos, wgrid_free_tos);
#ifdef MEMORY_CHECK_LEVEL3
  mem_CheckInvalidateGrid (wgrid_array[wgrid_free[wgrid_free_tos]].ptr);
#endif
  return wgrid_free[wgrid_free_tos];
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_ReinvalidateMemory
** PURPOSE:       invalidate the memory
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_ReinvalidateMemory ()
{
  int i;

  for (i = 0; i < wgrid_GetWGridCount (); i++)
  {
    mem_InvalidateGrid (wgrid_array[i].ptr);
  }
  mem_InvalidateCheckArray ();
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: memGetBytesPerGridRound
** PURPOSE:       return # bytes per grid rounded to word boundary
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
int
  memGetBytesPerGridRound ()
{
  return bytes_p_grid_rounded2wordboundary;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_LogMinFreeWGrids
** PURPOSE:       log the minmum # of free grids
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_LogMinFreeWGrids (FILE * fp)
{
  fprintf (fp, "Minmum number of Free working grids=%u\n",
           min_wgrid_free_tos);
  fprintf (fp,
   "For max efficiency of memory usage reduce NUM_WORKING_GRIDS by %u\n",
           min_wgrid_free_tos);
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_LogPartition
** PURPOSE:       log memory partition to FILE * fp_in
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_LogPartition (FILE * fp_in)
{
  int i;
  FILE *fp;

  fp = fp_in ? fp_in : stdout;
  if (!((fp == stdout) && (!scen_GetEchoFlag ())))
  {
    for (i = 0; i < igrid_GetIGridCount (); i++)
    {
      fprintf (fp, "%d igrid_array[%u].ptr\n", igrid_array[i].ptr, i);
    }
    for (i = 0; i < pgrid_GetPGridCount (); i++)
    {
      fprintf (fp, "pgrid_array[%u].ptr = %d\n", i, pgrid_array[i].ptr);
    }
    for (i = 0; i < wgrid_GetWGridCount (); i++)
    {
      fprintf (fp, "wgrid_array[%u].ptr = %d\n", i, wgrid_array[i].ptr);
    }
    for (i = 0; i < mem_check_count; i++)
    {
      fprintf (fp, "mem_check_array[%u].ptr = %d\n", i, mem_check_array[i]);
    }
  }
}