Exam Questions

Question 1

The Underground Tank Monitoring System is a classic example of an embedded system in that it involves input (sensors/buttons), output (display/printer) and real-time constraints. true/false

Answer 1

an underground tank mointoring system would include all of those logically, so yes

Question 2

6. Several models of computation for embedded systems are described in [Lee:2002].
   
   • The ROS software is a prime example of the publish-and-subscribe model. true/false

Answer 2

true, that s exactly what ROS is

Question 3

1. Finite State Machines can be coded in a number of ways in C.
   
   • In the function-based solution, every state is encoded as a separate function.

Answer 3

true, you have a pointer that memories the address of a function and that is how it changes the current state, by changing whatever is in that pointer variable.

Question 4

Specifying the type of statefp is difficult in C because forward declarations are not supported for function types.

Answer 4

1. what are forward declarations?
   
   1. a statement that declares the existence of a variable or struct or function without providing any actual implementation for it
   2. usually when a program needs to refer to a function or struct that has not yet been declared in code, but will be declared later
   3. and, it is supported in C.
      
      1. thus the statement is FALSE

Question 5

Valgrind is programming tool that provides controlled execution, as well as post mortem inspection of an executable.

Answer 5

this is false because this is actually what GDB does.

Question 6

To guarantee atomicity task switching must be disabled.

Answer 6

1. Atomicity is when a set of instructins to happen as a single, indivisible unit. An atomic op
   
   1. guarateed to execute completly and without interruption
   2. no intermediate states visible to other operations
   3. they are either fully executed or not at all
   4. no ops can interffer with them during operations
   5. usually implemented with mutexes and semaphores
   6. Interrupts and atomicity
      
      1. Because interrupts can interrupt execution, they can be disabled during critical sections to avoid them firing during an atomic op.
      2. or they can use mutexes etc

Task switching

• it s very important to the CPU and disabling it is usually not an option, or a very bad one
  
  • to preserve atomicity and not have it be affected by ttask switching (witch usually cant even be disabled) the only practical and used way is to use mutexes and semaphores.
    
    • so, disabling task switching is a bad idea, cant be done and the answer is false

Question 7

1. Since disabling interrupts increases interrupt latency, several alternative methods have been developed for dealing with shared data.
   
   • The Alternating Buffers technique can be used between two “communicating” tasks provided that the “producer” runs at a higher priority than the “consumer”.

Answer 7

• Alternating Buffer
  
  • it is a technique for dealing with shared data.
    
    • multiple buffers are used to hold shared data.
    • each thread uses its own buffer where it writes or reads data, or at least there are many buffers that can do this. This is faster then mutexes or semaphores as it has far less overhead and is better for the shared data. However it is difficult to implement and work with, but it can be done in very memory / power /computation critical systems
    • Yes it is based on the consumer and producer design pattern and the producer must have a higher priority for it to make sense.

Question 8

Priority inversionrequires a minimum of 3 tasks of different priority and 1 semaphoreto occur.

Answer 8

1. this is to be remebered because it s a standard question
   
   1. So, for a deadly embrace you need at least 2 tasks to hold eachother resources and mutexes.
   2. But for priority inversion you need at least 1 semaphore and at least 3 tasks to invert the priority.
   3. (Think about cups)

Question 9

An interrupt vector contains the address of an ISR.

Answer 9

The itnerrupt vector is a vector containing the address of ISRs.

Question 10

An ISR must be reentrant.

Answer 10

this is false because it should be reentrat but if u really need to, u can make it non reentrant. A bullshit question but remember it.

Question 11

The software architecture of the Network Simulator NS2 mainly uses the data flow computation model.

Answer 11

NS2 (network simulator 2)

• open soruce discrete network network sim that is used for research.
• simulates behaviour of packages transfered through TCP, UDP, HTTP and FTP and others
  
  • The statement is false because NS2 uses the discrete event simulator model.

Question 12

With an FQS architecture, a task signaled by an ISR is executed immediately after that ISR completes execution.

Answer 12

1. well it’s a queue so, if it follows the order of the queue the answer is no. However reasoning about the theory from FQS we know that the tasks have priority among themselves and the ISRs do too. Also, it s logical that ISRs have priority above any task.
   
   1. And with all this, also the fact that traditional task switching is not supported in FQS. I think that this would make a lot of sense to be false. Because of the no task switching part. However it is false it implies that after an ISR finishes the signaled task doesnt activate until the queue reaches it.
      
      1. function signaled by an ISR means → ISR notifies the scheduler that a certain function is READY to be executed and the ISR schedules the task to be executed as fast as possible (adds it at the killing end of the queue)
         
         1. makes it execute as fast as possible
            
            1. HOWEVER, this is not as fast as the ISR finishes, because even if it schedules it at the begining of the queue, THER IS A TASK STILL LEFT RUNNING AND THAT MUST FINISH FIRST, so it is not exactly after the ISR finishes.
               
               1. IT IS THUS FALSE.

Question 13

A separate hardware timer is needed for providing extremely accurate timing in RTOSs.

Answer 13

1. This is false because the hardware timer is built-in for the RTOS systems.
   
   1. an RTOS is pretty demanding and thus it has a more powerful chipset installed - >
      
      1. it has more stuff on the chipset, like a hardware timer.

Question 14

In the RR architecture, the worst-case response time of a task is the sum of the response times of the higher-priority tasks.

Answer 14

false because in RR the tasks have NO PRIORITY.

Question 15

In an RTOS, tasks can be in state BLOCKED, READY or RUNNING.

Answer 15

• a task starts in the state RUNNING.
  
  • in my logic, blocked is blocked, running is already running and ready is when it is ready to run, so at the instant of the start, it goes from ready → running. I say ready is the answer, thus it is false.

Question 16

An ISR may change a task’s status from RUNNING to READY.

Answer 16

an ISR can block a task, but to make it ready (considering that the task is interrupted by it) makes no sense. I think it has to go to blocked and then unblock when the ISR is finished executing. → it is false.

Question 17

An ISR must not invoke an RTOS function that may block.

Answer 17

Interrupting a function and the interrupt itself calling a functionn that may block can cause a clusterfuck as it blocks a running task stopped by an IR. It s a serious clusterfuck of a system event so it must NOT happen as there is no good outcome possible form it. BEst case is the entire system halting or slowing the fuck out of it.
MUST not happen → TRUE

Question 18

A function can be made reentrant by temporarily disabling interrupts, but additional bookkeeping is required as simply enabling interrupts on exit may cause errors.

Answer 18

This is true.

Question 19

When upgrading to an RTOS, signaling between ISRs and tasks may still be done through flags residing in global memory.

Answer 19

1. Handling of the ISR in an rtos functions in the following way
   
   1. there is a “global” counting semaphore on the main shared memory, created with kernel functions. That is used to signal, block, reenter etc of a task / function when a IR is triggered. A flag is a binary thing, however that is not enough, a proper counting semaphore is required for this to work properly
      
      1. thus i consider it false, because it should be done with a ‘global’ SEMAPHORE not FLAG.

Question 20

A program running on an RTOS may create tasks dynamically at runtime. the program ends as soon as the main() function returns.

Answer 20

This is false. Think about it like an OS, the os doesnt terminate whenever a function terminate, only when the PC is shutdown. THis is still an OS, but a very low level & specialized one.

Question 21

the semaphore “lock” must be initalized to 0 in the following C code:

os_pend(lock)
if (++cnt == 1) // first reader
os_pend(read_or_write)
os_post(lock)
…. // read action
os_pend (lock)
if (–cnt == 0) //last reader
os_post(read_or_write)
os_post(lock);

Answer 21

Here, the answer is false.
This is because due to many, many readers, it must be a counting semaphore. A counting semaphore is initalizes with the number of max resources that can simultaniosly aquire a resource, thus if it is 0, a resource can never be aquired and the program will forever halt ->fucked. Must never happen.

Question 22

reader code : “os_pend(lock)
if (++cnt == 1) // first reader
os_pend(read_or_write)
os_post(lock)
…. // read action
os_pend (lock)
if (–cnt == 0) //last reader
os_post(read_or_write)
os_post(lock);” and writer code : “os_pend(read_or_write)
…// write action
os_post(read_or_write)
QUESTION: Semaphore read_or_write must be initialized to the number of writers.

Answer 22

1. the number of tasks that can aquire the resource at one point is the initalization of the semaphore. Now, let s reason about what should that be.
2. from what it seems, it is a binary semaphore, and there is only one writer here
   
   1. This is false. I got it wrong. Let s see why
      
      • let s anaylize how this code works
        
        • the purpose of ******read_or_write****** is to protect a shared resource that can be accessed by either a single writer or multiple readers at a time.
          
          • this is inialized with a value of 1, which means that one thread can hold it a time. → it s binary
        • the purpose of lock is to protect the cnt value.
          
          • also with value of 1, both being binary
            
            • **********the question is thus false, as it must be initalized to 1, as it is binary**********

Question 23

The writer task can be “locked out” when multiple readers keep doing their actions while cnt never returns to zero.
- Such starvation can be avoided by assigning the writer task a priority higher than any reader.

Answer 23

false, because it remains locked nevertheless by the mutex / semaphore, so priority wouldnt mean anything in this context

Question 24

The heartbeat timer is a single hardware timer an RTOS is using to verify that the system is still progressing (i.e. not deadlocked).

Answer 24

false. It checks if it is still running and components are still alive. Doesnt check for deadlock as when it is deadlocked, technically it is still running.

Question 25

An RTOS usually provides two types of delay functions: polling-based and timer-based.

Answer 25

• Polling-based delays
  
  • continiosuly checking (polling) a condition to check when a specific time interval has passed
• Timer-based delays
  
  • this type involve hardware timers trigger an interrupt after a specific time has elapsed.
• There are no ticks specified, thus no.

Question 26

5. Assume that one system clock tick = 10 ms.
   
   • Calling the functionOSTimeDly(4) causes a delay of exactly 40 ms.

Answer 26

false, it is never perfect

Question 27

6. To address the shared-data problem, many RTOSs provide communication primitives likequeues, mailboxes, and pipes.
   
   • the unique property of a mailbox is that it can accept items from different tasks.

Answer 27

• the unique property of a mailbox is that it can accept items from different tasks.
  
  • false.
    
    • MAILBOXES
      
      • sending and receiving messagess between tasks in RTOS.
      • fixed sized buffer that can hold multiple messages.
      • tasks can send messages to a mailbox and receive using the receive operation
      • useful for sending large data structures between tasks
      • each data can have VARIABLE LENGTH
      • can receive data from multiple tasks.
        
        • the question is false because this isnt what makes it UNIQUE.
    • Queues
      
      • a mechanism for sending and receiving data between tasks in an RTOS
      • fixed sized buffer that can send data, each has a FIXED LENGTH.
    • Pipes
      
      • unidirectional mechanism for sending data between tasks in an RTOS
      • a pipe typically has a fixed size buffer that can hold multiple data items, each of witch has a fixed length.

→ (back to the question) the mailbox has the unique attribute of being able to store data of variable length, and that it can acccept data from multiple tasks is true but NOT UNIQUE, all of them can.

Question 28

A disadvantage of queues over pipes is that messages/items are handled strictly in FIFO order.

Answer 28

This is false. While a Queue is fifo, this is not striclty as u can have multiple oprations on it + a queue is bidrectioonal while a pipe is unidrectional. THere are many ways to approach this question and they all lead to a false answer. Plus they are not stricly FIFO.

Question 29

Printing from an ISR is to be avoided except when the RTOS provides a reentrant primitive to do so.

Answer 29

true.

Question 30

An advantage of using tasks is that it allows for better data encapsulation.

Answer 30

1. data encapsulation
   
   1. OOP concept that refers to a practical bundeling of data and the methods that oprerate on that data.
      
      1. it s true but i coinsider it to be a bad question.

Question 31

An ISR may not call OSPost as that may affect response time and may even cause deadlock!

Answer 31

1. os post unlocks a lock / semaphore decreases.
   
   1. deadlocks can happen when it tires to lock a resource, not unlock it.
      
      1. false, but still shouldnt happen cause it can fuck up the memory logic.

Question 32

3. Several models of computation for embedded systems are described in [Lee:2002].
   
   • Process Networks are primarily used to describe concurrency at the hardware level.

Answer 32

• process networks
  
  • are ways of designing embedded software where fault resistance is very important.
  • they consist of intervowen processes that communicate with eachother through shared memory, queus or pipes or sockets.
  • they are not hardware level, they are software level.
    
    • **the question is false**

Question 33

Embedded programming is more difficult than “classical” programming because of the event-based programming model.

Answer 33

1. This is a very bad question.
   
   1. so, embedded programming is harder then classical programming due to many reasons, the event based programming model being on of them
   2. so it is true
   3. but there are also other programming models
   4. and there are other reasons as to why it is false.

Question 34

Because embedded software engages the physical world, it has to embrace time and other non-functional properties, which requires the use of interrupt handlers to guarantee responsiveness.

Answer 34

1. This is a very bad question.
   
   1. so, the statement says that interrupt handlers are required for responsiveness.
      
      1. but there are also other ways to achieve responsiveness.
         
         1. like polling
            
            1. false

Question 35

9. Valgrind is programming tool that aids memory debugging.
   
   • it does so by executing a program in a safe environment

Answer 35

true, and the system calls and memory addresses are replaced with it s own mocks for easier tracking of every memory leak and the such.

Question 36

“typdef void (resolve) (void * old, void * new) “. this eclares resolve as a pointer to a function that takes two void
pointers as arguments and returns a void pointer as result.

Answer 36

true

Question 37

When a processor in an embedded system is powered up, interrupts are enabled to meet response-time requirements.

Answer 37

1. they are enabled at startup, but they are not due to response time requirements
2. even if they improve response time as a general thing

Question 38

The X32 interrupt controller and CPU use a three-way handshake to change the priority of an interrupt source (i.e. hardware device). true/false

Answer 38

false
the 3 way handshake is a network protocol

Question 39

Although there are techniques to avoid disabling interrupts, such as alternating buffers or using queues, they are fragile and should only be used if absolutely necessary.

Answer 39

1. this statement is comepletly true.
   
   1. true

Question 40

an intept service routing should restore the context upon entrancce

Answer 40

false. That is handled by the rest of the system, not the ISR.

Question 41

When detecting a car crash an airbag should not be inflated instantly. Does RR support delayed actions?

Answer 41

• the architecture itself doesnt. When u answer these questions u must only focus on the the question. But these are really bad questions anyway.

Question 42

The software architecture of the Network Simulator NS2 mainly uses the discrete events computation model.

Answer 42

the discrete events computation model is commonly used to simulate networks. Thus i think this is true.

Question 43

10. Time-slicing should be avoided in an RTOS because it makes the response time of tasks less predictable.
    
    1. eacch task has a special time attributed to it, so i dont see how it would make response time less predictable, on the contraty, it makes it more predictable.

Answer 43

1. true
   
   1. it adds additional overhead and if a task runs out of time to run, it can be preempted or blocked. Increasing unpredictability

Question 44

A guiding principle of embedded system design is to only create dynamic tasks when needed, even when the memory footprint is not an issue.

Answer 44

false, there is no such principle

Question 45

A guiding principle of embedded system design is to only create dynamic tasks when needed, even when the memory footprint is not an issue.

Answer 45

false, there is no such principle

Question 46

The ROS master provides naming and registration services to ROS nodes, and tracks publishers and subscribers to topics and services.

Answer 46

true

Question 47

With instruction set simulators, the whole platform can be simulated. true/false

Answer 47

1. it is a software simulaotr of the CPU, in low level.
2. but platform refers to the entire device, with senzors etc included
   
   1. which cant be simulated
   2. just the cpu can
   3. false

Question 48

the size of an int is architecture dependant

Answer 48

C is structured around the int, and the int is dpendentant on the architecture

Question 49

An interrupt service routine does not need to be allocated its own call stack.
- its activation record(s) can simply be allocated on the stack of the task that is being
interrupted

Answer 49

it s true

Question 49

An interrupt service routine does not need to be allocated its own call stack.
- its activation record(s) can simply be allocated on the stack of the task that is being
interrupted

Answer 49

it s true

Question 50

at startup, the interrupts are disabled

Answer 50

true

Question 51

at startup, the interrupts are disabled

Answer 51

true

Question 52

in RR, shared data probem doenst exist

Answer 52

true, each task has a fixed time to run, leading to no shared data

Question 53

Code coverage tools help in thorough testing.
- a good testset includes more cases than needed to achieve 100% coverage

Answer 53

true

Question 54

assert can only be used on host

Answer 54

false

Question 55

When debugging code for a distributed sensor network, collecting the (debug) output of
the nodes can be arranged in different ways.
- A wireless testbed requires physical instrumentation (i.e. wiring) of the sensor node.

Answer 55

true

Question 55

When debugging code for a distributed sensor network, collecting the (debug) output of
the nodes can be arranged in different ways.
- A wireless testbed requires physical instrumentation (i.e. wiring) of the sensor node.

Answer 55

true

Question 56

an ISR should save state upon entering

Answer 56

true

Question 57

The Alternating Buffers technique can be used between two “communicating” tasks of
equal priority.

Answer 57

This statement is false because the Alternating Buffers technique can be used between two communicating tasks of different or equal priority. The priority of the tasks is not relevant to the use of Alternating Buffers technique.

Question 58

While interrupts are disabled atomicity is guaranteed even when calling a non-reentrant
function.

Answer 58

true. remember what atomicity means from IDM

Question 59

In an RTOS, tasks can be in state BLOCKED, READY or RUNNING.
- a task starts in the state READY.

Answer 59

true

Question 60

A reentrant function may use hardware only in an atomic way

Answer 60

true

Question 61

a task can signal an ISR by operating a semaphore

Answer 61

false

Question 62

A reentrant function may use hardware only in an atomic way

Answer 62

true

Question 63

With the simple OS Pend()/OS Post() interface the RTOS cannot know in advance
which semaphore(s) will be used by a task.

Answer 63

true

Question 64

With the simple OS Pend()/OS Post() interface the RTOS cannot know in advance
which semaphore(s) will be used by a task.

Answer 64

true

Question 65

es requires a large volume of scale

Answer 65

false

Question 66

fsm can be made such that user acton triggers state changes

Answer 66

false

Question 67

int in C has at least 16 but the exact # of bits is archtiecture depndant

Question 68

queue inbetween a producer and consumer task can be controlled by a counting
semaphore that records the number of items in the queue.

Answer 68

true

Question 69

A program running on an RTOS may create tasks dynamically at runtime.
- the program ends once main() and all spawned tasks have finished.

Answer 69

true

Question 70

In the implementation of the OS Pend() primitive, the RTOS first switches the state of
the current task to BLOCKED, and then looks for a task in the READY queue.
- if the READY queue is empty the processor may be put into sleep mode to save energy
when idling.

Answer 70

true