Benchmarking weirdness on Mac OS X - c

Question

I am trying to run a benchmark on Mac with OS version 10.9.5, 2 GHz Intel Core i7 processor, and 8 GB 1600 MHz DDR3 memory. The workload reads in sections of a large file that was mmapped into the address space. I am interested in how performance is affected if the amount of buffer cache available to my process is limited. My colleague and I were not aware of straightforward ways of doing this (i.e. a direct system call, etc), so we created a memory hog program that runs in the background and constantly touches every page allocated to it, to force the kernel to allocate a certain chunk of physical memory to the hogger. Our basic problem is that we found the benchmark to run significantly faster with the hogger running in the background, and we did not know how to interpret that result.
The basic gist of the memhog code is (there is a bit of error checking in our actual code):
mem = malloc(size); // Allocate size bytes
for (int i = 0; ; i = (i + PAGE_SIZE) % size) { // Infinite loop
mem[i]++;
}
This program was compiled with gcc with no optimizations enabled. By adding print statements into the loop, we verified that every iteration of the loop (except the first one, due to all the page faults that must occur the first time we touch the memory) happens quickly, which suggests that about size bytes of physical memory is actually held by this process.
The oddness occurs when we tried running our benchmark while running the memory hog. Without running the memory hog, the benchmark runs in about 16 seconds. When we do run the memory hog in the background, however, the benchmark speeds up significantly! Namely, we found that when we are hogging 1 MB of memory (basically hogging almost nothing at all, but just having a useless process spin in the background), the benchmark finishes in about 13 seconds consistently. Hogging more memory (4 GB), it takes 14-15 seconds to finish, and hogging 6 GB, the benchmark takes roughly 16 seconds to finish. The benchmark itself takes about 4.3 GB of memory (as measured by getrusage by subtracting values for ru_maxrss before loading in all data and after loading in all data).
We found this to be very puzzling; while performance might not deteriorate with memhog in the background, it is odd that performance could improve by so much when a useless process is spinning in the background. Do you have any insights into this behavior? Thanks!
(We also have vm_stat data that we can post if it helps with the question; we didn't included it now as it was rather long).