memory_obj.c

CA仿真模型中SLEUTH模型

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include "globals.h"
#include "igrid_obj.h"
#include "pgrid_obj.h"
#include "wgrid_obj.h"
#include "scenario_obj.h"
#include "ugm_typedefs.h"
#include "ugm_macros.h"
#include "memory_obj.h"

/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                                 MACROS                                    **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
#define MEM_ARRAY_SIZE 50
#define INVALID_VAL 0xAAAAAAAA

/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                               SCCS ID                                     **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
char memory_obj_c_sccs_id[] = "@(#)memory_obj.c	1.84	12/4/00";

/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                      STATIC MEMORY FOR THIS OBJECT                        **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
typedef struct
{
  char previous_owner[MAX_FILENAME_LEN];
  char current_owner[MAX_FILENAME_LEN];
  char released_by[MAX_FILENAME_LEN];
  BOOLEAN free;
  GRID_P ptr;
}
mem_track_info;
static int nrows;
static int ncols;
static int total_pixels;
static PIXEL invalid_val;
static int igrid_free[MEM_ARRAY_SIZE];
static int igrid_free_tos;
static mem_track_info igrid_array[MEM_ARRAY_SIZE];
static int pgrid_free[MEM_ARRAY_SIZE];
static int pgrid_free_tos;
static mem_track_info pgrid_array[MEM_ARRAY_SIZE];
static int wgrid_free[MEM_ARRAY_SIZE];
static int wgrid_free_tos;
static int min_wgrid_free_tos;
static mem_track_info wgrid_array[MEM_ARRAY_SIZE];
static PIXEL *mem_check_array[MEM_ARRAY_SIZE];
static int mem_check_count;
static int mem_check_size;
static int igrid_size;
static int pgrid_size;
static int wgrid_size;
static int bytes_p_grid;
static int bytes_p_grid_rounded2wordboundary;
static int bytes_p_packed_grid;
static int bytes_p_packed_grid_rounded2wordboundary;
static int bytes2allocate;
static void *mem_ptr;
static int igrid_count;
static int pgrid_count;
static int wgrid_count;
static FILE *memlog_fp;
static char mem_log_filename[MAX_FILENAME_LEN];

/*****************************************************************************\
*******************************************************************************
**                                                                           **
**                        STATIC FUNCTION PROTOTYPES                         **
**                                                                           **
*******************************************************************************
\*****************************************************************************/
static void mem_CheckCheckArray ();
static void mem_partition ();
static void mem_allocate ();
static void mem_igrid_push (int i);
static int mem_igrid_pop ();
static void mem_pgrid_push (int i);
static int mem_pgrid_pop ();
static void mem_wgrid_push (int i);
static int mem_wgrid_pop ();
static void mem_InvalidateGrid (GRID_P ptr);
static void mem_CheckInvalidateGrid (GRID_P ptr);
static void mem_InvalidateCheckArray ();
void mem_Init ();
GRID_P mem_GetIGridPtr (char *owner);
GRID_P mem_GetPGridPtr (char *owner);
GRID_P mem_GetWGridPtr (char *module, char *who, int line);
GRID_P mem_GetWGridFree (char *module, char *who, int line, GRID_P ptr);


/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_MemoryLog
** PURPOSE:       log memory map to FILE* fp
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_MemoryLog (FILE * fp)
{
  LOG_MEM (fp, &nrows, sizeof (int), 1);
  LOG_MEM (fp, &ncols, sizeof (int), 1);
  LOG_MEM (fp, &total_pixels, sizeof (int), 1);
  LOG_MEM (fp, &invalid_val, sizeof (PIXEL), 1);

  LOG_MEM (fp, &igrid_free[0], sizeof (int), MEM_ARRAY_SIZE);
  LOG_MEM (fp, &igrid_free_tos, sizeof (int), 1);
  LOG_MEM (fp, &igrid_array[0], sizeof (mem_track_info), MEM_ARRAY_SIZE);

  LOG_MEM (fp, &pgrid_free[0], sizeof (int), MEM_ARRAY_SIZE);
  LOG_MEM (fp, &pgrid_free_tos, sizeof (int), 1);
  LOG_MEM (fp, &pgrid_array[0], sizeof (mem_track_info), MEM_ARRAY_SIZE);

  LOG_MEM (fp, &wgrid_free[0], sizeof (int), MEM_ARRAY_SIZE);
  LOG_MEM (fp, &wgrid_free_tos, sizeof (int), 1);
  LOG_MEM (fp, &min_wgrid_free_tos, sizeof (int), 1);
  LOG_MEM (fp, &wgrid_array[0], sizeof (mem_track_info), MEM_ARRAY_SIZE);

  LOG_MEM (fp, &mem_check_count, sizeof (int), 1);
  LOG_MEM (fp, &mem_check_size, sizeof (int), 1);
  LOG_MEM (fp, &igrid_size, sizeof (int), 1);
  LOG_MEM (fp, &pgrid_size, sizeof (int), 1);
  LOG_MEM (fp, &wgrid_size, sizeof (int), 1);

  LOG_MEM (fp, &bytes_p_grid, sizeof (int), 1);
  LOG_MEM (fp, &bytes_p_grid_rounded2wordboundary, sizeof (int), 1);
  LOG_MEM (fp, &bytes_p_packed_grid, sizeof (int), 1);
  LOG_MEM (fp, &bytes_p_packed_grid_rounded2wordboundary, sizeof (int), 1);
  LOG_MEM (fp, &bytes2allocate, sizeof (int), 1);
  LOG_MEM (fp, &mem_ptr, sizeof (void *), 1);
  LOG_MEM (fp, &igrid_count, sizeof (int), 1);
  LOG_MEM (fp, &pgrid_count, sizeof (int), 1);
  LOG_MEM (fp, &wgrid_count, sizeof (int), 1);
  LOG_MEM (fp, &memlog_fp, sizeof (FILE *), 1);
}

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

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_GetTotalPixels
** PURPOSE:       return total pixel count in a grid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
int
  mem_GetTotalPixels ()
{
  return total_pixels;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_GetIGridPtr
** PURPOSE:       return the pointer to the next igrid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
GRID_P
  mem_GetIGridPtr (char *owner)
{
  int index;

  index = mem_igrid_pop ();
  strcpy (igrid_array[index].current_owner, owner);
  return igrid_array[index].ptr;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_GetPGridPtr
** PURPOSE:       return ptr to next pgrid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
GRID_P
  mem_GetPGridPtr (char *owner)
{
  int index;

  index = mem_pgrid_pop ();
  strcpy (pgrid_array[index].current_owner, owner);
  return pgrid_array[index].ptr;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_GetWGridPtr
** PURPOSE:       return ptr to next wgrid
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
GRID_P
  mem_GetWGridPtr (char *module, char *who, int line)
{
  int index;

  index = mem_wgrid_pop ();
  strcpy (wgrid_array[index].previous_owner, wgrid_array[index].current_owner);
  sprintf (wgrid_array[index].current_owner,
           "Module: %s Function: %s Line %u", module, who, line);
  return wgrid_array[index].ptr;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_GetWGridFree
** PURPOSE:       
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
GRID_P
  mem_GetWGridFree (char *module, char *who, int line, GRID_P ptr)
{
  char func[] = "mem_GetWGridFree";
  int i;
  int index;
  BOOLEAN match = FALSE;

  for (i = 0; i < wgrid_count; i++)
  {
    if (wgrid_array[i].ptr == ptr)
    {
      match = TRUE;
      index = i;
      break;
    }
  }
  if (match == FALSE)
  {
    sprintf (msg_buf, "%s %u look in module %s %s %u\n",
             __FILE__, __LINE__, module, who, line);
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  if (wgrid_array[index].free == TRUE)
  {
    sprintf (msg_buf, "wgrid_array[%u].free == TRUE", index);
    LOG_ERROR (msg_buf);
    EXIT (1);
  }
  strcpy (wgrid_array[index].current_owner, "");
  sprintf (wgrid_array[index].released_by,
           "Module: %s Function: %s Line %u", module, who, line);
  mem_wgrid_push (index);
  return NULL;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_Init
** PURPOSE:       initialization routine
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_Init ()
{
  char func[] = "mem_Init";
  int check_pixel_count;


  sprintf (mem_log_filename, "%smemory.log", scen_GetOutputDir ());

  memlog_fp = NULL;
  if (scen_GetLogMemoryMapFlag ())
  {
    FILE_OPEN (memlog_fp, mem_log_filename, "w");
  }

  invalid_val = INVALID_VAL;
  igrid_free_tos = 0;
  pgrid_free_tos = 0;
  wgrid_free_tos = 0;
  nrows = igrid_GetNumRows ();
  ncols = igrid_GetNumCols ();
  total_pixels = nrows * ncols;
  igrid_count = igrid_GetIGridCount ();
  pgrid_count = pgrid_GetPGridCount ();
  wgrid_count = wgrid_GetWGridCount ();

  check_pixel_count = igrid_count + pgrid_count + wgrid_count + 1;

  bytes_p_grid = BYTES_PER_PIXEL * total_pixels;
  bytes_p_grid_rounded2wordboundary =
    ROUND_BYTES_TO_WORD_BNDRY (bytes_p_grid);
#ifdef PACKING
  bytes_p_packed_grid = BYTES_PER_PIXEL_PACKED * total_pixels;
  bytes_p_packed_grid_rounded2wordboundary =
    ROUND_BYTES_TO_WORD_BNDRY (bytes_p_packed_grid);
  bytes2allocate = igrid_count * bytes_p_packed_grid_rounded2wordboundary +
    pgrid_count * bytes_p_grid_rounded2wordboundary +
    wgrid_count * bytes_p_grid_rounded2wordboundary +
    check_pixel_count * BYTES_PER_PIXEL;
  igrid_size = bytes_p_packed_grid_rounded2wordboundary / BYTES_PER_WORD;
#else
  bytes2allocate = igrid_count * bytes_p_grid_rounded2wordboundary +
    pgrid_count * bytes_p_grid_rounded2wordboundary +
    wgrid_count * bytes_p_grid_rounded2wordboundary +
    check_pixel_count * BYTES_PER_PIXEL;
  igrid_size = bytes_p_grid_rounded2wordboundary / BYTES_PER_WORD;
#endif
  mem_check_size = 1;
  pgrid_size = bytes_p_grid_rounded2wordboundary / BYTES_PER_WORD;
  wgrid_size = bytes_p_grid_rounded2wordboundary / BYTES_PER_WORD;


  if (memlog_fp)
  {
    fprintf (memlog_fp, "nrows = %u\n", nrows);
    fprintf (memlog_fp, "ncols = %u\n", ncols);
    fprintf (memlog_fp, "total_pixels = %u\n", total_pixels);
    fprintf (memlog_fp, "igrid_count = %u\n", igrid_count);
    fprintf (memlog_fp, "pgrid_count = %u\n", pgrid_count);
    fprintf (memlog_fp, "wgrid_count = %u\n", wgrid_count);
    fprintf (memlog_fp, "check_pixel_count = %u\n", check_pixel_count);
    fprintf (memlog_fp, "BYTES_PER_WORD = %u\n", BYTES_PER_WORD);
    fprintf (memlog_fp, "BYTES_PER_PIXEL = %u\n", BYTES_PER_PIXEL);
    fprintf (memlog_fp, "bytes_p_grid = %u\n", bytes_p_grid);
    fprintf (memlog_fp, "bytes_p_grid_rounded2wordboundary = %u\n",
             bytes_p_grid_rounded2wordboundary);
    fprintf (memlog_fp, "words in a grid = %u\n",
             bytes_p_grid_rounded2wordboundary / BYTES_PER_WORD);
#ifdef PACKING
    fprintf (memlog_fp, "BYTES_PER_PIXEL_PACKED = %u\n",
             BYTES_PER_PIXEL_PACKED);
    fprintf (memlog_fp, "bytes_p_packed_grid = %u\n", bytes_p_packed_grid);
    fprintf (memlog_fp, "bytes_p_packed_grid_rounded2wordboundary = %u\n",
             bytes_p_packed_grid_rounded2wordboundary);
#endif
    fprintf (memlog_fp, "igrid_size = %u words\n", igrid_size);
    fprintf (memlog_fp, "pgrid_size = %u words\n", pgrid_size);
    fprintf (memlog_fp, "wgrid_size = %u words\n", wgrid_size);
    fprintf (memlog_fp, "mem_check_size = %u words\n", mem_check_size);
    fprintf (memlog_fp, "bytes2allocate = %u\n", bytes2allocate);
  }

  mem_allocate ();
  mem_partition (memlog_fp);
  mem_InvalidateCheckArray ();
  mem_CloseLog ();
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_GetLogFP
** PURPOSE:       return memory log fp
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
FILE *
  mem_GetLogFP ()
{
  char func[] = "mem_GetLogFP";
  if (memlog_fp == NULL)
  {
    FILE_OPEN (memlog_fp, mem_log_filename, "a");
  }
  return memlog_fp;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_CloseLog
** PURPOSE:       close log file
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_CloseLog ()
{
  fclose (memlog_fp);
  memlog_fp = NULL;
}

/******************************************************************************
*******************************************************************************
** FUNCTION NAME: mem_CheckMemory
** PURPOSE:       check memory
** AUTHOR:        Keith Clarke
** PROGRAMMER:    Tommy E. Cathey of NESC [phone]
** CREATION DATE: 11/11/1999
** DESCRIPTION:
**
**
*/
void
  mem_CheckMemory (FILE * fp, char *module, char *function, int line)
{
  char func[] = "mem_CheckMemory";
  int i;
  int j;

  fprintf (fp, "%s %u MEMORY CHECK at %s %s %u\n",
           __FILE__, __LINE__, module, function, line);
  mem_CheckCheckArray ();
  for (i = 0; i < wgrid_count; i++)
  {
    if (wgrid_array[i].free)
    {
#ifdef MEMORY_CHECK_LEVEL3
      for (j = 0; j < total_pixels; j++)
      {
        if (wgrid_array[i].ptr[j] != invalid_val)
        {
          sprintf (msg_buf, "grid %d is not invalid", wgrid_array[i].ptr);
          LOG_ERROR (msg_buf);
          sprintf (msg_buf, "current_owner: %s", wgrid_array[i].current_owner);
          LOG_ERROR (msg_buf);
          sprintf (msg_buf, "previous_owner: %s", wgrid_array[i].previous_owner);
          LOG_ERROR (msg_buf);
          EXIT (1);
        }
      }
#endif
    }
    else
    {
      for (j = 0; j < total_pixels; j++)
      {
        if (!((0 <= wgrid_array[i].ptr[j]) && (wgrid_array[i].ptr[j] < 256)))
        {
          sprintf (msg_buf, "grid %d is out of range", wgrid_array[i].ptr);
          LOG_ERROR (msg_buf);
          sprintf (msg_buf, "current_owner: %s", wgrid_array[i].current_owner);
          LOG_ERROR (msg_buf);
          sprintf (msg_buf, "previous_owner: %s", wgrid_array[i].previous_owner);