Placeholder Image

Subtitles section Play video

  • We're basically using the EDSAC as a classic example of a very early von

  • Neumann computer. And to the great credit of Cambridge, I mean, they did get

  • it working by, I think it was April-May 1949, something like that. And it went on

  • to great glory afterwards and calculations on there, from many

  • Cambridge scientists ... I mean it's no exaggeration to say Nobel Prizes were

  • won because of the availability of EDSAC in all sorts of areas.

  • We're going to take a look and try and answer this question of: "How on earth do you get this

  • wretched EDSAC to boot up ?!" And with the help of Martin Campbell-Kelly's

  • emulator we're going to be able to show you something of that, because

  • what I want to do is to describe how the initial boot programs ... first stab at it

  • was called Initial Orders I, ssecond stab was called Initial Orders II -

  • written by a really bright guy who was the PhD student of Maurice Wilkes (who led

  • the EDSAC team of course). That chap's name was David Wheeler - a really nice

  • chap. I did know him, only slightly, but he was fearfully bright and always good

  • for a chat about low-level issues like this, about how did you get this wretched

  • thing to work given that, I suspect - inherited on EDSAC but feeding back into

  • early things, again, like Tommy Flowers' "Colossus" - how do you get a bit

  • pattern in here to tell it what to do? Because if you once get the bit

  • pattern in, the electronics the logic and everything inside it will execute it

  • correctly, that will have been checked out, but how do you get the wretched

  • things in? And the answer certainly on the Colossus machine was you used a set

  • of what were called Uniselectors to set up the 1s and 0s. And by having

  • enough Uniselectors plus usually a sort of `load' lever, to load it into the

  • current location in memory. Then you had to have an automated way inside the

  • hardware of stepping on to the next word to be loaded.

  • People like me didn't use Uniselectors but learnt this when you booted up an

  • early PDP-11, even as late as the 60s and 70s.

  • It wasn't Uniselectors, it was hand- keys on [the] front of the panel. I think we've

  • shown those once or twice [in previous videos]. Same thing: "up" for a "1"; down for a "0"zero; boom boom boom

  • boom - Load. another pattern; Load; another pattern; Load. It's bad enough loading up a

  • little boot program. It's unthinkable to load in an entire multi-kilobyte program

  • that way. But on the basis of hand switches and Uniselectors in this case,

  • yes, these wonderful Initial Orders II and Initial Orders I were loaded in

  • from Uniselectors. Once you've downloaded Martin's emulator, it comes

  • with a Tutorial Guide and it makes it very clear in there that, on the actual

  • EDSAC, when you want you to load Initial Orders you just press a button !

  • >> Andy Herbert - [director EDSAC rebuild project] "John is working here on the Uniselector units I talked about the boot

  • ROM or the Initial Instructions. Those are coded by how he's wired up these Uniselectors.

  • When the operator presses the start button a rotor spins in here and

  • as it passes each set of contacts that gets injected into the memory to download

  • the program". >> DFB: To give some idea - the Initial Orders, I think, were about 42 words !

  • Not 42K. Not 42 Meg - like it might be on a modern BIOS - 42 words! Because memory

  • was fantastically precious. >> Sean: What was a `word' then? Is that a 16-bit ....

  • >> DFB: Well, actually it was 18 bits in EDSAC but, basically, yeah. An 18-bit word could be

  • loaded in and you could load the whole thing in by hand. But you wouldn't want

  • to! So, here's the challenge then, there's all this memory here, in mercury,

  • available. What you want is something sitting down at the bottom of memory to

  • help you get bit patterns in - off paper tape. OK? So that will be your boot

  • program now that's the kind of thing sitting

  • in low memory which nowadays is the BIOS. And it's a heck of a sight more

  • complicated than the Initial Orders I. So, what David Wheeler for Initial

  • Orders I - just to get us started - early 1949: "I will write a set of Initial

  • Orders that sits there, all the time. And other people's tapes that come along, I

  • want to say two things to them: first of all please do not trample all over my

  • Initial Orders that have been pre-loaded. Don't go into very low memory addresses,

  • like zero, and start trying to overwrite it - this will] kill the program stone-dead.

  • But starting from, I think, he finished at 42 with his Initial Orders. But to allow for

  • future expansion I think the recommendation was to start off at location

  • 64 in memory? 64 and above. you put your program there.

  • I will now help you load it because when you put your paper tape in, it will be my

  • Initial Orders I that is asking to read your tape, character by character.

  • OK? And initially, in Initial Orders I, he said, I will do the following. If you

  • type `A', I know that A is a certain bit pattern meaning ADD and I will put that

  • in the correct field of the correct word for you. You may then want to write an

  • explicit decimal number to be added, like 10. To save your brain I will translate

  • your decimal numbers in your instructions into binary. So there's two

  • things I'm doing for you: I'm translating the opcode; I'm translating

  • obviously decimal numbers into binary and I am keeping track of where I'm

  • loading them for you into memory, I will start - if you say start at 64 I'll start

  • at 64 - and I'll put them in successively, one after the other. >> Sean: So far it sounds to

  • me like he's doing the job of a modern CPU with registers and an interpreter to

  • interpret the code ... ? >> DFB: Yeah, it's like a very elementary assembler but whereas with

  • assembly it's a two-pass process: you run the assembler - then you've got your binary.

  • Here you're using assembly codes to make your own binary on-the-fly

  • >> Sean: Is this the great-grandfather of the operating system then? >> DFB: Oh yeah

  • The great-great-great-grandfather of the operating system! First of all we are

  • starting with a loader because that's all this is. It loads into memory but

  • it's very crude, Initial Orders I, right? What drove people mad about it was that

  • unfortunately you had to be in control of your [absolute] addresses. Because if your

  • program said "jump to location 70" - you started at 64, fine, but what happens if you

  • want to intervene [insert] a few more orders - a few more instructions - between 64 and 70?

  • You've got to [potentially] alter all the addresses in your program. Because what

  • was at 70 - where you wanted to go to - is now at 76. So you've got to go and say:

  • "Don't jump to 70, jump to 76". So, although it was a loader it couldn't do anything

  • much about being at all adaptive, or helping you to *relocate*, as it was called.

  • So, this was realized very quickly - that any alteration to your program involved

  • changing all your addresses on the tape. So, Initial Orders II: David Wheeler

  • became celebrated throughout the computer science world for this. He only in his

  • life ever published 11 papers, did David, but he was still an FRS [Fellow of the Royal Society].

  • That's how much he was rated I remember meeting Don Knuth saying, you know, who have

  • you met recently? What have you been doing? I said "I saw David Wheeler". "Not D.J. Wheeler?!" he

  • said. You know: R-E-S-P-E-C-T ! Initial Orders II ! I mean, yes, David was really celebrated

  • for this. It seems obvious now but it certainly was not obvious at the time.

  • Everybody: "Wow - your Initial Orders II - is going to help

  • us be able to alter the program. And just feed the tape in again without changing

  • all of the addresses! All we have to do is to change the load point [base address] at the top,

  • say, or something like that. Maybe we don't want to put it at 64, we

  • want to put it somewhere else. But what David Wheeler said was:

  • So long as you, throughout your orders, indicate and flag up to me the addresses

  • that will need changing. I will keep track of them and I will alter them for you.

  • >> Sean: Are these like variables then? >> DFB: Yeah! They ... basically it was doing what

  • modern assemblers can do anyway, but very early on. Saying no matter where you

  • choose to place this in memory. you might want to put it at 128 or

  • 256, or anywhere. Just tell me and I will load it there. And I will fix up all

  • the addresses. You can just sort of say, like, 0, 1, 2 if you like. But I will

  • add on 64 to them, or 128 added on, or whatever you want. All you must

  • do is flag up to me the addresses that need to be altered - in a special way that

  • my Initial Orders understand. And it just revolutionized the use of EDSAC because

  • what, of course, every computer scientist wants to do - and admittedly this was not

  • done in 1949 it was done recently - is get your computer to say "Hello World".

  • Well, there's a contributed program here [for the simulator] that, for the sake of brevity, just gets it to

  • say "HI". And perhaps you want to run "HI" first and then say: "How the heck does

  • Initial Orders II enable this to be loaded in and to work correctly?" So, here

  • we go then. This is the program that we'll first of all load, when I say "Start".

  • "Start" loads the program that is showing in your window on the left. It has loaded in the

  • "HI" program. However with my fading memory of EDSAC codes I can see

  • that the third instruction, ZF, means "Stop". That was a very common trick to use

  • in an EDSAC program, is make it stop in its execution, early on. Because then you

  • can check in your peep... - your peephole into the tanks. Does it look plausible?

  • Does all of this stuff here look like a binary interpretation of all your

  • elementary assembler op-codes? >> Sean: And people would know what to see? >> DFB: Oh! they know what

  • to see. Oh yes! you can look in there saying: "Ooh! looks like an ADD instruction to me!"

  • Yes, so there we are. Now that's stopped here but what you can now do is

  • to single-shot it. Those of you, again in assembler will know, you often have a

  • single-shot capability for debugging. >> Sean: This is like a step through is it?

  • >> DFB: Yeah! just to step through. But with a bit of luck - Single EP. Ah! got a cursor now!

  • If I "Single EP" again, look, it's printing the letter `H'. Single-shot again, `HI'. So I think

  • one of the exercises in Martin's instructions - I encourage you all to do

  • it - just to get it to actually say "HELLO WORLD". Just make a bit longer. But here,

  • when we look at the program, we can see an awful lot of what is actually

  • happening here. It's saying "Stop" but then it goes on to actually outputting the

  • message. How does it do it? It uses an `O' (output) instruction. And that is part of

  • the EDSAC opcode. It basically means "punch this to tape", which is the way it

  • would have come out initially. With this @ symbol - that was one of the signals to

  • David Wheeler's Initial Orders. This is a relative address not an absolute one, and

  • I want you to adjust it for me. And because, right at the top, we've said

  • T 64 K - for assembler programmers that's like saying ORG = 64, in many

  • assemblers. But here its starting point is 64. But look at this

  • `O5@' means output the thing that is five locations beyond where I

  • currently am [correction: 5 beyond the base pointer] The `@' says you've got to add on the baseline [of 64] now, to the 5, [to give] 69.

  • So, down here, then, what it does first of all is it outputs `*F'. That is the code

  • that says `turn [change] into letter shift'. Now if you go back and watch my previous

  • 5-hole paper tape program you'll find that, whether it's Baudot code or EDSAC code,

  • you have to make sure - if you want to print out letters - be doubly sure you are

  • in Letter shift not in Figure shift and vice-versa.

  • Otherwise it will all look like junk. So here is the code in EDSAC that says `turn

  • me into Letter shift' and make sure. Next instruction beyond here says output the

  • thing that is six beyond this location [i.e 6 beyond the base pointer] When you look there, right, it just says `HF' [i.e. put the bit pattern for `H' as data in this address]

  • So, in other words the letters H and I, that are to be output, are being picked

  • up as data from instructions further down and are being output by using this

  • memory relocation [and offset] capability. So that's all you have to do is to put down

  • asterisk - shortcut in EDSAC for saying `switch to letter shift'; print the letter

  • H; print the letter I. But it's all done very carefully by adjusting these

  • addresses here to actually be 69, 70 and 71 in real life. And if you do that you

  • then say output the bit pattern that is in 69. It's a `change to letter shift' request.

  • Do the one in 70 - it's the letter `H' because I've planted that there [as data] And so on.

  • So, I hope that if you work through that, very painfully, you can see that just

  • that ability to use relative offsets, yeah,

  • rather than absolute addresses means that the amount of rewriting of your

  • program - just because it gets bigger - can be greatly minimized. So, what is Initial

  • Orders II ? It's arguably the world's first, elementary, relocating loader. It is

  • keeping your program well away from trampling on Initial Orders II, but it's

  • relying on Initial Orders II for translation (well you don't even need to

  • translate opcodes into binary they are [already in] binary), decimal-to-binary conversion

  • and now relocation. All done for you. And all in much less than 64 words. So that's why

  • it's so celebrated!

We're basically using the EDSAC as a classic example of a very early von

Subtitles and vocabulary

Click the word to look it up Click the word to find further inforamtion about it