ખરાબ પરીક્ષણ વિશે થોડું વધુ

એક દિવસ મને આકસ્મિક રીતે કોડ મળ્યો કે એક વપરાશકર્તા તેના વર્ચ્યુઅલ મશીનમાં RAM પ્રદર્શનને મોનિટર કરવાનો પ્રયાસ કરી રહ્યો હતો. હું આ કોડ આપીશ નહીં (ત્યાં "ફુટક્લોથ" છે) અને હું ફક્ત સૌથી જરૂરી છોડીશ. તેથી, બિલાડી સ્ટુડિયોમાં છે!

#include <sys/time.h>
#include <string.h>
#include <iostream>

#define CNT 1024
#define SIZE (1024*1024)

int main() {
	struct timeval start;
	struct timeval end;
	long millis;
	double gbs;
	char ** buffers;
	buffers = new char*[CNT];
	for (int i=0;i<CNT;i++) {
		buffers[i] = new char[SIZE];
	}
	gettimeofday(&start, NULL);
	for (int i=0;i<CNT;i++) {
		memset(buffers[i], 0, SIZE);
	}
	gettimeofday(&end, NULL);
	millis = (end.tv_sec - start.tv_sec) * 1000 +
		(end.tv_usec - start.tv_usec) / 1000;
	gbs = 1000.0 / millis;
	std::cout << gbs << " GB/sn";
	for (int i=0;i<CNT;i++) {
		delete buffers[i];
	}
	delete buffers;
	return 0;
}

તે સરળ છે - મેમરી ફાળવો અને તેમાં એક ગીગાબાઈટ લખો. અને આ ટેસ્ટ શું બતાવે છે?

$ ./મેમટેસ્ટ
4.06504 GB / સેકંડ

આશરે 4GB/s.

શું?!?!

કેવી રીતે?!?!?

આ કોર i7 છે (જોકે સૌથી નવું નથી), DDR4, પ્રોસેસર લગભગ લોડ થયેલ નથી - શા માટે?!?!

જવાબ, હંમેશની જેમ, અસામાન્ય રીતે સામાન્ય છે.

નવું ઓપરેટર (જેમ કે malloc ફંક્શન, માર્ગ દ્વારા) વાસ્તવમાં મેમરી ફાળવતું નથી. આ કૉલ સાથે, ફાળવણીકર્તા મેમરી પૂલમાં મફત સ્થાનોની સૂચિ જુએ છે, અને જો ત્યાં કોઈ ન હોય તો, ડેટા સેગમેન્ટને વધારવા માટે sbrk() ને કૉલ કરે છે, અને પછી પ્રોગ્રામ પર પાછા ફરે છે ફક્ત નવા સ્થાનના સરનામાંનો સંદર્ભ ફાળવેલ.

સમસ્યા એ છે કે ફાળવેલ વિસ્તાર સંપૂર્ણપણે વર્ચ્યુઅલ છે. કોઈ વાસ્તવિક મેમરી પૃષ્ઠો ફાળવવામાં આવ્યા નથી.

અને જ્યારે આ ફાળવેલ સેગમેન્ટમાંથી દરેક પૃષ્ઠની પ્રથમ ઍક્સેસ થાય છે, ત્યારે MMU પૃષ્ઠની ખામીને "શૂટ" કરે છે, જે પછી જે વર્ચ્યુઅલ પૃષ્ઠને ઍક્સેસ કરવામાં આવે છે તેને વાસ્તવિક સોંપવામાં આવે છે.

તેથી, વાસ્તવમાં, અમે બસ અને રેમ મોડ્યુલોની કામગીરીનું પરીક્ષણ કરી રહ્યા નથી, પરંતુ ઓપરેટિંગ સિસ્ટમના MMU અને VMM નું પ્રદર્શન. અને RAM ના વાસ્તવિક પ્રદર્શનને ચકાસવા માટે, અમારે માત્ર એક વાર ફાળવેલ વિસ્તારોને પ્રારંભ કરવાની જરૂર છે. આના જેવા ઉદાહરણ તરીકે:

#include <sys/time.h>
#include <string.h>
#include <iostream>

#define CNT 1024
#define SIZE (1024*1024)

int main() {
	struct timeval start;
	struct timeval end;
	long millis;
	double gbs;
	char ** buffers;
	buffers = new char*[CNT];
	for (int i=0;i<CNT;i++) {
                // FIXED HERE!!!
		buffers[i] = new char[SIZE](); // Add brackets, &$# !!!
	}
	gettimeofday(&start, NULL);
	for (int i=0;i<CNT;i++) {
		memset(buffers[i], 0, SIZE);
	}
	gettimeofday(&end, NULL);
	millis = (end.tv_sec - start.tv_sec) * 1000 +
		(end.tv_usec - start.tv_usec) / 1000;
	gbs = 1000.0 / millis;
	std::cout << gbs << " GB/sn";
	for (int i=0;i<CNT;i++) {
		delete buffers[i];
	}
	delete buffers;
	return 0;
}

એટલે કે, અમે ડિફોલ્ટ મૂલ્ય (char 0) સાથે ફાળવેલ બફર્સને ફક્ત પ્રારંભ કરીએ છીએ.

તપાસ કરી રહ્યું છે:

$ ./મેમટેસ્ટ
28.5714 GB / સેકંડ

બીજી વાત.

વાર્તાની નૈતિકતા - જો તમને ઝડપથી કામ કરવા માટે મોટા બફરની જરૂર હોય, તો તેને પ્રારંભ કરવાનું ભૂલશો નહીં.

સોર્સ: www.habr.com