Krinkle · March 18, 2019 23:16
diff --git a/perfect-numbers.js b/perfect-numbers.js
 /**
 * Requires Node 6.0+
 *
 * Author: Timo Tijhof (2018).
 * License: Public domain.
 */

 const cluster = require('cluster');

 let pidLabel = cluster.isMaster ? 'master' : 'worker';

 if (cluster.isMaster) {
 	log('creating workers...');

 	let max = 1000 * 1000 * 1000; // 1 billion; // Number.MAX_SAFE_INTEGER
 	// Calls to getFactorSum() for numbers smaller than this
 	// run fast enough that it is not worth the master-worker overhead.
 	// So to ensure a quick start, distribute only ranges for which
 	// the sum exceeds this. Once we reach numbers higher than this,
 	// each work unit will represent a single number only.
 	let taskMinSize = 100 * 1000 * 1000; // 100 million
 	let wuf = new TaskFactory(2, max, taskMinSize);

 	let i = require('os').cpus().length;
 	while (i--) {
 		let worker = cluster.fork();
 	}

 	cluster.on('online', (worker) => {
 		// Assign the new worker its first task
 		let task = wuf.createTask();
 		if (task === false) {
 			worker.disconnect();
 		} else {
 			worker.send(task);
 		}
 	});
 	cluster.on('message', (worker, message) => {
 		// Worker finished a task, assign its next task
 		let task = wuf.createTask();
 		if (task === false) {
 			worker.disconnect();
 		} else {
 			worker.send(task);
 		}
 	});
 	cluster.on('exit', (worker, code, signal) => {
 		log(`worker process ${worker.process.pid} exited`);
 	});
 } else {
 	// Worker process
 	process.on('message', function (message) {
 		//log(`incoming message: ${message.type}`);
 		switch (message.type) {
 		case 'single':
 			processSingleNumber(message.num);
 			process.send( { type: 'done' } );
 			break;
 		case 'range':
 			processNumberRange(message.start, message.end);
 			process.send( { type: 'done' } );
 			break;
 		default:
 			log(`unknown message type: ${message.type}`);
 		}
 	});
 }

 /**
 * @param {string} text
 */
 function log(text) {
 	console.log(`[${process.pid} ${pidLabel}] ${text}`);
 }

 /** @return {Object} */
 function createSingleTask(num) {
 	return { type: 'single', num: num };
 }

 /** @return {Object} */
 function createRangeTask(start, end) {
 	return { type: 'range', start: start, end: end };
 }

 function TaskFactory(beginAt, endAt, size) {
 	let offset = beginAt;

 	/* @return {Object|false} Task object, or false to indicate no more tasks. */
 	this.createTask = function () {
 		this.checkMilestone();
 		if (offset >= endAt) {
 			return false;
 		}
 		if (offset > size) {
 			let num = offset;
 			// [optim] Only even numbers
 			offset += 2;
 			return createSingleTask(num);
 		}
 		let start = offset;
 		// [optim] Only even numbers
 		let end = start + 2;
 		let sum = start + end;
 		while (sum < size && end < endAt) {
 			end += 2;
 			sum += end;
 		}
 		offset = end + 2;
 		return createRangeTask(start, end);
 	}

 	// Steps of 0.01%, allow for 10,000 milestones
 	let milestoneChunk = Math.max(1, Math.floor((endAt - beginAt) / 10000));
 	let nextMilestoneN = 1;
 	let nextMilestone = beginAt + milestoneChunk;

 	this.checkMilestone = function () {
 		if (offset >= nextMilestone) {
 			log('progress ' + ((nextMilestoneN / 10000) * 100).toFixed(2) + '%');
 			nextMilestoneN++;
 			nextMilestone += milestoneChunk;
 		}
 	};
 }

 /**
 * @param {number} num
 * @return {number} Sum of num's factors
 */
 function getFactorSum(num) {
 	let fs = 1; // [optim] Assume `n % 1`
 	for (let i = 2; i < num; i++) {
 		if (num % i === 0) {
 			fs += i;
 		}
 	}
 	return fs;
 }

 /**
 * @param {number} num
 */
 function processSingleNumber(num) {
 	if (getFactorSum(i) === i) {
 		log('perfect number: ' + i);
 	}
 }

 /**
 * @param {number} start
 * @param {number} end
 */
 function processNumberRange(start, end) {
 	// [optim] Only even numbers
 	for (let i = start; i <= end; i += 2) {
 		if (getFactorSum(i) === i) {
 			log('perfect number: ' + i);
 		}
 	}
 }
	/**
	* Requires Node 6.0+
	*
	* Author: Timo Tijhof (2018).
	* License: Public domain.
	*/

	const cluster = require('cluster');

	let pidLabel = cluster.isMaster ? 'master' : 'worker';

	if (cluster.isMaster) {
	log('creating workers...');

	let max = 1000 * 1000 * 1000; // 1 billion; // Number.MAX_SAFE_INTEGER
	// Calls to getFactorSum() for numbers smaller than this
	// run fast enough that it is not worth the master-worker overhead.
	// So to ensure a quick start, distribute only ranges for which
	// the sum exceeds this. Once we reach numbers higher than this,
	// each work unit will represent a single number only.
	let taskMinSize = 100 * 1000 * 1000; // 100 million
	let wuf = new TaskFactory(2, max, taskMinSize);

	let i = require('os').cpus().length;
	while (i--) {
	let worker = cluster.fork();
	}

	cluster.on('online', (worker) => {
	// Assign the new worker its first task
	let task = wuf.createTask();
	if (task === false) {
	worker.disconnect();
	} else {
	worker.send(task);
	}
	});
	cluster.on('message', (worker, message) => {
	// Worker finished a task, assign its next task
	let task = wuf.createTask();
	if (task === false) {
	worker.disconnect();
	} else {
	worker.send(task);
	}
	});
	cluster.on('exit', (worker, code, signal) => {
	log(`worker process ${worker.process.pid} exited`);
	});
	} else {
	// Worker process
	process.on('message', function (message) {
	//log(`incoming message: ${message.type}`);
	switch (message.type) {
	case 'single':
	processSingleNumber(message.num);
	process.send( { type: 'done' } );
	break;
	case 'range':
	processNumberRange(message.start, message.end);
	process.send( { type: 'done' } );
	break;
	default:
	log(`unknown message type: ${message.type}`);
	}
	});
	}

	/**
	* @param {string} text
	*/
	function log(text) {
	console.log(`[${process.pid} ${pidLabel}] ${text}`);
	}

	/** @return {Object} */
	function createSingleTask(num) {
	return { type: 'single', num: num };
	}

	/** @return {Object} */
	function createRangeTask(start, end) {
	return { type: 'range', start: start, end: end };
	}

	function TaskFactory(beginAt, endAt, size) {
	let offset = beginAt;

	/* @return {Object\|false} Task object, or false to indicate no more tasks. */
	this.createTask = function () {
	this.checkMilestone();
	if (offset >= endAt) {
	return false;
	}
	if (offset > size) {
	let num = offset;
	// [optim] Only even numbers
	offset += 2;
	return createSingleTask(num);
	}
	let start = offset;
	// [optim] Only even numbers
	let end = start + 2;
	let sum = start + end;
	while (sum < size && end < endAt) {
	end += 2;
	sum += end;
	}
	offset = end + 2;
	return createRangeTask(start, end);
	}

	// Steps of 0.01%, allow for 10,000 milestones
	let milestoneChunk = Math.max(1, Math.floor((endAt - beginAt) / 10000));
	let nextMilestoneN = 1;
	let nextMilestone = beginAt + milestoneChunk;

	this.checkMilestone = function () {
	if (offset >= nextMilestone) {
	log('progress ' + ((nextMilestoneN / 10000) * 100).toFixed(2) + '%');
	nextMilestoneN++;
	nextMilestone += milestoneChunk;
	}
	};
	}

	/**
	* @param {number} num
	* @return {number} Sum of num's factors
	*/
	function getFactorSum(num) {
	let fs = 1; // [optim] Assume `n % 1`
	for (let i = 2; i < num; i++) {
	if (num % i === 0) {
	fs += i;
	}
	}
	return fs;
	}

	/**
	* @param {number} num
	*/
	function processSingleNumber(num) {
	if (getFactorSum(i) === i) {
	log('perfect number: ' + i);
	}
	}

	/**
	* @param {number} start
	* @param {number} end
	*/
	function processNumberRange(start, end) {
	// [optim] Only even numbers
	for (let i = start; i <= end; i += 2) {
	if (getFactorSum(i) === i) {
	log('perfect number: ' + i);
	}
	}
	}