Правило 50 процентов

Я пишу программу, которая проверяет распределение динамической памяти, чтобы увидеть, насколько хорошо выполняется правило 50 процентов.

Программа имеет 10 000 указателей на динамически выделяемые блоки памяти. Он также имеет массив для хранения размера каждого блока. Он должен:

1. Использовать malloc () для динамического выделения блока памяти для каждого элемента ptrList . Эти блоки должны иметь размеры, которые выбираются случайным образом в диапазоне от 1 до 10 000 байтов, а размер блока должен храниться в массиве sizeList .
2. После начального распределения блоков программа должна многократно освобождать блоки и выделять новые. Это должно пройти 100 000 итераций. На каждой итерации индекс в ptrList выбирается случайным образом, блок освобождается и затем заменяется новым динамически выделяемым блоком случайного размера.
3. После каждых 100 итераций он должен распечатать строку, которая показывает количество итераций, приблизительный размер кучи (определяемый разницей между самым высоким и самым низким адресами памяти, содержащимися в любом из блоков), а также общий размер всех блоки, на которые указывает ptrList .

Моя программа написана так:

#include <stdio.h>
#include <pthread.h>   /* for pthreads */
#include <stdlib.h>    /* for exit */

/** Number of memory blocks to allocate/deallocate. */
#define BLOCK_COUNT 10000

/** Number of free/malloc operations to perform */
#define TEST_LENGTH 100000

/** Maximum size of an allocated block. */
#define SIZE_LIMIT 10000

int main( int argc, char *argv[] ) {
  // Array of pointers to all blocks that have been allocated.
  char *ptrList[ BLOCK_COUNT ];

  // Array of sizes for each block, so we can know how much memory we're using.
  int sizeList[ BLOCK_COUNT ];

  // Insert your code here
  for (int j = 0; j < 1000; j++) {

      int minimum = 0;
      int maximum = 0;
      int total = 0, remainder = 0;

      for (int i = 0; i < BLOCK_COUNT; i++) {
          int size = (rand() % SIZE_LIMIT) + 1;
          ptrList[i] = malloc (size);
          sizeList[i] = size;
          total += size;
          int heapsize = (int)ptrList[i];

          if (i == 0) {
              maximum = heapsize;
              minimum = heapsize;
          }
          else {
              if (heapsize > maximum) {
                  maximum = heapsize;
              }
              if (heapsize < minimum) {
                  minimum = heapsize;
              }
          }
      }

      for (int i = 0; i < TEST_LENGTH; i++) {
          int index = rand() % BLOCK_COUNT;
          int size = (rand() % SIZE_LIMIT) + 1;
          free(ptrList[index]);
          total -= sizeList[index];
          ptrList[index] = malloc (size);
          sizeList[index] = size;
          total += sizeList[index];
          int heapsize = (int)ptrList[index];

          if (heapsize > maximum) {
              maximum = heapsize;
          }
          if (heapsize < minimum) {
              minimum = heapsize;
          }
      }

      if (j > 0) {
          remainder = j % 100;
      }

      if (remainder == 0 ) {
          //printf("%d", example);
          printf("%d %d %d\n", j, maximum - minimum, total);
      }

      for (int i = 0; i < BLOCK_COUNT; i++) {
          free(ptrList[i]);
      }

  }

  return 0;
}

Правильно ли я подхожу к выделению / освобождению памяти? Моя программа компилируется и запускается (без вывода) до того, как я реализовал цикл for с помощью int j . Он зависает после того, как я его реализовал, так что, возможно, кто-то может помочь мне решить проблему.

Редактировать: Правило 50 процентов: общий размер всех блоков, деленный на приблизительный размер кучи, обычно составляет около 50 процентов.