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

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

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.

> 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.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de