Kernel Timing Management

© 2014-15 SysPlay Workshops <workshop@sysplay.in>
All Rights Reserved.
Kernel Timing Management

2
What to Expect?
Timing Architecture
Ticking in jiffies
Delaying the process
Kernel Timers
Tasklets
Work Queues

3
Timing Architecture

4
W's of Time Keeping
User space deals with the absolute time
4 'O clock for back up
12 'O clock shutdown
Kernel space deals with relative timing
Data transfer should finish in 5 msecs
Operations mostly in msecs, worst case seconds

5
Unit of Time in Kernel
HZ – ticks per second
Varies from 50 to 1000
Typically 1000 for desktops & 100 for embedded Systems
Defined in <linux/params.h>
1 tick = 1ms (desktop), 10ms (embedded systems)
Jiffy
Internal kernel counter
Increments with each timer tick
jiffies & jiffies_64

6
API's
#include <linux/jiffies.h>
get_jiffies_64()
For accessing the 64 bit jiffies
Direct access not recommended
Comparison of time values
int time_before(a, b)
int time_after(a, b)
int time_before_eq(a, b)
int time_after_eq(a,b)

7
Dealing with User space
#include <linux/time.h>
unsigned long timespec_to_jiffies(struct
timespec *)
void jiffies_to_timespec(jiffies, struct timespec *)
unsigned long timeval_to_jiffies(struct timeval *)
void jiffies_to_timespec(jiffies, struct timeval *)

8
Resolution lesser than jiffies
Platform specific “Time Stamp Counter”
On x86
Header: <asm/msr.h>
API: rdtsc(ul low_tsc_ticks, ul high_tsc_ticks);
Getting it generically
Header: <linux/timex.h>
API: read_current_timer(unsigned long *timer_val);

9
Absolute Time
Header: <linux/time.h>
APIs
mktime(y, m, d, h, m, s) – Seconds since Epoch
void do_gettimeofday(struct timeval *tv);
struct timespec current_kernel_time(void);

10
Delays

11
Long Delays
Busy wait: cpu_relax
while (time_before(jiffies, j1))
cpu_relax();
Yielding: schedule/schedule_timeout
while (time_before(jiffies, j1))
schedule();

12
Hands On
Timing/busy_wait.c
Modify example above to use schedule().

13
Waiting for an event or timeout
#include <linux/wait.h>
wait_queue_head_t wq_head;
init_waitqueue_head(&wq_head);
wait_interruptible_timeout(wq, condition, timeout)
0 if process if timeout expires
Remaining delay, if event occured
schedule_timeout(delay_in_jiffies)
No condition to wait for
Returns 0, if timeout has expired

14
Hands On
Modify Timing/busy_wait to use wait queues &
sched_timeout

15
Short Delays but Busy Waiting
Header: <linux/delay.h>
Arch. specific Header: <asm/delay.h>
APIs
void ndelay(unsigned long ndelays);
void udelay(unsigned long udelays);
void mdelay(unsigned long mdelays);

16
Long Delays: Back to Yielding
Header: <linux/delay.h>
APIs
void msleep(unsigned int millisecs);
unsigned long msleep_interruptible(unsigned int millisecs);
void ssleep(unsigned int secs);

17
Timers

18
W's of Kernel Timers
Allows to schedule a task, sometime in future
Executes a user defined function at user defined time
Example usage
Elimination of bouncing in a key press
Finishing some lengthy shutdowns
Execute asynchronously & in interrupt context. So,
scheduling out is not allowed

19
Kernel Timer Data structures
Back end of the various delays
Header: <linux/timer.h>
Type: struct timer_list
APIs
void init_timer(struct timer_list *); /* Nullifies */
struct timer_list TIMER_INITIALIZER(f, t, p);
void add_timer(struct timer_list *);
void del_timer(struct timer_list *);
int mod_timer(struct timer_list *, unsigned long);
int del_timer_sync(struct timer_list *);

20
Hands On
Timing/timers.c
Create a thread which will wake up & blink the
led every 1 sec
Modify select.c to wake up the user space
application periodically

21
Tasklets
Tasklets mean baby tasks
Tasks to be executed later with no specific time
requirement
Normally, scheduled by interrupt handler to
finish the rest of the task such as data
processing
Executes in interrupt context

22
Data Structures
Header: <linux/interrupt.h>
Type: struct tasklet_struct
APIs
void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long),
unsigned long data);
DECLARE_TASKLET(name, func, data);
DECLARE_TASKLET_DISABLED(name, func, data);
tasklet_enable(t); tasklet_disable(t);
tasklet_disable_nosync(t);
tasklet_[hi_]schedule(t);
tasklet_kill(t);

23
Tasklet Features
Runs on the same CPU that schedules it
Kernel maintains a disable count for tasklet & re-enables
the tasklet only when enable is called as many times as
disables
Can be executed at higher priority
Execute latest by next timer tick
Tasklets is serialized with respect to itself
Runs in atomic context, so blocking is not allowed

24
Hands On
BottomHalves/tasklet.c
Schedule the tasklet normal & high from the
timer handler
Reschedule the tasklet from itself

25
Work Queues
Similar to tasklets, allow the task to be carried
out later
Work queues run in a context of special kernel
process
Its legitimate to sleep in work queues
Run on the processor from which they were
scheduled, by default

26
Data Structures
Header: <linux/workqueue.h>
Types: struct workqueue_struct, struct work_struct
Work Queue APIs
q = create_workqueue(name);
q = create_singlethread_workqueue(name);
flush_workqueue(q);
destroy_workqueue(q);
Work APIs
DECLARE_WORK(w, void (*function)(struct work_struct *));
INIT_WORK(w, void (*function)(struct work_struct *));
Combined APIs
int queue_work(q, &w);
int queue_delayed_work(q, &w, d);
int cancel_delayed_work(&w);

27
Hands On
BottomHalves/work_queue.c
Modify the above example to create a delayed
work
Try with cancel_delayed_work &
flush_workqueue
Use the shared work queue

28
What have we learnt?
Timing Architecture
Ticking in jiffies
Delaying the process
Kernel Timers
Tasklets
Work Queues

29
Any Queries?

Kernel Timing Management

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Kernel Timing Management

Ähnlich wie Kernel Timing Management (20)

Mehr von SysPlay eLearning Academy for You

Mehr von SysPlay eLearning Academy for You (11)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Kernel Timing Management