10.1.

Fine: Parallelism inherent in a single instruction stream.

Medium: Parallel processing or multitasking within a single application.
Coarse: Multiprocessing of concurrent processes in a multiprogramming environment.
Very Coarse: Distributed processing across network nodes to form a single computing
environment.
Independent: Multiple unrelated processes.
10.2.
1.Load sharing: Processes are not assigned to a particular processor but are in a shared ready
queue.
2. Gang scheduling: A set of related threads is scheduled to run on a set of processors at the
same time, on a one-to-one basis.
3. Dedicated processor assignment: Each program, for the duration of its execution, is
allocated a processor for each of its threads.
4. Dynamic scheduling: The number of threads in a process can be altered during the course
of execution
10.3.
First-come-first-served(FCFS):Whenajobarrives,eachofitsthreadsisplaced consecutively at the
end of the shared queue. When a processor becomes idle, it picks the next ready thread,
which it executes until completion or blocking.
Smallest number of threads first: The shared ready queue is organized as a pri- ority queue,
with highest priority given to threads from jobs with the smallest number of unscheduled
threads. Jobs of equal priority are ordered according to which job arrives first. As with FCFS,
a scheduled thread is run to completion or blocking.
Preemptive smallest number of threads first: Highest priority is given to jobs with the
smallest number of unscheduled threads. An arriving job with a smaller number of threads
than an executing job will preempt threads belonging to the scheduled job
10.4.
A hard real-time task is one that must meet its deadline; otherwise it will cause undesirable
damage or a fatal error to the system.
A soft real-time task has an associated deadline that is desirable but not mandatory; it still
makes sense to schedule and complete the task even if it has passed its deadline.
10.5.
an aperiodic task has a deadline by which it must finish or start, or it may have a constraint on
both start and finish time. In the case of a periodic task, the requirement may be stated as
"once per period T" or "exactly T units apart."
10.6.
Determinism: An operating system is deterministic to the extent that it performs operations at
fixed, predetermined times or within predetermined time intervals.
Responsiveness: Responsiveness is concerned with how long, after acknowledgment, it takes
an operating system to service the interrupt.
User control: The user should be able to distinguish between hard and soft tasks and to
specify relative priorities within each class. A real-time system may also allow the user to
specify such characteristics as the use of paging or process swapping, what processes must
always be resident in main memory, what disk transfer algorithms are to be used, what rights
the processes in various priority bands have, and so on.
Reliability: Reliability must be provided in such a way as to continue to meet real- time
deadlines.
Fail-soft operation:
Fail-soft operation is a characteristic that refers to the ability of a system to fail in such a way
as to preserve as much capability and data as possible.
10.7.
Static table-driven approaches: These perform a static analysis of feasible schedules of
dispatching. The result of the analysis is a schedule that determines, at run time, when a task
must begin execution.
Static priority-driven preemptive approaches: Again, a static analysis is performed, but no
schedule is drawn up. Rather, the analysis is used to assign priorities to tasks, so that a
traditional priority-driven preemptive scheduler can be used. Dynamic
planning-based approaches: Feasibility is determined at run time (dynamically) rather than
offline prior to the start of execution (statically). An arriving task is accepted for execution
only if it is feasible to meet its time constraints. One of the results of the feasibility analysis is
a schedule or plan that is used to decide when to dispatch this task.
Dynamic best effort approaches: No feasibility analysis is performed. The system tries to
meet all deadlines and aborts any started process whose deadline is missed.
10.8.
Ready time: Time at which task becomes ready for execution. In the case of a repetitive or
periodic task, this is actually a sequence of times that is known in advance. In the case of an
aperiodic task, this time may be known in advance, or the operating system may only be
aware when the task is actually ready.
Starting deadline: Time by which a task must begin
Completion deadline: Time by which a task must be completed. The typical real-time
application will either have starting deadlines or completion dead- lines, but not both.
Processing time: Time required to execute the task to completion. In some cases, this is
supplied. In others, the operating system measures an exponential average For still other
scheduling systems, this information is not used.
Resource requirements: Set of resources (other than the processor) required by the task while
it is executing
Priority: Measures relative importance of the task. Hard real-time tasks may have an
"absolute" priority, with the system failing if a deadline is missed. If the system is to continue
to run no matter what, then both hard and soft real- time tasks may be assigned relative
priorities as a guide to the scheduler. Subtask structure:
A task may be decomposed into a mandatory subtask and an optional subtask. Only the
mandatory subtask possesses a hard deadline.
13.1.
a small computer that is part of a larger system, device, or machine and is designed to
perform specific tasks
13.2.
Real-Time Performance: Many embedded systems must meet strict deadlines, ensuring that
tasks are completed within predetermined deadlines.
Resource Constraints: Embedded systems often operate with limited resources
Reliability and Stability: Embedded systems are often used in critical applications where
failure is not an option
13.3.
a specialized operating system (OS) designed to perform a specific task for a device that is
not a computer. The main job of an embedded OS is to run the code that allows the device to
do its job.
13.4.
Specific Functions
Efficient Design
Real-Time Operation
Reliable
Small Size
Low Cost
Minimal User Interface
13.5.
Task Management: An OS enables multitasking, crucial for complex applications needing
simultaneous data acquisition, processing, and communication.
Resource Management: It efficiently manages hardware resources like memory, CPU, and
I/O devices, reducing conflicts and optimizing performance.
Abstraction: OS abstracts hardware details, simplifying development and improving
portability across platforms.
Development Efficiency: With rich APIs and libraries, an OS reduces coding effort, speeding
up development.
Scalability: It supports scaling applications without redesign as system requirements grow.
Debugging: OS provides debugging tools and logs, aiding issue resolution during and after
development.
13.6.
Configurability: eCos is designed to be highly configurable, allowing developers to tailor the
operating system precisely to their application's needs, minimizing resource usage and
overhead.
Real-Time Performance: It focuses on delivering real-time capabilities with minimal latency,
making it suitable for embedded systems that require deterministic behavior.
Modularity: The kernel is modular, enabling developers to include only the necessary
components, optimizing the system's footprint.
Portability: eCos is designed to be portable across different hardware architectures,
supporting a wide range of embedded processors.
Small Footprint: It is optimized for minimal memory usage, which is critical for embedded
systems with limited resources.
Open Source: eCos was designed as an open-source operating system, encouraging
community-driven development and flexibility for customization.
13.7.
Interrupt Service Routine (ISR):

 Purpose: The ISR is the first handler that responds immediately when an interrupt
occurs.
 Execution: It executes at a high priority, directly in response to the hardware
interrupt, often with interrupts disabled.
 Functionality: ISR handles time-critical tasks that must be dealt with immediately,
like acknowledging the interrupt or performing minimal, high-priority tasks.
 Time Sensitivity: ISRs are meant to be short and fast to avoid blocking other
interrupts or processes for too long.

Deferred Service Routine (DSR):

 Purpose: The DSR completes tasks that were initiated by the ISR but are not time-
critical.
 Execution: It runs after the ISR, at a lower priority, when the system has re-enabled
interrupts and is not in the middle of handling more immediate tasks.
 Functionality: DSRs perform more complex or time-consuming operations that the
ISR deferred, such as processing data, updating state, or waking tasks.
 Time Sensitivity: DSRs allow the system to handle less urgent parts of the interrupt
without disrupting real-time constraints.
13.8.

Threads, Mutexes, Semaphores, Event Flags, Condition Variables, Message Queues, dan
Thread Priorities.

13.9.

Wireless Sensor Networks (WSNs): Applications like environmental monitoring, industrial

automation, and smart agriculture, where small sensors collect data and communicate
wirelessly.
Internet of Things (IoT): TinyOS is well-suited for IoT devices that require low-power,
small-footprint software for sensing, actuation, and communication.
Distributed Embedded Systems: Systems that involve multiple small devices working
together, such as in healthcare monitoring systems, smart homes, and military surveillance.

13.10.
TinyOS is designed with key goals like energy efficiency and minimal resource usage,
making it ideal for devices with limited power, memory, and processing capabilities. Its
event-driven model ensures efficient handling of tasks, conserving energy by keeping the
CPU idle when not needed. Modularity allows developers to include only the necessary
components, while its lightweight concurrency mechanisms manage tasks effectively. The OS
is also scalable, supporting both small devices and large distributed networks, making it well-
suited for wireless sensor networks and IoT applications.
13.11.
A TinyOS component is a modular unit that encapsulates specific functionality, like sensing
or communication, and interacts with other components through commands and events.
Components are connected by wiring interfaces, allowing flexible composition and reuse in
different applications.
13.12.
Kernel, Components, Network Stack, Device Drivers.
13.13.
FIFO, or first-in, first-out