Hello,
Some time ago, I announced I would be writing a paper on the
architecture of Parrot. The paper will be about 10 pages (I think, at
this point), so there will be quite a high level of abstraction in order
to be able to fit all important info. (so no "class" diagrams, if one
could even speak of classes, but more "components", or (black) boxes
that have some functionality).
Anyway, the structure will be more or less as follows (very global, for
details, the interested reader can refer to the paper, which is at
http://members.home.nl/joeijoei/parrot/paper.pdf , only 4 pages
currently, including references, and section headers):
the sections are:
-introduction *
-motives for Parrot *
-stakeholders *
-requirements *
-architecture overview
-main components -> some sections, each one on a different important
component, for example, a section on the Garbage Collector
-other features (things that I can't fit or are architecturally speaking
not very significant/interesting)
-summary
The *'ed items are more or less complete, but will be subject to
reviewing later on.
Now, I'm at the "architecture overview". In this section, I'd like to
give a picture of what Parrot looks like from 10 miles in the sky.
So, what main components are there, and, very important, what are the
mutual relations between those components.
As said, in the sections after that, I'll talk about a number of these
components that have interesting design decisions, such as the Parrot
core (i.e. why registers, and not stack oriented, data types, why not
PMC and Strings unified?, that kind of stuff), the garbage collector
(why not ref.counting, etc.), threads (how implemented, OS, or some library)
Luckily, a lot of that stuff is documented *somewhere* in the docs or
can be retrieved in the mailing list.
Now, my question is, are there any docs describing, or containing
pictures, of these main components of Parrot? (I'm talking about a
picture containing boxes, with lines of interaction between them). For
example, the part of Parrot running the actual opcodes would be a box,
(this is the engine), and it would have interaction with the registers
(themselves being represented by a box "registers" or something like
that). Then there is a box "heap" memory or something (would there
be??), and a box called Garbage collector having interaction with that
memory.
I vaguely remember a dependency graph which was generated, and could be
found on the Parrot Wiki (IIRC). Maybe something like that could be of
help too (the wiki is down, last time I checked). Of course, I would
very much like to include some graphics, which helps the reader to see
how Parrot is constructed of "components" with certain functionality.
Anyway, help of any kind (pointers to docs, or whatever) would be
greatly appreciated :-),
kind regards,
klaas-jan
