offbynull
commented
6 years ago Yes. If your coroutine suspends inside of synchronized blocks, those locks will automatically be unlocked when you suspend and re-locked when you continue.
However, I'm almost 100% sure your experiment won't give you the results you're expecting. Normal thread operations are already incredibly fast.
The real power of this project is the ability to serialize and version, not to speed up execution. Other people have tried to use coroutines to speed up. There's a framework called Quasar you can look at. It's still maintained but it makes some questionable claims and never really took off.
Quasar's author now works on Java. He's trying to make coroutines a built-in language feature. I'm trying to help with that effort, but it remains to be seen if that ends up happening.
On Jan 20, 2018 1:07 PM, "publicocean0" notifications@github.com wrote:
My idea is to use many coroutines instead to use many threads because it is more scalable. Consider i realize a scheduler in which i can push many coroutines. Pratically it is a coroutines pool inside the same thread.
When a corotuine is blocked by a wait() instruction(inside a synchronized block) it is not necessary to block the thread but it is sufficient to suspend the coroutine. When a corotuine is suspended , it is taken another coroutine ready to be resumed. In this way the thread is never blocked ... and the global performance will be very hight.
For this reason is important to instrument synchronized blocks. I read notes in your page that you instrument synchonized blocks. Do you instrument synchononized blocks for suspending/resuming coroutines automatically?
— You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub https://github.com/offbynull/coroutines/issues/80, or mute the thread https://github.com/notifications/unsubscribe-auth/AGD4Ikto9vEF34_SYH3SMW9Wqaxs4f7eks5tMlWBgaJpZM4RllgP .
publicocean0
My idea is to use many coroutines instead to use many threads because it is more scalable. Consider i realize a scheduler in which i can push many coroutines. Pratically it is a coroutines pool inside the same thread(in a more generic model the coroutine pool is over a pool of threads running , threads number is equals to cpus in the machine).
When a corotuine is blocked by a wait() instruction(inside a synchronized block) it is not necessary to block the thread but it is sufficient to suspend the coroutine. When a corotuine is suspended , it is taken another coroutine ready to be resumed. In this way the thread is never blocked ... and the global performance will be very hight.
For this reason is important to instrument synchronized blocks. I read notes in your page that you instrument synchonized blocks. Do you instrument synchononized blocks for suspending/resuming coroutines automatically?