Re: GNAT and Tasklets

[Brad Moore <brad.moore@shaw.ca>]

On 2014-12-21 2:35 PM, tmoran@acm.org wrote:
> Is it the intent that parallel blocks would be used, for instance,
> for Quicksort?
>
>      parallel
>         Sort(A(A'first .. Pivot-1));
>      and
>         Sort(A(Pivot+1 .. A'last));
>      end parallel;
>

Yes, exactly.

A full version (adapted from the parallel blocks Paraffin example) might be

procedure Quicksort
   (Container : in out Array_Type)
is

    procedure Swap (L, R : Index_Type);
    pragma Inline (Swap);

    procedure Parallel_Quicksort
      (Left, Right : Index_Type)
    is

       I : Index_Type'Base := Left;
       J : Index_Type'Base := Right;

       Pivot : constant Element_Type
         := Container
           (Index_Type'Val
                (Index_Type'Pos (Container'First) +
                 ((Index_Type'Pos (Left) +
                      Index_Type'Pos (Right)) / 2) - 1));

       use type Parallel.Local.CPU_Count;

    begin -- Parallel_Quicksort

       while I <= J loop

          while Container (I) < Pivot loop
             I := Index_Type'Succ (I);
          end loop;

          while Pivot < Container (J) loop
             J := Index_Type'Pred (J);
          end loop;

          if I <= J then

             Swap (I, J);

             I := Index_Type'Succ (I);
             J := Index_Type'Pred (J);
          end if;

       end loop;

       parallel
          if Left < J then
             Parallel_Quicksort (Left, J);
          end if;
       and
          if I < Right then
             Parallel_Quicksort (I, Right);
          end if;
       end parallel;

    end Parallel_Quicksort;

    procedure Swap (L, R : Index_Type) is
       Temp : constant Element_Type := Container (L);
    begin
       Container (L) := Container (R);
       Container (R) := Temp;
    end Swap;

begin
    Parallel_Quicksort (Container'First, Container'Last);
end Quicksort;