Benchmark: Rule Benchmark (2)

Script Preparation code:

var namespaces = [];
for (var i = 0; i < 10000; i++) {
  let predicate = Math.random();
  let level = '';
  if (predicate < 0.25) {
    level = ':error';
  } else if (predicate < 0.5) {
    level = ':warn';
  } else if (predicate < 0.75) {
    level = ':verbose';
  }
  namespaces.push(`LH:${Math.floor(Math.random() * 1000)}${level}`);
}

Tests:

VERBOSE (1)
const level = 'LH:*'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let key = 'enabled'; if ('-' === namespace[0]) { key = 'disabled'; namespace = namespace.slice(1); } const rule = new RegExp(`^${namespace}$`); const ruleGroup = rules[key] ?? []; return { ...rules, [key]: [...ruleGroup, rule] }; }, {}); for (const ns of namespaces) { const testRule = (rule) => rule.test(ns); const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule); }
VERBOSE (2)
const level = 'LH:*'; let enabled_ = false; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let enabled = true; if ('-' === namespace[0]) { namespace = namespace.slice(1); enabled = false; } rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled }; return rules; }, {}); for (const ns of namespaces) { for (const key of Object.keys(rules).sort().reverse()) { if (rules[key].pattern.test(ns)) { enabled_ = rules[key].enabled; break; } } }
INFO (1)
const level = 'LH:*, -LH:*:verbose'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let key = 'enabled'; if ('-' === namespace[0]) { key = 'disabled'; namespace = namespace.slice(1); } const rule = new RegExp(`^${namespace}$`); const ruleGroup = rules[key] ?? []; return { ...rules, [key]: [...ruleGroup, rule] }; }, {}); for (const ns of namespaces) { const testRule = (rule) => rule.test(ns); const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule); }
INFO (2)
const level = 'LH:*, -LH:*:verbose'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let enabled = true; if ('-' === namespace[0]) { namespace = namespace.slice(1); enabled = false; } rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled }; return rules; }, {}); for (const ns of namespaces) { for (const key of Object.keys(rules).sort().reverse()) { if (rules[key].pattern.test(ns)) { enabled_ = rules[key].enabled; break; } } }
WARN (1)
const level = '-LH:*, LH:*:warn, LH:*:error'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let key = 'enabled'; if ('-' === namespace[0]) { key = 'disabled'; namespace = namespace.slice(1); } const rule = new RegExp(`^${namespace}$`); const ruleGroup = rules[key] ?? []; return { ...rules, [key]: [...ruleGroup, rule] }; }, {}); for (const ns of namespaces) { const testRule = (rule) => rule.test(ns); const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule); }
WARN (2)
const level = '-LH:*, LH:*:warn, LH:*:error'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let enabled = true; if ('-' === namespace[0]) { namespace = namespace.slice(1); enabled = false; } rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled }; return rules; }, {}); for (const ns of namespaces) { for (const key of Object.keys(rules).sort().reverse()) { if (rules[key].pattern.test(ns)) { enabled_ = rules[key].enabled; break; } } }
ERROR (1)
const level = '-LH:*, LH:*:error'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let key = 'enabled'; if ('-' === namespace[0]) { key = 'disabled'; namespace = namespace.slice(1); } const rule = new RegExp(`^${namespace}$`); const ruleGroup = rules[key] ?? []; return { ...rules, [key]: [...ruleGroup, rule] }; }, {}); for (const ns of namespaces) { const testRule = (rule) => rule.test(ns); const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule); }
ERROR (2)
const level = '-LH:*, LH:*:error'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let enabled = true; if ('-' === namespace[0]) { namespace = namespace.slice(1); enabled = false; } rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled }; return rules; }, {}); for (const ns of namespaces) { for (const key of Object.keys(rules).sort().reverse()) { if (rules[key].pattern.test(ns)) { enabled_ = rules[key].enabled; break; } } }
SILENT (1)
const level = '-LH:*'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let key = 'enabled'; if ('-' === namespace[0]) { key = 'disabled'; namespace = namespace.slice(1); } const rule = new RegExp(`^${namespace}$`); const ruleGroup = rules[key] ?? []; return { ...rules, [key]: [...ruleGroup, rule] }; }, {}); for (const ns of namespaces) { const testRule = (rule) => rule.test(ns); const enabled_ = (rules.enabled?.some(testRule) ?? true) && !rules.disabled?.some(testRule); }
SILENT (2)
const level = '-LH:*'; const rules = level .replace(/\s/g, '') .replace(/\*/g, '.+') .split(',') .reduce((rules, namespace) => { if (!/^-?LH:/.test(namespace)) return rules; let enabled = true; if ('-' === namespace[0]) { namespace = namespace.slice(1); enabled = false; } rules[namespace] = { pattern: new RegExp(`^${namespace}$`), enabled }; return rules; }, {}); for (const ns of namespaces) { for (const key of Object.keys(rules).sort().reverse()) { if (rules[key].pattern.test(ns)) { enabled_ = rules[key].enabled; break; } } }

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
VERBOSE (1)
VERBOSE (2)
INFO (1)
INFO (2)
WARN (1)
WARN (2)
ERROR (1)
ERROR (2)
SILENT (1)
SILENT (2)

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: one year ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 Safari/537.36

Browser/OS: Chrome 111 on Windows

View result in a separate tab

Test name	Executions per second
VERBOSE (1)	1845.8 Ops/sec
VERBOSE (2)	431.9 Ops/sec
INFO (1)	865.1 Ops/sec
INFO (2)	149.3 Ops/sec
WARN (1)	831.9 Ops/sec
WARN (2)	126.6 Ops/sec
ERROR (1)	1250.8 Ops/sec
ERROR (2)	147.2 Ops/sec
SILENT (1)	2006.8 Ops/sec
SILENT (2)	244.9 Ops/sec

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Related benchmarks:

Rule Benchmark (2) (version: 0)

Comparing performance of: VERBOSE (1) vs VERBOSE (2) vs INFO (1) vs INFO (2) vs WARN (1) vs WARN (2) vs ERROR (1) vs ERROR (2) vs SILENT (1) vs SILENT (2)

Created: one year ago by: Guest

Jump to the latest result

VERBOSE (1)

VERBOSE (2)

INFO (1)

INFO (2)

WARN (1)

WARN (2)

ERROR (1)

ERROR (2)

SILENT (1)

SILENT (2)

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):