മോശം പരിശോധനയെക്കുറിച്ച് കുറച്ചുകൂടി

ഒരു ഉപയോക്താവ് തന്റെ വെർച്വൽ മെഷീനിലെ റാം പ്രകടനം നിരീക്ഷിക്കാൻ ശ്രമിക്കുന്നതായി ഒരു ദിവസം ഞാൻ അബദ്ധത്തിൽ കോഡ് കണ്ടു. ഞാൻ ഈ കോഡ് നൽകില്ല (അവിടെ ഒരു "കാൽതുണി" ഉണ്ട്) ഞാൻ ഏറ്റവും അത്യാവശ്യമായത് മാത്രം വിടും. അതിനാൽ, പൂച്ച സ്റ്റുഡിയോയിലാണ്!

#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;
}

ഇത് ലളിതമാണ് - മെമ്മറി അനുവദിച്ച് അതിൽ ഒരു ജിഗാബൈറ്റ് എഴുതുക. ഈ പരിശോധന എന്താണ് കാണിക്കുന്നത്?

$./memtest
4.06504 GB / s

ഏകദേശം 4GB/s.

എന്ത്?!?!

എങ്ങനെ?!?!?

ഇതാണ് Core i7 (ഏറ്റവും പുതിയതല്ലെങ്കിലും), DDR4, പ്രോസസർ മിക്കവാറും ലോഡുചെയ്തിട്ടില്ല - എന്തുകൊണ്ട്?!?!

ഉത്തരം, എല്ലായ്പ്പോഴും എന്നപോലെ, അസാധാരണമാംവിധം സാധാരണമാണ്.

പുതിയ ഓപ്പറേറ്റർ (malloc ഫംഗ്‌ഷൻ പോലെ) യഥാർത്ഥത്തിൽ മെമ്മറി അനുവദിക്കുന്നില്ല. ഈ കോളിലൂടെ, അലോക്കേറ്റർ മെമ്മറി പൂളിലെ സൌജന്യ ലൊക്കേഷനുകളുടെ ലിസ്റ്റ് നോക്കുന്നു, ഒന്നുമില്ലെങ്കിൽ, ഡാറ്റ സെഗ്മെന്റ് വർദ്ധിപ്പിക്കാൻ sbrk() എന്ന് വിളിക്കുന്നു, തുടർന്ന് പുതിയ സ്ഥലത്ത് നിന്ന് വിലാസത്തിലേക്ക് ഒരു റഫറൻസ് പ്രോഗ്രാമിലേക്ക് മടങ്ങുന്നു. അനുവദിച്ചു.

അനുവദിച്ച പ്രദേശം പൂർണ്ണമായും വെർച്വൽ ആണ് എന്നതാണ് പ്രശ്നം. യഥാർത്ഥ മെമ്മറി പേജുകളൊന്നും അനുവദിച്ചിട്ടില്ല.

ഈ അനുവദിച്ച സെഗ്‌മെന്റിൽ നിന്ന് ഓരോ പേജിലേക്കും ആദ്യ ആക്‌സസ് സംഭവിക്കുമ്പോൾ, MMU ഒരു പേജ് തകരാർ "ഷൂട്ട്" ചെയ്യുന്നു, അതിനുശേഷം ആക്‌സസ് ചെയ്യുന്ന വെർച്വൽ പേജിന് യഥാർത്ഥമായ ഒന്ന് നൽകും.

അതിനാൽ, വാസ്തവത്തിൽ, ഞങ്ങൾ ബസിന്റെയും റാം മൊഡ്യൂളുകളുടെയും പ്രകടനമല്ല, ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിന്റെ MMU, VMM എന്നിവയുടെ പ്രകടനമാണ് പരിശോധിക്കുന്നത്. റാമിന്റെ യഥാർത്ഥ പ്രകടനം പരിശോധിക്കുന്നതിന്, ഞങ്ങൾ അനുവദിച്ച ഏരിയകൾ ഒരിക്കൽ ആരംഭിക്കേണ്ടതുണ്ട്. ഉദാഹരണത്തിന് ഇതുപോലെ:

#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) ഉപയോഗിച്ച് ഞങ്ങൾ അനുവദിച്ച ബഫറുകൾ ആരംഭിക്കുന്നു.

ഞങ്ങൾ പരിശോധിക്കുന്നു:

$./memtest
28.5714 GB / s

മറ്റൊരു കാര്യം.

കഥയുടെ ധാർമ്മികത - വേഗത്തിൽ പ്രവർത്തിക്കാൻ നിങ്ങൾക്ക് വലിയ ബഫറുകൾ ആവശ്യമുണ്ടെങ്കിൽ, അവ ആരംഭിക്കാൻ മറക്കരുത്.

അവലംബം: www.habr.com