मुझे यह समझने में परेशानी हो रही है कि क्यों मेरा प्रदर्शन परीक्षण 2 अलग-अलग प्रकार के रनों पर महत्वपूर्ण परिणाम देता है।process.hrtime() के साथ निष्पादन समय काफी अलग परिणाम
- सार से कोड प्राप्त करें::
कदम समस्या को ठीक करने https://gist.github.com/AVAVT/83685bfe5280efc7278465f90657b9ea
- भागो
node practice1.generator - भागो
node practice1.performance-test
practice1.generator एक test-data.json फाइल उत्पन्न करना चाहिए, और कुछ खोज लॉग इन करें कंसोल में एल्गोरिदम निष्पादन समय। उसके बाद, practice1.performance-testtest-data.json से पढ़ता है, और उसी डेटा पर सटीक मूल्यांकन मूल्यांकन कार्य करता है।
मेरी मशीन पर उत्पादन लगातार इस के समान है:
> node practice1.generator
Generate time: 9,307,061,368 nanoseconds
Total time using indexOf : 7,005,750 nanoseconds
Total time using for loop : 7,463,967 nanoseconds
Total time using binary search : 1,741,822 nanoseconds
Total time using interpolation search: 915,532 nanoseconds
> node practice1.performance-test
Total time using indexOf : 11,574,993 nanoseconds
Total time using for loop : 8,765,902 nanoseconds
Total time using binary search : 2,365,598 nanoseconds
Total time using interpolation search: 771,005 nanoseconds
नोट indexOf और binary search अन्य एल्गोरिदम की तुलना के मामले में निष्पादन समय में अंतर।
मैं बार-बार node practice1.generatorयाnode practice1.performance-test चलाते हैं, तो परिणाम हालांकि काफी संगत है।
अब यह इतना परेशान है, मुझे यह पता लगाने का कोई तरीका नहीं मिल रहा है कि कौन सा परिणाम विश्वसनीय है, और ऐसे मतभेद क्यों होते हैं। क्या जेनरेट टेस्ट सरणी बनाम JSON.parse-d परीक्षण सरणी के बीच एक अंतर के कारण होता है; या यह process.hrtime() के कारण होता है; या यह कुछ अज्ञात कारण है कि मैं भी समझ नहीं सकता?
अद्यतन: मैं का पता लगाया है indexOf मामले के कारण JSON.parse की वजह से किया जाना है। practice1.generator के अंदर, tests सरणी मूल जेनरेटेड सरणी है; जबकि practice1.performance-test में सरणी जेसन फ़ाइल से पढ़ी जाती है और शायद किसी भी तरह से मूल सरणी से अलग होती है।
practice1.generator मैं बजाय JSON.parse() स्ट्रिंग से एक नई सरणी के भीतर हैं:
var tests2 = JSON.parse(JSON.stringify(tests));
performanceUtil.performanceTest(tests2);
indexOf के निष्पादन के समय अब दोनों फ़ाइलों पर संगत है।
> node practice1.generator
Generate time: 9,026,080,466 nanoseconds
Total time using indexOf : 11,016,420 nanoseconds
Total time using for loop : 8,534,540 nanoseconds
Total time using binary search : 1,586,780 nanoseconds
Total time using interpolation search: 742,460 nanoseconds
> node practice1.performance-test
Total time using indexOf : 11,423,556 nanoseconds
Total time using for loop : 8,509,602 nanoseconds
Total time using binary search : 2,303,099 nanoseconds
Total time using interpolation search: 718,723 nanoseconds
तो कम से कम मैं indexOf रन एक JSON.parse -d सरणी पर मूल सरणी पर बेहतर और बदतर पता है। फिर भी मुझे केवल कारण पता है, कोई संकेत क्यों नहीं।
द्विआधारी खोज निष्पादन समय लगातार 1.7ms practice1.generator में (यहां तक कि जब एक JSON.parse -d वस्तु का प्रयोग करके) 2.3ms practice1.performance-test में ले रही है ~ और ~ 2 फ़ाइलें पर अलग अलग रहते हैं,।
नीचे भविष्य के संदर्भ उद्देश्य के लिए प्रदान की गई जिंदगी के समान कोड है।
/*
* performance-utils.js
*/
'use strict';
const performanceTest = function(tests){
var tindexOf = process.hrtime();
tests.forEach(testcase => {
var result = testcase.input.indexOf(testcase.target);
if(result !== testcase.output) console.log("Errr", result, testcase.output);
});
tindexOf = process.hrtime(tindexOf);
var tmanual = process.hrtime();
tests.forEach(testcase => {
const arrLen = testcase.input.length;
var result = -1;
for(var i=0;i<arrLen;i++){
if(testcase.input[i] === testcase.target){
result = i;
break;
}
}
if(result !== testcase.output) console.log("Errr", result, testcase.output);
});
tmanual = process.hrtime(tmanual);
var tbinary = process.hrtime();
tests.forEach(testcase => {
var max = testcase.input.length-1;
var min = 0;
var check, num;
var result = -1;
while(max => min){
check = Math.floor((max+min)/2);
num = testcase.input[check];
if(num === testcase.target){
result = check;
break;
}
else if(num > testcase.target) max = check-1;
else min = check+1;
}
if(result !== testcase.output) console.log("Errr", result, testcase.output);
});
tbinary = process.hrtime(tbinary);
var tinterpolation = process.hrtime();
tests.forEach(testcase => {
var max = testcase.input.length-1;
var min = 0;
var result = -1;
var check, num;
while(max > min && testcase.target >= testcase.input[min] && testcase.target <= testcase.input[max]){
check = min + Math.round((max-min) * (testcase.target - testcase.input[min])/(testcase.input[max]-testcase.input[min]));
num = testcase.input[check];
if(num === testcase.target){
result = check;
break;
}
else if(testcase.target > num) min = check + 1;
else max = check - 1;
}
if(result === -1 && testcase.input[max] == testcase.target) result = max;
if(result !== testcase.output) console.log("Errr", result, testcase.output);
});
tinterpolation = process.hrtime(tinterpolation);
console.log(`Total time using indexOf : ${(tindexOf[0] * 1e9 + tindexOf[1]).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")} nanoseconds`);
console.log(`Total time using for loop : ${(tmanual[0] * 1e9 + tmanual[1]).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")} nanoseconds`);
console.log(`Total time using binary search : ${(tbinary[0] * 1e9 + tbinary[1]).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")} nanoseconds`);
console.log(`Total time using interpolation search: ${(tinterpolation[0] * 1e9 + tinterpolation[1]).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")} nanoseconds`);
}
module.exports = { performanceTest }
/*
* practice1.generator.js
*/
'use strict';
require('util');
const performanceUtil = require('./performance-utils');
const fs = require('fs');
const path = require('path');
const outputFilePath = path.join(__dirname, process.argv[3] || 'test-data.json');
const AMOUNT_TO_GENERATE = parseInt(process.argv[2] || 1000);
// Make sure ARRAY_LENGTH_MAX < (MAX_NUMBER - MIN_NUMBER)
const ARRAY_LENGTH_MIN = 10000;
const ARRAY_LENGTH_MAX = 18000;
const MIN_NUMBER = -10000;
const MAX_NUMBER = 10000;
const candidates = Array.from(Array(MAX_NUMBER - MIN_NUMBER + 1), (item, index) => MIN_NUMBER + index);
function createNewTestcase(){
var input = candidates.slice();
const lengthToGenerate = Math.floor(Math.random()*(ARRAY_LENGTH_MAX - ARRAY_LENGTH_MIN + 1)) + ARRAY_LENGTH_MIN;
while(input.length > lengthToGenerate){
input.splice(Math.floor(Math.random()*input.length), 1);
}
const notfound = input.length === lengthToGenerate ?
input.splice(Math.floor(Math.random()*input.length), 1)[0] : MIN_NUMBER-1;
const output = Math.floor(Math.random()*(input.length+1)) - 1;
const target = output === -1 ? notfound : input[output];
return {
input,
target,
output
};
}
var tgen = process.hrtime();
var tests = [];
while(tests.length < AMOUNT_TO_GENERATE){
tests.push(createNewTestcase());
}
fs.writeFileSync(outputFilePath, JSON.stringify(tests));
var tgen = process.hrtime(tgen);
console.log(`Generate time: ${(tgen[0] * 1e9 + tgen[1]).toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",")} nanoseconds`);
performanceUtil.performanceTest(tests);
/*
* practice1.performance-test.js
*/
'use strict';
require('util');
const performanceUtil = require('./performance-utils');
const fs = require('fs');
const path = require('path');
const outputFilePath = path.join(__dirname, process.argv[2] || 'test-data.json');
var tests = JSON.parse(fs.readFileSync(outputFilePath));
performanceUtil.performanceTest(tests);
आप नोड के क्या संस्करण चला रहे हैं है? –
हे वहाँ @ एसएएमएच। मैं नोड v6.11 – AVAVT
का उपयोग कर रहा हूं बस 8.5.0 वर्तमान पर परीक्षण किया और एक ही परिणाम मिला। – AVAVT