Skip to main content
Link
Menu
Expand
(external link)
Document
Search
Copy
Copied
Search cs492-stevens
Lectures
Lecture 14 Template
14 - Linux Threads & Scheduling (1)
Outline
Scheduling Algorithm Categories
Basic Scheduling Algorithms
Linux Threads
Scheduling Basics
Announcements
Reading:
Linux Threads
Scheduling Basics
Scheduling Algorithm Categories
Linux processes and threads are both represented
as kernel-space tasks.
pthread_create()
Clone creates a new task as
The task is assigned both a PID and TID
Fundamental question: Which thread runs next?
Basic Problem:
Scheduling is a class of optimization problems that
centers on resource allocation.
It is a deep topic that spans many fields and we
will be restricting our focus very significantly.
We will primarily consider the single-core scenario.
A scheduling algorithm makes a scheduling decision
by solving the problem and producing a schedule.
We can represent a schedule with a Gantt chart or
a timing diagram.
Assignment, ordering, and timing of tasks can be
affected by many more factors than those above.
In a general-purpose OS, the scheduler does not
usually know the tasks' traits beforehand, so the
scheduling algorithm must be chosen to perform
well in the average case.
When can scheduling decisions be made?
Any time the kernel runs.
Clock interrupts are special hardware interrupts
Clock interrupts allow for both:
Non-Preemptive Scheduling
Preemptive Scheduling
Different computing environments require different
scheduling algorithms that make different
optimizations.
We'll look at 3 contexts:
Scheduling algorithms have some shared goals, as
well as context-specific goals:
All systems:
Batch systems:
Batch systems:
Interactive systems:
Interactive systems:
Real-Time systems:
Real-Time systems:
The scheduler is the part of the OS that makes
the decision, using a scheduling algorithm.
Given K tasks that have:
and N cores to run on, determine:
clone()
Tasks combine functionality from both
We discussed tasks last week in lecture 11.
PCB and TCB are combined into task_struct
User-space POSIX API for thread creation
Tasks generally cannot influence the scheduler's
decisions
when process/thread:
when interrupts occur:
allows system to track time
allows scheduling to take place regularly
Tasks cannot be interrupted
Tasks can be rescheduled during execution
Used everywhere now
Scheduler only runs on task exit or by request
a thread in current process (shared space)
always a new TID
processing time (CPU time)
release time
(maybe) deadline
(maybe) weight/priority
assignment of tasks to cores
ordering of task execution
timing of task execution
new PID only if separate process (fork)
PID and TID will be same in a new process
child threads have same PID, different TID
shows PID, PPID, and TID (LWP)
TID can be accessed with
a new process (new address space)
Linux implementation uses clone syscall
Process and thread table => task table
single-threaded process => 1 task
multithreaded process => 1 task per thread
PA 3 will be out early next week instead of today.
(there was a bug in the reference implementation)
Reminder that PA 2 is due next Friday
1)
2)
3)
MOS 10.3.1 - 10.3.3, LDD 2
MOS 2.4
-
-
-
-
-
-
-
-
-
-
-
-
-
-
=>
=>
=>
-
-
-
-
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
>
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
>
>
>
-
-
-
-
-
-
child_id = clone(function, stack_ptr, sharing_flags, arg);
gettid()
ps -eLf
Thread 1
running
ready
blocked
Thread 2
Thread 3
Thread 4
time
is created (fork/clone)
Clock interrupt (running -> ready)
occurs at regular intervals (ticks)
blocking syscall
high priority (must be handled ASAP)
prevents a task from keeping CPU forever
clock interrupts do not cause switching
Batch Systems
Fairness - each process gets "enough" CPU time
Throughput - maximize total jobs per unit time
First-Come, First-Serve (FIFO)
Response Time - respond to request quickly
Priority
Deadlines - cannot miss them
Fixed Priority
Predictability - prevent quality degradation
Dynamic Priority
Proportionality - match users' expectations
Multiple Queues
Others (briefly)
Turnaround Time - minimize mean time to finish
Shortest Job First
Shortest Remaining Time Next
CPU Utilization - keep the CPU busy
Round Robin
Policy Enforcement - meet imposed restrictions
Balance - use CPU and I/O efficiently
Interactive Systems
Real-Time Systems
large servers or mainframes with very high workload
general-purpose computers (e.g. your PC)
safety-critical and embedded systems (e.g. a pacemaker)
clock interrupts can cause switching
I/O interrupt (blocked -> ready)
terminates (exit)
block on I/O or event
other non-blocking syscall
voluntary switch (user-space threads)
involuntary switch