Fix getGarbageLen to retrun correct size

[devleejb]

What this PR does / why we need it?

• To ensure that the getGarbageLen function returns the correct length, I used a Set to eliminate duplicate counting
• Add test case for getGarbageLen

Any background context you want to provide?

Refer to issue yorkie/#688 for details.

What are the relevant tickets?

Fixes # yorkie-team/yorkie#688

Checklist

• Added relevant tests or not required
• Didn't break anything

[codecov]

Codecov Report

All modified and coverable lines are covered by tests ✅

Comparison is base (5ef1e8f) 81.75% compared to head (4b8a34c) 81.76%.
Report is 1 commits behind head on main.

Additional details and impacted files

@@           Coverage Diff           @@
##             main     #714   +/-   ##
=======================================
  Coverage   81.75%   81.76%           
=======================================
  Files          57       57           
  Lines        4161     4163    +2     
  Branches      805      805           
=======================================
+ Hits         3402     3404    +2     
  Misses        502      502           
  Partials      257      257           

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[hackerwins]

Thanks for your contribution.

It seems like an intuitive solution. Because of Set, we use space for GC targets. but I'm curious if there are any ideas for further improvement.

CC) @justiceHui

[devleejb]

Improved time complexity for getGarbageLen using sort

Discussed this topic with @justiceHui .

[devleejb]

I have executed the benchmark, and the results have changed as shown below. I am curious to know if there is a significant difference that can be observed.

Before sorting

After sorting

[devleejb]

@hackerwins @justiceHui
I have newly written a benchmark to measure the performance of getGarbageLen with @justiceHui . To simulate the worst-case scenario, I created a scenario where deeply nested objects are generated and deleted starting from the children.

I expect the following code will pass the tests successfully. However, although getGarbageLen operates as expected, garbageCollect returns a value of 2^(size - 1) + size. I would like to discuss the reasons behind this discrepancy.

Additionally, when running the test without reversing the childList, garbageCollect returns 2^size.

const benchmarkGCLen = (size: number) => {
  const doc = new Document<{ a: any }>('test-doc');

  doc.update((root) => {
    let temp = root;
    for (let i = 0; i < size; i++) {
      temp.a = {};
      temp = temp.a;
    }
  });
  doc.update((root) => {
    let temp = root;
    const childList = [];
    for (let i = 0; i < size; i++) {
      temp.a = {};
      childList.push(temp);
      temp = temp.a;
    }

    for (const child of childList.reverse()) {
      delete child.a;
    }
  });
  const expect = 2 * size;
  assert.equal(expect, doc.getGarbageLen());
  assert.equal(expect, doc.garbageCollect(MaxTimeTicket));
};

[devleejb]

@hackerwins As discussed during today's daily sync, I have restored the commit to the state where duplicate counting is eliminated using a Set.

Regarding performance optimization, we agreed to proceed after @chacha912 submit the related issue.

[chacha912]

Thanks for your contribution! I left a brief comment.
And thanks for reporting the bug in the GC logic. I will create a separate issue for this bug.

[justiceHui]

I modified the benchmark code with @devleejb test for the worst-case scenario of getGarbageLen using the Set, and benchmarked it with O(n log n) time implementation using sorting. In the image below, GC represents the getGarbageLen using Set, and new GC represents using sorting.

In this scenario, garbageCollect returns expected value, but if delete nodes without reverse the childList, it will return 2^(size-1).

const benchmarkSkewTreeGC = (size: number) => {
  const doc = new Document<{ a: any }>('test-doc');

  doc.update((root) => {
    let temp = root;
    const childList = [];
    for (let i = 0; i < size; i++) {
      temp.a = {};
      childList.push(temp);
      temp = temp.a;
    }
    for (const child of childList.reverse()) {
      delete child.a;
    }
  });

  assert.equal(size, doc.getGarbageLen());
  assert.equal(size, doc.garbageCollect(MaxTimeTicket));
};

[chacha912]

Thanks!

[hackerwins]

LGTM 👍