Weird loop optimizations with C++

[DelinWorks]

One question about cpp is when I was working on improving the particle system, there were comments saying that separating loops to fill each data field was the best optimization, like:

And then I was told that std::fill_n is even better for static values, like:

Soo I've ran a test and the results were shocking:

Why is the method of combining the loops into a single one the fastest? even though people say that separating loops is faster because cache hit rates are better.

A single loop is something like this:

Can someone explain to me why is this the case?

The code:

#include <iostream>
#include "debug.hpp"

class bigData {
public:


	float* dummy1;
	float* dummy2;
	float* dummy3;

	bigData(int count);
};

int main() {

	auto watch = StopWatch();

	int count = 10000000;

	watch.start();
	auto d = bigData(count);
	watch.stop();

	printf("Allocating data took: %dms\n", watch.getElapsed());

	watch.start();
	for (size_t i = 0; i < count; i++)
	{
		d.dummy1[i] = 1.0F;
		d.dummy2[i] = 1.0F;
		d.dummy3[i] = 1.0F;
	}
	watch.stop();

	printf("Filling data single loop took: %dms\n", watch.getElapsed());

	watch.start();
	for (size_t i = 0; i < count; i++)
	{
		d.dummy1[i] = 1.0F;
	}
	for (size_t i = 0; i < count; i++)
	{
		d.dummy2[i] = 1.0F;
	}
	for (size_t i = 0; i < count; i++)
	{
		d.dummy3[i] = 1.0F;
	}
	watch.stop();

	printf("Filling data multiple loops took: %dms\n", watch.getElapsed());

	watch.start();
	std::fill_n(d.dummy1, count, 1.0F);
	std::fill_n(d.dummy2, count, 1.0F);
	std::fill_n(d.dummy3, count, 1.0F);
	watch.stop();

	printf("Filling data using std::fill_n took: %dms\n", watch.getElapsed());

	std::cin.get();
	return 0;
}

bigData::bigData(int count)
{
	dummy1 = (float*)malloc(count * sizeof(float));
	dummy2 = (float*)malloc(count * sizeof(float));
	dummy3 = (float*)malloc(count * sizeof(float));
}

[halx99]

Does the test result is from release build?

[DelinWorks]

yes.

[halx99]

well, std::fill_n, 1.0f can't be optimized by compiler with memset, just try 0

[DelinWorks]

True it's reduced significantly:

What about separating loops? what's the optimization about it?

[halx99]

You can view the asm code by visual studio, it will simply inline std:fill_n to invoke system memset when fill 0 for float array, it's so fast.