<html><head><meta http-equiv="Content-Type" content="text/html charset=iso-8859-1"></head><body style="word-wrap: break-word; -webkit-nbsp-mode: space; -webkit-line-break: after-white-space; "><br><div><div>On Sep 19, 2013, at 12:52 PM, Bin Huang <<a href="mailto:bin.arthur@gmail.com">bin.arthur@gmail.com</a>> wrote:</div><br class="Apple-interchange-newline"><blockquote type="cite"><div dir="ltr">Thanks, Rich. What I did not fully understand before was that the tasklets are all part of the one thread. </div></blockquote><div><br></div><div>Hm. Tasklets are not precisely "all part of one thread" -- however (see below) they might as well be for</div><div>purposes of multi-core utilization.</div><br><blockquote type="cite"><div dir="ltr">I just found the stackless SVN repository with talks and documents in google code. Those are excellent resources for me to understand the stackless. And I suggest putting a link to the SVN repository on <a href="http://www.stackless.com/">www.stackless.com</a>. Or maybe not if <a href="http://www.stackless.com/">www.stackless.com</a> is depleted... <div>
<br></div><div>Now my question is, how can stackless take advantage of multiple cores on my machine since there is essentially only one thread? </div></div></blockquote><div><br></div><div>The first question should be "how can *python* take advantage of multiple cores..."</div><div><br></div><div>The simple answer is that it cannot (at least in a single interpreter instance) -- except for a few  borderline cases for overlapped IO or non-python accessing extensions.</div><div>This is due to something called the Global Interpreter Lock (GIL) -- you can read a lot about this merely by searching google for "python gil" (more than we can, or should, say here).   </div><div><br></div><div>Since stackless is "layered" on Python, it inherits this behavior as a basic assumption.</div><br><blockquote type="cite"><div dir="ltr"><div>Tasklet is designed to reduce overhead but not for parallel hardware, right? It seems natural to me to combine stackless with classic 'threading' and 'multiprocessing' modules in Python, which is hinted by the examples in the SVN repository. But I haven't found any document talking about this issue yet.</div></div></blockquote><div><br></div>As you mention there are many methods for working around the basic problem, mostly involving</div><div>moving computation (perhaps by serializing/unserializing tasklets) into separate Python interpreter instances.</div><div>The difficulty is that the overhead of serialization may, in many use cases, simply overwhelm any performance</div><div>you would gain by core utilization.</div><div><br></div><div><blockquote type="cite"><div dir="ltr"><div><div><br></div><div>Thanks.</div><div><br></div></div></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Wed, Sep 18, 2013 at 1:32 PM, Richard Tew <span dir="ltr"><<a href="mailto:richard.m.tew@gmail.com" target="_blank">richard.m.tew@gmail.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">You have to run the scheduler to get tasklets to run and be switched<br>
between.  Remember that the tasklets are all part of the one thread<br>
they are running on.  So you need to run the thread, to run the<br>
tasklets.  If you use some external functionality to block the thread,<br>
then the thread is going to be... blocked.  It will not be able to run<br>
your code, which runs the scheduler.  nanosleep, whatever that is,<br>
obviously blocks the thread until it completes.<br>
<br>
If you need to make a single tasklet sleep, then you need to write<br>
further logic to more intelligently run the scheduler.  Or you can<br>
install stacklesslib, which has implemented this functionality<br>
already.<br>
<div><div class="h5"><br>
<br>
On 9/19/13, Bin Huang <<a href="mailto:bin.arthur@gmail.com">bin.arthur@gmail.com</a>> wrote:<br>
> Hi list,<br>
><br>
> I am working on a project that is based on stackless Python. I tried to<br>
> suspend the execution of a stackless tasklet from a Python C module<br>
> extension by calling nanosleep(). The Python C module that calls<br>
> nanosleep() is embedded inside the tasklet handler. However, my approach<br>
> does not work as I expected. It seems that the entire stackless interpreter<br>
> is suspended. And all tasklets had to delay (instead of sleeping) for the<br>
> interval time I assigned to nanosleep(). (I tried up to 10 second interval<br>
> so I could clearly see it).<br>
><br>
> I also tried using sleep() in the Python C module extension and I observed<br>
> the same phenomenon.<br>
><br>
> I know I could use stackless.schedule() to suspend a tasklet. But I am<br>
> still interested in why nanosleep() did not work in my experiment. Is it<br>
> because nanosleep() suspend the execution of the stackless scheduler?<br>
><br>
> I can post my source code if needed. Thanks in advance.<br>
><br>
> Bin<br>
><br>
<br>
</div></div>_______________________________________________<br>
Stackless mailing list<br>
<a href="mailto:Stackless@stackless.com">Stackless@stackless.com</a><br>
<a href="http://www.stackless.com/mailman/listinfo/stackless" target="_blank">http://www.stackless.com/mailman/listinfo/stackless</a><br>
</blockquote></div><br></div>
_______________________________________________<br>Stackless mailing list<br><a href="mailto:Stackless@stackless.com">Stackless@stackless.com</a><br>http://www.stackless.com/mailman/listinfo/stackless</blockquote></div><br></body></html>