WEBVTT 00:06.780 --> 00:08.780 Hello, good day. 00:09.120 --> 00:11.400 I welcome you to the lecture on computer organization. 00:12.580 --> 00:16.960 We are still in the chapter on addressing types, in this case, but 00:16.960 --> 00:19.440 overall instruction set architecture. 00:20.340 --> 00:25.400 If you remember, I said it's about instruction sets, so how is the 00:25.400 --> 00:29.720 architecture, how are instruction sets built, how can you address, and 00:29.720 --> 00:31.000 that's what we want to discuss today. 00:31.840 --> 00:37.060 Addressing means I have an operation, a command, and it attacks any 00:37.060 --> 00:37.620 data. 00:38.660 --> 00:42.100 And addressing means how do I attack this data. 00:43.120 --> 00:45.260 And of course, that depends on where the data is. 00:45.600 --> 00:49.820 They can be in the main memory, they can be in the register memory, 00:50.720 --> 00:55.200 and regardless of whether they are there, I have different ways of 00:55.200 --> 00:56.320 accessing them. 00:56.320 --> 01:00.320 Above all, I can also delete any indirect addresses. 01:01.000 --> 01:07.260 For example, I can say that there is an address in a memory cell, and 01:07.260 --> 01:10.360 on this address, which is saved there, I should actually write 01:10.360 --> 01:10.640 something. 01:11.080 --> 01:12.520 So there are things like that, right? 01:13.020 --> 01:16.180 And I showed you this tree of addressing types, which we want to go 01:16.180 --> 01:16.400 through today. 01:18.840 --> 01:21.520 And it always follows the same pattern. 01:21.740 --> 01:27.480 There is an example command, which I will explain to you, and based on 01:27.480 --> 01:32.900 this example command, a certain type of addressing is presented, of 01:32.900 --> 01:35.760 which there are many other commands that use this type of addressing. 01:37.120 --> 01:40.900 And additionally, how is the address calculated? 01:41.400 --> 01:42.320 That's what it's all about. 01:43.660 --> 01:47.140 Because, of course, it helps to understand when I know how the address 01:47.140 --> 01:47.640 is calculated. 01:48.240 --> 01:52.460 And it also helps to understand when I know that this does not happen 01:52.460 --> 01:54.360 instantly, that it takes time. 01:55.840 --> 01:58.000 Well, let's start here. 01:58.440 --> 01:59.520 We had that last time. 01:59.680 --> 02:01.180 There is an address in the program. 02:01.320 --> 02:03.960 I would really like to go through that again, as a bit of a 02:03.960 --> 02:04.300 repetition. 02:05.180 --> 02:09.980 There is an address in the program, and it says, for example, jump to 02:09.980 --> 02:13.860 the end of the loop, or jump to the sub-program, or something like 02:13.860 --> 02:14.800 that, something symbolic. 02:15.740 --> 02:16.960 I would say that in the program. 02:18.160 --> 02:20.420 This is an address in the program. 02:20.840 --> 02:24.980 Jump to a sub-program U5 or something like that. 02:25.100 --> 02:28.520 Then U5 would be the address in the program, I could say. 02:30.060 --> 02:34.260 Well, but that has nothing to do with where the whole thing should be 02:34.260 --> 02:35.480 stored now. 02:36.280 --> 02:38.120 Because I'll write the program at some point. 02:38.220 --> 02:40.780 I don't even know yet on which computer I want to compile it in the 02:40.780 --> 02:40.780 end. 02:43.620 --> 02:48.060 And depending on which computer it runs on, it has an effective or 02:48.060 --> 02:48.760 logical address. 02:50.260 --> 02:52.860 And this is the address that the processor knows. 02:52.980 --> 02:55.480 So the processor has an address space for itself. 02:55.700 --> 02:56.900 And we also talked about that. 02:57.080 --> 02:58.420 We talked about command formats. 03:00.020 --> 03:02.900 Addressing, for example, 32-bit. 03:04.400 --> 03:06.680 Which memory space can you address with 32-bit? 03:07.420 --> 03:07.960 How was that? 03:08.460 --> 03:08.960 How many bytes? 03:10.700 --> 03:11.560 4 gigabytes. 03:11.960 --> 03:15.480 Exactly, 2 x 32 is 4.2 gigabytes, something like that. 03:17.460 --> 03:19.760 So then the processor knows that. 03:20.100 --> 03:22.600 But that doesn't mean for a long time, and I said that back then too, 03:22.940 --> 03:26.280 that doesn't mean for a long time that this effective address that the 03:26.280 --> 03:28.760 processor knows, that it even exists. 03:29.860 --> 03:33.500 Maybe I have a small system that has less than 4 gigabytes. 03:34.360 --> 03:37.480 Or I have a big system that has much more than 4 gigabytes. 03:37.480 --> 03:42.160 If, for example, I want to save big data somewhere, then I can't do 03:42.160 --> 03:44.200 that on a telephone or something. 03:44.880 --> 03:48.320 Then maybe I also need a computer center with today's data densities 03:49.100 --> 03:50.380 where I save the data. 03:51.320 --> 03:53.200 And the address space is much larger there. 03:54.300 --> 03:59.460 But the processor obviously sees something that it can calculate well, 03:59.780 --> 04:00.860 to put it that way. 04:01.600 --> 04:06.280 But that's not where I could physically point my finger at, for 04:06.280 --> 04:06.280 example. 04:07.440 --> 04:11.300 That means we are here at the logical address. 04:11.900 --> 04:17.260 And after I said that, it is obvious that there is more than a logical 04:17.260 --> 04:19.480 address, namely a physical address. 04:20.120 --> 04:25.040 And that's really where my byte, where my bits are saved at the end. 04:26.080 --> 04:32.140 If I didn't have such big fingers, I could point it at the memory 04:32.140 --> 04:32.580 cell. 04:32.580 --> 04:35.560 But at least you can imagine it that way. 04:36.200 --> 04:37.320 So that really exists. 04:38.240 --> 04:41.320 And then there are things like I have a large address space, which is 04:41.320 --> 04:44.160 larger than 32 bits, i.e. 04:44.880 --> 04:46.660 4 gigabytes. 04:48.100 --> 04:50.060 And there can also be gaps in between. 04:50.520 --> 04:55.040 That means the entire address space doesn't necessarily have to be 04:55.040 --> 04:56.480 filled with memory all the time. 04:58.960 --> 05:02.560 There's nothing wrong with that, as long as I don't access the empty 05:02.560 --> 05:03.680 space, so to speak. 05:04.080 --> 05:07.480 But the operating system knows that and makes sure that no program is 05:07.480 --> 05:09.200 pushed there because there is no memory there. 05:09.720 --> 05:10.820 And then it's okay. 05:12.100 --> 05:18.040 So there is an effective logical address and a physical one. 05:18.300 --> 05:18.900 And that's a difference. 05:19.040 --> 05:20.480 I hope that came out of the discussion. 05:21.120 --> 05:24.080 So if there is still a need, please ask. 05:24.280 --> 05:28.380 Any questions can always contribute to making it more understandable 05:28.380 --> 05:29.460 for everyone in general. 05:33.460 --> 05:36.260 Any questions or comments? 05:37.480 --> 05:39.960 Then we assume that we have roughly understood that. 05:40.880 --> 05:47.780 And then we go in with this knowledge to look at the address data 05:47.780 --> 05:47.880 again. 05:50.590 --> 05:53.790 Then there was something with virtual memory management. 05:53.910 --> 05:55.910 I said, okay, let's leave that now. 05:56.310 --> 05:56.990 Let's mention that. 05:56.990 --> 05:58.290 That still exists somewhere. 05:58.430 --> 06:02.710 We have special folio sets for what virtual memory management is. 06:03.070 --> 06:07.590 Ultimately, it is about that the processor does not know the memory 06:07.590 --> 06:07.890 address. 06:09.010 --> 06:13.310 But there is a hardware called MMU, Memory Managing Unit. 06:14.370 --> 06:15.070 And then it knows that. 06:15.470 --> 06:18.230 But how exactly that works, that's not what we're going to talk about 06:18.230 --> 06:18.530 today. 06:18.830 --> 06:19.730 We'll talk about that in a few weeks. 06:21.390 --> 06:24.290 And this is now the entire tree of the addressing types. 06:25.090 --> 06:30.070 I think for almost every sheet of this tree we have some kind of 06:30.070 --> 06:34.970 example in the next half an hour. 06:37.690 --> 06:39.970 Registering is something simple. 06:40.290 --> 06:41.190 We'll start with that. 06:41.710 --> 06:44.750 Then there is one-stage memory and two-stage. 06:45.610 --> 06:50.870 We have to be careful that we understand how that works, how it is 06:50.870 --> 06:51.230 calculated. 06:51.790 --> 06:52.830 But I'll go through it individually. 06:55.810 --> 06:56.570 Registering. 06:56.570 --> 07:04.470 Obviously, an address in the register or the register itself contains 07:04.470 --> 07:06.190 the date I want to calculate. 07:07.990 --> 07:09.870 And there are also different ones. 07:10.090 --> 07:11.010 With the names, it's always like that. 07:11.510 --> 07:14.250 There are a lot of things, especially when you look at it here, on 07:14.250 --> 07:21.410 this whole tree, you can only notice it if you have an example for it. 07:21.610 --> 07:23.490 Learning by heart, that wouldn't make any sense at all. 07:24.470 --> 07:28.530 But if, for example, there is an exam somewhere and it says indirectly 07:28.530 --> 07:33.730 indicated address or something like that, if you have an example 07:33.730 --> 07:36.730 ready, how it works, then you can explain it very well. 07:37.210 --> 07:40.050 That would be my tip, to remember the whole thing. 07:42.370 --> 07:44.310 Well, let's just take a look at that. 07:46.150 --> 07:48.410 The writing style is always as follows. 07:48.690 --> 07:51.650 We have the assembler writing style and here I said, that means 07:51.650 --> 07:54.290 mnemonic, very difficult to pronounce. 07:55.050 --> 07:58.030 That's just the symbolic command. 07:58.450 --> 08:03.230 So STO, save something or LD, load something or something. 08:04.210 --> 08:09.770 That's what you call mnemonic, a symbolic command name. 08:11.190 --> 08:14.250 And what we have indicated here in green, that is now always the case 08:14.250 --> 08:19.510 on the following slides, that we have the effective address, i.e. 08:19.510 --> 08:22.710 how the address is calculated at the end of the day. 08:22.730 --> 08:26.830 It is given here in green and there is a typical addition or something 08:26.830 --> 08:27.850 with brackets. 08:27.990 --> 08:29.830 I'll explain what that means. 08:29.910 --> 08:34.690 Just so that you get a hint of how the next slides are built up, how 08:34.690 --> 08:35.670 to interpret it. 08:37.590 --> 08:39.590 Then we also have an architecture. 08:39.770 --> 08:40.970 You can say two things about it. 08:41.090 --> 08:44.190 On the one hand, you can say, okay, that confuses me, then I don't 08:44.190 --> 08:44.850 understand it anymore. 08:44.850 --> 08:49.170 That's why I wouldn't go into this architecture so much today, because 08:49.170 --> 08:51.030 I think it may confuse you more. 08:51.550 --> 08:53.730 I'm more interested in how you calculate the address. 08:54.790 --> 08:57.750 And if you have learned more about the architecture during the 08:57.750 --> 09:01.350 lecture, you can go back to the slides and look, ah, now I understand 09:01.350 --> 09:01.830 it better. 09:02.510 --> 09:05.430 Today we just want to understand from the point of view of a 09:05.430 --> 09:10.470 programmer, what happens there, why do I do it and what does it do. 09:12.550 --> 09:13.690 And then it looks like this. 09:13.690 --> 09:15.970 And now we have an example. 09:16.210 --> 09:19.850 For example, here it says LogicalShiftWriteAccumulator. 09:20.610 --> 09:21.990 Accumulator is a register. 09:24.450 --> 09:30.150 In LogicalShiftWrite, which we have already gone through, in the word 09:30.150 --> 09:35.230 that is stored in the register, let's say in 32 bits, is logically 09:35.230 --> 09:35.690 pushed to the right. 09:36.190 --> 09:38.410 I had also asked and I ask what is caused by it. 09:38.510 --> 09:40.830 If you push it to the right, two are divided, so to speak. 09:41.370 --> 09:45.070 And if a 1 comes out in the back, a 1 falls out, then it was an uneven 09:45.070 --> 09:45.450 number. 09:45.570 --> 09:47.790 If a 0 falls out in the back, then it was an even number. 09:49.630 --> 09:52.930 Now it's called LogicalShiftWriteAccumulator. 09:53.650 --> 09:54.770 And I'll read it again. 09:55.770 --> 09:56.670 What does it do? 09:56.710 --> 09:57.610 I just said it. 09:57.750 --> 10:02.590 Push the content of the accumulator A one bit position to the right. 10:04.050 --> 10:04.570 Good. 10:05.230 --> 10:09.990 There is nothing more to say here, except here is the opcode, which 10:09.990 --> 10:11.190 says what you have to do. 10:11.630 --> 10:15.550 Here is the register sentence and here you could now draw in a small 10:15.550 --> 10:18.250 row how the whole thing is pushed to the right. 10:19.570 --> 10:21.010 This architecture doesn't say anything more up here. 10:21.970 --> 10:25.630 It's so simple that it's self-explanatory in words. 10:27.370 --> 10:28.490 What else can you do? 10:28.610 --> 10:29.970 You can do flag addressing. 10:31.950 --> 10:33.070 And here I have to say the following. 10:33.430 --> 10:34.630 There are different flags. 10:35.390 --> 10:36.130 This is a flag. 10:36.410 --> 10:37.150 This is a symbol. 10:37.450 --> 10:39.710 If I say hello to a white flag, then I give up somewhere. 10:40.090 --> 10:41.330 The processor also says that sometimes. 10:41.570 --> 10:44.050 You have to do a reset or something. 10:45.570 --> 10:48.590 Then it sets a bit and says I can no longer calculate here. 10:49.370 --> 10:50.330 That can happen. 10:51.590 --> 10:55.770 What could be the reason that the processor says I have to show the 10:55.770 --> 10:56.870 white flag here. 10:56.910 --> 10:58.110 I can no longer calculate. 10:59.570 --> 11:00.610 And that happens. 11:00.610 --> 11:04.410 I claim that as long as we sit here in the room, it happens once 11:04.410 --> 11:05.650 somewhere in your throne. 11:05.810 --> 11:06.810 You don't get anything out of it. 11:10.600 --> 11:11.960 What could be the reason for that? 11:12.140 --> 11:14.040 The processor says I can't go on here. 11:15.480 --> 11:16.500 And raises his hand. 11:16.680 --> 11:17.400 So there's a flag. 11:17.560 --> 11:18.580 We're talking about flags. 11:19.840 --> 11:20.440 Do the 1. 11:20.560 --> 11:21.480 I can no longer calculate. 11:24.260 --> 11:24.660 Okay. 11:25.020 --> 11:25.280 Divide by 0. 11:25.680 --> 11:26.560 That would be a good thing. 11:29.000 --> 11:30.160 Something with infinite. 11:30.160 --> 11:31.780 You can't calculate that very well. 11:33.080 --> 11:34.820 We don't have a number representation for that. 11:34.880 --> 11:37.580 We don't know exactly what comes out when we add 1 plus infinity. 11:40.120 --> 11:41.300 We have to come up with something. 11:41.880 --> 11:45.340 The processor says that is divided by 0. 11:46.560 --> 11:51.380 And then there would be a routine that would then try to do something. 11:52.340 --> 11:56.020 Then you can think about was that really so important now? 11:56.500 --> 11:57.640 Was that just a subprogram? 11:57.640 --> 12:00.580 Then I'll just do it like this and give some value back. 12:00.660 --> 12:02.240 Maybe the rest of the program can cope with it. 12:03.020 --> 12:04.580 So there are different levels. 12:05.300 --> 12:09.400 And the hardest level would be the processor doesn't do anything at 12:09.400 --> 12:09.400 all. 12:10.240 --> 12:17.180 But typically you can still live with it without having to do hard 12:17.180 --> 12:17.540 reset. 12:18.160 --> 12:22.120 It would actually be enough to just restart the app and not the whole 12:22.120 --> 12:23.200 computer or something. 12:23.460 --> 12:24.480 You had another example. 12:26.800 --> 12:27.480 Overlap? 12:27.900 --> 12:29.060 Okay, overlap. 12:29.260 --> 12:31.720 So we add or multiply. 12:31.940 --> 12:37.420 We have an operation and this operation exceeds the value range that 12:37.420 --> 12:38.040 we can represent. 12:39.020 --> 12:41.760 We had already said that we have certain bits available. 12:41.960 --> 12:43.820 64 or even more at floating point. 12:45.060 --> 12:47.320 But somewhere the value range is at the end. 12:47.980 --> 12:49.720 We would exceed that. 12:50.700 --> 12:53.760 And then I also have to think about what I start with. 12:54.840 --> 13:00.060 You could, for example, think that you give the program back. 13:01.600 --> 13:02.900 There was an overlap. 13:04.000 --> 13:06.040 With the overlap you can still continue to calculate. 13:06.180 --> 13:08.660 You can pretend that the overlap was not there. 13:09.220 --> 13:13.780 So you calculate with the values that you have and say additionally, 13:14.180 --> 13:15.680 but I had an overlap. 13:16.020 --> 13:18.500 So then you can think about whether you want to use the result and 13:18.500 --> 13:21.480 what you want to do with it. 13:21.720 --> 13:27.440 But normally it would not be fatal for the processor and you would not 13:27.440 --> 13:29.360 have to do a hard reboot, for example. 13:29.860 --> 13:32.200 But that is also one of these flags. 13:32.880 --> 13:34.100 And important. 13:34.280 --> 13:35.560 What else can you imagine? 13:41.330 --> 13:42.430 Timer and interrupt. 13:42.810 --> 13:43.070 Exactly. 13:43.490 --> 13:46.110 There are flags that say we have an interrupt. 13:46.890 --> 13:50.550 We recently had an example where we said, for example, an automobile 13:50.550 --> 13:51.770 could have an interrupt. 13:53.770 --> 13:55.990 We do what we normally do. 13:56.170 --> 13:58.950 We drive with the car and then something happens. 13:59.510 --> 14:00.630 A tire bursts or something like that. 14:01.130 --> 14:04.010 That is something that requires a very fast reaction. 14:04.870 --> 14:05.490 An interrupt. 14:06.290 --> 14:14.690 And that would then lead to the airbag being triggered or the brakes 14:14.690 --> 14:17.210 being activated or even self-activated or something like that. 14:18.330 --> 14:23.310 This is also a very good example for such a flag where we can find 14:23.310 --> 14:23.410 ourselves. 14:23.950 --> 14:25.450 What else can you imagine? 14:26.150 --> 14:26.610 There are a lot. 14:30.810 --> 14:32.570 The main memory is full. 14:33.790 --> 14:37.770 That would typically I mean, that's very good, but typically the 14:37.770 --> 14:39.130 processor would not do it. 14:39.830 --> 14:43.050 It would typically do the operating system. 14:43.710 --> 14:47.830 The operating system is a program that manages the main memory. 14:47.990 --> 14:53.370 So this is a program that ensures that the main memory does not run 14:53.370 --> 14:53.390 out. 14:54.030 --> 14:59.710 And this program would then, so to speak, prohibit other programs from 14:59.710 --> 15:00.670 requiring more memory. 15:02.010 --> 15:04.910 I would notice that when I program as a programmer. 15:05.050 --> 15:09.110 I have malloc, alloc and such things that you may know where I require 15:09.110 --> 15:14.090 memory and then, for example, come back to full. 15:14.790 --> 15:17.650 That means I do not get the memory as a programmer. 15:19.170 --> 15:22.110 So that would be a thing that is also very good. 15:22.230 --> 15:25.310 We also have another example, but that would typically do the 15:25.310 --> 15:26.110 operating system. 15:28.170 --> 15:28.990 What else do you notice? 15:29.490 --> 15:33.050 So everything is ultimately right and we learn something from it. 15:41.780 --> 15:42.560 Yes, for example. 15:43.820 --> 15:47.200 You could imagine, for example, you have a bidder who says the result 15:47.200 --> 15:47.860 is zero. 15:48.780 --> 15:49.860 And there really is something like that. 15:50.820 --> 15:54.700 Namely, for example, you compare two numbers. 15:55.160 --> 15:57.440 Imagine you compare two numbers. 15:57.660 --> 15:59.300 How do I compare two numbers? 16:00.000 --> 16:01.360 I compare two numbers. 16:01.560 --> 16:03.180 For example, how would you compare two numbers? 16:04.380 --> 16:09.160 Let's say we have question A greater than B. 16:10.660 --> 16:12.120 How could you do it? 16:12.300 --> 16:14.140 So that now concerns this thing. 16:14.140 --> 16:16.500 It's about this example that was just mentioned. 16:22.600 --> 16:23.100 Exactly. 16:23.860 --> 16:24.860 You subtract the numbers. 16:25.060 --> 16:26.240 Is A greater than B? 16:26.540 --> 16:28.180 You subtract the numbers. 16:28.960 --> 16:33.740 And if I now have a spot, as you rightly said, that shows that the 16:33.740 --> 16:37.520 result of an operation is zero, then I only need to do one thing. 16:38.220 --> 16:40.820 I just need to test whether this spot is set. 16:40.940 --> 16:43.160 And with that I know they are the same. 16:43.500 --> 16:45.320 At least that's the statement I can make. 16:45.500 --> 16:51.360 It has the advantage of having a flex that you can then ask because it 16:51.360 --> 16:53.740 is also very easy to process as logic. 16:55.640 --> 16:59.340 It is a logic from a gutter that enables me to do this. 17:00.240 --> 17:02.400 Direct hardware reference, so to speak. 17:03.240 --> 17:04.260 What else could you come up with? 17:04.760 --> 17:07.060 Why can the processor still say I can't go on? 17:08.440 --> 17:12.180 Everything was right and everything is important and I still notice 17:12.180 --> 17:12.580 more. 17:17.860 --> 17:19.400 If you want to calculate with one. 17:22.300 --> 17:24.660 These are also things that are on a higher level. 17:25.400 --> 17:29.460 Operating systems, programming languages on that level. 17:30.900 --> 17:34.220 There are also routines for such things, but that would not be what a 17:34.220 --> 17:34.940 hardware register is for. 17:35.580 --> 17:37.840 Thank you very much for the contribution. 17:37.840 --> 17:39.280 How about the following? 17:41.660 --> 17:48.360 We have an instruction word and there is an opcode in it. 17:49.000 --> 17:50.720 And we said these are opcodes. 17:50.920 --> 17:51.680 I'm not going back to the slide. 17:52.280 --> 17:57.480 You can remember, for example, 5-bit or 6-bit were reserved and these 17:57.480 --> 18:03.800 5 or 6-bit code then 64 different opcodes. 18:03.900 --> 18:06.640 So add, load and so on. 18:08.100 --> 18:12.820 Now it can happen that there is an opcode in it that does not exist at 18:12.820 --> 18:13.540 all. 18:14.620 --> 18:16.220 That can happen. 18:16.380 --> 18:20.260 That can happen because the memory can be faulty. 18:21.680 --> 18:23.220 For example, we can have a bit flip. 18:24.200 --> 18:32.140 That means a small particle hits from space and this small particle 18:32.140 --> 18:37.800 causes a transistor to switch and instead of a 0 we have a 1 or vice 18:37.800 --> 18:37.820 versa. 18:38.460 --> 18:44.380 That means we have a bit flip and through this bit flip an opcode 18:44.380 --> 18:45.740 comes out that does not exist. 18:46.200 --> 18:50.420 Because if I have 5 or 6 bits for opcodes, that does not mean that I 18:50.420 --> 18:54.100 have exactly 64 operations. 18:54.860 --> 19:00.120 The processor may only need 45 or so and the others are then simply 19:00.120 --> 19:00.400 invalid. 19:02.800 --> 19:08.140 Then the processor wants to decode and finds out that this code does 19:08.140 --> 19:09.000 not exist in my table. 19:09.320 --> 19:10.720 Therefore, there is no opcode. 19:11.420 --> 19:11.940 That happens. 19:13.900 --> 19:16.220 This is a pretty fatal thing. 19:16.360 --> 19:17.860 There is also a flag for this. 19:18.480 --> 19:20.280 It is clear that you cannot continue calculating. 19:21.060 --> 19:22.720 It is not just a wrong date. 19:22.920 --> 19:23.560 It is an opcode. 19:23.700 --> 19:25.420 I do not know what to do. 19:25.420 --> 19:26.860 It could be a jump command. 19:27.500 --> 19:29.180 I cannot continue. 19:29.500 --> 19:37.740 It is guaranteed that if I simply skip it, it will not make sense. 19:40.280 --> 19:43.280 Then you may have to reset the application. 19:45.820 --> 19:52.000 But that can also lead to assuming that the whole thing happens in the 19:52.000 --> 19:52.680 operating system. 19:54.440 --> 19:56.000 I can have any app here. 19:56.040 --> 19:59.920 If I have many apps, then it is not a problem for me if I have to 19:59.920 --> 20:01.360 reset and restart one. 20:01.880 --> 20:05.880 But the operating system is ultimately also a program that controls 20:05.880 --> 20:06.580 everything else. 20:07.160 --> 20:12.000 In the operating system, there is an opcode in the code that is wrong. 20:14.340 --> 20:16.220 Then it is pretty fatal. 20:16.420 --> 20:19.060 Then the whole computer system can hardly continue. 20:19.060 --> 20:26.140 Then it is most likely that you have to say that you have to reboot 20:26.140 --> 20:26.200 the computer. 20:28.240 --> 20:31.040 So there are different flags. 20:32.260 --> 20:33.940 We have two of them here. 20:34.120 --> 20:38.100 In the next slide, when we deal with architecture, we will go through 20:38.100 --> 20:41.120 what certain architectures really do. 20:41.140 --> 20:46.360 Here you get an idea of how to deal with it. 20:46.360 --> 20:51.840 Here, for example, in exemplar writing, it looks like this, where 20:51.840 --> 20:56.160 different flags are manipulated or asked. 20:56.740 --> 20:58.180 I can set them. 20:59.000 --> 21:03.320 For example, I could also pretend that I have a division by zero, even 21:03.320 --> 21:04.100 though I didn't have it. 21:04.780 --> 21:07.180 Or I can query it. 21:07.360 --> 21:08.700 So set or query. 21:10.100 --> 21:13.040 This is what it looks like as a mnemonic. 21:15.100 --> 21:18.020 And as an example, we would have something like this. 21:18.620 --> 21:20.160 And that was just correctly said. 21:20.240 --> 21:21.520 Now we have exactly such an example. 21:21.780 --> 21:24.420 Here it says set or clear, i.e. 21:24.540 --> 21:27.780 set or delete the interrupt flag. 21:29.520 --> 21:35.920 So someone noticed on the pins of the processor that an emergency 21:35.920 --> 21:36.380 comes in. 21:37.540 --> 21:44.360 Then a service program would set the bit here and the rest of the 21:44.360 --> 21:49.680 program would know that I am in an emergency mode, so to speak. 21:50.700 --> 21:53.200 And when I'm done with it, then I delete it. 21:53.320 --> 21:55.640 Then, for example, I have fixed it. 21:55.740 --> 21:59.180 Then I have, for example, the emergency situation when we think of the 21:59.180 --> 22:01.340 car that has put an emergency brake on it. 22:08.400 --> 22:12.400 So set or reset the interrupt enable flag and so on. 22:12.800 --> 22:14.220 Here it's even about something else. 22:14.440 --> 22:15.700 An interrupt enable flag. 22:16.260 --> 22:17.840 That goes one step further. 22:18.320 --> 22:23.080 Here I would say, for example, do I want to allow an interrupt at all? 22:24.400 --> 22:28.300 We just said we have an interrupt or can have an interrupt. 22:29.500 --> 22:31.180 What kind of incentive could I have? 22:31.200 --> 22:36.740 What kind of reason could I have to say I don't allow the interrupt? 22:40.220 --> 22:43.680 I just told you there was an airbag and so on and it's important and 22:43.680 --> 22:44.340 there has to be an interrupt. 22:44.860 --> 22:47.620 And now I say I don't allow the interrupt. 22:48.780 --> 22:49.480 Is there such a thing? 22:51.500 --> 22:53.320 What could be a reason for that? 22:57.050 --> 22:59.530 It doesn't necessarily have to be the car, for example. 22:59.710 --> 23:00.670 It can be described a little more generally. 23:02.630 --> 23:07.610 So in general it would simply be there are hierarchies of interrupts. 23:07.970 --> 23:10.510 There are important ones and not so important ones. 23:10.510 --> 23:16.030 Some interrupt could say, okay, the battery of the car will last 23:16.030 --> 23:21.950 another half hour and then something would happen and a light would 23:21.950 --> 23:23.130 blink or something like that. 23:23.570 --> 23:26.610 That would be a routine that would make the light blink. 23:26.870 --> 23:27.770 That's bad. 23:28.170 --> 23:31.710 But then there could be this emergency situation with the brakes. 23:32.650 --> 23:34.370 That's even worse, so to speak. 23:34.530 --> 23:37.330 That's even more important in the sense of interrupts. 23:37.670 --> 23:40.930 Then you would say this interrupt has a higher priority. 23:41.870 --> 23:43.470 And then I would do the following very specifically. 23:44.090 --> 23:47.670 Then I would say in the sense that the driver has to preserve this 23:47.670 --> 23:52.150 life, so to speak, and to ensure maximum safety, I only want to 23:52.150 --> 23:53.050 operate the airbag now. 23:53.670 --> 23:56.750 If another interrupt comes in, that somewhere a battery is empty or a 23:56.750 --> 23:58.050 lamp is broken or something like that. 23:58.130 --> 23:59.370 That's not so bad now. 23:59.930 --> 24:04.150 I turn that off now and do the more important thing. 24:04.590 --> 24:11.450 So it's about priorities of interrupts where there is a hierarchy of 24:11.450 --> 24:13.570 less and more important. 24:14.070 --> 24:20.050 For example, I can easily do this in the processor by setting such 24:20.050 --> 24:22.530 interrupts in Nebelflex or not. 24:22.870 --> 24:28.570 These are extremely important registers in the computer or bits of a 24:28.570 --> 24:30.990 register that I can influence here. 24:31.170 --> 24:33.170 Typically, I wouldn't do that myself. 24:33.630 --> 24:34.970 The operating system would do that. 24:35.270 --> 24:39.990 So if I write in the operating system, write code for it, then I would 24:39.990 --> 24:41.210 have to do such things. 24:42.190 --> 24:46.570 If I write C, I don't get around to doing something like that. 24:46.570 --> 24:49.430 But of course you should know that there is something like that. 24:49.790 --> 24:53.930 And of course there is also the possibility of other programming 24:53.930 --> 24:58.730 languages to indirectly ensure that no interrupts are allowed, which 24:58.730 --> 25:00.130 then happens. 25:00.210 --> 25:02.830 Even if you don't do that yourself, that would then happen in the 25:02.830 --> 25:02.970 computer. 25:04.310 --> 25:05.750 Now let's look at the second one. 25:06.370 --> 25:07.550 Explicit register address. 25:08.090 --> 25:09.350 Here we have the example. 25:10.810 --> 25:11.950 It says DEC. 25:12.970 --> 25:13.610 Decrement. 25:13.910 --> 25:18.850 Decrement means to make it smaller, to decrement. 25:20.230 --> 25:21.370 And what? 25:21.950 --> 25:24.330 Decrement the content of the register. 25:24.330 --> 25:26.570 That's also a super easy command. 25:28.010 --> 25:29.910 And the effective address is simple. 25:30.810 --> 25:31.570 What is the address? 25:32.170 --> 25:38.310 The address is obviously the value, the number of the register. 25:38.670 --> 25:40.250 So register R0. 25:42.070 --> 25:47.650 And if I have 16 registers, then I just have to find the R0 through 25:47.650 --> 25:50.390 this address, which is stored here. 25:50.990 --> 25:57.330 And the content, the value that is in the register, I would like to 25:57.330 --> 25:58.130 decrement by 1. 26:00.170 --> 26:01.150 So reduce by 1. 26:02.510 --> 26:03.850 So that's all super easy. 26:03.970 --> 26:04.430 You understand that. 26:05.890 --> 26:07.530 And then it goes on like this. 26:08.450 --> 26:09.270 What else is there? 26:11.390 --> 26:16.090 Here it is just shown again how it now appears in the architecture. 26:16.670 --> 26:17.690 Here is the opcode. 26:17.850 --> 26:18.830 This is the DEC. 26:18.830 --> 26:20.750 Here is the register number. 26:21.710 --> 26:23.110 And that's the command. 26:23.410 --> 26:24.070 So what does it do? 26:24.150 --> 26:28.390 It goes into the register and executes exactly this thing, this 26:28.390 --> 26:30.430 content, to decrement by 1. 26:31.530 --> 26:32.990 So that was the easiest. 26:33.330 --> 26:35.310 You can do that almost without thinking. 26:37.470 --> 26:38.670 And good. 26:38.790 --> 26:40.830 Then we have something like one-step memory address. 26:41.150 --> 26:42.410 And then comes the two-step. 26:42.870 --> 26:44.030 So a one-step. 26:44.850 --> 26:49.350 And that is now divided up again into different nomenclatures. 26:49.970 --> 26:55.170 Although I'm not always a fan of going through and counting it. 26:55.270 --> 26:58.310 We just look at it and see what it is in the end. 26:58.990 --> 27:00.470 And you have the folders yourself. 27:00.590 --> 27:01.890 They can come back up here. 27:02.490 --> 27:08.090 But before we go any further here, we have to know something about a 27:08.090 --> 27:08.470 computer. 27:09.190 --> 27:11.870 There is something called PC. 27:13.630 --> 27:17.370 PC stands for Program Counter. 27:18.830 --> 27:19.250 PC. 27:21.950 --> 27:23.310 Program Counter. 27:23.510 --> 27:25.150 And you think about it. 27:25.710 --> 27:27.810 What does the Program Counter do? 27:27.910 --> 27:28.490 What is that? 27:28.590 --> 27:33.250 If you translate it directly from English, then it's not that helpful. 27:34.290 --> 27:39.890 It doesn't count the number of programs I have in my memory or the 27:39.890 --> 27:42.110 number of apps I have running or anything like that. 27:43.090 --> 27:44.410 It's obviously something else. 27:44.930 --> 27:46.490 Does anyone know what a Program Counter is? 27:49.130 --> 27:50.070 Does anyone have an idea? 27:50.590 --> 27:51.470 Because that's important now. 27:51.570 --> 27:53.370 I'll tell you right away, but maybe someone knows. 27:54.470 --> 27:55.950 A Program Counter. 27:56.150 --> 27:58.530 So it has something to do with a program and with counting. 28:03.130 --> 28:13.110 The Program Counter, what it does, it just shows where we are in the 28:13.110 --> 28:13.450 memory. 28:14.090 --> 28:21.470 So a program is in the memory and where we are right now, where it is 28:21.470 --> 28:24.130 being executed in the sequence of the program. 28:25.150 --> 28:28.430 That's where the Program Counter is pointing to. 28:28.670 --> 28:32.770 It shows, so to speak, at the current top of the program. 28:33.390 --> 28:35.810 I can symbolically draw it up like this. 28:38.450 --> 28:39.810 Symbolically, it looks like this. 28:40.210 --> 28:40.930 We have a program. 28:41.150 --> 28:42.570 You can do that from below or above. 28:42.830 --> 28:43.770 That doesn't matter now. 28:45.610 --> 28:46.490 That's supposed to be the memory. 28:48.090 --> 28:53.250 And every line is a command word. 28:54.910 --> 29:00.270 So here it says, for example, add something, here it says load, here 29:00.270 --> 29:03.270 it says store, here it says go to, or something like that. 29:05.510 --> 29:09.230 And then of course there are the 32 bits here, for example. 29:10.950 --> 29:12.250 And everything is coded in there. 29:12.810 --> 29:13.290 That's all we have. 29:14.490 --> 29:16.770 We know how a command word is built up. 29:16.930 --> 29:19.270 That was in the last lecture. 29:19.470 --> 29:20.450 That's 32 bits. 29:20.550 --> 29:21.090 I won't repeat it. 29:21.890 --> 29:23.370 And in the memory it looks like this. 29:24.370 --> 29:25.710 I could have drawn it from top to bottom. 29:26.150 --> 29:30.250 So we have a command here, add command, load command, store command, 29:30.390 --> 29:30.910 and so on. 29:31.830 --> 29:32.470 And we execute. 29:33.830 --> 29:37.850 Each command takes a few cycles. 29:39.030 --> 29:40.870 And let's say we execute. 29:40.950 --> 29:41.890 Here's the time. 29:42.490 --> 29:45.830 And the program counter does the following. 29:46.050 --> 29:46.830 It points here. 29:47.990 --> 29:49.170 Then it points here. 29:49.670 --> 29:50.890 Then it points here. 29:51.730 --> 29:56.570 That means the program counter points to the current command. 30:03.680 --> 30:07.340 You could also instruction pointer. 30:09.900 --> 30:14.080 I don't know where to go now. 30:15.520 --> 30:17.000 Oh yes, yes, yes. 30:17.120 --> 30:17.760 Okay, okay, okay. 30:19.020 --> 30:19.420 Exactly. 30:19.840 --> 30:20.460 It was said. 30:22.000 --> 30:23.180 It's the same. 30:24.500 --> 30:26.600 Very good contribution. 30:27.120 --> 30:29.780 There are different ways to name this program counter. 30:29.780 --> 30:31.280 It depends on the database. 30:31.520 --> 30:32.400 It depends on the company. 30:33.120 --> 30:36.060 It depends on whether it's old or new, and so on. 30:37.860 --> 30:39.580 There are different names for it. 30:39.920 --> 30:43.880 We just call our lecture Program Counter. 30:44.760 --> 30:48.800 Although, if I think about it, instruction counter would be better. 30:49.720 --> 30:53.140 Because then you would say it counts the instructions of a program. 30:54.020 --> 30:56.760 And program counter, if you translate it, means program counter, but 30:56.760 --> 30:57.500 that's actually not true. 30:57.740 --> 31:01.120 We don't argue about how someone named something. 31:02.140 --> 31:04.060 I didn't do it myself, but took over. 31:05.380 --> 31:12.340 We just try not to imagine, but we try to figure out what is meant by 31:12.340 --> 31:12.340 it. 31:12.580 --> 31:16.820 In this case, the same instruction counter or program counter points 31:16.820 --> 31:18.200 to the tip of the program. 31:18.200 --> 31:20.280 We execute a program and it points there. 31:22.000 --> 31:26.440 That means, what is the value of the program counter? 31:26.960 --> 31:30.800 If we understood that now, I assume you understood it that way. 31:31.420 --> 31:37.880 The program counter points to the tip of the program. 31:38.540 --> 31:41.620 What is the value of the program counter? 31:42.980 --> 31:46.840 The program counter itself also has a value, so to speak. 31:50.100 --> 31:51.400 This is an address. 31:51.960 --> 31:52.120 Exactly. 31:53.380 --> 31:56.020 That's why we say it points. 31:56.220 --> 31:57.980 It points with its finger on it. 31:58.960 --> 32:04.320 The program counter does not represent the top command or the last 32:04.320 --> 32:07.200 command in the program, but it points to it. 32:07.300 --> 32:08.080 That's why I said point. 32:09.220 --> 32:09.940 You got that right. 32:10.220 --> 32:11.400 It points to it. 32:11.400 --> 32:18.260 That means it contains the address of the command that I just 32:18.260 --> 32:18.820 executed. 32:21.100 --> 32:22.360 It is very important to know. 32:22.880 --> 32:26.680 Because on these following slides we calculate with the program 32:26.680 --> 32:27.160 counter. 32:27.260 --> 32:29.040 You have to know exactly what you said. 32:31.000 --> 32:32.260 Very good contribution. 32:33.260 --> 32:34.440 Did you understand that? 32:34.600 --> 32:35.060 Please ask. 32:35.420 --> 32:38.180 It is a very important principle that you know what the program 32:38.180 --> 32:43.480 counter is and what the value of the program counter is and what it is 32:43.480 --> 32:43.860 not. 32:44.260 --> 32:45.180 What I just said twice. 32:47.300 --> 32:49.380 Don't hesitate to ask. 32:49.780 --> 32:53.140 Every question has so far contributed to the fact that we have 32:53.140 --> 32:54.500 understood things more closely. 32:56.760 --> 32:57.000 Good. 32:57.720 --> 32:59.620 Then I repeat it again. 33:00.140 --> 33:05.740 The program counter points to the top part of the program, where we 33:05.740 --> 33:06.480 are currently executing. 33:07.180 --> 33:13.380 The value of the program counter is the address of the top command 33:13.380 --> 33:14.500 that we are currently executing. 33:15.820 --> 33:16.380 Good. 33:16.800 --> 33:18.700 If we know that, the rest is very simple. 33:19.920 --> 33:20.580 There it is. 33:20.860 --> 33:22.180 There is the program counter. 33:22.200 --> 33:23.760 Now I have to know what I am doing with it. 33:25.460 --> 33:27.060 But let's go here first. 33:27.700 --> 33:33.000 Now we have an example and this is called immediate addressing. 33:33.000 --> 33:35.520 What do I want to do? 33:36.160 --> 33:47.920 Load the accumulator A with the hexadecimal value A3 and in itself 33:47.920 --> 33:54.160 also a very simple command that does exactly that. 33:55.040 --> 33:55.680 We know the battery. 33:56.060 --> 34:00.320 We should push the value into the battery to do something with it 34:00.320 --> 34:00.320 later. 34:01.320 --> 34:02.420 What do I do? 34:04.540 --> 34:07.620 The calculation of the address looks like this. 34:07.820 --> 34:08.820 I wonder now. 34:10.280 --> 34:11.380 I wonder now. 34:13.640 --> 34:14.840 You can ask. 34:14.940 --> 34:15.820 We just understood that. 34:15.960 --> 34:18.100 Now we need to know what that means. 34:18.700 --> 34:19.920 We need to know that now. 34:22.620 --> 34:28.260 If we understand what the program counter means and if we know that 34:28.260 --> 34:34.140 with this command this hexadecimal value should be loaded into the 34:34.140 --> 34:40.660 accumulator, then we would have exactly expected that the address 34:40.660 --> 34:42.660 would be calculated like this. 34:42.700 --> 34:44.560 Would we have expected that or is it a surprise? 34:48.110 --> 34:55.690 Here it says the effective address EA is PC plus 1. 34:55.690 --> 35:00.440 How does that work? 35:01.940 --> 35:04.220 For whom is it clear and for whom is it surprising? 35:04.620 --> 35:06.020 You don't have to answer one question. 35:07.520 --> 35:10.520 I don't want to be mean, but still. 35:10.940 --> 35:12.460 Could someone explain it? 35:16.640 --> 35:17.840 What happens? 35:17.960 --> 35:19.020 It is obviously very important. 35:19.340 --> 35:22.680 If I hadn't asked everyone would have said PC plus 1. 35:22.740 --> 35:24.900 I don't need to listen anymore. 35:24.900 --> 35:28.060 But it is not so trivial. 35:28.340 --> 35:30.040 Here it says PC plus 1. 35:30.800 --> 35:32.860 Of course it is easy, but I'll show it to you. 35:35.540 --> 35:39.520 Here is the current command and here it says LDA. 35:41.120 --> 35:41.960 Let's assume that. 35:42.220 --> 35:45.400 And here is the memory again, as I just painted it, the program. 35:46.800 --> 35:48.220 And then it goes on like this. 35:50.080 --> 35:55.220 And now, this is the interesting part, here the program counter points 35:55.220 --> 36:01.920 to this LDA command that we just had on this page. 36:02.760 --> 36:03.280 Namely this one. 36:04.720 --> 36:05.780 This one is in here. 36:09.300 --> 36:16.140 And here, and this is exactly the thing, this hexadecimal has 36:16.140 --> 36:17.280 something in it. 36:17.280 --> 36:18.340 What was that value? 36:18.340 --> 36:21.640 We can imagine but that was A3 in this case. 36:22.620 --> 36:23.300 It is in here. 36:24.160 --> 36:25.660 And that is exactly the thing now. 36:26.940 --> 36:28.220 I didn't have space. 36:28.860 --> 36:29.620 That is very important. 36:29.820 --> 36:32.440 There are a lot of things behind such a simple addition. 36:33.040 --> 36:38.520 I didn't have space to put this value A3 in this instruction word 36:38.520 --> 36:38.680 here. 36:40.080 --> 36:44.160 We have learned that there are different ways to code an instruction. 36:44.820 --> 36:46.020 32-bit. 36:47.680 --> 36:52.720 And in 32-bit I can of course not put a 32-bit value and the opcode. 36:53.220 --> 37:00.200 So obviously for this command I need two command words. 37:00.700 --> 37:09.580 I need this one where the LDA is in it and I need this one where the 37:09.580 --> 37:10.540 actual value is in it. 37:10.540 --> 37:13.320 Well, now it is a small value A3, I could have put it in there. 37:14.260 --> 37:18.640 But in the worst case it could be a 32-bit number. 37:19.220 --> 37:23.140 So I need a new word for it. 37:23.320 --> 37:23.960 That is the thing. 37:24.440 --> 37:25.300 And now we get closer to the point. 37:26.640 --> 37:28.560 Here the PC points to. 37:28.900 --> 37:30.320 Here the PC points to. 37:31.680 --> 37:36.120 The PC points to So it has the content. 37:36.360 --> 37:38.340 Not the content, it points to it. 37:38.340 --> 37:42.300 It has the memory address where the LDA is. 37:43.760 --> 37:46.120 And now comes the plus one. 37:47.140 --> 37:52.080 In the plus one, namely PC plus one, there is this value. 37:54.200 --> 37:55.780 That is the address. 37:56.140 --> 38:02.380 PC is the address of this memory cell and PC plus one is the address 38:02.380 --> 38:03.700 of this memory cell. 38:04.300 --> 38:07.420 And with that we have the address of this command. 38:11.660 --> 38:14.080 So you can see what is happening here. 38:14.560 --> 38:17.920 Not only is something moved here, a value in there. 38:18.400 --> 38:26.080 To achieve this, I have to know the PC value, add one to it, take out 38:26.080 --> 38:31.080 this value and then I can do what the command is supposed to do, 38:32.200 --> 38:35.260 namely take this value and write it into the battery. 38:38.340 --> 38:40.540 And here I would like to ask if this is understood. 38:41.680 --> 38:45.720 Once you have understood it, then you have understood the whole 38:45.720 --> 38:46.200 principle. 38:46.580 --> 38:49.960 Then all the folders that come later can be derived. 38:50.040 --> 38:53.200 Only if you do not know what the PC is, where it points to, or whether 38:53.200 --> 38:56.440 it has the value or the address, then you will never get it. 38:56.840 --> 38:59.760 Then the folders look trivial, but they are not trivial. 39:00.580 --> 39:05.040 So the honest question and the honest answer is if you have understood 39:05.040 --> 39:05.040 it. 39:05.820 --> 39:10.460 And if not, then I explain it the other way around so that everyone 39:10.460 --> 39:11.120 understands. 39:18.790 --> 39:19.090 Good. 39:19.550 --> 39:19.910 I assume. 39:25.720 --> 39:26.960 Absolutely right. 39:27.820 --> 39:28.740 Very good comment. 39:29.840 --> 39:31.540 If the command is executed, 39:35.920 --> 39:41.620 then the PC is enlarged by one or two values. 39:43.900 --> 39:49.380 That makes the logic in the background, I say at some point I have 39:49.380 --> 39:52.540 executed the command, I am done with it. 39:52.620 --> 40:01.380 And in the background it was then said PC results from PC plus 1 or PC 40:01.380 --> 40:07.000 results from PC plus 2. 40:07.940 --> 40:10.820 Here I do not only have to go one further, because that was the 40:10.820 --> 40:13.760 argument of this command, but I have to go on at 2. 40:14.960 --> 40:16.880 So very, very good comment. 40:17.840 --> 40:18.920 This is of course continued. 40:20.160 --> 40:24.200 And then when I have the PC in this line, then I look at what is in 40:24.200 --> 40:25.660 there and so on. 40:25.660 --> 40:31.240 The PC is automatically incremented. 40:31.460 --> 40:35.980 I do not have to take care of it myself, but the computer, not the 40:35.980 --> 40:40.120 operating system, but the computer itself in the hardware, it 40:40.120 --> 40:40.840 increases it by one. 40:41.340 --> 40:45.740 And that is actually a good example of that a lot happens in such a 40:45.740 --> 40:48.940 computer that as a programmer I do not even notice. 40:50.040 --> 40:53.920 Obviously someone has to increment the PC by one. 40:55.180 --> 40:58.200 It is not in the program, but someone has to do it. 40:58.380 --> 41:00.360 It takes time, it costs computing resources. 41:01.720 --> 41:02.960 So thank you very much for the contribution. 41:03.260 --> 41:06.040 Anyone else, a contribution or a question about it? 41:10.230 --> 41:13.970 Well, then we just go on and it always runs according to the same 41:13.970 --> 41:14.810 scheme, so to speak. 41:15.030 --> 41:20.890 I read it to you and explain what is meant by it and then we can 41:20.890 --> 41:21.870 continue to talk about it. 41:22.750 --> 41:23.870 So now let's take a look at that first. 41:25.490 --> 41:32.550 Now it says here jump to the address that actually just sounds like. 41:32.550 --> 41:33.510 This is a jump command. 41:34.110 --> 41:36.310 We have control commands in a program. 41:36.470 --> 41:40.230 In this case it is an unconditional jump command. 41:40.390 --> 41:44.130 That means I jump in the program when I get there with my PC. 41:44.130 --> 41:48.290 When I arrive there, I definitely jump somewhere else. 41:48.790 --> 41:52.810 No matter whether any calculation has gone wrong or has a certain 41:52.810 --> 41:54.150 value or not. 41:55.270 --> 41:57.730 So an unconditional command, jump. 42:00.810 --> 42:09.570 What I'm doing here now is I jump to this value here, take the PC plus 42:09.570 --> 42:12.070 one and the content of it. 42:12.970 --> 42:16.710 I just wanted to calculate the address and now I take the content and 42:16.710 --> 42:19.390 the content is then an address for it. 42:20.430 --> 42:23.890 PC, the program counter plus one has the same reason. 42:25.490 --> 42:28.910 That is this value. 42:29.450 --> 42:33.650 But with the value I don't calculate in that sense now, but I use it 42:33.650 --> 42:36.110 as an address to jump there. 42:38.350 --> 42:39.150 That's meant here. 42:39.730 --> 42:42.610 So actually from the explanation also relatively simple. 42:43.170 --> 42:48.170 From the presentation as an architecture it looks a bit different. 42:48.470 --> 42:50.190 Here I have the address, the operand. 42:50.350 --> 42:51.530 I don't know if it helps you. 42:51.810 --> 42:54.270 I would say I don't refer to it here. 42:55.090 --> 42:58.550 We just explain what is meant by it and how the address is calculated. 43:02.150 --> 43:06.210 Now I wanted to tell you a few other things that we have to put in 43:06.210 --> 43:06.210 here. 43:06.850 --> 43:11.170 There are of course different pages of an address and different 43:11.750 --> 43:15.630 possibilities of the address and different pages in the computer. 43:15.950 --> 43:23.130 So pages are here and there is something like a zero page and a zero 43:23.130 --> 43:26.010 page, okay, the name says that's the zero page or something. 43:26.910 --> 43:28.250 The idea here is the following. 43:28.830 --> 43:30.350 So what is a page anyway? 43:30.530 --> 43:32.230 First we have to explain what a page is. 43:32.570 --> 43:36.370 Typically the memory is divided into pages. 43:36.370 --> 43:43.910 Just like a book consists of words and each book also has pages and on 43:43.910 --> 43:45.290 each page are words. 43:45.670 --> 43:46.970 So nothing else in the end. 43:47.790 --> 43:50.430 It's just a hierarchy in between. 43:50.650 --> 43:51.570 So there are pages. 43:51.750 --> 43:53.610 Pages are many words, I would say. 43:54.770 --> 43:56.350 And how big that is, I can't tell you. 43:56.430 --> 43:58.530 That depends again on the microprocessor system. 43:58.810 --> 44:02.470 Let's say that's a kilobyte or 4 kilobyte or 512 byte, something like 44:02.470 --> 44:02.710 that. 44:03.270 --> 44:06.890 So a page consists of many words. 44:09.170 --> 44:10.910 Why do we even have such a hierarchy? 44:11.010 --> 44:16.450 You can ask yourself, isn't it enough if you only address words? 44:18.810 --> 44:21.990 But because memory is very large, because there are different types of 44:21.990 --> 44:26.030 memory, I don't quite agree with this knowledge yet, they introduced 44:26.030 --> 44:28.510 something and said, let's take a step in between. 44:28.650 --> 44:29.770 There are also pages. 44:31.070 --> 44:38.170 I can, for example, address and say, I want to go to this page and 44:38.170 --> 44:39.710 stay on this page for the time being. 44:40.530 --> 44:46.610 And then everything I then do, address, refers implicitly to this 44:46.610 --> 44:47.090 page. 44:49.710 --> 44:52.030 That's the reason why I have pages. 44:53.210 --> 44:54.350 And now comes the question of price. 44:55.230 --> 44:58.030 What I just said, why could that be an advantage? 44:59.650 --> 45:10.870 I repeat it again, I say at some point I go to this page and before I 45:10.870 --> 45:14.730 say anything else, I assume for the rest of the program that I stay on 45:14.730 --> 45:15.490 this page. 45:17.550 --> 45:23.430 And all the calculations I do or all the addresses I make refer to 45:23.430 --> 45:24.410 this page. 45:26.330 --> 45:27.530 Why can that make sense? 45:33.540 --> 45:36.920 More memory addresses, that comes very close to it. 45:37.840 --> 45:38.980 It's related to addressing. 45:40.980 --> 45:43.300 The question is half right. 45:44.480 --> 45:50.520 It's related to the fact that I need fewer bits when I'm on this page 45:50.520 --> 45:51.940 to address. 45:53.020 --> 45:55.060 I have many pages in the memory. 45:55.760 --> 45:57.820 I say, I'll just stay in this memory. 45:57.820 --> 46:02.220 And since the memory is smaller and as I just said, there are only 46:02.220 --> 46:09.840 four kilobytes or something like that, I obviously need 12 bits to 46:09.840 --> 46:13.060 find an address on this page. 46:13.840 --> 46:15.920 And I don't need 32 bits. 46:16.680 --> 46:21.440 So say something, be in this context, continue in this context and 46:21.440 --> 46:25.960 then need fewer bits to go back to parts of this page. 46:25.960 --> 46:29.340 So your answer was very good. 46:32.040 --> 46:36.660 And then there is also a page, this is now a very well-drawn page, 46:36.800 --> 46:39.860 it's called Zero Page, as it says here, the zero page. 46:41.300 --> 46:44.540 And typically this is the page that is at the bottom of your memory. 46:45.220 --> 46:48.480 So where the memory starts, where you start counting. 46:48.680 --> 46:51.600 So the first or the zeroth. 46:51.700 --> 46:54.120 In this case, the zeroth is where the computers start counting at 46:54.120 --> 46:54.280 zero. 46:57.000 --> 47:01.240 And this page, and this is also a very important thing, is typically 47:01.240 --> 47:05.040 used by the operating system. 47:05.740 --> 47:08.540 The operating system has to do the calculations itself. 47:08.760 --> 47:10.900 We already had examples of what an operating system can do. 47:12.300 --> 47:20.620 And the operating system would reserve this zero page for itself and 47:20.620 --> 47:26.120 thus have the easy possibility or a simple possibility to access the 47:26.120 --> 47:26.460 memory. 47:27.260 --> 47:29.860 It needs fewer address bits for this. 47:31.680 --> 47:34.540 If it is clear that it refers to the zeroth page. 47:36.820 --> 47:37.980 And that is a bit excellent. 47:38.240 --> 47:42.260 So if you read something in the literature, Zero Page is a good chance 47:42.260 --> 47:48.820 that this is the page that is not available to me as a user, which is 47:48.820 --> 47:49.600 used by the operating system. 47:50.920 --> 47:52.640 And in practice, this is also prevented. 47:52.960 --> 47:55.800 I could not even access it from the C program. 47:56.780 --> 48:02.420 If I would try to access the zero page from the C program, then 48:02.420 --> 48:05.340 someone would prevent it. 48:05.340 --> 48:07.660 At the latest, if the operating system itself. 48:08.380 --> 48:09.500 But there is such a page. 48:09.500 --> 48:12.440 And that's why I put it in now. 48:12.940 --> 48:17.200 Because we need to know that for the address types. 48:17.760 --> 48:26.740 Sometimes we can jump on the entire memory without the number of 48:26.740 --> 48:28.600 necessary bits for it. 48:29.340 --> 48:35.080 And that's exactly the case when I know which page I am referring to. 48:35.900 --> 48:39.320 And of course there are also historical examples for such 48:39.320 --> 48:43.640 microprocessors, for example Intel 8086 or whatever they have always 48:43.640 --> 48:43.940 done. 48:44.420 --> 48:49.060 They had two program counters, Now we come back to this thing about 48:49.060 --> 48:49.920 the program counter. 48:50.740 --> 48:57.860 A program counter counts when I am in the program within a page. 48:58.760 --> 49:02.520 And from time to time it happens that a program is larger than a page. 49:02.760 --> 49:04.280 I have to jump across page boundaries. 49:05.780 --> 49:07.900 Then there is another counter. 49:08.760 --> 49:10.720 Let's put it there, what it's called now. 49:11.080 --> 49:12.320 But it would go up by one second. 49:13.360 --> 49:15.000 I am now on the other side. 49:15.120 --> 49:18.260 I read on the other side, so to speak, when we compare it with a book. 49:18.820 --> 49:24.140 And then I can go back to my smaller program counter, which can only 49:24.140 --> 49:27.020 address the size of this page. 49:27.020 --> 49:27.740 And then I can continue. 49:29.220 --> 49:31.280 In this case, of course, it would start again at zero. 49:33.520 --> 49:34.940 So that's what's behind it. 49:35.960 --> 49:38.040 And you can see all these pieces of art. 49:38.260 --> 49:42.520 Why are there such zero pages and why don't you save the entire 49:42.520 --> 49:45.860 address in the command word? 49:46.200 --> 49:49.880 In the end, there is always only one very, very simple reason. 49:51.100 --> 49:53.180 You want to fight for every bit in the end. 49:53.180 --> 49:55.980 Every bit costs space. 49:56.180 --> 49:57.320 It costs resources. 49:58.460 --> 50:00.700 And with these resources I'm having fun. 50:01.180 --> 50:06.040 And for that you consider many techniques to make the most of bits and 50:06.040 --> 50:07.100 bytes. 50:08.380 --> 50:09.460 It's nothing else. 50:11.480 --> 50:15.880 So the argument that you say we have so many bits and bytes, we don't 50:15.880 --> 50:17.880 need to look at it that way, why are we making an effort? 50:18.260 --> 50:20.100 It actually never applies. 50:20.700 --> 50:25.220 Because you have to imagine that if there is a new technology and I 50:25.220 --> 50:31.160 have a memory, I can buy a memory stick of 128 gigabytes for, I don't 50:31.160 --> 50:32.820 know, 50 euros or something like that. 50:33.560 --> 50:37.920 Then, of course, I also have applications that fill up quickly. 50:38.240 --> 50:40.120 The memory is actually always too short. 50:40.280 --> 50:41.440 That's the way it is. 50:41.520 --> 50:43.240 I used to have a computer. 50:43.780 --> 50:48.060 My first computer, I don't know if I told you in the first lecture, it 50:48.060 --> 50:50.460 had 38,911 bytes free. 50:51.160 --> 50:56.120 You can type in Google by the way, 38,911 bytes free. 50:56.440 --> 51:00.240 That's typing in Google and then you get to C64 computer. 51:00.400 --> 51:01.420 It had always registered. 51:01.760 --> 51:04.980 That was exactly the thing, 38,960 bytes free. 51:05.520 --> 51:06.440 That was a lot back then. 51:07.060 --> 51:10.540 And today, when you save a word file and there's nothing in it, I 51:10.540 --> 51:12.320 don't know, 100 kilobytes or something. 51:12.320 --> 51:17.760 And with these 38,911 bytes, you could even program on computer games 51:18.440 --> 51:19.400 and they did something. 51:19.940 --> 51:21.560 They even had colors and something happened. 51:21.920 --> 51:23.480 It's unimaginable. 51:24.240 --> 51:27.660 Of course, back then you thought it wouldn't be bad if I had 128 51:27.660 --> 51:28.480 kilobytes. 51:29.260 --> 51:32.160 And then if I had a megabyte or something like that, no question. 51:32.420 --> 51:36.540 But you see what was a lot back then where you said, if I had twice as 51:36.540 --> 51:39.100 much, then I would be happy and then I don't need more. 51:39.100 --> 51:42.640 Yes, then it was 100 kilobytes or a megabyte. 51:42.780 --> 51:45.340 Now we're talking about a gigabyte or 100 gigabytes or something. 51:46.840 --> 51:50.580 My statement here is storage. 51:51.660 --> 51:56.640 This storage bit is valuable, no matter how much it costs. 51:56.900 --> 51:59.260 I need it and storage is always short, so to speak. 52:00.340 --> 52:03.860 So don't see this as historical things. 52:04.400 --> 52:05.440 That still applies today. 52:06.280 --> 52:08.040 Above all, does storage cost money? 52:08.040 --> 52:10.100 Storage has storage hierarchies. 52:11.140 --> 52:16.600 Fast, small, big, slow, which are also cheaper and so on. 52:17.200 --> 52:18.700 All in all, does it cost money? 52:18.780 --> 52:19.540 It adds up. 52:19.800 --> 52:20.580 No question at all. 52:20.700 --> 52:21.860 We don't want to discuss that. 52:22.320 --> 52:23.440 Storage costs money. 52:24.380 --> 52:28.160 And in every complicated, complex microprocessor that you can buy 52:28.160 --> 52:35.100 today, an infinite number of efforts are driven to get the last bit 52:35.100 --> 52:37.700 out of any bit, so to speak. 52:38.820 --> 52:45.120 These are really only basic techniques that we describe here, but they 52:45.120 --> 52:46.900 are by no means outdated. 52:48.680 --> 52:52.880 Now we've done a little overview of zero addressing. 52:53.920 --> 52:57.860 Now let's look at what register indirect addressing means. 52:58.900 --> 53:01.720 Here's an example for register indirect addressing. 53:01.720 --> 53:03.520 I'll just read it out. 53:03.640 --> 53:04.620 I'll explain it to you then. 53:05.080 --> 53:11.580 Load the register R1, this one, with the content that is stored by the 53:11.580 --> 53:13.700 address register A0. 53:17.760 --> 53:21.440 So there are two registers here, two types of registers. 53:22.260 --> 53:27.140 One is where I have my data in it, the R1, and the other has a 53:27.140 --> 53:30.920 different name, it starts with A, I use it to store addresses. 53:31.740 --> 53:33.700 Well, you can think about that, it's not a problem. 53:34.260 --> 53:38.760 And now load the register R1, I want to push something into the R1, 53:39.020 --> 53:42.480 with the content that is stored by the address register A0. 53:44.300 --> 53:45.380 What does that mean? 53:45.740 --> 53:56.480 That means in this register A0 there is a value, an address value. 53:57.940 --> 54:01.160 And I calculate that in this way. 54:01.860 --> 54:05.940 It looks trivial, it just means the content of this bracket. 54:06.560 --> 54:07.980 Take the content of. 54:08.380 --> 54:08.880 That's all it means. 54:09.840 --> 54:12.800 So these brackets that we have in the coming slides, they don't stand 54:12.800 --> 54:14.660 there, you can cut them out or something. 54:15.140 --> 54:16.500 It has a semantic meaning. 54:16.820 --> 54:20.340 The semantic meaning is take the content of. 54:20.960 --> 54:22.380 That's the effective address. 54:23.020 --> 54:26.880 So if you think about it, nothing more happens here. 54:28.840 --> 54:33.100 Just take the content of this register and put it in there. 54:35.140 --> 54:38.440 But we still have a few combinations, we still have a few slides, and 54:38.440 --> 54:40.680 it gets a little more interesting. 54:43.240 --> 54:44.840 So let's go on. 54:44.940 --> 54:46.200 What happens here now? 54:46.380 --> 54:47.160 Here we have the following. 54:49.660 --> 54:56.840 Increment, inc, increment, the content of the bracket that is 54:56.840 --> 55:03.980 addressed by register A0 and then the content of A0. 55:04.460 --> 55:07.100 I'm doing two things in one line here. 55:08.020 --> 55:10.840 You have to be a little careful that you know what is being 55:10.840 --> 55:12.860 incremented here and why. 55:14.800 --> 55:17.520 First increment the content of the bracket. 55:18.140 --> 55:20.400 So R0 is a bracket. 55:20.780 --> 55:22.300 There is a word in it. 55:22.860 --> 55:24.420 I'm supposed to increment that. 55:24.540 --> 55:25.300 That's what it says here. 55:27.140 --> 55:32.260 And then, when I'm done with it, something else happens. 55:34.560 --> 55:37.320 The content of R0 is then incremented. 55:41.060 --> 55:42.940 It is incremented twice here. 55:44.740 --> 55:51.200 And then there are things like post-increment or pre-decrement. 55:51.300 --> 55:52.460 The plus is after that. 55:52.660 --> 55:53.720 The plus is after that. 55:53.840 --> 55:57.720 That means, do it first and then increment it. 55:59.520 --> 56:02.000 And you could now put the plus in front of it. 56:02.500 --> 56:03.700 Then it would increment it first. 56:04.960 --> 56:06.640 That's a little confusing now, of course. 56:07.040 --> 56:09.960 It's already built in a bit so that you pay a little more attention, 56:10.160 --> 56:10.400 etc. 56:11.360 --> 56:14.200 That this is now an increment command, we wouldn't even have to say 56:14.200 --> 56:17.380 where it's about address types here. 56:17.780 --> 56:21.660 But at least you can see that you can do quite a lot with a simple 56:21.660 --> 56:26.520 command that, admittedly, starts to look a bit cryptic. 56:30.560 --> 56:31.780 Now let's go on. 56:31.920 --> 56:34.940 Here we have the same thing again, only here a clear is made. 56:35.080 --> 56:39.040 It says here, decrement the content of the register R0 and then delete 56:39.040 --> 56:41.360 the memory word that is addressed by R0. 56:41.360 --> 56:43.980 It's about the address. 56:45.240 --> 56:48.020 Decrement the content of the register R0. 56:48.300 --> 56:57.090 R0 is a register, has a content, decrement it. 56:59.590 --> 57:04.670 And then delete the memory word afterwards. 57:06.350 --> 57:09.710 In the register there is a number. 57:10.150 --> 57:16.690 This number is an address and this address shows on a memory word. 57:17.210 --> 57:20.130 And this memory word should then be deleted. 57:22.710 --> 57:23.710 Does that make sense? 57:27.010 --> 57:31.590 Decrement first the content of the register R0. 57:33.710 --> 57:36.090 A register, there is a value in it, let's say 1000. 57:37.430 --> 57:39.170 I'll do that to 999. 57:41.650 --> 57:44.530 And then delete the memory word that is addressed by R0. 57:45.530 --> 57:51.470 Then I look in the memory where is the memory number 999 and delete 57:51.470 --> 57:51.530 that. 57:54.610 --> 57:55.870 That's what it's meant for. 57:58.410 --> 58:02.990 And that's why the bracket says here, content of the register. 58:13.790 --> 58:16.110 Here is a clear, it could also be a decrement. 58:17.970 --> 58:19.670 So I hope you understood it that way. 58:19.670 --> 58:24.290 That this simple arithmetic with the simple brackets and the plus sign 58:24.290 --> 58:25.710 what is meant by it. 58:26.770 --> 58:32.850 I just say if you look through the slides too late and didn't listen 58:32.850 --> 58:37.490 to the lecture, you can hardly get it out. 58:37.850 --> 58:42.970 That's why I always try to repeat it twice and hope that you 58:42.970 --> 58:47.670 understood what that means. 58:49.670 --> 58:51.450 Now I can do many other things. 58:51.910 --> 58:52.930 Indexed addressing. 58:53.510 --> 58:58.430 We can of course also do things like we have some fields and so on and 58:58.430 --> 58:58.990 so forth. 58:59.570 --> 59:01.010 Indexed table processing. 59:01.190 --> 59:01.490 Here it is. 59:02.550 --> 59:04.770 Address distance to a base value. 59:05.410 --> 59:10.170 A very simple example is we want to program sorting algorithms and 59:10.170 --> 59:14.510 want an address type that is suitable for it. 59:16.630 --> 59:19.150 And for that we would have a base value somewhere. 59:19.510 --> 59:21.590 That is the beginning of the table. 59:23.050 --> 59:26.110 And relative to this table we would then address. 59:26.370 --> 59:30.150 So it would be the element 0, 1, 2, 3, 4, 5, up to 10 or something 59:30.150 --> 59:30.350 like that. 59:31.550 --> 59:35.750 And for that we would like to have an address type that allows us to 59:35.750 --> 59:37.570 search in a table and sort. 59:38.970 --> 59:42.570 And for that there are these memory-relative, register-relative, 59:42.570 --> 59:47.390 address -relative with index, for example. 59:47.730 --> 59:49.130 And for that we now have examples again. 59:49.270 --> 59:49.830 First let's take a look at this. 59:50.850 --> 59:56.450 I think if you have understood what is written down here, then it is 59:56.450 --> 59:59.930 easier to understand the address calculation of the previous slide. 01:00:00.610 --> 01:00:06.730 So let's just read it out very slowly and try to understand it. 01:00:07.310 --> 01:00:09.990 Save the content of R1. 01:00:09.990 --> 01:00:12.610 ST stands for save and store. 01:00:13.790 --> 01:00:15.210 Register is the register R1. 01:00:15.450 --> 01:00:20.170 So save the content of R1 into the memory word. 01:00:22.070 --> 01:00:24.390 And now a second sentence. 01:00:24.490 --> 01:00:28.090 How do I get to this memory word? 01:00:28.130 --> 01:00:33.890 Namely the memory word whose address results from the addition of the 01:00:33.890 --> 01:00:35.570 content of R0. 01:00:36.350 --> 01:00:42.990 Content of R0, the round brackets, content of R0 to the base and this 01:00:42.990 --> 01:00:47.470 A740 hexadecimal results. 01:00:48.830 --> 01:00:49.870 So again. 01:00:50.690 --> 01:00:52.010 We want to save something. 01:00:52.750 --> 01:00:53.590 That's what the store says. 01:00:54.450 --> 01:00:56.930 And we want to save it into register R1. 01:00:57.290 --> 01:00:58.790 That's quite simple. 01:00:59.530 --> 01:01:01.670 And what do I want to save in it? 01:01:01.990 --> 01:01:11.030 I want to save a value that results from an address that is in 01:01:11.030 --> 01:01:11.830 register R0. 01:01:12.110 --> 01:01:13.430 There is another register. 01:01:13.830 --> 01:01:16.550 There is an address, a house number in it. 01:01:17.450 --> 01:01:20.470 For example, the beginning of the table is in there. 01:01:20.790 --> 01:01:24.250 It's on the memory address 5667. 01:01:24.970 --> 01:01:25.970 That's in there. 01:01:27.590 --> 01:01:30.110 And well, that would be this value. 01:01:30.530 --> 01:01:32.150 And here is the index. 01:01:32.150 --> 01:01:35.910 That is, the tenth element of it. 01:01:38.110 --> 01:01:44.550 And if you then calculate that as an effective address, then it looks 01:01:44.550 --> 01:01:45.390 exactly like this. 01:01:47.650 --> 01:01:49.370 We got to know the program counter. 01:01:51.310 --> 01:01:57.090 The PC plus 1 is the PC plus 1. 01:01:57.230 --> 01:02:04.790 We want to try to find exactly what is on this slide in this command 01:02:04.790 --> 01:02:04.930 here. 01:02:05.910 --> 01:02:08.110 It shouldn't be magic or anything. 01:02:09.150 --> 01:02:10.430 We want to try to find exactly that. 01:02:11.610 --> 01:02:13.090 PC plus 1. 01:02:13.990 --> 01:02:14.170 We already had that. 01:02:15.730 --> 01:02:17.450 That's exactly what's there. 01:02:18.210 --> 01:02:21.710 That's this constant, which can now be worth 32 bits. 01:02:22.950 --> 01:02:30.510 So it's a place before the command word. 01:02:30.990 --> 01:02:32.750 That means the PC plus 1. 01:02:33.010 --> 01:02:33.690 That's what we have there. 01:02:36.090 --> 01:02:38.490 And now we have the index. 01:02:39.330 --> 01:02:43.930 And the index is stored in the register A0. 01:02:44.110 --> 01:02:45.750 There is now, for example, 10 in there. 01:02:46.490 --> 01:02:47.430 The element 10. 01:02:48.170 --> 01:02:49.570 And now I'm doing exactly that. 01:02:49.790 --> 01:02:53.750 Now I add the address where my field starts. 01:02:53.750 --> 01:02:55.390 My field, which I want to sort. 01:02:56.290 --> 01:03:00.470 I add up with the value that is in A0. 01:03:01.410 --> 01:03:04.530 And that is my effective address. 01:03:05.010 --> 01:03:05.530 It doesn't mean anything else. 01:03:07.390 --> 01:03:11.030 I just have to understand the semantic meaning of what is here. 01:03:11.410 --> 01:03:12.510 What is the command counter? 01:03:12.650 --> 01:03:15.530 Command counter 1 is what is in front of the memory. 01:03:17.630 --> 01:03:22.450 And the content of it is exactly this value here. 01:03:23.870 --> 01:03:30.990 And the index is in this case the content, round brackets, of what is 01:03:30.990 --> 01:03:31.910 in the register A0. 01:03:36.140 --> 01:03:37.400 So that's understandable. 01:03:37.700 --> 01:03:42.780 I think this sentence is always easy to understand. 01:03:43.940 --> 01:03:50.080 from here, how to calculate the effective address, I would say is not 01:03:50.080 --> 01:03:52.040 very trivial if you don't know it. 01:03:52.040 --> 01:03:53.900 But I hope you understood the principle. 01:03:54.880 --> 01:03:58.820 And you see, you can of course do various other arithmetic with all 01:03:58.820 --> 01:03:59.500 these things. 01:04:00.480 --> 01:04:06.160 Of course, I also have to say that as a programmer I luckily don't 01:04:06.160 --> 01:04:07.340 have to calculate the effective address. 01:04:08.880 --> 01:04:10.680 The computer does that for me, so to speak. 01:04:11.380 --> 01:04:17.700 So I mainly have to remember what this address type does, what these 01:04:17.700 --> 01:04:21.540 round brackets mean here, and that there is an implicit plus in 01:04:21.540 --> 01:04:22.600 between, and so on. 01:04:22.720 --> 01:04:24.420 So exactly what is meant here. 01:04:26.400 --> 01:04:28.520 Well, I assume we understood that. 01:04:29.740 --> 01:04:31.040 And of course you can continue as you like. 01:04:34.520 --> 01:04:35.620 And here we have the following. 01:04:36.220 --> 01:04:43.320 Here is the memory word whose address is due to the addition of 01:04:43.320 --> 01:04:48.160 hexadecimal offset A7 to the content of the base register B0. 01:04:48.520 --> 01:04:52.960 So it's relatively similar. 01:04:53.940 --> 01:04:54.960 Something is added again. 01:04:56.120 --> 01:04:57.740 This serves again as an index. 01:04:58.220 --> 01:05:00.060 We have a constant here again. 01:05:01.500 --> 01:05:04.380 And you see, it looks significantly different. 01:05:04.960 --> 01:05:08.820 Only the nomenclature here is a little different because it's about 01:05:10.260 --> 01:05:11.080 register B. 01:05:11.300 --> 01:05:14.340 But you see, in principle, nothing is different here. 01:05:14.340 --> 01:05:15.680 And what do I do with it in the end? 01:05:16.040 --> 01:05:18.560 I want to delete the address resulting from it. 01:05:20.520 --> 01:05:22.060 That means the command then. 01:05:23.880 --> 01:05:28.220 I hope, I have always explained it in such detail, that I can no 01:05:28.220 --> 01:05:33.720 longer go through so many sentences in each coming slide, but that you 01:05:33.720 --> 01:05:38.420 can at least understand at home with this explanation what was meant 01:05:38.420 --> 01:05:38.720 by it. 01:05:40.480 --> 01:05:44.920 And above all, how the address, the effective address, is calculated. 01:05:45.140 --> 01:05:46.040 What is the PC? 01:05:46.740 --> 01:05:49.940 In PC plus one there is another value. 01:05:50.380 --> 01:05:54.880 And this value is then the address of a memory cell whose content I 01:05:54.880 --> 01:05:58.660 take and add to the content of a register. 01:05:59.400 --> 01:06:04.560 So that's the interpretation of this expression here. 01:06:07.990 --> 01:06:14.150 And as I said, this up here, I'll say who is good in architecture, but 01:06:14.150 --> 01:06:16.850 that will only be later, when we look at computer architecture. 01:06:17.990 --> 01:06:22.110 Then this up here helps to further explain what the whole thing does. 01:06:22.410 --> 01:06:25.570 And I have deliberately omitted it because I think at the moment it 01:06:25.570 --> 01:06:26.530 would only be confusing. 01:06:27.630 --> 01:06:31.970 But as I said, if we go a few slides further, we'll see what computer 01:06:31.970 --> 01:06:32.930 architecture looks like. 01:06:33.110 --> 01:06:37.250 And then you have different tools to explain yourself when you prepare 01:06:37.250 --> 01:06:41.130 for the exam, how the address is calculated. 01:06:42.450 --> 01:06:44.470 And with that I would almost leave it here. 01:06:44.670 --> 01:06:45.410 There is another one. 01:06:45.510 --> 01:06:47.290 We have another one to put on it. 01:06:47.490 --> 01:06:50.750 Register-relative addressing with index. 01:06:53.010 --> 01:06:56.630 In the end, there are only two things that are different here. 01:06:56.630 --> 01:07:02.770 One thing that is different here is that one more thing is added here. 01:07:03.850 --> 01:07:09.770 Again, a value is taken that is placed in the program counter. 01:07:14.410 --> 01:07:20.350 Then the content of an index register is taken and added to it and a 01:07:20.350 --> 01:07:21.650 second index register. 01:07:23.450 --> 01:07:25.210 What could this be, for example? 01:07:25.570 --> 01:07:30.310 Of course, you can always come up with wild things, but at least what 01:07:30.310 --> 01:07:32.250 we do here still makes sense somewhere. 01:07:32.590 --> 01:07:38.870 I just said that this could be a field that I sort. 01:07:39.490 --> 01:07:42.510 I have an index, a base and an index. 01:07:44.410 --> 01:07:45.550 And now two appear here. 01:07:46.110 --> 01:07:47.110 Maybe there could also be three. 01:07:47.470 --> 01:07:47.810 I don't know. 01:07:49.970 --> 01:07:52.250 But what could you imagine here now? 01:07:52.970 --> 01:07:54.630 What could I do with this now? 01:07:56.010 --> 01:07:57.590 What would you come up with? 01:07:59.090 --> 01:08:04.930 Sorting a field of integer numbers was the example just now. 01:08:05.830 --> 01:08:07.190 What would that be here? 01:08:09.590 --> 01:08:11.270 That was a one-dimensional field. 01:08:18.030 --> 01:08:21.170 I can imagine I have a matrix here, for example. 01:08:21.950 --> 01:08:23.870 I can imagine I have a matrix. 01:08:25.190 --> 01:08:29.530 Here in the command word the base is specified where it is in the 01:08:29.530 --> 01:08:29.750 memory. 01:08:31.670 --> 01:08:35.570 And then I have lines and crevices here, for example. 01:08:38.410 --> 01:08:45.770 Here I would have an address that I can use to address a matrix in a 01:08:45.770 --> 01:08:51.170 memory, to access, to read or to write. 01:08:51.310 --> 01:08:54.950 Of course, I can also use this type of address for other commands. 01:08:55.390 --> 01:08:56.210 But that's just an example. 01:08:57.190 --> 01:08:58.970 Now let's see what we had here for an example. 01:08:59.950 --> 01:09:01.570 And here it is a decrement. 01:09:02.570 --> 01:09:03.490 So let's go through. 01:09:03.750 --> 01:09:05.770 Decrement the memory word. 01:09:06.630 --> 01:09:09.790 Decrement says here and what memory word is it now? 01:09:10.510 --> 01:09:16.090 Its address is defined by adding the contents of the register I0, B0 01:09:16.090 --> 01:09:19.930 to the offset A7. 01:09:23.170 --> 01:09:28.410 I have an offset which is stored in PC plus 1. 01:09:29.930 --> 01:09:31.870 I have two different types. 01:09:31.990 --> 01:09:33.510 Now the third type of registers. 01:09:33.770 --> 01:09:35.570 You should also remember what we did here. 01:09:36.190 --> 01:09:38.910 We had registers that called themselves R. 01:09:38.910 --> 01:09:40.830 Then we had register A. 01:09:41.090 --> 01:09:44.430 Now we have register B or even register I for index. 01:09:45.030 --> 01:09:49.050 So one thing we learn here is that there are different types of 01:09:49.050 --> 01:09:52.990 registers in a microprocessor that I use for different tasks. 01:09:54.170 --> 01:09:56.310 And here, for example, there is an address register. 01:09:56.430 --> 01:09:57.770 That was this A0 from earlier. 01:09:58.370 --> 01:10:00.570 Or, for example, an index register. 01:10:00.950 --> 01:10:04.910 I work at the same time with different tables where I have different 01:10:04.910 --> 01:10:08.850 indices and I store them in the index register. 01:10:13.510 --> 01:10:15.550 Now there is another one on top of it. 01:10:15.890 --> 01:10:21.630 And then I increase the content of the register I0. 01:10:23.310 --> 01:10:25.970 So you have to think carefully what has happened here. 01:10:28.810 --> 01:10:32.850 I am looking for the base address 01:10:36.570 --> 01:10:37.110 in the index register. 01:10:38.390 --> 01:10:41.530 I have an index register that has a value. 01:10:41.890 --> 01:10:43.190 I add that to it. 01:10:44.230 --> 01:10:46.710 I have a second index that is B0 here. 01:10:47.150 --> 01:10:48.730 I add that to it. 01:10:49.010 --> 01:10:51.790 That adds up to an address in the storage. 01:10:55.630 --> 01:10:57.750 And I decrement it. 01:10:58.050 --> 01:10:58.950 I put it down by one. 01:10:59.270 --> 01:11:00.530 That tells me the command word. 01:11:01.010 --> 01:11:02.890 But now comes the thing that comes on top of it. 01:11:03.130 --> 01:11:08.410 Namely, that the index register is automatically increased by one. 01:11:10.590 --> 01:11:12.130 Exactly what I just said. 01:11:12.430 --> 01:11:13.950 We go through a matrix. 01:11:15.250 --> 01:11:20.550 And if I now write the command just as it is there, then it does not 01:11:20.550 --> 01:11:24.430 mean that I repeat the command, but what does it mean? 01:11:25.170 --> 01:11:30.150 So it would not be a mistake or stupidity if I would repeat the 01:11:30.150 --> 01:11:31.230 command three times. 01:11:33.130 --> 01:11:38.110 I would just treat the element that comes after exactly the same, 01:11:38.290 --> 01:11:38.970 namely decrement by one. 01:11:40.730 --> 01:11:44.570 And the element that follows because I automatically increase it by 01:11:44.570 --> 01:11:45.230 one. 01:11:47.310 --> 01:11:50.330 So I go on in the matrix by one, so to speak. 01:11:51.090 --> 01:11:55.550 While the decrement says the content in the matrix I would like to 01:11:55.550 --> 01:11:56.370 reduce by one. 01:12:09.810 --> 01:12:15.050 So what we actually mean is to decrement a memory cell. 01:12:17.090 --> 01:12:22.250 And the registers only hold the addresses to calculate this memory 01:12:22.250 --> 01:12:22.670 cell. 01:12:24.030 --> 01:12:31.190 That means this index register is an index to pass a column or line in 01:12:31.190 --> 01:12:31.190 this matrix. 01:12:32.330 --> 01:12:37.990 And if I increase the value of this register by one, it means that the 01:12:37.990 --> 01:12:42.310 next time I do it, I am in a different space in the memory, so to 01:12:42.310 --> 01:12:42.310 speak. 01:12:50.820 --> 01:12:52.420 Well, okay. 01:12:57.220 --> 01:12:57.560 I see. 01:12:58.680 --> 01:12:58.780 Okay. 01:13:00.660 --> 01:13:05.340 The question is, I think the question is why is there a comma, so to 01:13:05.340 --> 01:13:05.480 speak? 01:13:09.330 --> 01:13:11.670 It would mean something else semantically. 01:13:13.010 --> 01:13:14.110 You also have to consider the following. 01:13:15.190 --> 01:13:19.850 It is not that I can logically explain that there is a comma because. 01:13:20.570 --> 01:13:23.710 It is typically the case that you have to say that this is a 01:13:23.710 --> 01:13:25.250 convention to do this. 01:13:25.650 --> 01:13:30.410 I can't even tell you, to be honest, if I remove the comma, whether it 01:13:30.410 --> 01:13:32.150 would make sense, so to speak. 01:13:32.530 --> 01:13:34.450 Maybe there is no address type at all. 01:13:34.890 --> 01:13:39.150 Here it is really the case that everything I see has a semantic 01:13:39.150 --> 01:13:42.310 meaning and I have to know what the semantic meaning is. 01:13:43.770 --> 01:13:46.910 And accordingly, it is then interpreted. 01:13:47.230 --> 01:13:49.530 And this semantic meaning corresponds to this word. 01:13:52.470 --> 01:13:54.330 But the rest is not clear. 01:13:54.510 --> 01:13:58.550 The content of this memory, of this cell is then increased, which 01:13:58.550 --> 01:14:02.670 means that the next time I execute the command in another line or 01:14:02.670 --> 01:14:07.450 column of the main memory and then decrement it, for example. 01:14:10.120 --> 01:14:14.880 Well, that means that we have already gone through the address types 01:14:14.880 --> 01:14:18.100 or have given an example for everyone. 01:14:20.240 --> 01:14:24.220 And the rest, I would just say, there is of course still, 01:14:35.790 --> 01:14:42.650 well, I can at least say that all characters and sequences make some 01:14:42.650 --> 01:14:42.910 sense. 01:14:42.910 --> 01:14:44.650 I can tell you that. 01:14:45.170 --> 01:14:46.070 Very good question. 01:14:46.310 --> 01:14:48.470 The question is, if this plus is here, 01:14:53.490 --> 01:14:54.670 that makes sense. 01:14:55.570 --> 01:14:56.530 And then I would do the following. 01:14:56.970 --> 01:15:02.310 If I execute the command here, before I access this address in the 01:15:02.310 --> 01:15:07.970 matrix that we are talking about all the time, before I do that, I 01:15:07.970 --> 01:15:14.270 would say that I increment the column, if it is the column. 01:15:15.210 --> 01:15:21.850 That means, I first pass a column on and then I calculate the entire 01:15:21.850 --> 01:15:22.190 address from here. 01:15:22.330 --> 01:15:24.330 That would then be called pre-increment. 01:15:25.170 --> 01:15:30.210 That means, before I go to this calculation here, I would increase the 01:15:30.210 --> 01:15:34.150 content of this register and thus the column or line, whatever I do in 01:15:34.150 --> 01:15:39.950 my program, and then calculate this address. 01:15:40.830 --> 01:15:40.950 Yes? 01:15:49.110 --> 01:15:52.470 Ah, look, these are all super good questions. 01:15:52.930 --> 01:15:57.030 Here you have to, no, I tell you, and the reason why I don't know this 01:15:57.030 --> 01:15:58.490 is because it's all symbolic. 01:15:58.790 --> 01:16:01.570 What I have to do here, that's a very good question, I have to look 01:16:01.570 --> 01:16:06.170 closely in a database, when I buy an assembler, how is it interpreted 01:16:06.170 --> 01:16:06.490 at all? 01:16:07.130 --> 01:16:07.510 Yes? 01:16:07.850 --> 01:16:11.330 You have the very good question, when this plus is now here, you said, 01:16:11.490 --> 01:16:15.310 when the plus is there, I gave you an example, I said, this is a pre 01:16:15.310 --> 01:16:21.890 -increment and you say, now it could not be that this is a post 01:16:21.890 --> 01:16:23.230 -increment for the B0. 01:16:23.870 --> 01:16:27.310 Then I say, yes, it could be, and I say, oh, I don't know because I 01:16:27.310 --> 01:16:30.770 don't have a database for the thing, but I have to know, does it go 01:16:30.770 --> 01:16:33.550 from left to right, from right to left, how is it put together? 01:16:34.350 --> 01:16:36.410 What does the plus refer to when it is here? 01:16:38.090 --> 01:16:42.690 Very good comments, and how it really is is in the database. 01:16:42.810 --> 01:16:48.390 Incidentally, this also applies to the C++, or C, you remember two 01:16:48.390 --> 01:16:51.390 weeks ago or something, we had different operations. 01:16:51.390 --> 01:16:55.350 I think ASFOR had presented that, I didn't do that myself, but there 01:16:55.350 --> 01:17:01.850 were tables and there was, for example, an addition, a pointer 01:17:01.850 --> 01:17:05.790 operation, things like that, you remember, there were 14 or 20 01:17:05.790 --> 01:17:10.710 different levels and there was a priority and it said that this 01:17:10.710 --> 01:17:15.010 operation is more binding, it has a higher priority, so logically I 01:17:15.010 --> 01:17:18.530 have to start putting things together. 01:17:19.170 --> 01:17:22.690 And then there were also things like I have to do it from left to 01:17:22.690 --> 01:17:25.750 right, sometimes it even said I have to do it from right to left. 01:17:26.850 --> 01:17:31.670 And my answer to your question is I just have to know how I put it 01:17:31.670 --> 01:17:32.170 together. 01:17:33.350 --> 01:17:36.890 And if I have an example, then there is guaranteed in the back of the 01:17:36.890 --> 01:17:40.390 manual a table that says how I have to interpret it. 01:17:40.710 --> 01:17:46.110 So if the plus was here, then I would have to look there and I gave 01:17:46.110 --> 01:17:48.630 him two examples of what it could mean. 01:17:50.330 --> 01:17:56.150 So those were very good comments that definitely contributed to that 01:17:56.150 --> 01:17:58.190 we don't make any mistakes later. 01:18:00.150 --> 01:18:00.450 Good. 01:18:04.330 --> 01:18:05.790 Oh, it goes on, we have another one. 01:18:06.290 --> 01:18:11.370 Now we have another one, and now it's about having a long branch. 01:18:11.370 --> 01:18:14.350 What is a long branch? 01:18:17.670 --> 01:18:21.610 A branch is a branch, a long is a long branch. 01:18:22.750 --> 01:18:28.050 Long is relative, relative to the memory size, relative in this case 01:18:28.050 --> 01:18:34.470 to the address, to the address possibility of the processor, for 01:18:34.470 --> 01:18:34.790 example. 01:18:35.110 --> 01:18:35.670 Imagine the following. 01:18:37.070 --> 01:18:46.330 We have a memory that is larger than the address possibility, than the 01:18:46.330 --> 01:18:48.630 primary address possibility of the processor. 01:18:49.250 --> 01:18:57.650 So, for example, the processor can address 32 bits, but the memory has 01:18:57.650 --> 01:19:00.050 an address range of 34 bits or something like that. 01:19:00.710 --> 01:19:01.930 That could be a long branch. 01:19:03.450 --> 01:19:08.190 I have to jump over the area that my processor knows. 01:19:09.060 --> 01:19:11.230 Or another example. 01:19:12.030 --> 01:19:21.070 I want a long jump, which is only 32 bits, but it is called long jump 01:19:21.070 --> 01:19:30.750 or branch because the address fits in 32 bits, but I can't code this 01:19:30.750 --> 01:19:36.250 address in an instruction word, because in an instruction word of 32 01:19:36.250 --> 01:19:41.650 bits, the opcode can still be included. 01:19:41.690 --> 01:19:46.870 And if I want to submit the address, then it may only be 25 bits or 01:19:46.870 --> 01:19:51.510 something like that, then 32 bits may be interpreted as long. 01:19:52.210 --> 01:19:53.230 So long is relative. 01:19:53.750 --> 01:20:00.490 It just means that I want to be able to address something that I can't 01:20:00.490 --> 01:20:02.230 address in any other way. 01:20:03.570 --> 01:20:04.110 That's all it means. 01:20:05.050 --> 01:20:07.270 And now we have an example here. 01:20:08.070 --> 01:20:12.990 Long branch always, so always necessarily, branch necessarily, so 01:20:12.990 --> 01:20:19.490 without it depending on any program operation conditions, to a memory 01:20:19.490 --> 01:20:27.770 cell whose address distance to the current program counter is 7FFF. 01:20:27.770 --> 01:20:36.470 So I don't assume that I jump to the physical memory address, but I 01:20:36.470 --> 01:20:43.170 say to the point where I am right now, namely in the program, I add 01:20:43.770 --> 01:20:49.810 this long address distance on it and that's where I then continue my 01:20:49.810 --> 01:20:53.270 program, the place where I want to continue my program. 01:20:54.990 --> 01:20:58.870 And if we have understood that, then we can at least understand this 01:20:58.870 --> 01:20:59.090 here. 01:21:00.210 --> 01:21:02.990 Now there is a 2 here, now it gets a little more difficult. 01:21:04.170 --> 01:21:05.290 But it's very simple. 01:21:05.990 --> 01:21:07.430 Let's start on the right here, we already had that. 01:21:07.750 --> 01:21:13.330 PC is our, the LBRA is in the PC. 01:21:14.230 --> 01:21:19.110 Plus 1, well, there's my argument in there. 01:21:21.010 --> 01:21:23.310 There's my argument in there, but 01:21:27.360 --> 01:21:28.240 there's the argument. 01:21:28.460 --> 01:21:29.600 So here, that was the right thing to do. 01:21:30.020 --> 01:21:37.640 And some of you wrote in, you could now say that my 7FFF would be 01:21:38.460 --> 01:21:38.980 this. 01:21:41.100 --> 01:21:43.240 The 7FFF is in here. 01:21:44.120 --> 01:21:49.700 That was the correspondence between this file and this program and 01:21:49.700 --> 01:21:50.020 this one. 01:21:50.020 --> 01:21:51.300 Here's the 7FF in there. 01:21:51.300 --> 01:21:56.660 But now it says PC plus 2. 01:22:00.920 --> 01:22:02.220 PC plus 2. 01:22:04.700 --> 01:22:06.020 Why plus 2? 01:22:06.280 --> 01:22:08.760 We had plus 1, now we have plus 2. 01:22:29.840 --> 01:22:31.720 That's partly right. 01:22:31.860 --> 01:22:34.860 So with the 7FFF I can't get any further. 01:22:35.160 --> 01:22:37.240 That's part of the address, so to speak. 01:22:38.060 --> 01:22:39.860 Which is in here, you said that correctly. 01:22:41.740 --> 01:22:51.620 And this 7FFF, I'm adding that now to the place where I am at the 01:22:51.620 --> 01:22:51.920 moment. 01:22:52.840 --> 01:22:53.980 So I'm somewhere in the program. 01:22:54.100 --> 01:22:57.420 I'm the program, I run it, I look, I swim in the program. 01:22:58.020 --> 01:22:59.140 I'm somewhere there. 01:23:00.220 --> 01:23:04.620 Now I see PC plus 1, there's my 7FFF. 01:23:05.040 --> 01:23:10.960 And now I want to jump from PC plus 1 to 7FFF. 01:23:12.300 --> 01:23:15.480 So I have to ask myself first, where am I at all? 01:23:16.560 --> 01:23:22.160 I'm in PC and I want to jump from PC. 01:23:22.900 --> 01:23:29.360 That means I need the value, the command counter itself, to calculate 01:23:29.490 --> 01:23:31.580 the address where I want to jump. 01:23:34.520 --> 01:23:40.380 And that's because in plus 1 there is the 7FFF. 01:23:41.000 --> 01:23:46.020 In 2, that would be the next free place, the next command I would 01:23:46.020 --> 01:23:48.160 execute if I didn't jump. 01:23:48.940 --> 01:23:51.160 That is, so to speak, the base address. 01:23:52.120 --> 01:23:55.180 And then I add that to the 7FFF. 01:23:56.340 --> 01:23:57.240 Does that make sense? 01:23:57.460 --> 01:24:00.160 Of course, with words it is a bit difficult to explain again. 01:24:00.340 --> 01:24:04.000 But with the formula too. 01:24:04.000 --> 01:24:06.960 Has anyone not understood or understood? 01:24:07.080 --> 01:24:08.220 I think we'll go through it again. 01:24:08.360 --> 01:24:11.960 I don't know if I explained it understandably, what exactly happens. 01:24:14.440 --> 01:24:17.520 It's about this command, which actually, and that's the interesting 01:24:17.520 --> 01:24:20.140 thing about this, it looks so super simple. 01:24:21.580 --> 01:24:26.300 You wouldn't have thought that such a complex operation would take 01:24:26.300 --> 01:24:27.640 place if I found such a simple command. 01:24:28.040 --> 01:24:29.080 I'll say so, right? 01:24:30.580 --> 01:24:32.520 But maybe I'll record that again. 01:24:32.900 --> 01:24:34.740 If we record that, then we can understand it better. 01:24:40.640 --> 01:24:41.940 Then let's do it here. 01:24:42.620 --> 01:24:42.860 So. 01:24:44.420 --> 01:24:45.560 Here is our memory. 01:24:47.700 --> 01:24:50.220 And it was about what command was it? 01:24:50.260 --> 01:24:51.380 It was a store command. 01:24:51.500 --> 01:24:54.840 So let's just do LBRA. 01:24:56.360 --> 01:24:56.980 It's in here. 01:24:57.900 --> 01:24:58.980 Here is the PC. 01:24:59.740 --> 01:25:00.240 PC. 01:25:00.240 --> 01:25:00.380 PC. 01:25:02.300 --> 01:25:02.940 So. 01:25:03.300 --> 01:25:05.160 Now it says 7FFF. 01:25:06.620 --> 01:25:10.540 Here is the value in it. 01:25:14.960 --> 01:25:15.600 7FFF. 01:25:15.760 --> 01:25:16.320 It's in here. 01:25:16.800 --> 01:25:17.900 That's the plus one. 01:25:18.300 --> 01:25:21.040 Here we have the PC, then I'll do plus one here. 01:25:21.960 --> 01:25:22.080 So. 01:25:24.660 --> 01:25:24.920 So. 01:25:25.240 --> 01:25:28.740 And after what is written here, I want to jump relatively. 01:25:30.060 --> 01:25:33.380 Relatively to the place where I am currently. 01:25:34.120 --> 01:25:35.860 Where am I currently? 01:25:36.040 --> 01:25:37.040 On the PC. 01:25:38.100 --> 01:25:38.300 So. 01:25:38.500 --> 01:25:39.400 I'm here. 01:25:40.580 --> 01:25:45.200 And here would be the next free address, so to speak. 01:25:45.520 --> 01:25:49.180 This is the PC plus two. 01:25:49.520 --> 01:25:49.920 That there. 01:25:50.480 --> 01:25:51.360 That's empty. 01:25:52.120 --> 01:25:53.600 I don't want to jump in there at all. 01:25:53.600 --> 01:26:01.680 I just say relative to this address in the main memory, I want to jump 01:26:01.680 --> 01:26:01.980 now. 01:26:02.860 --> 01:26:08.540 So to this address, whatever it is, namely PC plus two. 01:26:08.760 --> 01:26:09.420 That's this one. 01:26:10.480 --> 01:26:16.300 There I add the value 7FFF on it and then jump up here. 01:26:16.740 --> 01:26:17.660 That's all it says. 01:26:20.100 --> 01:26:22.080 And the PC plus one. 01:26:22.080 --> 01:26:22.820 Here is the PC. 01:26:22.960 --> 01:26:25.680 PC plus one, there is the 7FFF saved. 01:26:26.000 --> 01:26:30.260 So that's how the PC plus two plus the PC plus one comes about here. 01:26:35.270 --> 01:26:35.800 They nod. 01:26:36.400 --> 01:26:38.500 If everyone nods now, then I'll go on. 01:26:41.570 --> 01:26:42.350 Well, now two. 01:26:46.040 --> 01:26:48.580 Of course I really care that they understand it. 01:26:48.720 --> 01:26:49.340 No question. 01:26:49.920 --> 01:26:52.660 But I still doubt that everyone has already understood it. 01:26:52.660 --> 01:26:58.140 So ask a question. 01:26:58.840 --> 01:27:01.920 Before that, when someone asked a question, then it always became 01:27:01.920 --> 01:27:02.660 somehow clearer. 01:27:03.000 --> 01:27:04.020 Something still came up. 01:27:04.400 --> 01:27:07.740 So if you have a question, no problem. 01:27:13.570 --> 01:27:15.070 I'll go over it again next time. 01:27:16.710 --> 01:27:19.930 Because you have to let it sit a bit that you really understood it. 01:27:21.710 --> 01:27:27.930 I think that's it with the addressing possibilities. 01:27:28.130 --> 01:27:29.110 But one more thing. 01:27:29.570 --> 01:27:33.770 Of course, we have always only shown examples for different addressing 01:27:33.770 --> 01:27:34.350 types. 01:27:36.590 --> 01:27:37.650 Example commands. 01:27:38.490 --> 01:27:42.990 Now, of course, there are a huge number of commands that I can combine 01:27:42.990 --> 01:27:45.970 with these addressing types for the most part. 01:27:47.490 --> 01:27:53.350 That means, in the end, we only got draft samples and what that means 01:27:53.350 --> 01:27:57.810 for the execution of the command, if I use one or the other addressing 01:27:57.810 --> 01:27:58.250 type. 01:27:59.890 --> 01:28:02.970 That would be the transfer performance, if you understood all these 01:28:02.970 --> 01:28:06.210 files and understood what was happening. 01:28:08.090 --> 01:28:10.070 So it's pretty basic, the whole thing. 01:28:12.010 --> 01:28:14.490 And maybe think about a few more questions for the next time. 01:28:14.590 --> 01:28:18.590 Then we can go through them and see if we understood everything. 01:28:18.990 --> 01:28:19.870 See you next time. 01:28:19.890 --> 01:28:19.990 Bye.