I have a memory allocator which allocates in blocks. Each next block size is the previous size plus the page size. Units to store in such blocks are 26 bytes in size, for example, but they may be of any size as long as it’s less than the page size. Therefore, there will usually be some leftover bytes at the end of each block, which introduces an error accumulation when calculating the cumulative number of units up to a certain block N. The goal is to calculate this correctly for any given block index without having to loop through all previous blocks to sum up their unit counts. Is there a way to precalculate some values or tables at compile time for each specific page size and unit size in order to correct this accumulated error and obtain the accurate number of units?

Here’s an example code which calculates the values incorrectly and displays the correct values next to them, as they were found during iteration:

void LogTestFlt(void)
{
 const double groupSize   = 4096;
 const double unitSize    = 26;
 const double scaleFactor = groupSize / unitSize;  // NOTE: Each group will have different amount of leftover bytes which will accumulate the error.
 unsigned int cumul       = 0;
 printf("|%-14s|%-14s|%-14s|n", "WRONG","CORRECT","LEFTOVER");
 printf("|%-14s|%-14s|%-14s|n", "--------------","--------------","--------------");
 for(int group=1;group < 32;group++)
  {   
   double previousCumulativeUnits = ((group - 1) * group * scaleFactor) / 2.0;    // NOTE: Incorrect! Need to correct the accumulated error somehow.
   unsigned int leftover = ((unsigned int)groupSize * group) % (unsigned int)unitSize;
   printf("|%-14f|%-14u|%-14u|n", previousCumulativeUnits,cumul,leftover);
   cumul += (groupSize * group) / unitSize;        // This is the correct value
  }
}

The result will be: