15:33 <satacker[m]> How do I launch hpx::async without new thread spawning for execution? (deferred policy? but don't know the semantics/usage)

15:33 <hkaiser> satacker[m]: why would you want to do that?

15:33 <hkaiser> async's task _is_ to create a new thread

15:36 <satacker[m]> Yes, I know it does not make sense, but just wanted to try if I can get a proper reasoning for a implementation problem which is described in detail on discord

15:37 <satacker[m]> s/a/an/

15:37 <hkaiser> if you don't need a new thread, just call the the function

15:39 <satacker[m]> But will it be the same thread as hpx's thread or will it be the thread where python's interpreter is or where will that be?

15:40 <hkaiser> not sure what you're asking - if you call a function then it will run on the same thread as the parent is running on

15:59 <satacker[m]> If I build it as a library and invoke it from another process (not a thread)?

16:29 <hkaiser> satacker[m]: you always run code on a thread, it's the main facility that executes operations

16:49 <Aarya[m]> hkaiser @hkaiser:libera.chat: Is this correctly starting and ending hpx runtime - https://github.com/light2802/hpxmp_meta/blob/main/hpx_example/hello.cpp

16:51 <satacker[m]> private*

16:53 <Aarya[m]> Sorry - https://pastebin.com/SLs3x8iD

16:55 <satacker[m]> <hkaiser> "satacker: you always run code on..." <- Yes i understand that, thanks. It is more complicated to understand how pybind11 is handling the ref count and managing lifetimes when entering a funciton (python) and then deleting it for example https://github.com/pybind/pybind11/blob/v2.10.4/include/pybind11/detail/type_caster_base.h#L68 . I could not figure out how to manage lifetime with hpx shared future

17:18 <hkaiser> Aarya[m]: no, disconnect doesn't do what you think, use finalize instead

17:19 <hkaiser> see https://hpx-docs.stellar-group.org/latest/html/manual/starting_the_hpx_runtime.html

17:19 <hkaiser> in particular: https://hpx-docs.stellar-group.org/latest/html/manual/starting_the_hpx_runtime.html#supply-your-own-main-hpx-entry-point-while-avoiding-blocking-the-main-thread

17:22 <Aarya[m]> Finalize isn't calling the shutdown functions though

17:23 <Aarya[m]> It says it should call in the docs

17:23 <Aarya[m]> But isn't

18:10 <hkaiser> Aarya[m]: finalize tells the runtime that it's ok to exit once no more work is available

18:11 <hkaiser> you still need to tell the threads that omp created that they should exit

18:17 <hkaiser> Aarya[m]: essentially do what the global destructor is doing anyways, just earlier

18:18 <hkaiser> I'd first call finalize and then invoke that functionality that makes the omp threads exit