f



Hardware Design supporting Ada

In the Ada IR thread an interesting sub-discussion regarding specialized ha=
rdware came up; some of the HW mentioned were:
* The Rational R-1000
=E2=80=94=E2=80=94 https://en.wikipedia.org/wiki/Rational_R1000
=E2=80=94=E2=80=94 http://datamuseum.dk/wiki/Rational/R1000s400
=E2=80=94=E2=80=94 http://www.somethinkodd.com/oddthinking/category/geek/so=
ftware-development/rat1000/
=E2=80=94=E2=80=94 http://repository.cmu.edu/cgi/viewcontent.cgi?article=3D=
1141&context=3Dsei
* The Intel iAPX 432
=E2=80=94=E2=80=94 https://en.wikipedia.org/wiki/Intel_iAPX_432
=E2=80=94=E2=80=94 http://www.brouhaha.com/~eric/retrocomputing/intel/iapx4=
32/cs460/
=E2=80=94=E2=80=94 http://bitsavers.trailing-edge.com/pdf/intel/iAPX_432/17=
2283-001_Reference_Manual_for_the_Intel_432_Extensions_to_Ada_Dec81.pdf
* The Rekursiv
=E2=80=94=E2=80=94 https://en.wikipedia.org/wiki/Rekursiv
=E2=80=94=E2=80=94 http://web.archive.org/web/20070607072521/http://www.erg=
..abdn.ac.uk/research/projects/rekursiv.html
=E2=80=94=E2=80=94 http://www.slideshare.net/sebrose/rekursiv

In addition to this, I've been doing some work looking into balanced-ternar=
y computers -- like this: http://practicaldev.herokuapp.com/buntine/the-bal=
anced-ternary-machines-of-soviet-russia and this: http://citeseerx.ist.psu.=
edu/viewdoc/download?doi=3D10.1.1.139.3198&rep=3Drep1&type=3Dpdf -- which i=
ndicate that it is possible and implementable w/ current fabrication proces=
ses.

Further, [balanced] ternary provides some interesting properties; if, for e=
xample, we define {1, 0, -1} as {greater-than, equal, less-than} respective=
ly then we can have a JUMP instruction that takes this single Trit comparis=
on result and three offsets and take care of ALL the JUMP combinations in b=
inary instruction-sets with one instruction. Moreover, if we define ((x,x,x=
),(x,x,x),(x,x,x)) as a "Byte" then a single Byte may be used to describe a=
ny binary operation. (e.g. Result =3D Byte_Value(A)(B).)

Taking these properties into consideration we could reduce something like
if A AND B then
statements_1;
elsif A XOR B then
statements_2;
else
statements_3;
end if;

to a single compare and a single jump via the following byte/table ((-1,1,-=
1)(1,0,1)(-1,1,-1)) with the jump populated w/ offset-values appropriately =
set.

I may be able to get into some chip manufacturing (I have a few contacts, a=
nd some family involved in the industry) -- there's also a university nearb=
y which may be interested (HEAVY tech and math emphases; students needing s=
enior-projects, professors possibly needing research topics, etc) and my pa=
rticular State (in the US) is looking to stimulate its economy, so obtainin=
g a grant is not out-of-the-question.

However, this is all moot w/o having a clear vision WRT to what the end-pro=
duct should be. What I have in mind now is a ternary computer with a co-pro=
cessor of 9 'cores' where each core is a 3-stack stack-machine; this -- htt=
p://fpgacpu.ca/stack/Second-Generation_Stack_Computer_Architecture.pdf -- i=
llustrates a few stack-machines, one of which has a predicted sustained exe=
cution rate of 2400 MIPS.... but I honestly have little idea of what I coul=
d do in-hardware to support Ada, which I'd like to do.

What's everyone on comp.lang.ada's suggestions, insights, and advice on the=
 topic?
0
Shark8
12/11/2016 8:55:10 PM
comp.lang.ada 8774 articles. 2 followers. Post Follow

2 Replies
551 Views

Similar Articles

[PageSpeed] 39

On 16-12-11 22:55 , Shark8 wrote:
> In the Ada IR thread an interesting sub-discussion regarding
> specialized hardware came up; some of the HW mentioned were:
> * The Rational R-1000
   ...
> * The Intel iAPX 432
    ...
> * The Rekursiv

Did they mention the Nokia MPS-10:

http://dl.acm.org/citation.cfm?id=989799&dl=ACM&coll=DL&CFID=874929794&CFTOKEN=55213355

http://computer-programming-forum.com/44-ada/596b4e2f57763ce6.htm

> In addition to this, I've been doing some work looking into
> balanced-ternary computers ...
 > Further, [balanced] ternary provides some interesting properties;
 > if,for example, we define {1, 0, -1} as {greater-than, equal,
 > less-than} respectively then we can have a JUMP instruction
 > that takes this single Trit comparison result and three offsets
 > and take care of ALL the JUMP combinations in binary instruction
 > -sets with one instruction.

Then you will be able to implement the original FORTRAN "arithmetic 
IF-statement" very efficiently, it being of the form

    IF (expr) 100, 200, 300

which would pass control to the label 100 if the expression in the 
parenthesis is negative, to 200 if it is zero, and to 300 if it is positive.

However, I don't see how such an instruction would help Ada, in particular.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
       .      @       .
0
Niklas
12/11/2016 9:15:16 PM
On Sunday, December 11, 2016 at 2:15:18 PM UTC-7, Niklas Holsti wrote:
>=20
> Did they mention the Nokia MPS-10:
>=20
> http://dl.acm.org/citation.cfm?id=3D989799&dl=3DACM&coll=3DDL&CFID=3D8749=
29794&CFTOKEN=3D55213355
>=20
> http://computer-programming-forum.com/44-ada/596b4e2f57763ce6.htm

No, but thank you for the information there!
It looks really interesting -- the MPS-10 along w/ the R-1000 makes it seem=
 like while a considerable effort, HW (and OS) designed for (and programmed=
 in) Ada is a good choice for reliability and maintainability.

> > In addition to this, I've been doing some work looking into
> > balanced-ternary computers ...
>  > Further, [balanced] ternary provides some interesting properties;
>  > if,for example, we define {1, 0, -1} as {greater-than, equal,
>  > less-than} respectively then we can have a JUMP instruction
>  > that takes this single Trit comparison result and three offsets
>  > and take care of ALL the JUMP combinations in binary instruction
>  > -sets with one instruction.
>=20
> Then you will be able to implement the original FORTRAN "arithmetic=20
> IF-statement" very efficiently, it being of the form
>=20
>     IF (expr) 100, 200, 300
>=20
> which would pass control to the label 100 if the expression in the=20
> parenthesis is negative, to 200 if it is zero, and to 300 if it is positi=
ve.
>=20
> However, I don't see how such an instruction would help Ada, in particula=
r.

That's true, it /would/ have a more natural mapping to FORTRAN in this case=
.. But, OTOH, Ada's always been of the mindset that the compiler should hand=
le little optimizations like that. (On a semi-related note, the implementat=
ion of ternary search-trees would be simple.)

You, and others here, might be interested in this manual on the iAPX 432's =
proposed extensions to Ada:
http://bitsavers.trailing-edge.com/pdf/intel/iAPX_432/172283-001_Reference_=
Manual_for_the_Intel_432_Extensions_to_Ada_Dec81.pdf

These extensions mapped to and "conveniently expose[s] the concepts and cap=
abilities of the iAPX 432."
0
Shark8
12/12/2016 9:46:45 PM
Reply: