benchmark: fix destructuring in dgram/single-buffer

PR #59872 renamed the config key from `num` to `n` but did not update
the destructuring in main(), leaving `{ num: n }` which resolves to
undefined. This caused the benchmark to produce near-zero throughput
since the send-batching logic never fires when n is undefined.
Refs: #59872
PR-URL: #62084
Refs: nodejs/performance#187
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>

Author: thisalihassan

benchmark/crypto/hash-stream-creation.js

@@ -5,15 +5,15 @@ const common = require('../common.js');
 constcrypto=require('crypto');
 
 constbench=common.createBenchmark(main,{
-writes: [500],
+n: [500],
 algo: ['sha256','md5'],
 type: ['asc','utf','buf'],
 out: ['hex','binary','buffer'],
 len: [2,1024,102400,1024*1024],
 api: ['legacy','stream'],
 });
 
-functionmain({ api, type, len, out,writes, algo }){
+functionmain({ api, type, len, out,n, algo }){
 if(api==='stream'&&/^v0\.[0-8]\./.test(process.version)){
 console.error('Crypto streams not available until v0.10');
 // Use the legacy, just so that we can compare them.
@@ -41,15 +41,15 @@ function main({ api, type, len, out, writes, algo }) {
 constfn=api==='stream' ? streamWrite : legacyWrite;
 
 bench.start();
-fn(algo,message,encoding,writes,len,out);
+fn(algo,message,encoding,n,len,out);
 }
 
-functionlegacyWrite(algo,message,encoding,writes,len,outEnc){
-constwritten=writes*len;
+functionlegacyWrite(algo,message,encoding,n,len,outEnc){
+constwritten=n*len;
 constbits=written*8;
 constgbits=bits/(1024*1024*1024);
 
-while(writes-->0){
+while(n-->0){
 consth=crypto.createHash(algo);
 h.update(message,encoding);
 h.digest(outEnc);
@@ -58,12 +58,12 @@ function legacyWrite(algo, message, encoding, writes, len, outEnc) {
 bench.end(gbits);
 }
 
-functionstreamWrite(algo,message,encoding,writes,len,outEnc){
-constwritten=writes*len;
+functionstreamWrite(algo,message,encoding,n,len,outEnc){
+constwritten=n*len;
 constbits=written*8;
 constgbits=bits/(1024*1024*1024);
 
-while(writes-->0){
+while(n-->0){
 consth=crypto.createHash(algo);
 
 if(outEnc!=='buffer')

benchmark/crypto/hash-stream-throughput.js

@@ -5,14 +5,14 @@ const common = require('../common.js');
 constcrypto=require('crypto');
 
 constbench=common.createBenchmark(main,{
-writes: [500],
+n: [500],
 algo: ['sha1','sha256','sha512'],
 type: ['asc','utf','buf'],
 len: [2,1024,102400,1024*1024],
 api: ['legacy','stream'],
 });
 
-functionmain({ api, type, len, algo,writes}){
+functionmain({ api, type, len, algo,n}){
 if(api==='stream'&&/^v0\.[0-8]\./.test(process.version)){
 console.error('Crypto streams not available until v0.10');
 // Use the legacy, just so that we can compare them.
@@ -40,30 +40,30 @@ function main({ api, type, len, algo, writes }) {
 constfn=api==='stream' ? streamWrite : legacyWrite;
 
 bench.start();
-fn(algo,message,encoding,writes,len);
+fn(algo,message,encoding,n,len);
 }
 
-functionlegacyWrite(algo,message,encoding,writes,len){
-constwritten=writes*len;
+functionlegacyWrite(algo,message,encoding,n,len){
+constwritten=n*len;
 constbits=written*8;
 constgbits=bits/(1024*1024*1024);
 consth=crypto.createHash(algo);
 
-while(writes-->0)
+while(n-->0)
 h.update(message,encoding);
 
 h.digest();
 
 bench.end(gbits);
 }
 
-functionstreamWrite(algo,message,encoding,writes,len){
-constwritten=writes*len;
+functionstreamWrite(algo,message,encoding,n,len){
+constwritten=n*len;
 constbits=written*8;
 constgbits=bits/(1024*1024*1024);
 consth=crypto.createHash(algo);
 
-while(writes-->0)
+while(n-->0)
 h.write(message,encoding);
 
 h.end();

benchmark/crypto/rsa-sign-verify-throughput.js

@@ -17,28 +17,28 @@ keylen_list.forEach((key) => {
 });
 
 constbench=common.createBenchmark(main,{
-writes: [500],
+n: [500],
 algo: ['SHA1','SHA224','SHA256','SHA384','SHA512'],
 keylen: keylen_list,
 len: [1024,102400,2*102400,3*102400,1024*1024],
 });
 
-functionmain({ len, algo, keylen,writes}){
+functionmain({ len, algo, keylen,n}){
 constmessage=Buffer.alloc(len,'b');
 bench.start();
-StreamWrite(algo,keylen,message,writes,len);
+StreamWrite(algo,keylen,message,n,len);
 }
 
-functionStreamWrite(algo,keylen,message,writes,len){
-constwritten=writes*len;
+functionStreamWrite(algo,keylen,message,n,len){
+constwritten=n*len;
 constbits=written*8;
 constkbits=bits/(1024);
 
 constprivateKey=RSA_PrivatePem[keylen];
 consts=crypto.createSign(algo);
 constv=crypto.createVerify(algo);
 
-while(writes-->0){
+while(n-->0){
 s.update(message);
 v.update(message);
 }

benchmark/dgram/single-buffer.js

@@ -5,7 +5,7 @@ const common = require('../common.js');
 constdgram=require('dgram');
 constPORT=common.PORT;
 
-// `num` is the number of send requests to queue up each time.
+// `n` is the number of send requests to queue up each time.
 // Keep it reasonably high (>10) otherwise you're benchmarking the speed of
 // event loop cycles more than anything else.
 constbench=common.createBenchmark(main,{
@@ -15,7 +15,7 @@ const bench = common.createBenchmark(main, {
 dur: [5],
 });
 
-functionmain({ dur, len,num: n, type }){
+functionmain({ dur, len, n, type }){
 constchunk=Buffer.allocUnsafe(len);
 letsent=0;
 letreceived=0;