Scribd
Upload
34 views23 pages

Associated Name A Unique ID A Priority (If Part of A Pre-Emptive Scheduling Plan) A Task Control Block (TCB) A Stack and A Task Routine Task Objects

A task is an independent thread of execution that can compete for processor time. When created, a task is assigned a name, ID, priority, task control block, stack, and task routine. Tasks can be in ready, blocked, running, suspended, pended, or delayed states. The kernel creates system tasks like initialization and idle tasks. Semaphores allow tasks to synchronize access to shared resources and coordinate mutually exclusive access. There are binary, counting, and mutex semaphores that tasks use to acquire and release resources.

Uploaded by

Aleena
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
34 views23 pages

Associated Name A Unique ID A Priority (If Part of A Pre-Emptive Scheduling Plan) A Task Control Block (TCB) A Stack and A Task Routine Task Objects

A task is an independent thread of execution that can compete for processor time. When created, a task is assigned a name, ID, priority, task control block, stack, and task routine. Tasks can be in ready, blocked, running, suspended, pended, or delayed states. The kernel creates system tasks like initialization and idle tasks. Semaphores allow tasks to synchronize access to shared resources and coordinate mutually exclusive access. There are binary, counting, and mutex semaphores that tasks use to acquire and release resources.

Uploaded by

Aleena
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPTX, PDF, TXT or read online on Scribd
You are on page 1/ 23

Task

 A task is an independent thread of execution that


can compete with other concurrent tasks for
processor execution time.
 A task is schedulable.
 A task is defined by its distinct set of parameters
and supporting data structures.
 Specifically, upon creation, each task has an
associated name
 a unique ID
 a priority (if part of a pre-emptive scheduling plan)
 a task control block (TCB)
 a stack and
 a task routine
 Together these components are known as task
objects
 When the kernel first starts, it creates its own set of
system tasks and allocates the appropriate priority for
each from a set of reserved priority levels.
 initialization or startup task initializes the
system and creates and starts system tasks,
 idle task uses up processor idle cycles when
no other activity is present,
 logging task logs system messages,
 exception-handling task handles exceptions,
and
 debug agent task allows debugging with a
host debugger.
Task States

 ready state-the task is ready to run but cannot because a higher priority task is
executing.·
 blocked state-the task has requested a resource that is not available, has requested
to wait until some event occurs, or has delayed itself for some duration.
 running state-the task is the highest priority task and is running.
 Some other states are
 Suspended, Pended, and Delayed.
 Pended and delayed are actually sub-states of
the blocked state.
 A pended task is waiting for a resource that it
needs to be freed; a delayed task is waiting
for a timing delay to end.
 The suspended state exists for debugging
purposes.
SEMAPHORES

 Multiple concurrent threads of execution


within an application must be able to
 􀂄 Synchronize their execution
 􀂄 Coordinate mutually exclusive access to
shared resources
 􀂄 RTOS provides a semaphore object and
associated semaphore management services
 Semaphore Definition
 A kernel object that one or more threads of
execution can acquire or release for the
purpose of synchronization or mutual
exclusion
 When a semaphore is first created, kernel
assign
 A semaphore control block (SCB)
 A unique ID
 A value (binary or a count)
 A task-waiting list
A semaphore, associated parameters and
supporting data structures
 A semaphore is a key that allows a task to
carry out some operation or to access a
resource
 A single semaphore can be acquired a finite
number of times
 Acquire a semaphore is like acquiring the
duplicate of a key
 If the token counter reach zero
o The semaphore has no token left
o A requesting task cannot acquire the
semaphore and may block if it chooses to
wait
 Task-waiting list track of all tasks blocked
while waiting on an unavailable semaphore
* FIFO: first-in-first-out order
* Highest-priority first order
 􀂄 When an unavailable semaphore becomes
available
Kernel allow the first task in the task-
waiting list to acquire it
 Semaphore - Types
* Binary semaphores
* Counting semaphores
* Mutual-exclusion (mutex)
semaphores
Binary Semaphore
 Have a value either 0 or 1
0 : Semaphore is considered unavailable
1 : Semaphore is considered available
 When a binary semaphore is first created:
# It can be initialized to either availiable
or unavailable (0 or 1 respectively)

 When created as global resources


# They are shared among all tasks
# Any task would release a binary semaphore
even if the task did not initially acquire it
State Diagram of a Binary Semaphore
Counting Semaphores
 Use a counter to allow it to be acquired or released multiple
times
 The semaphore count assigned when it first created
denotes the number of semaphores tokens it has initially
 If initial count is 0 the counting semaphore is created in
unavailable state.
 If initial count is greater than 0 the counting semaphore is
created in available state.
 When all tokens are gone semaphore moves from available
to unavailable state.
 If a token is released by any task semaphore is moved to
available state.
 Are global resources that can be used by any task that need
them.
The State Diagram of a Counting
Semaphore
Bounded and unbounded counts:

 Bounded count:
 Count in which initial count set for counting
semaphore, determine when the semaphore
was first created acts as the maximum count
for the semaphore.
 Unbounded count:
 Allow counting semaphore to count beyond
the initial count to the maximum value that
can be held by the counter’s data type
Mutual Exclusion (Mutex) Semaphores

 A special binary semaphore that supports


* Ownership
* Recursive access
* Task deletion safety
* One or more protocols avoiding problems
inherent to mutual exclusions
 The states of a mutex
Locked and unlocked
 A mutex is initially created in the unlocked state
The State Diagram of a Mutual
Exclusion ( Mutex ) Semaphore Mutex
Mutex Ownership
 Ownership of a mutexis gained when a task first locks the mutex
When a task owns the mutex
--> No other task can lock or unlock that
mutex
-- > Contrast to the binary semaphore that can be
released by any task

 Implementation
* A lock countkeep track of
--Two states of a mutex
0 for unlocked and 1 for locked
 􀂄 And the number of timesit has been recursively locked
 􀂄 Lock count > 1
 Implementation: a mutexmight maintain two counts
A binary value to track its state
A separate lock countto track the number of
times it has been acquired in the lock state

 Implementation: a mutexmight maintain two counts
 􀂄 A binary valueto track its state
 􀂄 A separate lock countto track the number of times
it has been acquired in the lock state by the task
owns it
by the task owns it
Initializing Semaphores
 The function SemCreate is used to initialize
the semaphore.
 Semaphore must be initialized before
attempting to do any operation on it.
Reentrancy and Semaphore
 In data sharing, the resources are protected
by semaphores.
 The second task that calls the semaphore for
the second time will be blocked.
 We can make the function reentrant.
 The atomicity of operation of the function
will be protected by the semaphore.
Multiple Semaphore
 RTOS allow us to have as many semaphores as we like.
 Each call to the RTOS must identify the semaphore on
which to operate.
 The semaphores are all independent of one another.
 If one task take semaphore A another task can take
semaphore B without blocking.
 Similarly if one task is waiting for semaphore
 C that task will still be blocked even if some other task
releases semaphore D.

You might also like