From: eoahmad@ntuix.ntu.ac.sg (Othman Ahmad)
Subject: Re: One Instruction Computers
Organization: Nanyang Technological University - Singapore
X-Newsreader: Tin 1.1 PL4
Date: Wed, 7 Oct 1992 01:13:31 GMT

borasky@ogicse.ogi.edu (M. Edward Borasky) writes:
: In 1962, this was a common exercise for undergraduate programming 
: students.  Essentially, you design a CLASSICAL von Neumann machine --
: self-modifying code is not only allowed but NECESSARY for loops, 
: indexing, etc. -- like the IAS machines.  The only instruction is a two-
: address one: subtract location 's' from the accumulator and branch to
: 'b' if negative.  Registers need to have addresses; you have to clear a

This is what I call "super-intelligent" machines. It has managed to separate the
intelligent part from the "stupid part". I never thought that this machine can
ever do useful thing, but I've a strange feeling, this is the way our brains
work.
	After stumbling on a "Quantitative Measure of Intelligence", I realise 
that standard computer architectures are "obsolete", only optimised for
"stupid" applications, when it can be shown that it is the intelligence 
part that make them useful.

: register by subtracting it from itself.  Two's-complement is used to 
: test for zero -- if a number's postive and its twos-complement is 
: positive, it's zero.  It's quaint, but it works.  I/O is memory-mapped,
: of course!

I'm extremely excited. Please give me more references, published or not,
on the work along this line. I want to study this technique further. Knowing
that it may work, suddenly give me more channels for research.
	comp.arch has been more useful than the established journals because
it has given to light a few  "revolutionary" ideas, coming out of the blue(?).

: 
: Let's update this exercise for TODAY'S students.  My question is, for 
: all you Hennessy and Patterson readers out there: suppose we actually 
: BUILT such a beast.  Update the technology to be the fastest available 
: (say, GaAs) and use 1990s address and data widths (let's say 64-bit 
: twos-complement data path and 32-bit addresses).  Recognizing that it's
: going to take several cycles to do simple things like stepping through 
: an array, calling a subroutine, manipulating stacks, etc., and that 

If we have the latest technology, then there should be little problem in
doing a lot of instructions in one cycle. 

i) stepping through an array. 
Doing what?

ii)calling subroutine.
Why should we call a subroutine, when optimising compilers routinely can 
collapse it for us. There is no more need to do that. gotos is the most
efficent for a machine but may be difficult for a human to debug, but the
optimising compiler can do the work for us.

iii)manipulating stacks
Again I do not understand the question. What for? Stacks are just one
form of data structure. If we use different architecture, it may be prudent
to use different data structure.
	We should be more goal oriented, intead of "method" oriented.

: niceties like multiplies, floating point arithmetic, string collating 
: sequence compares, etc. take HUNDREDS or THOUSANDS of cycles, what does

If you have the technology, you do not need thousands of cycles.

: the cycle time of such a machine have to be to be as fast as an IBM 
: PC/AT with co-processor on Lotus 1-2-3?

My rought estimate is 0.5 milisecond. 500 cycles of 1 micro second, average.
Because of the "string collating sequence compares" or "convolution".

I may have misunderstood the questions. Please be free to comment or correct
it for me.

--
Othman bin Ahmad, School of EEE,
Nanyang Technological University, Singapore 2263.
Internet Email: eoahmad@ntuix.ntu.ac.sg
Bitnet Email: eoahmad@ntuvax.bitnet

Newsgroups: comp.arch