Francesco Mecca ha written an experience report for the D Blog about his SAOC 2018 project, porting Leandro Lucarella's old GC from D1 to D2.

The blog:
https://dlang.org/blog/wp-admin/post.php?post=2148&action=edit

Reddit:
https://www.reddit.com/r/programming/comments/cgdk1r/symmetry_autumn_of_code_experience_report_porting/

https://dlang.org/blog/2019/07/22/symmetry-autumn-of-code-experience-report-porting-a-fork-based-gc/

On Monday, 22 July 2019 at 14:04:32 UTC, rikki cattermole wrote:
> https://dlang.org/blog/2019/07/22/symmetry-autumn-of-code-experience-report-porting-a-fork-based-gc/

Thanks!

On Monday, 22 July 2019 at 14:03:15 UTC, Mike Parker wrote:
> Francesco Mecca ha written an experience report for the D Blog about his SAOC 2018 project, porting Leandro Lucarella's old GC from D1 to D2.
>
> The blog:
> https://dlang.org/blog/wp-admin/post.php?post=2148&action=edit
>
> Reddit:
> https://www.reddit.com/r/programming/comments/cgdk1r/symmetry_autumn_of_code_experience_report_porting/

interesting idea do Mark phase through fork process.

I want more technical details:
- about Windows: will such idea work on Windows? does Windows support similar technique? (VirtualQueryEx/ReadProcessMemory/mmap/or_something)
- can GC-process run full time and just exchange with parent process about changes in memory configuration? or GC-process can not to see changes in parent process after fork? I mean GC-process can see snapshots of parent-process memory in realtime when it has just readonly-access.
- does GC-process uses some AA for building graph of objects or set Mark-bits in situ? in last case COW makes copies so memory differs and GC-process should be forked every GC-cycle.
- digits in PR benchmark scary me: max pause 969ms or 260ms. why not to use Golang-GC? Go-GC is non-compacting/non-moving GC that has STW(stop the world) ~10ms and Google can spend money to build best GC that can help to D-users too.

On Monday, 22 July 2019 at 14:03:15 UTC, Mike Parker wrote:
> Francesco Mecca ha written an experience report for the D Blog about his SAOC 2018 project, porting Leandro Lucarella's old GC from D1 to D2.
>
> The blog:
> https://dlang.org/blog/wp-admin/post.php?post=2148&action=edit
>
> Reddit:
> https://www.reddit.com/r/programming/comments/cgdk1r/symmetry_autumn_of_code_experience_report_porting/

Should have included mention of D in the title

On Monday, 22 July 2019 at 14:03:15 UTC, Mike Parker wrote:
> Francesco Mecca ha written an experience report for the D Blog about his SAOC 2018 project, porting Leandro Lucarella's old GC from D1 to D2.
>
> The blog:
> https://dlang.org/blog/wp-admin/post.php?post=2148&action=edit
>
OT: this link try to login me in WordPress and to redirect to D-blog
probably cuz "wp-admin" and "&action=edit" in URL

On 23/07/2019 3:58 AM, a11e99z wrote:
> On Monday, 22 July 2019 at 14:03:15 UTC, Mike Parker wrote:
>> Francesco Mecca ha written an experience report for the D Blog about his SAOC 2018 project, porting Leandro Lucarella's old GC from D1 to D2.
>>
>> The blog:
>> https://dlang.org/blog/wp-admin/post.php?post=2148&action=edit
>>
>> Reddit:
>> https://www.reddit.com/r/programming/comments/cgdk1r/symmetry_autumn_of_code_experience_report_porting/ 
>>
> 
> interesting idea do Mark phase through fork process.
> 
> I want more technical details:
> - about Windows: will such idea work on Windows? does Windows support similar technique? (VirtualQueryEx/ReadProcessMemory/mmap/or_something)

The problem with Windows is not so much reading another process memory, is the fact that you cannot create another process which is copied from your own memory space AND be able to have live threads running in it.

What we can do (which will be good for things like audio and game engines) is make the GC only suspend the current thread and read from a snapshot of the heap space of the process. This we can do.

Unfortunately I remembered that marking is a bit more complex than just locating memory a bit too late tonight. No wonder I never tried before now to implement this (I have evaluated it).

I may have another try at it, if somebody can give me pointers on where the actual reading occurs in the GC. Because it has left me a bit stumped.

On Monday, 22 July 2019 at 14:03:15 UTC, Mike Parker wrote:
> Francesco Mecca ha written an experience report for the D Blog about his SAOC 2018 project, porting Leandro Lucarella's old GC from D1 to D2.
>
> The blog:
> https://dlang.org/blog/wp-admin/post.php?post=2148&action=edit
>
> Reddit:
> > https://www.reddit.com/r/programming/comments/cgdk1r/symmetry_autumn_of_code_experience_report_porting/

A pull request to the D runtime was my final milestone. I was ready at the beginning of February, but I started to procrastinate. I’d had no previous communication with any of the reviewers and I was timorous about engaging with them. I spent a lot of time refactoring my code back and forth and delaying my pull request. At a certain point, I even considered abandoning the final milestone and providing the GC as a library. In the meantime, Rainer Scheutze published a threaded implementation of the mark phase that reduced the mark time in the GC and I lost faith in my project.

This seems like a major failure in the process that this was allowed to happen - good work almost went abandoned. How can we prevent this in future SAoC/GSoC? Without knowing what the mentor did/didn't do, an obvious answer seems like there should be a follow-up to ensure that the work done is actually getting in to the compiler/runtime/etc. To go so far and trip right at the finish line is unfortunate (glad to see that a PR is now open).

On Monday, 22 July 2019 at 20:57:19 UTC, Meta wrote:
> [snip]
>
> This seems like a major failure in the process that this was allowed to happen - good work almost went abandoned. How can we prevent this in future SAoC/GSoC? Without knowing what the mentor did/didn't do, an obvious answer seems like there should be a follow-up to ensure that the work done is actually getting in to the compiler/runtime/etc. To go so far and trip right at the finish line is unfortunate (glad to see that a PR is now open).

I've been really liking the progress updates that the GSoC students are doing this year.

On Monday, 22 July 2019 at 20:57:19 UTC, Meta wrote:
> On Monday, 22 July 2019 at 14:03:15 UTC, Mike Parker wrote:
>> > [...]
>
> A pull request to the D runtime was my final milestone. I was ready at the beginning of February, but I started to procrastinate. I’d had no previous communication with any of the reviewers and I was timorous about engaging with them. I spent a lot of time refactoring my code back and forth and delaying my pull request. At a certain point, I even considered abandoning the final milestone and providing the GC as a library. In the meantime, Rainer Scheutze published a threaded implementation of the mark phase that reduced the mark time in the GC and I lost faith in my project.
>
> [...]

at the dconf I had the possibility to talk about this with many people and I think that so far we are witnessing major improvements regarding the GSOC students.