memory_chunks.c

关于遗传算法的一些见地。特别是关于简单遗传程序设计的实现。

      mem_chunk->mem_area->free = mem_chunk->area_size;
      mem_chunk->mem_area->used = 0;
    }

/*
 * Get the memory and modify the state variables appropriately.
 */
  mem = (vpointer) &(mem_chunk->mem_area->mem[mem_chunk->mem_area->index]);
  mem_chunk->mem_area->index += mem_chunk->atom_size;
  mem_chunk->mem_area->free -= mem_chunk->atom_size;
  mem_chunk->mem_area->used++;

#if MEMORY_PADDING==TRUE
  set_pad_low(mem_chunk, mem);
  set_pad_high(mem_chunk, mem);
/*
  if (check_pad_low(mem_chunk, mem)!=0) die("LOW MEMORY_PADDING ALREADY CORRUPT!");
  if (check_pad_high(mem_chunk, mem)!=0) die("HIGH MEMORY_PADDING ALREADY CORRUPT!");
*/
  mem = BUMP_UP(mem);
#endif

  return mem;
  }


void mem_chunk_free_real(MemChunk *mem_chunk, void *mem)
  {
  MemArea *temp_area;
  FreeAtom *free_atom;

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  if (!mem_chunk->mem_tree) die("MemChunk passed has no freeable atoms.");
  if (!mem) die("NULL pointer passed.");

#if MEMORY_PADDING==TRUE
  mem = BUMP_DOWN(mem);
  if (check_pad_low(mem_chunk, mem)!=0)
    dief("LOW MEMORY_PADDING CORRUPT! (%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);
  if (check_pad_high(mem_chunk, mem)!=0)
    dief("HIGH MEMORY_PADDING CORRUPT!(%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);
#endif

/*
 * Place the memory on the "free_atoms" list.
 */
  free_atom = (FreeAtom*) mem;
  free_atom->next = mem_chunk->free_atoms;
  mem_chunk->free_atoms = free_atom;

  if (!(temp_area = ordered_search(mem_chunk->mem_tree, mem)) )
    die("Unable to find temp_area.");

  temp_area->used--;

  if (temp_area->used == 0)
    {
    mem_chunk->num_unused_areas++;
    }

  return;
  }


/* This doesn't free the free_area if there is one */
void mem_chunk_clean_real(MemChunk *mem_chunk)
  {
  MemArea *mem_area;
  FreeAtom *prev_free_atom;
  FreeAtom *temp_free_atom;
  void *mem;

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  if (!mem_chunk->mem_tree) die("MemChunk passed has no freeable atoms.");

  if (mem_chunk->mem_tree)
    {
    prev_free_atom = NULL;
    temp_free_atom = mem_chunk->free_atoms;

    while (temp_free_atom)
      {
      mem = (vpointer) temp_free_atom;

      if (!(mem_area = ordered_search(mem_chunk->mem_tree, mem)) ) die("mem_area not found.");

/*
 * If this memory area is unused, delete the area, list node and decrement the free mem.
 */
      if (mem_area->used==0)
        {
        if (prev_free_atom)
          prev_free_atom->next = temp_free_atom->next;
        else
          mem_chunk->free_atoms = temp_free_atom->next;
        temp_free_atom = temp_free_atom->next;

        mem_area->free += mem_chunk->atom_size;
        if (mem_area->free == mem_chunk->area_size)
          {
          mem_chunk->num_mem_areas--;
          mem_chunk->num_unused_areas--;

          if (mem_area->next)
          mem_area->next->prev = mem_area->prev;
          if (mem_area->prev)
            mem_area->prev->next = mem_area->next;
          if (mem_area == mem_chunk->mem_areas)
            mem_chunk->mem_areas = mem_chunk->mem_areas->next;
          if (mem_area == mem_chunk->mem_area)
            mem_chunk->mem_area = NULL;
 
          if (mem_chunk->mem_tree)
            {
            if (!remove_key(mem_chunk->mem_tree, (Key_t) mem_area))
              die("mem_area not found.");
            }

          free(mem_area);
          }
        }
      else
        {
        prev_free_atom = temp_free_atom;
        temp_free_atom = temp_free_atom->next;
        }
      }
    }

  return;
  }


void mem_chunk_reset_real(MemChunk *mem_chunk)
  {
  MemArea *mem_areas;
  MemArea *temp_area;
  
  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  
  mem_areas = mem_chunk->mem_areas;
  mem_chunk->num_mem_areas = 0;
  mem_chunk->mem_areas = NULL;
  mem_chunk->mem_area = NULL;
  
  while (mem_areas)
    {
    temp_area = mem_areas;
    mem_areas = mem_areas->next;
    free(temp_area);
    }
  
  mem_chunk->free_atoms = NULL;
  
  if (mem_chunk->mem_tree)
    {
    delete(mem_chunk->mem_tree);
    mem_chunk->mem_tree = tree_new();
    }

  return;
  }


#if MEMORY_PADDING==TRUE
static int memarea_check_bounds(MemChunk *mem_chunk, MemArea *mem_area)
  {
  int		count = 0;
  unsigned char	*mem;
  int		index = 0;

  while (index < mem_area->index)
    {
    mem = (unsigned char*) &mem_area->mem[index];
    if (check_pad_low(mem_chunk, mem)!=0) count++;
    if (check_pad_high(mem_chunk, mem)!=0) count++;
    index += mem_chunk->atom_size;
    }

  return count;
  }


boolean mem_chunk_check_all_bounds_real(MemChunk *mem_chunk)
  {
  MemArea	*mem_area;
  int		badcount=0;
  
  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  
  mem_area = mem_chunk->mem_areas;
  
  while (mem_area)
    {
    if (mem_chunk->mem_area->used>0)
      {
      badcount += memarea_check_bounds(mem_chunk, mem_area);
      mem_area = mem_area->next;
      }
    }

  printf("%d pads corrupt or free.\n", badcount);
  
  return badcount>0;
  }


boolean mem_chunk_check_bounds_real(MemChunk *mem_chunk, void *mem)
  {
  mem = BUMP_DOWN(mem);
  if (check_pad_low(mem_chunk, mem)!=0)
    dief("Low padding corrupt! (%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);
  if (check_pad_high(mem_chunk, mem)!=0)
    dief("High padding corrupt!(%*s)", MEMORY_ALIGN_SIZE, (unsigned char *)mem);

  return TRUE;
  }
#else


boolean mem_chunk_check_all_bounds_real(MemChunk *mem_chunk)
  {
  return TRUE;
  }


boolean mem_chunk_check_bounds_real(MemChunk *mem_chunk, void *mem)
  {
  return TRUE;
  }
#endif


boolean mem_chunk_test_real(void)
  {
  unsigned char	*tmem[10000];
  MemChunk	*tmem_chunk=NULL;
  size_t	atomsize=40;
  int		i, j;

  printf("checking mem chunks...\n");

  tmem_chunk = mem_chunk_new(atomsize, 100);

  printf("alloc*1000...\n");
  for (i = 0; i < 1000; i++)
    {
    tmem[i] = mem_chunk_alloc(tmem_chunk);

    *tmem[i] = i%254;
    }

  for (i = 0; i < 1000; i++)
    {
    mem_chunk_check_bounds_real(tmem_chunk, tmem[i]);
    }

  printf("free*500...\n");
  for (i = 0; i < 500; i++)
    {
    mem_chunk_free(tmem_chunk, tmem[i]);
    }

  for (i = 500; i < 1000; i++)
    {
    mem_chunk_check_bounds_real(tmem_chunk, tmem[i]);
    }

  printf("alloc*500...\n");
  for (i = 0; i < 500; i++)
    {
    tmem[i] = mem_chunk_alloc(tmem_chunk);

    *tmem[i] = i%254;
    }

  for (i = 0; i < 1000; i++)
    {
    mem_chunk_check_bounds_real(tmem_chunk, tmem[i]);
    }

  printf("free*1000...\n");

  for (i = 0; i < 1000; i++)
    {
    if (*tmem[i] != i%254) die("Uh oh.");

    for (j = i; j<1000; j++)
      mem_chunk_check_bounds_real(tmem_chunk, tmem[j]);

    mem_chunk_free(tmem_chunk, tmem[i]);
    }

  printf("ok.\n");

  return TRUE;
  }


void mem_chunk_diagnostics_real(void)
  {
  printf("=== mem_chunk diagnostics ====================================\n");
  printf("Version:                   %s\n", GA_VERSION_STRING);
  printf("Build date:                %s\n", GA_BUILD_DATE_STRING);
  printf("Compilation machine characteristics:\n%s\n", GA_UNAME_STRING);

  printf("--------------------------------------------------------------\n");
  printf("MEMORY_PADDING:    %s\n", MEMORY_PADDING?"TRUE":"FALSE");
  printf("MEMORY_ALIGN_SIZE  %zd\n", MEMORY_ALIGN_SIZE);
  printf("MEMORY_AREA_SIZE   %ld\n", MEMORY_AREA_SIZE);

  printf("--------------------------------------------------------------\n");
  printf("structure          sizeof\n");
  printf("FreeAtom           %lu\n", (unsigned long) sizeof(FreeAtom));
  printf("MemArea            %lu\n", (unsigned long) sizeof(MemArea));
  printf("MemChunk           %lu\n", (unsigned long) sizeof(MemChunk));
  printf("==============================================================\n");

  return;
  }


/*
 * The following functions mimic the Memory chunk API, but are just
 * wrappers around the system malloc.
 */

/*
 * Return TRUE is the memory chunk is empty.
 */
boolean mem_chunk_isempty_mimic(MemChunk *mem_chunk)
  {

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");

  return mem_chunk->num_atoms_alloc==0;
  }


/*
 * Create new memory chunk.
 */

MemChunk *mem_chunk_new_mimic(size_t atom_size, unsigned int num_atoms)
  {
  MemChunk	*mem_chunk;

  mem_chunk = malloc(sizeof(MemChunk));

  if (!mem_chunk) die("Unable to allocate memory.");

  mem_chunk->atom_size = atom_size;
  mem_chunk->num_atoms_alloc = 0;

  return mem_chunk;
  }


MemChunk *mem_chunk_new_unfreeable_mimic(size_t atom_size, unsigned int num_atoms)
  {
  return mem_chunk_new(atom_size, num_atoms);
  }


boolean mem_chunk_has_freeable_atoms_mimic(MemChunk *mem_chunk)
  {
  return TRUE;
  }


void mem_chunk_destroy_mimic(MemChunk *mem_chunk)
  {

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  
  free(mem_chunk);

  return;
  }


void *mem_chunk_alloc_mimic(MemChunk *mem_chunk)
  {
  void	*mem;

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");

  mem_chunk->num_atoms_alloc++;

  mem = malloc(mem_chunk->atom_size);

  if (!mem) die("Unable to allocate memory.");
  
  return mem;
  }


void mem_chunk_free_mimic(MemChunk *mem_chunk, void *mem)
  {

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  if (!mem) die("Null pointer to memory passed.");

  free(mem);

  mem_chunk->num_atoms_alloc--;

  return;
  }


void mem_chunk_clean_mimic(MemChunk *mem_chunk)
  {

  if (!mem_chunk) die("Null pointer to mem_chunk passed.");

  mem_chunk->num_atoms_alloc=0;

  return;
  }


void mem_chunk_reset_mimic(MemChunk *mem_chunk)
  {
  
  if (!mem_chunk) die("Null pointer to mem_chunk passed.");
  
  mem_chunk->num_atoms_alloc=0;

  return;
  }


boolean mem_chunk_check_bounds_mimic(MemChunk *mem_chunk, void *mem)
  {
  return TRUE;
  }


boolean mem_chunk_test_mimic(void)
  {
  return TRUE;
  }


void mem_chunk_diagnostics_mimic(void)
  {
  printf("=== mem_chunk diagnostics *** MIMIC *** ======================\n");
  printf("Version:                   %s\n", GA_VERSION_STRING);
  printf("Build date:                %s\n", GA_BUILD_DATE_STRING);
  printf("Compilation machine characteristics:\n%s\n", GA_UNAME_STRING);

  printf("--------------------------------------------------------------\n");
  printf("structure          sizeof\n");
  printf("MemChunk           %lu\n", (unsigned long) sizeof(MemChunk));
  printf("==============================================================\n");

  return;
  }