How to make tasks to run in parallel

How to make tasks to run in parallel

[reinert]

Hi,

The test program below includes two tasks. The first task gets an "argument" (input data) via a discriminant. The other task gets data via entry/accept. The first task runs easily in parallel. The other not.

I would prefer to enter data via entry/accept. But is it possible without giving up parallel processing? I feel it is something I should understand better here :-)

reinert


with Text_IO;       use Text_IO;
with Ada.Numerics.Generic_Elementary_Functions;
with Ada.Text_IO;
procedure ttest1 is
  type Real is new Float;
  package Flt_Io is new Text_IO.Float_Io   (Real);
  package Int_Io is new Text_IO.Integer_Io (Integer);
  package E_F is new Ada.Numerics.Generic_Elementary_Functions (Real);
  use E_F,Flt_Io,Int_Io;

  N : constant Integer := 10_000_000;

-- ---------------------------------------------------------------------------
  task type test1_t(a : access real);

  task body test1_t is
      x : real := a.all;
  begin
-- stupid time consuming loop:
      for I in 1 .. N loop
          x := x + Real(I)/Real(N);
          x := 0.5*x + 1.0 + sin(x)*cos(x) + sin(x) + cos(x) +
                             sin(x)*sin(x) + cos(x)*cos(x);
      end loop;
      new_line;Put("test1 x:");Put (x,4,16,0); New_Line (1);
  end test1_t;
-- ---------------------------------------------------------------------------
  task type test2_t is
     entry run1(a : in real);
  end test2_t;

  task body test2_t is
    x : real;
  begin
      accept run1(a : in real) do
        x := a;
-- stupid time consuming loop:
        for I in 1 .. N loop
            x := x + Real(I)/Real(N);
            x := 0.5*x + 1.0 + sin(x)*cos(x) + sin(x) + cos(x) +
                             sin(x)*sin(x) + cos(x)*cos(x);
        end loop;
        new_line;Put("test2 x:");Put (x,4,16,0); New_Line (1);
        return;
      end run1;
  end test2_t;

  x : aliased real;
  y : real;
  dx,dy : constant := 0.5;

  test1 : array(1..4) of access test1_t;
  test2 : array(1..4) of access test2_t;
-- ---------------------------------------------------------------------------

begin

-- This goes in parallel:
     x := 1.0;
     for e of test1 loop
         x := x + dx;
         Put_Line(" Test1: ");
         e := new test1_t(a => x'access);
     end loop;

-- This goes *not* in parallel (why?):
     y := 1.0;
     for e of test2 loop
         y := y + dy;
         Put_Line(" Test2: ");
         e := new test2_t;
         e.run1(y);
     end loop;

end ttest1;

Re: How to make tasks to run in parallel

[gautier_niouzes]

Just move "end run1" just after "x := a"

      accept run1(a : in real) do
        x := a;
      end run1;

Between "accept" and "end run1" it is a rendezvous: the calling task and task test2_t are flirting together and passing messages; after the rendezvous they do their jobs separately, possibly in parallel.
BTW: for a real program, don't use Float, use Long_Float!...

HTH
Gautier
_____________________________________________________________
A free online game in Ada: http://pasta.phyrama.com/game.html
New: High Scores lists!

Re: How to make tasks to run in parallel

[Per Sandberg]

It won't run in parallel since all the computations are done within the 
roundevouz where both tasks are are running "in the same thread".
And also why a private Real type when there is a general Float.
Have a look on the updated code.
/P
----------------------------
with Ada.Text_IO;
with Ada.Integer_Text_IO;
with Ada.Float_Text_IO;
with Ada.Numerics.Elementary_Functions;

procedure Main is

    use Ada.Text_IO;
    use Ada.Integer_Text_IO;
    use Ada.Float_Text_IO;
    use Ada.Numerics.Elementary_Functions;

    N : constant Integer := 10_000_000;

    -- 
---------------------------------------------------------------------------
    task type Test1_T (A : access Float);

    task body Test1_T is
       X : Float := A.all;
    begin
       -- stupid time consuming loop:
       for I in 1 .. N loop
          X := X + Float (I) / Float (N);
          X := 0.5 * X + 1.0 + Sin (X) * Cos (X) + Sin (X) + Cos (X) +
            Sin (X) * Sin (X) + Cos (X) * Cos (X);
       end loop;
       New_Line; Put ("test1 x:"); Put (X, 4, 16, 0); New_Line (1);
    end Test1_T;
    -- 
---------------------------------------------------------------------------
    task type Test2_T is
       entry Run1 (A : in Float);
    end Test2_T;

    task body Test2_T is
       X : Float;
    begin
       accept Run1 (A : in Float) do
          X := A;
       end Run1;
       -- stupid time consuming loop:
       for I in 1 .. N loop
          X := X + Float (I) / Float (N);
          X := 0.5 * X + 1.0 + Sin (X) * Cos (X) + Sin (X) + Cos (X) +
            Sin (X) * Sin (X) + Cos (X) * Cos (X);
       end loop;
       New_Line; Put ("test2 x:"); Put (X, 4, 16, 0); New_Line (1);
    end Test2_T;

    X     : aliased Float;
    Y     : Float;
    Dx, Dy : constant := 0.5;

    Test1 : array (1 .. 4) of access Test1_T;
    Test2 : array (1 .. 4) of access Test2_T;
    -- 
---------------------------------------------------------------------------

begin

    -- This goes in parallel:
    X := 1.0;
    for E of Test1 loop
       X := X + Dx;
       Put_Line (" Test1: ");
       E := new Test1_T (A => X'Access);
    end loop;

    Y := 1.0;
    for E of Test2 loop
       Y := Y + Dy;
       Put_Line (" Test2: ");
       E := new Test2_T;
       E.Run1 (Y);
    end loop;

end Main;
---------------------------------------------------------------------





Den 2017-10-17 kl. 06:58, skrev reinert:
> Hi,
> 
> The test program below includes two tasks. The first task gets an "argument" (input data) via a discriminant. The other task gets data via entry/accept. The first task runs easily in parallel. The other not.
> 
> I would prefer to enter data via entry/accept. But is it possible without giving up parallel processing? I feel it is something I should understand better here :-)
> 
> reinert
> 
> 
> with Text_IO;       use Text_IO;
> with Ada.Numerics.Generic_Elementary_Functions;
> with Ada.Text_IO;
> procedure ttest1 is
>    type Real is new Float;
>    package Flt_Io is new Text_IO.Float_Io   (Real);
>    package Int_Io is new Text_IO.Integer_Io (Integer);
>    package E_F is new Ada.Numerics.Generic_Elementary_Functions (Real);
>    use E_F,Flt_Io,Int_Io;
> 
>    N : constant Integer := 10_000_000;
> 
> -- ---------------------------------------------------------------------------
>    task type test1_t(a : access real);
> 
>    task body test1_t is
>        x : real := a.all;
>    begin
> -- stupid time consuming loop:
>        for I in 1 .. N loop
>            x := x + Real(I)/Real(N);
>            x := 0.5*x + 1.0 + sin(x)*cos(x) + sin(x) + cos(x) +
>                               sin(x)*sin(x) + cos(x)*cos(x);
>        end loop;
>        new_line;Put("test1 x:");Put (x,4,16,0); New_Line (1);
>    end test1_t;
> -- ---------------------------------------------------------------------------
>    task type test2_t is
>       entry run1(a : in real);
>    end test2_t;
> 
>    task body test2_t is
>      x : real;
>    begin
>        accept run1(a : in real) do
>          x := a;
> -- stupid time consuming loop:
>          for I in 1 .. N loop
>              x := x + Real(I)/Real(N);
>              x := 0.5*x + 1.0 + sin(x)*cos(x) + sin(x) + cos(x) +
>                               sin(x)*sin(x) + cos(x)*cos(x);
>          end loop;
>          new_line;Put("test2 x:");Put (x,4,16,0); New_Line (1);
>          return;
>        end run1;
>    end test2_t;
> 
>    x : aliased real;
>    y : real;
>    dx,dy : constant := 0.5;
> 
>    test1 : array(1..4) of access test1_t;
>    test2 : array(1..4) of access test2_t;
> -- ---------------------------------------------------------------------------
> 
> begin
> 
> -- This goes in parallel:
>       x := 1.0;
>       for e of test1 loop
>           x := x + dx;
>           Put_Line(" Test1: ");
>           e := new test1_t(a => x'access);
>       end loop;
> 
> -- This goes *not* in parallel (why?):
>       y := 1.0;
>       for e of test2 loop
>           y := y + dy;
>           Put_Line(" Test2: ");
>           e := new test2_t;
>           e.run1(y);
>       end loop;
> 
> end ttest1;
> 

Re: How to make tasks to run in parallel

[gautier_niouzes]

> And also why a private Real type when there is a general Float.

Probably Reinert meant rather "subtype Real is Float".
And it is very useful, especially when you discover that the chosen floating-point type is too inaccurate: you just need to change a few characters in a single line of code...

G.

Re: How to make tasks to run in parallel

[reinert]

Yes yes... 

On Tuesday, October 17, 2017 at 8:08:05 AM UTC+2, gautier...@hotmail.com wrote:
> Just move "end run1" just after "x := a"
> 
>       accept run1(a : in real) do
>         x := a;
>       end run1;
> 
> Between "accept" and "end run1" it is a rendezvous: the calling task and task test2_t are flirting together and passing messages; after the rendezvous they do their jobs separately, possibly in parallel.
> BTW: for a real program, don't use Float, use Long_Float!...
> 
> HTH
> Gautier
> _____________________________________________________________
> A free online game in Ada: http://pasta.phyrama.com/game.html
> New: High Scores lists!

Re: How to make tasks to run in parallel

[Dmitry A. Kazakov]

On 17/10/2017 06:58, reinert wrote:

> I would prefer to enter data via entry/accept. But is it possible
> without giving up parallel processing? I feel it is something I should
> understand better here :-)

    select
       accept run1(a : in real) do
         x := a; -- Store parameter and let the caller go
       end run1;
       for I in 1 .. N loop -- Do the work concurrently
         x := x + Real(I)/Real(N);
         x := 0.5*x + 1.0 + sin(x)*cos(x) + sin(x) + cos(x) +
                            sin(x)*sin(x) + cos(x)*cos(x);
       end loop;
       new_line;Put("test2 x:");Put (x,4,16,0); New_Line (1);
    or terminate; -- Exit if the parent does
    end select;

First, as others mentioned, you should not do concurrent work in the 
rendezvous. Second, add "terminate" to let the task exit even if "run1" 
was never called.

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

Re: How to make tasks to run in parallel

[reinert]

On Tuesday, October 17, 2017 at 8:30:06 AM UTC+2, gautier...@hotmail.com wrote:
> > And also why a private Real type when there is a general Float.
> 
> Probably Reinert meant rather "subtype Real is Float".
> And it is very useful, especially when you discover that the chosen floating-point type is too inaccurate: you just need to change a few characters in a single line of code...
> 
> G.

It sometimes use:
"type Real is Digits 18;"

I see the point (sometimes) using "substype" here. But I also like to avoid to add meter and seconds :-) I.e. to be "clean" with respect to dimensions/units.

reinert 

Re: How to make tasks to run in parallel

[reinert]

On Tuesday, October 17, 2017 at 9:29:02 AM UTC+2, Dmitry A. Kazakov wrote:
> On 17/10/2017 06:58, reinert wrote:
> 
....
> 
> First, as others mentioned, you should not do concurrent work in the 
> rendezvous. Second, add "terminate" to let the task exit even if "run1" 
> was never called.

uups, thanks, 
reinert


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

Re: How to make tasks to run in parallel

[Dmitry A. Kazakov]

On 17/10/2017 09:32, reinert wrote:

> It sometimes use:
> "type Real is Digits 18;"
> 
> I see the point (sometimes) using "substype" here. But I also like to
> avoid to add meter and seconds :-) I.e. to be "clean" with respect
> to  dimensions/units.

GNAT has a non-standard dimension aspect which does that.

But that is a wrong approach. Dimension cannot be made a part of the 
type. Because that would preclude major use cases where dimensioned 
values are actually used. Dimension should be subtype constraint.

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

Re: How to make tasks to run in parallel

[Niklas Holsti]

On 17-10-17 10:47 , Dmitry A. Kazakov wrote:
> On 17/10/2017 09:32, reinert wrote:
>
>> It sometimes use:
>> "type Real is Digits 18;"
>>
>> I see the point (sometimes) using "substype" here. But I also like to
>> avoid to add meter and seconds :-) I.e. to be "clean" with respect
>> to  dimensions/units.
>
> GNAT has a non-standard dimension aspect which does that.
>
> But that is a wrong approach.

By "that", did you mean the GNAT approach? Or the approach suggested by 
reinert, using different types?

> Dimension cannot be made a part of the
> type. Because that would preclude major use cases where dimensioned
> values are actually used. Dimension should be subtype constraint.

AdaCore agree with you: the GNAT Dimension aspect is per subtype, not 
per type.

https://gcc.gnu.org/onlinedocs/gnat_rm/Aspect-Dimension.html

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .

Re: How to make tasks to run in parallel

[Dmitry A. Kazakov]

On 17/10/2017 10:06, Niklas Holsti wrote:

> By "that", did you mean the GNAT approach? Or the approach suggested by 
> reinert, using different types?

Yes.

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

Re: How to make tasks to run in parallel

[reinert]

On Tuesday, October 17, 2017 at 9:47:11 AM UTC+2, Dmitry A. Kazakov wrote:
> On 17/10/2017 09:32, reinert wrote:
> 
> > It sometimes use:
> > "type Real is Digits 18;"
> > 
> > I see the point (sometimes) using "substype" here. But I also like to
> > avoid to add meter and seconds :-) I.e. to be "clean" with respect
> > to  dimensions/units.
> 
> GNAT has a non-standard dimension aspect which does that.
> 
> But that is a wrong approach. Dimension cannot be made a part of the 
> type. Because that would preclude major use cases where dimensioned 
> values are actually used. Dimension should be subtype constraint.
> 
> -- 
> Regards,
> Dmitry A. Kazakov
> http://www.dmitry-kazakov.de

I may have learned several thing before the evening :-) 

My current understanding of Ada is mainly from John Barnes, "Programming in Ada 2012".  On page 243 he introduces new (derived) types for number of apples and oranges, so one can write:

No_Of_Apples := No_Of_Apples + 1;
No_Of_Oranges := No_Of_Oranges + 1;

But one cannot write:

No_Of_Apples := No_Of_Oranges + 1; -- error

Using derived types here seems "clean" to me and contributing to avoid future errors.

reinert

Re: How to make tasks to run in parallel

[Dmitry A. Kazakov]

On 17/10/2017 11:06, reinert wrote:

> My current understanding of Ada is mainly from John Barnes,
> "Programming in Ada 2012". On page 243 he introduces new (derived) types
> for number of apples and oranges, so one can write:
> 
> No_Of_Apples := No_Of_Apples + 1;
> No_Of_Oranges := No_Of_Oranges + 1;
> 
> But one cannot write:
> 
> No_Of_Apples := No_Of_Oranges + 1; -- error
> 
> Using derived types here seems "clean" to me and contributing to avoid future errors.

This is not how dimensioned values are used in practice. The problem is 
that you frequently need No_Of_Fruits too.

    No_Of_Fruits := No_Of_Apples + No_Of_Oranges; -- This is OK

For dimensions consider writing a dimensioned calculator, GUI, DB 
storage, communication protocol etc.

In terms of types, one need to have values of any, unspecified at 
compile time, dimension. This is like a class-wide value which may have 
any tag or an unconstrained value, e.g. String which may have any 
length. I leave the question whether the dimension of an object may 
change. That is not so important for numbers (by-value things), however 
less so in the case dimensioned containers (vectors, matrices etc 
by-reference stuff). Anyway, one could go along with immutable 
dimensions, but static-only dimensions is a non-starter.

When unconstrained dimensioned values are manipulated, the dimensions 
must be checked dynamically. When statically constrained values are, the 
dimensions better be checked statically.

This is very difficult to achieve. Existing solutions are either fully 
dynamic or fully static. The latter is unusable for practical purposes, 
e.g. in automation and control systems. The former is inefficient and 
statically unsafe when dimensions are indeed known.

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

Re: How to make tasks to run in parallel

[Simon Wright]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:

> On 17/10/2017 10:06, Niklas Holsti wrote:
>
>> By "that", did you mean the GNAT approach? Or the approach suggested
>> by reinert, using different types?
>
> Yes.

Or No.

Re: How to make tasks to run in parallel

[Dmitry A. Kazakov]

On 17/10/2017 13:13, Simon Wright wrote:
> "Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> writes:
> 
>> On 17/10/2017 10:06, Niklas Holsti wrote:
>>
>>> By "that", did you mean the GNAT approach? Or the approach suggested
>>> by reinert, using different types?
>>
>> Yes.
> 
> Or No.

No, yes. (:-))

Aspect dimension is only partially a subtype. It is a subtype in the 
sense that it supports mixed operations [*]. But it lacks the base type 
with values of its own. (And for that matter, it cannot handle irregular 
(km/h, Celsius degree) and prefixed units (ms) essential for a great 
number of applications)

---------------------------------
* The operations could simply be overloaded with the same effect.

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

Re: How to make tasks to run in parallel

[AdaMagica]

For a review of Physical Units with Gnat, see
http://ada-europe.org/archive/auj/auj-35-1.pdf, p. 42

For a general overview of dimensioned Ada, see
http://www.christ-usch-grein.homepage.t-online.de/Ada/Dimension/Dimension.html

Re: How to make tasks to run in parallel

[Jeffrey R. Carter]

On 10/17/2017 08:08 AM, gautier_niouzes@hotmail.com wrote:
> BTW: for a real program, don't use Float, use Long_Float!...

BTW, for a real program, never use Long_Float, as it's not guaranteed to exist.

-- 
Jeff Carter
"I'm a kike, a yid, a heebie, a hook nose! I'm Kosher,
Mum! I'm a Red Sea pedestrian, and proud of it!"
Monty Python's Life of Brian
77

Re: How to make tasks to run in parallel

[Jacob Sparre Andersen]

gautier_niouzes@hotmail.com writes:

> BTW: for a real program, don't use Float, use Long_Float!...

For a real program you use application defined types matching the
requirements of the problem.

Greetings,

Jacob
-- 
Scripts for automating parts of the daily
operations of your Linux system:
                    http://edb.jacob-sparre.dk/tcsh-samling/