Re: RFC: Prototype for a user threading library in Ada

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:nknrui$15bn$1@gioia.aioe.org...
> On 2016-06-26 05:21, Randy Brukardt wrote:
>> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message
>> news:nkl8bm$19q7$1@gioia.aioe.org...
>>> On 2016-06-24 02:38, rieachus@comcast.net wrote:
>>>> I don't get it.  If this is your "motivation":
>>>>
>>>>> The motivation is a two-liner. Let you have some consumer of data:
>>>>>
>>>>>    procedure Write (Buffer : String; Last : out Integer);
>>>>>
>>>>> It may take less than the whole string when called, but will take more
>>>>> data later. So, the parameter Last. Now you want to write a program in 
>>>>> a
>>>>> *normal* way:
>>>>>
>>>>>    Write ("This");
>>>>>    Write ("That");
>>>>>
>>>>> That's it.
>>>>
>>>> You may want to make your Last parameter in or in out, but that's a
>>>> detail.
>>>
>>> It is not a detail. The caller of Write does not know how much data the
>>> transport layer is ready to accept. That is the nature of non-blocking
>>> I/O. Write takes as much data it can and tells through Last where the
>>> caller must continue *later*.
>>>
>>> A blocking busy-waiting wrapper looks this way:
>>>
>>>    procedure Write (Buffer : String) is
>>>       First : Integer := Buffer'First;
>>>       Last  : Integer;
>>>    begin
>>>       loop
>>>          Write (Buffer (First..Buffer'Last), Last);
>>>          exit when Last = Buffer'Last;
>>>          First := Last + 1;
>>>       end loop;
>>>    end Write;
>>
>> You forgot the "delay 0.0;"
>
> I didn't. With yielding processor it would no more be busy-waiting.

Nothing wrong with busy-waiting; it gets a bad rep.

>> That, combined with proper tasking runtimes, would seem to provide better
>> results than doing all one thing (task = thread) or all othe ther (some
>> fancy coroutine system).
>
> Not really. The whole point is that in the imaginary case under 
> consideration you don't need a timer event in order to wake Write up. I 
> presume that there is an I/O event that tells this:
>
>    procedure Write (Buffer : String) is
>       First : Integer := Buffer'First;
>       Last  : Integer;
>    begin
>       loop
>          Write (Buffer (First..Buffer'Last), Last);
>          exit when Last = Buffer'Last;
>          First := Last + 1;
>          Output_Buffer.Wait_For_State (Not_Full); -- A PO's entry call
>       end loop;
>    end Write;
>
> Now the code is exactly same for a task and a co-routine. What is left is 
> the overhead of thread scheduling to remove.

I agree this is better than using Yield. If this sort of formulation is 
possible, it ought to be used. And then there is no problem -- there's no 
thread scheduling overhead with Janus/Ada, 'cause there are no threads! :-)

Seriously, I'm thinking that thread scheduling overhead could be 
reduced/eliminated by the task supervisor, and thus there's no real problem 
with writing Ada tasks this way -- except of course that existing 
implementations don't try to do this sort of optimization.

Or I could just be mad. :-) [When it comes to tasking, I know just enough to 
be dangerous. ;-)]

                               Randy.