---

ArraysTest.c

The Arrays memory manager's test/example program:

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

#include "MeMessage.h"
#include "MeMemory.h"
#include "MeAssert.h"

#define maxBLOCKSPOOL   100
#define maxBLOCKS       1000

extern struct MeMemoryAPI MeMemoryAPIArrays;

struct MeMemoryOptions  opts;
struct MeMemoryOptions  opts2;
struct MeMemoryStats    stats;  

#define optsB           opts.block.fixed
#define statsB          stats.block.fixed

struct MeMemoryOptionsFixed optsF[] =
{
  /* align2Addr, minSize,defSize, minCount,maxCount */
  { 2,  15,24,  5,5 },
  { 4,  28,48,  6,6 },
  { 8,  50,64,  3,3 }
};

int main(int argc,char *(argv[]))
{
  MeMemoryDoTrace       = 1;

  opts.allocation       = MeMemoryArrays;
  opts.reclamation      = MeMemoryManual;

  opts.maxArena         = 128*1024;
  opts.minArena         = 0;

  opts.blockFixed       = sizeof optsF/sizeof *optsF;

  optsB                 = &optsF[0];

  MeInfo(4,"Options: before 'setOptions':\n");
  if (MeInfoLevel >= 4)
    MeMemoryPrintOptions(&opts);

  (*MeMemoryAPIArrays.setOptions)(&opts);

  MeInfo(9,"Options: after 'setOptions'\n");
  (*MeMemoryAPIArrays.getOptions)(&opts2);
  if (MeInfoLevel >= 9)
    MeMemoryPrintOptions(&opts2);

  MeInfo(9,"Stats: after 'getOptions'\n");
  (*MeMemoryAPIArrays.getStats)(&stats);
  if (MeInfoLevel >= 9)
    MeMemoryPrintStats(&stats);

  (*MeMemoryAPIArrays.init)(malloc(stats.maxArena),stats.maxArena);

  MeInfo(9,"Options: after 'init':\n");
  (*MeMemoryAPIArrays.getOptions)(&opts2);
  if (MeInfoLevel >= 9)
    MeMemoryPrintOptions(&opts2);

  MeInfo(9,"Stats: after 'init'\n");
  (*MeMemoryAPIArrays.getStats)(&stats);
  if (MeInfoLevel >= 9)
    MeMemoryPrintStats(&stats);

  {
    unsigned l,m;
    register unsigned n = 0;
    void *(blocks)[maxBLOCKS];

    for (l = 0; l < opts.blockFixed; l++)
      {
        const struct MeMemoryOptionsFixed *const o = optsB+l;

        for (m = 0; m < o->maxCount; m++)
          {
            register void *const block = (*MeMemoryAPIArrays.create)(o->defSize);

            if (m < maxBLOCKSPOOL && n < maxBLOCKS)
              {
                (*MeMemoryAPIArrays.incRef)(block);
                blocks[n++] = block;
              }

            *(char *) block = 0xAA;

            MeInfo(2,"Create: pool %lu-%lu count %u b 0x%0lx\n",
                   (long unsigned) o->minSize,
                   (long unsigned) o->defSize,
                   m,(long unsigned) block);

            MeInfo(2,"Stats: after each 'create'\n");
            if (MeInfoLevel >= 2)
              {
                (*MeMemoryAPIArrays.getStats)(&stats);
                MeMemoryPrintStats(&stats);
              }
          }
      }

    MeInfo(9,"Stats: after all 'create's and 'incRef's\n");
    (*MeMemoryAPIArrays.getStats)(&stats);
    if (MeInfoLevel >= 9)
      MeMemoryPrintStats(&stats);

    MEASSERT (n != 0);

    do
      {
        --n;

        (*MeMemoryAPIArrays.decRef)(blocks[n]);

        MeInfo(2,"Destroy: 0x%0lx\n",(long unsigned) blocks[n]);
        (*MeMemoryAPIArrays.destroy)(blocks[n]);

        MeInfo(2,"Stats: after each 'decRef' and 'destroy'\n");
        if (MeInfoLevel >= 2)
          {
            (*MeMemoryAPIArrays.getStats)(&stats);
            MeMemoryPrintStats(&stats);
          }
      } 
    while (n != 0);

    MeInfo(9,"Stats: after all 'decRef's and 'destroy's\n");
    (*MeMemoryAPIArrays.getStats)(&stats);
    if (MeInfoLevel >= 9)
      MeMemoryPrintStats(&stats);
  }

  (*MeMemoryAPIArrays.term)();

  MeInfo(9,"Stats: after 'term' in increasing\n");
  (*MeMemoryAPIArrays.getStats)(&stats);
  if (MeInfoLevel >= 9)
    MeMemoryPrintStats(&stats);

  return 0;
}

---