Web    Images    Groups    News    Froogle    more »   Advanced Groups Search   Preferences

The first systems I worked on were the '32 and '34.  That was a long 
(very long) time ago.

The circuit technology for both machines was an IBM bipolar technology 
that had 100 to 120 circuits per chip.  Ok for it's time.  It's 
internal code name was Dutchess.

The processor on the '32 was a 16 bit register based machine that is 
philosophically similar to RISC.  All logical and arithmetic 
operations are performed with register to register operations (16 
16bit registers). Branches used the side effects of the register to 
register operations or tested registers directly.  Memory operations 
only load data to registers or store data from registers. Memory was 
logically divided into an instruction space and a data space (aka 
control store and main store).  On the '32 the two spaces were 
physically implemented as one.  There was no cacheint, branch 
prediction, etc.  The internal name of the processor was the CSP 
(Control Store Processor).

The kernal and I/O processing of the '32 was implemented in the native 
instruction set of the CSP.  The upper levels of the operating system 
and application code were in the System/3 instruction set.  The '32's 
RISCish processor implemented an emulator of the S/3 instruction set 
to run the code.  

The S/3 instruction set is almost diametrically opposed to the '32 
instruction set.  It is very memory to memory oriented with very few 
registers.  All logical and arithmetic operations in the S/3 
instruction set are performed on memory to memory operations.  The few 
(2) registers were used to index addresses to memory.

All of this emulation was ok for one user, but pretty slow is you 
wanted to run multiple users.  So the '34 took the emulator out of 
software and put it into hardware (Dutchess technology).  
This processor was called the MSP (Main Store Processor).  To be 
clear, the '34 had two processors in its "CPU".  The original CSP from 
it's System/32 heritage and the MSP.  Neither processor supported 
virtual memory.

The I/O was also interesting on the '34 since it introduced the IOP 
(I/O Processor to the mix).  But that's another story.

Larry

PS: Don't know of any books on the subject.  We were all too busy.  
:-)

In article <qh3e2tb0w9.fsf@ruckus.brouhaha.com>, Eric Smith 
<eric-no-spam-for-me@brouhaha.com> wrote:
>I'm searching for articles (or books) on the implementation of the IBM
>System/32 and System/34 minicomputers, or any other small IBM systems
>from the early to mid-70s.  I'm specifically interested in details of
>the semiconductor technology, degree of integration, and processor or
>system architecture.
>
>So far I'm not turning up a lot.  I had hoped to find some articles in
>the IBM Journal of R&D, or the IBM Systems Journal, but the bibliography
>database at the University of Utah doesn't show anything promising.
>
>There is brief mention of some of this stuff in _IBM's 360 and Early 370
>Systems_ by Pugh, Johnson, and Palmer, but of course it is really
>outside the scope of that book.  If there were a similar book that
>covered small systems, it would be very useful to me.
>
>Any ideas?
>
>Thanks!
>
>Eric
>
>[If for some reason you want to send me a private reply, you'll have to
>remove the obvious anti-spam cruft from my email address.  Otherwise,
>I'm perfectly happy to watch for followups in this newsgroup.]

---------------------------------------------------------
IBM Server Group - Architecture, Performance and Design
home: ldwhit -at- ibm.net 
work: ldw -at- us.ibm.com
(Note the address modifications to reduce the spam load.)