Reasons for main memory access time variance - caching

Question

I have conducted a few experiments with a simple c program to estimate the cost of fetching a value from main memory as a result of a cache miss.
My first experiment involves accessing a global variable after invalidating the global variable's corresponding cache line with the help of the clflush instruction. BEGIN, CLOSE and GET_TIME are macros I have defined for timing snippets of code using the number of clock cycles as measurement.
int global_var = 0; // Global variable
int main() {
for(int i = 0; i < rounds + warmup; ++i) {
clflush(&global_var);
BEGIN
int x = global_var;
CLOSE
access_times[i] = GET_TIME;
}
return 0;
}
My experiment shows that it costs around ~200 clock cycles to access "global_var" when it is not located in the CPU cache which corresponds to access times I have heard from other sources. However, some main memory accesses in my experiment takes much longer than 200 clock cycles, between 500-1000 clock cycles, which brings me to my first question.
What are likely reasons why some main memory accesses are much slower than the vast majority?
My second experiment involves accessing the same global variable but instead of flushing the cache line with the help of the clflush instruction, I am flushing the entire CPU cache (L1, L2 and L3) by reading a memory block at least as large as my L3 cache (4MB in my case). The size of the written block is kept in the BLOCK_SIZE constant in the code below.
int global_var = 0; // Global variable
int main() {
char *dummy = malloc(BLOCK_SIZE);
for(int i = 0; i < rounds + warmup; ++i) {
memset_s(dummy, 1, BLOCK_SIZE);
BEGIN
int x = global_var;
CLOSE
access_times[i] = GET_TIME;
}
return 0;
}
The result of this experiment shows that if I write a block which is a bit bigger than the size of my L3 cache, most main memory accesses takes roughly 200 clock cycles. However, as I increase the size of the written block the access times becomes larger. For instance, if I write a block of size L3_SIZE * 2, then the average time to fetch "global_var" from main memory is roughly 500 clock cycles.
My second question is, why are main memory access times becoming larger when I clear my CPU cache by writing larger blocks? The memory/cache hierarchy of my system is: L1 -> L2 -> L3 -> Main memory -> Disk.
Thanks in advance.