ਮਾੜੇ ਟੈਸਟਿੰਗ ਬਾਰੇ ਥੋੜਾ ਹੋਰ

ਇੱਕ ਦਿਨ ਮੈਨੂੰ ਗਲਤੀ ਨਾਲ ਕੋਡ ਮਿਲਿਆ ਕਿ ਇੱਕ ਉਪਭੋਗਤਾ ਆਪਣੀ ਵਰਚੁਅਲ ਮਸ਼ੀਨ ਵਿੱਚ ਰੈਮ ਪ੍ਰਦਰਸ਼ਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਰਿਹਾ ਸੀ। ਮੈਂ ਇਹ ਕੋਡ ਨਹੀਂ ਦੇਵਾਂਗਾ (ਉੱਥੇ ਇੱਕ "ਫੁਟਕਲੌਥ" ਹੈ) ਅਤੇ ਮੈਂ ਸਿਰਫ਼ ਸਭ ਤੋਂ ਜ਼ਰੂਰੀ ਛੱਡਾਂਗਾ। ਇਸ ਲਈ, ਬਿੱਲੀ ਸਟੂਡੀਓ ਵਿੱਚ ਹੈ!

#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 / ਸਕਿੰਟ

ਲਗਭਗ 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) ਨਾਲ ਨਿਰਧਾਰਤ ਬਫਰਾਂ ਨੂੰ ਸਿਰਫ਼ ਸ਼ੁਰੂ ਕਰਦੇ ਹਾਂ।

ਅਸੀਂ ਜਾਂਚਦੇ ਹਾਂ:

$ ./memtest
28.5714 GB / ਸਕਿੰਟ

ਇਕ ਹੋਰ ਗੱਲ ਇਹ ਹੈ ਕਿ.

ਕਹਾਣੀ ਦਾ ਨੈਤਿਕ - ਜੇਕਰ ਤੁਹਾਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਵੱਡੇ ਬਫਰਾਂ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ ਨਾ ਭੁੱਲੋ।

ਸਰੋਤ: www.habr.com