Examples of software written in ParaSail?

[Samuel Lotz]

I was looking for and failed to find any open source examples of software having been written in ParaSail. I realize there might be some commercial unadvertised projects out there though. Can anyone tell me about or point me to any projects to see the kind of applications that ParaSail would be good for?

As a side note I am also kind of interested in comparison of ParaSail to Chapel. The documents on Chapel are much more clear about how it actually achieves distributed computing (through GASNet UDP channels, Cray networking stuff, etc.) and thus where it could be appropriate to use it. I haven't really found any details that are the same for ParaSail. Insights, links, etc. appreciated.

~Sam

[Anton Lobach]

If I understand correctly, in the ParaSails’s compiler, the translator from PSVM instructions to LLVM IR and ParaScope are written in ParaSail.

Best,

Anton

--
You received this message because you are subscribed to the Google Groups "ParaSail Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to parasail-programming-language+unsub...@googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/parasail-programming-language/e6302978-8e0e-496a-af47-436401666df8%40googlegroups.com.

--

Regards,

Anton Lobach

[Tucker Taft]

As mentioned in the response from Anton Lobach, there are some large-ish examples of ParaSail included in the ParaSail release, in the "lib" subdirectory:

aaa.psi  --  ParaSail library written in ParaSail
compiled_main.psl  --  Stub for invoking a main routine that has been compiled into object code
compiler.ps{i,l}  -- the bulk of the code for the PSVM => LLVM compiler (PSVM == ParaSail Virtual Machine)
compiler_main.psl  --  the "main" routine for the compiler
debugger_console.psl --  a simple interactive debugger written in ParaSail
llvm_printer.ps{i,l} --  a set of modules used by the compiler for writing out LLVM
parascope.ps{i,l} -- a static analysis tool, based on a variant of abstract interpretation, that tries to find bugs in ParaSail code, by reading the PSVM
parascope_main.psl -- the "main" routine for ParaScope
psvm_debugging.psl -- some utility routines for displaying PSVM in a human readable format
reflection.ps{i,l} -- a ParaSail interface to the internals of the ParaSail front end/interpreter used by the compiler and ParaScope to get information about the program that has been read in by the ParaSail front end
type_desc_llvm_utils.ps{i,l} --  Some higher-level routines for generating sequences of LLVM instructions for particular ParaSail constructs

In the "examples" subdirectory there are a number of smaller ParaSail programs illustrating particular features.  N_queens.psl and drinking_phils.psl are implementations of the classic N-Queens problem, and a variant of the "Dining Philosophers" called the "Drinking Philosophers" ;-).

As far as the target market for ParaSail, it is for general purpose (parallel) programming (with full compilation to object code), with an emphasis on algorithms that benefit from heavy use of (strongly-typed) container abstractions such as sets/maps/vectors/strings, and with full automatic storage management without having to worry about a garbage collector.  ParaSail and Rust have similar underlying concepts, though the programmer-level views of those concepts are quite different, with ParaSail using an "extendable/shrinkable object" model, while Rust uses a pointer ownership/borrowing model.

The most complete academic paper on ParaSail may be found here:

     https://arxiv.org/ftp/arxiv/papers/1902/1902.00525.pdf

Take care,

-Tuck

--

You received this message because you are subscribed to the Google Groups "ParaSail Programming Language" group.

To unsubscribe from this group and stop receiving emails from it, send an email to parasail-programming...@googlegroups.com.

[Samuel Lotz]

Thanks for the overview! The project seems strangely mature compared if you look past the lack of hype and marketing of PLs like Rust... Since AdaCore is sponsoring the development of ParaSail, does that mean there is an intention to support it in the future? Are there any customers interested in it succeeding?

I have a few deeper questions on some of those points you bring up that I haven't seen in my skimming of the paper.

> ParaSail using an "extendable/shrinkable object" model, while Rust uses a pointer ownership/borrowing model.

Is one or the other model better suited for controlling memory layouts for cache locality etc.? 

This is one of the big concerns from C/C++ programmers about automatic memory management in any form (I'm not an expert here but I do want to have a rough understanding of the trade offs).

And with respect the "distributed" part of the parallelism. In the paper, the title of the section is "Parallel and Distributed Programming" but there isn't anything there specific to the challenges of distributed programming that are disjoint from parallel issues. For example in Chapel (https://chapel-lang.org/) they have the concept of "locales" (places where objects reside like different nodes etc.) and "domain mappings" so that programmers can actually access these resources directly. Is there something similar in ParaSail language (or the potential for it)? Or would the network essentially be viewed as transparent to the programmer and just be taken care of in the compiler?

Thanks, ~Sam

[Tucker Taft]

On Sat, Feb 29, 2020 at 12:58 PM Samuel Lotz <samue...@gmail.com> wrote:

Thanks for the overview! The project seems strangely mature compared if you look past the lack of hype and marketing of PLs like Rust... Since AdaCore is sponsoring the development of ParaSail, does that mean there is an intention to support it in the future? Are there any customers interested in it succeeding?

I have a few deeper questions on some of those points you bring up that I haven't seen in my skimming of the paper.

> ParaSail using an "extendable/shrinkable object" model, while Rust uses a pointer ownership/borrowing model.

Is one or the other model better suited for controlling memory layouts for cache locality etc.? 

Section 3.3 of the paper I mentioned is all about locality of reference achieved through a region-based storage management.  I don't believe Rust has this same approach, so my guess is that ParaSail achieves better locality of reference within a computation, and better separation of data between separate computations.

This is one of the big concerns from C/C++ programmers about automatic memory management in any form (I'm not an expert here but I do want to have a rough understanding of the trade offs).

I believe ParaSail's approach is better than many other approaches, because of the relatively large number of well-managed local heaps.

And with respect the "distributed" part of the parallelism. In the paper, the title of the section is "Parallel and Distributed Programming" but there isn't anything there specific to the challenges of distributed programming that are disjoint from parallel issues. For example in Chapel (https://chapel-lang.org/) they have the concept of "locales" (places where objects reside like different nodes etc.) and "domain mappings" so that programmers can actually access these resources directly. Is there something similar in ParaSail language (or the potential for it)? Or would the network essentially be viewed as transparent to the programmer and just be taken care of in the compiler?

ParaSail's lack of globals and pointers enables transparent distributed programming.  But it is clear that in many situations you want more control over placement, granularity, etc.  To some degree it is analogous to the kind of control you want with "placing" computations on distinct cores, but the consequences are worse when you get things wrong with distribution.  I have recently been looking into designing a new language specifically focused on Parallel, Distributed, Object-based computing.  Tentative name:  PARADISO  ;-)  The intent is for it to provide a ParaSail-like model sitting on top of something like OpenMPI, Apache Spark, or Hadoop Distributed File System (HDFS).

Take care,

-Tuck

Thanks, ~Sam

--
You received this message because you are subscribed to the Google Groups "ParaSail Programming Language" group.
To unsubscribe from this group and stop receiving emails from it, send an email to parasail-programming...@googlegroups.com.

To view this discussion on the web visit https://groups.google.com/d/msgid/parasail-programming-language/225164fd-de04-485b-9028-1fa085ece672%40googlegroups.com.

[Olivier Henley]

A simple bank application in ParaSail. I do not remember if I had to arrange things but I made it work a couple of months back:

https://groups.google.com/group/parasail-programming-language/attach/8e2c5280768cb58/final_data.zip?part=0.1&authuser=0&view=1

> Is one or the other model better suited for controlling memory layouts for cache locality etc.? 

> This is one of the big concerns from C/C++ programmers about automatic memory management in any form (I'm not an expert here but I do want to have a rough understanding of the trade offs).

Correct me if I am wrong but like I was told, you can easily unload any 'wild/custom low level' programming to Ada in a well integrated fashion.