1
$\begingroup$

I read this in my Operating System textbook. Does it mean that the logical addresses generated by compile-time binding scheme are the same as the logical addresses generated by load-time binding? Or does it mean that the logical addresses and the physical addresses generated are the same in both compile-time binding as well as load-time binding?

If the first interpretation is correct, then how is it possible to generate same logical addresses in both compile-time and load-time? AFAIK in compile-time binding, we already have a fixed location in the memory where we'll load our program, so we can generate absolute addresses. But in load-time scheme, we do not know where the program will be loaded in memory. So we put relative addresses. How can absolute and relative addresses be the same?

$\endgroup$
5
  • $\begingroup$ How old is that textbook? Even on your iPhone, they make quite sure that libraries will be loaded to random locations (because that prevents lots of attacks against an application). $\endgroup$
    – gnasher729
    Jan 22, 2020 at 20:51
  • $\begingroup$ The book is from 2007. But it does mention that compile time binding was only used in MS-DOS .COM files. $\endgroup$ Jan 23, 2020 at 5:31
  • $\begingroup$ Please clearly identify sources of quotes. (Couldn't tell the context (a multiple choice "answer"?), seems to be from Silberschatz/Galvin/Gagne Operating System Concepts, Wiley) $\endgroup$
    – greybeard
    Dec 18, 2020 at 7:00
  • $\begingroup$ @greybeard The textbook I was using at that time was written by some local college professor but I am 100% sure the content was completely plagiarized from Operating System Conepts by Silberschatz, Galvin and Gagne. You can find the quoted statement here in these notes boron.physics.metu.edu.tr/ozdogan/OperatingSystems/week9/… which are based on the same text book. $\endgroup$ Dec 19, 2020 at 18:06
  • 1
    $\begingroup$ Unfortunately worded, to say the least. $\endgroup$
    – greybeard
    Dec 19, 2020 at 21:59

2 Answers 2

3
$\begingroup$

What your TB says is absolutely correct & the answer is the latter i.e. the second interpretation.

More particularly:

  • The logical address & the physical address generated in the compile-time address binding scheme are the same.
  • The logical address & the physical address generated in the load-time address binding scheme are the same.

Why?

Context:

Definition of Logical address: A logical address or virtual address is an address that is generated by the CPU during program execution. - afteracademy

Definition of Physical address: physical address refers to a memory address or the location of a memory cell in the main memory - Techopedia

The compile-time binding is used when the base address of the process memory allocation is known before hand i.e. " a priori ". This never happens in real-life because you never know any mechanism/system to predict what the addresses will be at the time of writing the program itself.

However, in case that really happens (How? Static allocation / magic), the address generated by compiler (i.e. the logical address/virtual address) is indeed the actual physical address because the programmer hard-coded the addresses.

Similar (but not same) is the case with Load-time binding.

$\endgroup$
4
  • 1
    $\begingroup$ Welcome to COMPUTER SCIENCE @SE. You use a block quote for definitions: Please tell who originated the contents and where to find it (& make it a habit). $\endgroup$
    – greybeard
    Dec 18, 2020 at 6:51
  • $\begingroup$ (Static allocation used to be common with embedded computers. The extent to which OS concepts like process apply stands to argue.) $\endgroup$
    – greybeard
    Dec 18, 2020 at 7:01
  • $\begingroup$ Hey @greybeard, thanks for letting me know. $\endgroup$
    – schegu
    Dec 19, 2020 at 15:36
  • $\begingroup$ But doesn't the programmer use the symbolic address in the source program? $\endgroup$ Aug 7, 2021 at 3:20
0
$\begingroup$

Silberschatz defined "logical address" as the address leaving the CPU. In this case, the address leaving the CPU is the same as the address sent to memory. But in execution-time binding, the addresses may differ.

$\endgroup$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.