Benchmark: Proxy size - factory closure

Proxy size - factory closure (version: 0)

Comparing performance of: Large Proxy - literal vs Small Proxy - literal vs Large Proxy - class vs Small Proxy - class vs Large GetterSetter - literal vs Small GetterSetter - literal vs Large GetterSetter - class vs Small GetterSetter - class vs control case vs Large Proxy - factory vs Small Proxy - factory vs Large Proxy - factory closure methods vs Small Proxy - factory closure methods

Created: 2 years ago by: Registered User

Jump to the latest result

Script Preparation code:

function prep() {
    class BigFoo {
        constructor() {
            this.b = 2;
            this.c = 2;
            this.d = 2;
            this.e = 2;
            this.f = 2;
            this.g = 2;
            this.h = 2;
        }
        j() {}
        k() {}
        l() {}
        m() {}
        n() {}
        o() {}
        p() {}
    }

    class LilFoo {
        constructor() {
            this.a = 1;
        }
        i() {}
    }

    function bigBar() {
        return {
            b: 2,
            c: 2,
            d: 2,
            e: 2,
            f: 2,
            g: 2,
            h: 2,
            j: () => {},
            k: () => {},
            l: () => {},
            m: () => {},
            n: () => {},
            o: () => {},
            p: () => {},
        };
    }

    function lilCar() {
        return {
            a: 1,
            i,
        };
    }
  
  function i(){}
  
      function bigCar() {
        return {
            b: 2,
            c: 2,
            d: 2,
            e: 2,
            f: 2,
            g: 2,
            h: 2,
            j,
            k,
            l,
            m,
            n,
            o,
            p,
        };
    }
  
  function j(){}
  function k(){}
  function l(){}
  function m(){}
  function n(){}
  function o(){}
  function p(){}

    function lilBar() {
        return {
            a: 1,
            i: () => {},
        };
    }

    const handlersP = {
        get: (target, key) => target[key],
        set: (target, key, val) => {
            target[key] = val;
        },
    };

    const handlersD = {
        get() {
            return bValue;
        },
        set(newValue) {
            bValue = newValue;
        },
    };
    return {
        BigFoo,
        LilFoo,
        handlersP,
        handlersD,
        bigBar,
        lilBar,
      bigCar,
      lilCar
    }
}


function _proxy(target, handlers) {
    for (const key in target) {
        Object.defineProperty(target, key, handlers);
    }
}

Tests:

Large Proxy - literal
const {BigFoo, LilFoo, bigBar, lilBar, bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const proxy = new Proxy(bigFoo, handlersP);
Small Proxy - literal
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = { a: 1, i: () => {}, }; const proxy = new Proxy(lilFoo, handlersP)
Large Proxy - class
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = new BigFoo(); const proxy = new Proxy(bigFoo, handlersP)
Small Proxy - class
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = new LilFoo(); const proxy = new Proxy(lilFoo, handlersP)
Large GetterSetter - literal
const {BigFoo, LilFoo,bigBar, lilBar, bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const proxy = _proxy(bigFoo, handlersD);
Small GetterSetter - literal
const {BigFoo, LilFoo,bigBar, lilBar, bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = { a: 1, i: () => {}, }; const proxy = _proxy(lilFoo, handlersD);
Large GetterSetter - class
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = new BigFoo(); const proxy = _proxy(bigFoo, handlersD);
Small GetterSetter - class
const {BigFoo, LilFoo,bigBar, lilBar, bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = new LilFoo(); const proxy = _proxy(lilFoo, handlersD);
control case
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const proxy = bigFoo;
Large Proxy - factory
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = bigBar(); const proxy = new Proxy(bigFoo, handlersP);
Small Proxy - factory
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = lilBar(); const proxy = new Proxy(lilFoo, handlersP)
Large Proxy - factory closure methods
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { a: 1, i: () => {}, }; const bigFoo = bigCar(); const proxy = new Proxy(bigFoo, handlersP);
Small Proxy - factory closure methods
const {BigFoo, LilFoo, bigBar, lilBar,bigCar, lilCar,handlersP, handlersD} = prep(); const _foo = { b: 2, c: 2, d: 2, e: 2, f: 2, g: 2, h: 2, j: () => {}, k: () => {}, l: () => {}, m: () => {}, n: () => {}, o: () => {}, p: () => {}, }; const lilFoo = lilCar(); const proxy = new Proxy(lilFoo, handlersP)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Large Proxy - literal
Small Proxy - literal
Large Proxy - class
Small Proxy - class
Large GetterSetter - literal
Small GetterSetter - literal
Large GetterSetter - class
Small GetterSetter - class
control case
Large Proxy - factory
Small Proxy - factory
Large Proxy - factory closure methods
Small Proxy - factory closure methods

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):

LLMs can make mistakes. Check important info.

I'll do my best to help.

To analyze the provided data, I can see that it appears to be a list of web browser usage statistics for Firefox on Mac OS X 10.15. Here are some observations and insights:

1. **Browser distribution**: The data suggests that Firefox is being used extensively across various testing scenarios.
2. **Device platform**: The majority of tests (14 out of 16) were run on desktop devices, with no instances of mobile device usage reported.
3. **Operating system**: All tests were conducted on Mac OS X 10.15.
4. **Test types**: There are different test categories, such as "Small Proxy", "Large Proxy", "Small GetterSetter", and "Large GetterSetter". This might indicate that the data is intended to support testing and validation of certain scenarios or features.

However, without more context or information about the specific goals, objectives, or requirements behind this data, it's challenging to provide more detailed insights. If you have any additional questions or would like me to help with something specific, feel free to ask!

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:103.0) Gecko/20100101 Firefox/103.0

Browser/OS: Firefox 103 on Mac OS X 10.15

View result in a separate tab

Test name	Executions per second
Large Proxy - literal	356320.9 Ops/sec
Small Proxy - literal	448304.0 Ops/sec
Large Proxy - class	125173.6 Ops/sec
Small Proxy - class	221662.8 Ops/sec
Large GetterSetter - literal	172099.8 Ops/sec
Small GetterSetter - literal	377827.9 Ops/sec
Large GetterSetter - class	97535.3 Ops/sec
Small GetterSetter - class	181015.8 Ops/sec
control case	1977389.0 Ops/sec
Large Proxy - factory	342971.9 Ops/sec
Small Proxy - factory	460451.4 Ops/sec
Large Proxy - factory closure methods	426778.2 Ops/sec
Small Proxy - factory closure methods	465395.1 Ops/sec

Related benchmarks:

Proxy size - factory closure (version: 0)

Created: 2 years ago by: Registered User

Jump to the latest result

Large Proxy - literal

Small Proxy - literal

Large Proxy - class

Small Proxy - class

Large GetterSetter - literal

Small GetterSetter - literal

Large GetterSetter - class

Small GetterSetter - class

control case

Large Proxy - factory

Small Proxy - factory

Large Proxy - factory closure methods

Small Proxy - factory closure methods

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated 26 days ago):