05:49 <Arnav-Negi> In the asynchronous IO project, what exactly does a use case refer to? Is the goal to make a module for async IO?

05:57 <satacker[m]> <Arnav-Negi> "In the asynchronous IO project..." <- I did not think of having it as a module, do we need such a module hkaiser: ?

05:57 <satacker[m]> As far as the use case is concerned, there is a reference paper attached that describes a use case very nicely, did you go through it?

06:01 <matrixb01x> is there any sample of previous year proposals for STELLAR

06:02 <matrixb01x> satacker

06:04 <satacker[m]> https://docs.google.com/document/d/15BBkabJE600V0477QLXU3pfXcXWt7JPuvkhEXejOZ0c/edit?usp=drivesdk

06:04 <satacker[m]> This one is mine

06:05 <matrixb01x> thanks

06:14 <matrixb01x> can anyone tell me what could be pitfalls/issues in a python wrapper for cpp lib ? gonidelis[m]

06:15 <gonidelis[m]> matrixb01x: templates ;)

06:17 <gonidelis[m]> https://en.wikipedia.org/wiki/Just-in-time_compilation

06:17 <gonidelis[m]> rtohid: can tell you more on that

06:17 <gonidelis[m]> there is room for exploration space though

06:20 <gonidelis[m]> there is space for exploration I meant

06:21 <satacker[m]> IMHO - Designing an interface that leverages the benefits of python and provides the efficient backend of HPX is the core of this project. Although stating the obvious part, it's important to clarify that it's not easy to simply wrap things around with pybind11/boost python/tolc automatic binding generation, the interface that the python wrapper will provide matters the most.

06:36 <Arnav-Negi> Hi sorry for the late reply satacker, my I had to charge my laptop. I was reading up on the tools but will be reading the paper today. So will the project be an implementation of such a paper in hpx?

06:38 <satacker[m]> Not a paper, haven't thought that far. For now you should focus on what the non-trivial example should be.

06:39 <satacker[m]> Also that paper is already implemented and it's link is in the references.

07:08 <gonidelis[m]> K-ballo: https://godbolt.org/z/E1beo9ExT where does `suffix` dangle?

07:10 <matrixb01x> what problems JIT can have in the wrapping hpx . I dont get it  rtohid[m]

07:16 <gonidelis[m]> jit might be needed when using python to execute generic code

08:15 <K-ballo> gonidelis[m]: the by-ref capture in the lambda

08:15 <K-ballo> it says so in the comments already

08:21 <gonidelis[m]> Ah, suffix is captured by ref

08:21 <gonidelis[m]> And then what?

08:22 <gonidelis[m]> Suffix is Destroyed ?

08:29 <K-ballo> the temporary it points to is

19:35 <gonidelis[m]> K-ballo: the temporary being {3,4}

19:35 <gonidelis[m]> why is it destroyed?

19:36 <gonidelis[m]> what does the lambda by-ref capture have to do with an external temporary being destroyed

19:38 <gonidelis[m]> impov:... (full message at <https://libera.ems.host/_matrix/media/v3/download/libera.chat/3bfb996195f358e3ad2fa323454ecc0f38a7343e>)

19:40 <gonidelis[m]> hkaiser: too

19:40 <hkaiser> have some code?

19:42 <gonidelis[m]> K-ballo: https://godbolt.org/z/E1beo9ExT where does `suffix` dangle?

19:43 <hkaiser> well {3, 4} goes out of scope at the semicolon in line 31

19:49 <gonidelis[m]> so the by-ref capture is not even a problem

19:50 <gonidelis[m]> how is it being used afterwards then? should be kept as internal state smh in order to be used in line 35 (obvisouly it isn't)

19:51 <hkaiser> the lambda captures a reference to the argument and refers to it after the argument went out of scope

19:55 <gonidelis[m]> wow

19:56 <gonidelis[m]> so again, the problem is passing a temporary as a function argument as a `const&`

19:56 <hkaiser> no

19:56 <hkaiser> the problem is capturing a reference to a reference in this case

19:56 <gonidelis[m]> i regretted it as soon as i type it

19:56 <gonidelis[m]> ok

19:57 <hkaiser> capturing by value would do the trick

19:58 <hkaiser> capturing a reference like here is not wrong, it is just dangerous as the user has to ensure the object the reference is referring to is kept alive long enough

19:59 <gonidelis[m]> cause suffix would refer to it in the beginning, and then it would be copied over in the lambda. whereas now, suffix refers to it (the temporary) and then lambda refers to it. but then line 31 ends and after the semicolon, the temp does not exist no more, so it's UB

20:00 <gonidelis[m]> lambda refers to its reference ^^

20:02 <gonidelis[m]> final takeaway, when capturing by ref make sure your thingy remains alive long enough

20:02 <gonidelis[m]> ¯_(ツ)_/¯

20:44 <Arnav-Negi> Hi I wanted to check if I am understanding the 'use case' required for the async IO project correctly

20:44 <Arnav-Negi> So for example in a video game when multiple models are loaded (eg. .glb files) this requires I/O which can be dealt with asynchronously

20:44 <Arnav-Negi> Is this a plausible use case for it

20:46 <Arnav-Negi> S/R can be used to schedule the read request for all the files on a thread pool and then they can be read and parsed in coroutines

20:46 <Arnav-Negi> as in https://pabloariasal.github.io/2022/11/13/couring-3/

21:05 <hkaiser> gonidelis[m]: btw, a better API design would have made this a bit more robust

21:06 <hkaiser> gonidelis[m]: https://godbolt.org/z/nsxhedd64

21:07 <hkaiser> Arnav-Negi: yes, that sounds plausib;e

21:10 <Arnav-Negi> Great, I will be moving forward with this use case then

21:10 <Arnav-Negi> Can I suggest more use cases if they strike me later?

21:11 <hkaiser> Arnav-Negi: the whole point of utilizing asynchrony (in IO and other places) is to enable the different pieces of hardware we have to work independently and concurrently

21:12 <hkaiser> but doing so is difficult in sequential programming models, so we have to find ways to do it in new ways, preferrably without making the programmers brain explode by requiring to write code in ways that are difficult to understand

21:13 <hkaiser> Arnav-Negi: yes, please do that

21:19 <Arnav-Negi> I see so the goal is to use S/R and coroutines to make asynchronous programming more readable?

21:19 <Arnav-Negi> Also how will the code written for the use cases be included in the hpx library? Maybe as an example?

21:27 <hkaiser> Arnav-Negi: yes, or as some applications demonstrating (and comparing) things

21:27 <hkaiser> readability, performance, functionality, etc.

21:30 <Arnav-Negi> I see thanks a lot!

21:32 <Arnav-Negi> One last question - Is it fine if I spend the first 2-3 weeks learning about S/R, coroutines and io_uring before I start implementing the use case?

21:33 <hkaiser> absolutely

21:34 <Arnav-Negi> Alright thanks!

21:51 <satacker[m]> It was my intention to demonstrate the usage of S/R facilities, coroutines and algorithms in HPX that are more efficient than std:: and other equivalents, all in one single example. An example that highlights such a case needs to be implemented. There are many (ig) coroutine examples that use io_uring and a few that use with S/R (of which we don't expect much performance benefit when used along with coroutines), but we don't have one that

21:51 <satacker[m]> uses HPX with the efficient algorithms it provides. Arnav-Negi

21:54 <satacker[m]> To find such an example would mean that you collect information about all of those and think of an example. I see that you need time for P2300. That's not an issue at all. However HPX should be understood beforehand because that's the whole point IMHO.

21:59 <Arnav-Negi> Thats alright I can see that the gsoc timeline has May 4 - 28 as time when we can read documentation and get up to speed

22:00 <Arnav-Negi> So I definitely will be able to read up on the algorithms hpx provides which might be useful for this

22:02 <satacker[m]> Without the plan for a concrete example there is no well defined scope, it would be best if we can decide it before deadline.

22:04 <Arnav-Negi> I see then for the example would using hpx in the couring blog by pablo arias be fine?

22:04 <Arnav-Negi> The one that I linked above

22:04 <Arnav-Negi> Or does the example have to be something different

22:05 <satacker[m]> It would be better if it's different.

22:06 <satacker[m]> To make this even more interesting hkaiser has implemented hpx::generator

22:08 <satacker[m]> You don't need to rush into anything, think it over, if you want you might as well discuss other projects until you get a good example.

22:18 <Arnav-Negi> Alright sure I'll look into it more

22:34 <Arnav-Negi> So I was thinking that games need to be responsive, so with coroutines we can suspend and process frames during I/O so that it doesn't feel like the game is lagging while it loads them.

22:35 <Arnav-Negi> We can use hpx algorithms in tandem with this

22:38 <satacker[m]> I don't think we can process frames, it is not an I/O operation that you can rely on using coroutines and requires much speed and low latency.

22:57 <Arnav-Negi> Is there an example on parallelized FFT?

22:58 <Arnav-Negi> I was looking into implementing it for the project "implement your favourite algorithm in hpx"