12:56 <beneroth> [OT] someone using the Microsoft (node.js-based) IDE Visual Studio Code? a number of malicious extensions were found on its official marketplace: https://blog.checkpoint.com/securing-the-cloud/malicious-vscode-extensions-with-more-than-45k-downloads-steal-pii-and-enable-backdoors/

14:05 <tankf33der> Hi all

14:06 <tankf33der> https://pkolaczk.github.io/memory-consumption-of-async/

14:06 <tankf33der> I want to write the same code for picolisp, let me try.

14:06 <abu[m]> Hi tankf33der! Very interesting!

14:07 <abu[m]> What kind of tasks are those? Not PicoLisp 'task', right?

14:08 <tankf33der> I think about task and co

14:09 <abu[m]> One million tasks needs one million file descriptors

14:10 <abu[m]> One million 'co' are possible, but you better set a smaller stack size

14:10 <abu[m]> e.g. (stack 2)

14:11 <abu[m]> Needs 2 GiB stack space then

14:15 <abu[m]> And: Use a pil >= (23 4 18), because it is a *lot* faster in 'yield' for larger numbers of coroutines

14:19 <tankf33der> I am always on latest.

14:40 <beneroth> cool interesting topic, I'm excited for your results, good luck and lots of fun tankf33der :)

14:40 <abu[m]> Yeah, I'm excited too

14:41 <abu[m]> Still, one million file descriptors are impossible ;)

14:42 <beneroth> well the tasks also sounds more like in line for 'co than processes

14:43 <beneroth> abu[m], what about processes but using (detach) after forking?

14:44 <abu[m]> True, that's possible. Good idea.

14:44 <abu[m]> But it looks it only needs timer tasks

14:45 <abu[m]> And not even 'tasks' I think

14:45 <abu[m]> Not sure

14:46 <abu[m]> In Pil, each 'task' needs a unique key. A negative number for timers.

14:47 <abu[m]> So it needs one million negative timers, which conflicts with the requirement that each task waits 10 secs

14:48 <abu[m]> I think this benchmark really just wants to test threads. Pil uses (fork) for that. So you are right, we need (fork) and (detach).

14:49 <abu[m]> (unless (fork) (detach) (wait 10000) (bye))

14:57 <beneroth> aye

14:59 <beneroth> processes are more heavy than threads, so especially the setup phase should take longer in pil, no? and 2MB per process minimum?

14:59 <beneroth> how was that with the minimum memory allocation per pil process?

14:59 <beneroth> (maybe not actually used, but allocated just in case)

15:00 <abu[m]> I do not think that processes are much heavier than threads. Only if they modify memory, the heap is copied

15:00 <abu[m]> Stack usage and kernel structures are the same

15:00 <beneroth> ok

15:01 <beneroth> what about the minimum memory allocation by the pil interpreter? only applies to the top process, or to every forked process too?

15:01 <beneroth> was it 2MB? or 20MB? something like that I believe I remember. I don't know.

15:01 <abu[m]> The memory is shared until modified

15:01 <beneroth> so only applies to top process

15:01 <abu[m]> Yes

15:02 <abu[m]> Must go

15:02 <beneroth> kk

15:02 <abu[m]> Back soon :)

15:02 <beneroth> take care :)

15:34 <abu[m]> yess :)

15:34 <abu[m]> Still, we cannot create so many processes

15:35 <abu[m]> This works

15:35 <abu[m]> (bench (do 10000 (wait 1) (unless (fork) (detach) (wait 10000) (bye))))

15:35 <abu[m]> But not more. Too many processes.

15:35 <abu[m]> We could use 'co' and 'pause' from @lib/simul.l

16:17 <abu[m]> I have a solution with 'co', put I don't want to spoil here

16:18 <abu[m]> Also, 'co' is probably not what is expected by the above task

16:48 <beneroth> well it's concurrency, but not parallelism.

16:48 <abu[m]> true

16:52 <abu[m]> In my solution I can go only till 10 tthousand, not a million. I need I KiB per coroutine, and run out of stack space

17:30 <tankf33der> will continue tomorrow.

17:31 <abu[m]> 👍