memory_in_javascript.pdf

Transcript

1. 1.

   Memory in javascript

2. 2.

   Name !CSO
   5BLFUPTIJ
   "POP੨໺݈ར
   Occupation 'SPOUFOE
   %FWFMPQFS
   
   1SPEVDU
   0XOFS
   Company $ZCFSBHFOU"EUFDI
   4UVEJP"*
   .FTTFOHFS
   OSS $POUSJCVUPS
   PG
   7
   

   About IUUQJOGPCODI
3. 3.

   How javascript treat memory

4. 4.

   Allocation HEAP { a: 1, b: 2 } I wanna

   create object!!
5. 5.

   If space is not exists HEAP { a: 1, b:

   2 } I wanna create an object!! I can’t allocate no more!
6. 6.

   Search spaces HEAP { a: 1, b: 2 } I

   wanna create an object!! I found unused space
7. 7.

   Garbage Collection

8. 8.

   Marking Phase HEAP 1 2 3 4 5 This object

   is not referenced from anywhere
9. 9.

   Sweeping Phase HEAP 1 2 3 4 Object not referenced

   will be deleted.
10. 10.

    Heap

11. 11.

    Heap structure Young generation Old generation "U
    pSTU
    PCKFDU
    BMMPDBUFE
    BU
    ZPVOH
    HFOFSBUJPO
    *G
    PCKFDU
    TVSWJWFE
    GSPN
    ($
    TFSWFSBM
    UJNFT
    

    XJMM
    
    CF
    NPWFE
    UP
    0ME
    HFO
12. 12.

    Generational GC Allocated objects are managed by separete generation, to

    more efficient sweeping. If VM can’t keep enough memory space, VM starting sweeping Young Generation, so Young Generation may be held many Short-lived objects and possibility that is found empty space is higher. This called Minor GC. If empty spaces are not found in Young Generation, VM start sweeping Old Generation. This called Major GC.
13. 13.

    Memory leak In many case, Javascript will not leak memory

    today. MarkSweep GC has solve cyclic reference. But MarkSweep is not a silver bullet, if you holding many large object, that will still cause memory exhaustion.
14. 14.

    Preventing useless reference •Cleanup object •WeakMap •WeakRef NEW!

15. 15.

    Cleanup object const indices = {}; indices['testA'] = new SomeClass();

    indices['testB'] = new SomeClass(); delete indices['testA']; delete indices['testB'];
16. 16.

    Cleanup object but … const indices = {}; indices['testA'] =

    new SomeClass(); indices['testB'] = new SomeClass(); delete indices['testA']; delete indices['testB']; When can we delete these objects?
17. 17.

    Finalizer We want to delete these, when SomeClass will be

    swept. HEAP 4PNF $MBTT 1 2 3 4 This time
18. 18.

    WeakMap const indices = new WeakMap(); const a = new

    SomeClass(); const b = new SomeClass(); indices.set(a, someValue); indices.set(b, someValue);
19. 19.

    WeakMap hooks When an object whose registered as the key

    of a WeakMap deleted, the bound value will be deleted too. HEAP 4PNF $MBTT 1 2 3 4 WeakMap WeakMap delete a bound value of SomeClass.
20. 20.

    But WeakMap not match some situations… const cache = {};

    function cache(factory) { return key => { const ret = cache[key]; if (ret) { return ret; } return cache[key] = factory(); } }
21. 21.

    WeakRef

22. 22.

    What is WeakRef? WeakRef is now proposed ecamscript functionality that

    enable user to be concerned to Object lifetime and GarbageCollection. WeakRef is now stage-2
23. 23.

    WeakRef function makeWeakCached(f) { const cache = new Map(); return

    key => { const ref = cache.get(key); if (ref) { const cached = ref.deref(); if (cached !== undefined) return cached; } const fresh = f(key); cache.set(key, new WeakRef(fresh)); return fresh; }; }
24. 24.

    How WeakRef works? WeakRef will holds a value without references.

    So, Garbage Collector will not traverse object whose held by WeakRef.
25. 25.

    Hooks for Garbage Collector WeakRef provides finalizer functionality for GC.

    If finalizer callback is registered, that callback will be called when object is swept.
26. 26.

    WeakRef finalizer const object = {}; const finalizer = new

    FinalizationGroup((holdings) => {}); finalizer.register( object, holdings, token); finalizer.unregister(token);
27. 27.

    WeakRef finalizer function makeWeakCached(f) { const cache = new Map();

    const cleanup = new FinalizationGroup(iterator => { for (const key of iterator) { // See note below on concurrency considerations. const ref = cache.get(key); if (ref && !ref.deref()) cache.delete(key); } }); return key => { const ref = cache.get(key); if (ref) { const cached = ref.deref(); // See note below on concurrency considerations. if (cached !== undefined) return cached; } const fresh = f(key); cache.set(key, new WeakRef(fresh)); cleanup.register(fresh, key, key); return fresh; }; }
28. 28.

    WeakRef HEAP 1 2 3 4 5 The object referenced

    by WeakRef is not treat as referenced object
29. 29.

    WeakRef hooks When an object whose registered to FinalizerGroup is

    deleted, Finalizer callback will be invoked. HEAP  1 2 3 4 FinalizerGroup FinalizerGroup callback will be called
30. 30.

    Warnings Finalizer might not be called, because implementations of GC

    are different from each engines and sweep timing is different from each object or may not be deleted until end of process. So above reasons, you should not use Finalizer as a resource cleanup process.
31. 31.

    References/Resources • https://www.freepik.com/? __hstc=57440181.4254316b754c2c3a441d625d6c5b46d3.1559749420254.1559749420254.1559749420254.1&__hssc=574 40181.4.1559749420255&__hsfp=2297408259 • https://github.com/tc39/proposal-weakrefs

32. 32.

    Thank you for your time.