Next Previous Contents

9. Glossary

9.1 Definitions

  • SMP Symmetric Multi-Processors.
  • UP Uni-Processor: system with one processor.
  • APIC Advanced Programmable Interrupt Controler.
  • thread A thread is a processor activity in a process. The same process can have multiple threads. Those threads share the process address space and can therefore share data.
  • pthread Posix thread, threads defined by the Posix standard.
  • process Program in execution, with its environment.
  • MTRR Memory Type Range Register
  • APM Advanced Power Management.
  • FPU Floating Point Unit. Also called arithmetic co-processor.
  • IRQ Interrupt ReQuest.
  • EBDA Extended BIOS Data Area.
  • ACPI Advanced Configuration and Power Interface.
  • oops Internal kernel error.
  • Cluster Group of computers that achieve a common computation (also known as Beowulf within the Linux community).

9.2 Concepts

  • Data Races

    A data race happens when to processes want to modify a shared variable concurrently without protecting themselves from the effect of the other process.

    Let A a shared variable. Let P1 and P2 two processes that access this variable. Those two processes are making the same following operation: "read A in tmp variable (local to the precess); do tmp = tmp + 1 ; write tmp in A". If the A variable is not protected by a lock, resulting executions could not correspond to what is espected. For example, here is two examples if one do not lock A:

    case #1:
    A=0
    P1: read A -> tmp1 (so tmp1 is 0)
    P2: read A -> tmp2 (so tmp2 is 0)
    P1: tmp1 = tmp1 + 1 (so tmp1 is 1)
    P2: tmp2 = tmp2 + 1 (so tmp2 is 1)
    P1: tmp1 -> write A (so A is 1)
    P2: tmp2 -> write A (so A is 1)
    

    case #2:
    A=0
    P1: read A -> tmp1 (so tmp1 is 0)
    P1: tmp1 = tmp1 + 1 (so tmp1 is 1)
    P1: tmp1 -> write A (so A is 1)
    P2: read A -> tmp2 (so tmp2 is 1)
    P2: tmp2 = tmp2 + 1 (so tmp2 is 2)
    P2: tmp2 -> write A (so A is 2)
    

    To avoid this kind of problem, one uses a lock:

    A=0:
    P1: lock A
    P1: read A -> tmp1 (so tmp1 is 0)
    P2: lock A (so P2 is blocked)
    P1: tmp1 = tmp1 + 1 (so tmp1 is 1)
    P1: tmp1 -> write A (so A is 1)
    P1: unlock A (so P2 is unblocked)
    P2: read A -> tmp2 (so tmp2 is 1)
    P2: tmp2 = tmp2 + 1 (so tmp2 is 2)
    P2: tmp2 -> write A (so A is 2)
    P2: unlock A
    

  • Deadlock

    This is an inter-blocking that occurs when two processes want to access at shared variables mutually locked. For example, let A and B two locks and P1 and P2 two processes:

    P1: lock A
    P2: lock B
    P1: lock B (so P1 is blocked by P2)
    P2: lock A (so P2 is blocked by P1)
    
    Process P1 is blocked because it is waiting for the unlocking of B variable by P2. However P2 also needs the A variable to finish its computation and free B. So we have a deadlock.

    In this example, the problem is very simple. But imagine what can happen in a 2 millions of lines of code (like the linux kernel) with hundreds of locks. :-)


Next Previous Contents
Copyright © 2010-2024 Platon Technologies, s.r.o.           Home | Man pages | tLDP | Documents | Utilities | About
Design by styleshout