crypto: optimize normalizeAlgorithm dispatch hot path

Replace the O(n) case-insensitive algorithm-name scan
with an O(1) SafeMap lookup. The map is pre-built at
module init alongside kSupportedAlgorithms.
Hoist the opts object literal used in normalizeAlgorithm
to module level to avoid allocating identical
{ prefix, context } objects on every call.
Pre-compute ObjectKeys() for simpleAlgorithmDictionaries
entries at module init to avoid allocating a new keys
array on every normalizeAlgorithm call.
Signed-off-by: Filip Skokan <panva.ip@gmail.com>
PR-URL: #62756
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>

Author: panva

lib/internal/crypto/util.js

@@ -16,6 +16,7 @@ const {
  ObjectKeys,
  ObjectPrototypeHasOwnProperty,
  PromiseWithResolvers,
+ SafeMap,
  SafeSet,
  StringPrototypeToUpperCase,
  Symbol,
@@ -453,8 +454,11 @@ const experimentalAlgorithms = [
 ];
 
 // Transform the algorithm definitions into the operation-keyed structure
+// Also builds a parallel Map<UPPERCASED_NAME, canonicalName> per operation
+// for O(1) case-insensitive algorithm name lookup in normalizeAlgorithm.
 functioncreateSupportedAlgorithms(algorithmDefs){
 constresult={};
+constnameMap={};
 
 for(const{0: algorithmName,1: operations}ofObjectEntries(algorithmDefs)){
 // Skip algorithms that are conditionally not supported
@@ -465,6 +469,8 @@ function createSupportedAlgorithms(algorithmDefs) {
 
 for(const{0: operation,1: dict}ofObjectEntries(operations)){
 result[operation]||={};
+nameMap[operation]||=newSafeMap();
+nameMap[operation].set(StringPrototypeToUpperCase(algorithmName),algorithmName);
 
 // Add experimental warnings for experimental algorithms
 if(ArrayPrototypeIncludes(experimentalAlgorithms,algorithmName)){
@@ -482,10 +488,11 @@ function createSupportedAlgorithms(algorithmDefs) {
 }
 }
 
-returnresult;
+return{algorithms: result, nameMap };
 }
 
-constkSupportedAlgorithms=createSupportedAlgorithms(kAlgorithmDefinitions);
+const{algorithms: kSupportedAlgorithms,nameMap: kAlgorithmNameMap}=
+createSupportedAlgorithms(kAlgorithmDefinitions);
 
 constsimpleAlgorithmDictionaries={
 AesCbcParams: {iv: 'BufferSource'},
@@ -527,6 +534,12 @@ const simpleAlgorithmDictionaries = {
 TurboShakeParams: {},
 };
 
+// Pre-compute ObjectKeys() for each dictionary entry at module init
+// to avoid allocating a new keys array on every normalizeAlgorithm call.
+for(const{0: name,1: types}ofObjectEntries(simpleAlgorithmDictionaries)){
+simpleAlgorithmDictionaries[name]={keys: ObjectKeys(types), types };
+}
+
 functionvalidateMaxBufferLength(data,name,max=kMaxBufferLength){
 if(data.byteLength>max){
 throwlazyDOMException(
@@ -537,6 +550,14 @@ function validateMaxBufferLength(data, name, max = kMaxBufferLength) {
 
 letwebidl;
 
+// Keep this as a regular object. The WebIDL converters read and spread these
+// options on the normalizeAlgorithm hot path, and a null-prototype object
+// measurably regresses benchmark/misc/webcrypto-webidl normalizeAlgorithm-*.
+constkNormalizeAlgorithmOpts={
+prefix: 'Failed to normalize algorithm',
+context: 'passed algorithm',
+};
+
 // https://w3c.github.io/webcrypto/#algorithm-normalization-normalize-an-algorithm
 // adapted for Node.js from Deno's implementation
 // https://github.com/denoland/deno/blob/v1.29.1/ext/crypto/00_crypto.js#L195
@@ -549,69 +570,56 @@ function normalizeAlgorithm(algorithm, op) {
 // 1.
 constregisteredAlgorithms=kSupportedAlgorithms[op];
 // 2. 3.
-constinitialAlg=webidl.converters.Algorithm(algorithm,{
-prefix: 'Failed to normalize algorithm',
-context: 'passed algorithm',
-});
+constinitialAlg=webidl.converters.Algorithm(algorithm,
+kNormalizeAlgorithmOpts);
 // 4.
 letalgName=initialAlg.name;
 
-// 5.
-letdesiredType;
-for(constkeyinregisteredAlgorithms){
-if(!ObjectPrototypeHasOwnProperty(registeredAlgorithms,key)){
-continue;
-}
-if(
-StringPrototypeToUpperCase(key)===StringPrototypeToUpperCase(algName)
-){
-algName=key;
-desiredType=registeredAlgorithms[key];
-}
-}
-if(desiredType===undefined)
+// 5. Case-insensitive lookup via pre-built Map (O(1) instead of O(n)).
+constcanonicalName=kAlgorithmNameMap[op]?.get(
+StringPrototypeToUpperCase(algName));
+if(canonicalName===undefined)
 throwlazyDOMException('Unrecognized algorithm name','NotSupportedError');
 
+algName=canonicalName;
+constdesiredType=registeredAlgorithms[algName];
+
 // Fast path everything below if the registered dictionary is null
 if(desiredType===null)
 return{name: algName};
 
 // 6.
 constnormalizedAlgorithm=webidl.converters[desiredType](
 {__proto__: algorithm,name: algName},
-{
-prefix: 'Failed to normalize algorithm',
-context: 'passed algorithm',
-},
+kNormalizeAlgorithmOpts,
 );
 // 7.
 normalizedAlgorithm.name=algName;
 
-// 9.
-constdict=simpleAlgorithmDictionaries[desiredType];
-// 10.
-constdictKeys=dict ? ObjectKeys(dict) : [];
-for(leti=0;i<dictKeys.length;i++){
-constmember=dictKeys[i];
-if(!ObjectPrototypeHasOwnProperty(dict,member))
-continue;
-constidlType=dict[member];
-constidlValue=normalizedAlgorithm[member];
-// 3.
-if(idlType==='BufferSource'&&idlValue){
-constisView=ArrayBufferIsView(idlValue);
-normalizedAlgorithm[member]=TypedArrayPrototypeSlice(
-newUint8Array(
-isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue,
-isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0,
-isView ? getDataViewOrTypedArrayByteLength(idlValue) : ArrayBufferPrototypeGetByteLength(idlValue),
-),
-);
-}elseif(idlType==='HashAlgorithmIdentifier'){
-normalizedAlgorithm[member]=normalizeAlgorithm(idlValue,'digest');
-}elseif(idlType==='AlgorithmIdentifier'){
-// This extension point is not used by any supported algorithm (yet?)
-throwlazyDOMException('Not implemented.','NotSupportedError');
+// 9. 10. Pre-computed keys and types from simpleAlgorithmDictionaries.
+constdictMeta=simpleAlgorithmDictionaries[desiredType];
+if(dictMeta){
+const{keys: dictKeys,types: dictTypes}=dictMeta;
+for(leti=0;i<dictKeys.length;i++){
+constmember=dictKeys[i];
+constidlType=dictTypes[member];
+constidlValue=normalizedAlgorithm[member];
+// 3.
+if(idlType==='BufferSource'&&idlValue){
+constisView=ArrayBufferIsView(idlValue);
+normalizedAlgorithm[member]=TypedArrayPrototypeSlice(
+newUint8Array(
+isView ? getDataViewOrTypedArrayBuffer(idlValue) : idlValue,
+isView ? getDataViewOrTypedArrayByteOffset(idlValue) : 0,
+isView ? getDataViewOrTypedArrayByteLength(idlValue) : ArrayBufferPrototypeGetByteLength(idlValue),
+),
+);
+}elseif(idlType==='HashAlgorithmIdentifier'){
+normalizedAlgorithm[member]=normalizeAlgorithm(idlValue,'digest');
+}elseif(idlType==='AlgorithmIdentifier'){
+// This extension point is not used by any supported algorithm (yet?)
+throwlazyDOMException('Not implemented.','NotSupportedError');
+}
 }
 }