BÖLÜM 5

advertisement
BÖLÜM 5
THREADS
İçerik




Giriş
Multithreading
Windows Threads
Linux Threads
Giriş




Eğer bir proses birden çok thread e sahip ise belirli
bir zamanda birden çok görevi yürütebilir.
Her thread aynı prosese ait diğer threadler ile
prosesin kod kısmını data kısmını ve diğer işletim
sistemi kaynaklarını (açık dosyalar, signals) paylaşır.
Bir proses tekil bir thread kontrolü ile işletilen bir
programdır.(heavyweight proses )
Thread = light weight process




thread ID
bir program counter
bir register seti
ve yığın içerir.
Single & MultiThreaded
Process
Faydaları




Cevap verebilirlik: Örneğin bir web browserda bir
imaj yüklenirken başka bir tred kullanıcının başka
işlemleri aynı anda yapmasına izin verir.
Kaynak Paylaşımı: Varsayılan olarak, tredler ait
oldukları prosesin kaynaklarının ve belleğini paylaşır.
Ekonomi: Proses yaratmak tred yaratmaya göre
daha maliyetli bir iştir. Proses yaratmak, tred
yaratmaktan daha uzun sürer. Tred yaratmak ve
aralarında geçiş yapmak daha az maliyetlidir.
Çok işlemci Yapılarının Verimliliği: Bir çok işlemci
mimarisinde, multitred yapıların faydaları kat kat
artırılabilir.
Kullanıcı Tredleri




Tred yönetimi, kullanıcı seviyesinde bir
tred kütüphanesi tarafından
gerçekleştirilir.
Çekirdek, kullanıcı tredlerinin farkında
değildir.
Yaratılması ve yönetilmesi hızlıdır.
3 Temel tred kütüphanesi



POSIX Pthreads
Win32 threads
Java threads
Çekirdek Tredleri



İşletim sistemi tarafından desteklenirler.
Tredler üzerindeki tüm işlemler
kernel’da gerçekleşir.
Örnek:





Windows
Solaris
Linux
UNIX
Mac OS X
Kullanıcı ve Çekirdek Tredleri
Thread States

5 durumda bulunabilirler:

init: The thread is being created

ready: The thread is waiting to be assigned to a CPU

running: The thread’s instructions are being executed

waiting: The thread is waiting for some event to occur

terminated: The thread has finished execution
interrupt
quantum expired
init
admitted
ready
I/O or event
completion
scheduler
dispatch
waiting
terminated
running
waiting for
I/O or event
exit
Proses Verisi

Her proses,





Sanal adres alanı (program kodu, global
değişkenler, tred yığınları içerir)
Prosesler birbirlerinin adres alanına
yanlışlıkla da olsa erişemezler.
Working Set
Access Token
Kernel nesneleri için Handle Table
gibi veriler içerir.
Tred Verisi

Her tred,





User-mod stack (trede aktarılmış parametreler,
çağrılan frameler vs.)
Kernel-mod stack (sistem çağrıları için)
Tred Local Storage (TLS) verisinin yerleşimini
gösteren işaretçi dizisi
State (wait, ready, running vs.) ve öncelik
Donanım içeriği (Program counter, stack pointer,
register değerleri, güncel erişim modu(user ya da
kernel mod))
Struct Proc
























2050 enum procstate { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE };
2051
2052 // Per−process state
2053 struct proc {
2054
uint sz; // Size of process memory (bytes)
2055
pde_t* pgdir; // Page table
2056
char *kstack; // Bottom of kernel stack for this process
2057
enum procstate state; // Process state
2058
volatile int pid; // Process ID
2059
struct proc *parent; // Parent process
2060
struct trapframe *tf; // Trap frame for current syscall
2061
struct context *context; // swtch() here to run process
2062
void *chan; // If non−zero, sleeping on chan
2063
int killed; // If non−zero, have been killed
2064
struct file *ofile[NOFILE]; // Open files
2065
struct inode *cwd; // Current directory
2066
char name[16]; // Process name (debugging)
2067 };
2068
2069 // Process memory is laid out contiguously, low addresses first:
2070 // text
2071 // original data and bss
2072 // fixed−size stack
2073 // expandable heap
Kernel tred/user tred

Bir prosesin kernel state’inin en önemli kısımları:





Tred bir işletim gerçekleştirir, durdurulabilir ve sonlandırılabilir.
Proses bir sistem çağrısı yaptığında:





Page table’ı ve işaret ettiği fiziksel bellek
Kernel stack’i
ve run state’i
CPU, prosesi işletmekten prosesin kernel tredini işletmeye anahtarlar.
Prosesin kernel tredi, sistem çağrısı uygulamasını (read file) işletir ve
sonra prosese geri döner.
Kernel tredin state’i (yerel parametreler), kernel tred stack’inde
depolanır.
Her prosesin kernel stack’i, user stack’ten ayrıdır.
Bu şekilde bir proses iki tred işletimine sahiptir: user tred ve kernel
tred.
Process-Related Performance Counters
Object: Counter
Function
Process:%PrivilegedTime
Percentage of time that the threads in
the process have run in kernel
Process:%ProcessorTime
Percentage of CPU time that threads
have used during specified interval
Process:%UserTime
Percentage of time that the threads in
the process have run in user m.
Process: ElapsedTime
Total lifetime of process in seconds
Process: ID Process
PID – process IDs
Process: ThreadCount
Number of threads in a process
Thread-Related Performance
Counters
Object: Counter
Function
Process: Priority Base
Base priority of process: starting priority for thread
within process
Thread:%PrivilegedTime
Percentage of time that the thread was run in kernel
mode
Thread:%ProcessorTime
Percentage of CPU time that the threads has used
during specified interval
Thread:%UserTime
Percentage of time that the thread has run in user
mode
Thread: ElapsedTime
Total lifetime of process in seconds
Thread: ID Process
PID – process IDs
Thread: ID Thread
Thread ID
Thread-Related Performance
Counters (contd.)
Object: Counter
Function
Thread: Priority Base
Base priority of thread: may differ from the thread‘s
starting priority
Thread: Priority Current
The thread‘s current dynamic priority
Thread: Start Address
The thread‘s starting virtual address (the same for
most threads)
Thread: Thread State
Value from 0 through 7 – current state of thread
Thread: Thread Wait Reason
Value from 0 through 19 – reason why the thread is
in wait state
Multithreading Modelleri

Many-to-One

One-to-One

Many-to-Many
Many-to-One



Bir çok kullanıcı tredini tek bir kernel
tredine map eder.
Tred yönetimi kullanıcı alanında yapılır.
Kullanıcı-seviyeli tred kütüphaneleri,
kernel tredlerini desteklemeyen manyto-one modelini kullanan işletim sistemi
üzerinde gerçekleştirilirler.
Many-to-One
One-to-One




Her kullanıcı tredini bir kernel tredine
map eder.
Many-to-one modeline göre daha fazla
eş zamanlılık sağlar.
Birden çok tredin çoklu işlemciler
üzerinde çalışabilmesine olanak tanır.
Bu modelde, bir kullanıcı tredi
yaratmak, uygun kernel tredin
yaratılması ile gerçekleşir.
One-to-One
Many-to-Many



Birden çok kullanıcı tredini eşit sayıda ya da daha az
sayıda kernel tredine çoklar.
Uygulama geliştiriciye istediği kadar tred yaratma
şansı verir.
Eş zamanlılık doğru olarak uygulanmış olmaz. Çünkü
kernel belirli bir zamanda yalnızca bir tredi
düzenleyebilir.


One-to-one model daha iyi bir eş zamanlılık sağlarken,
kullanıcı bir uygulamada çok fazla sayıda tred
yaratmamalıdır.
Many-to-many modeli ise tüm bu kısıtlamalardan
kurtulmuştur. Uygulama geliştiriciler istedikleri kadar
kullanıcı prosesi yaratabilirler. Aynı zamanda ne zaman bir
tred blok sistem çağrısı gerçekleştirirse, kernel işletim için
başka bir tred düzenleyebilir
Many-to-Many
Solaris Threads
Solaris Threads








Ptred API sini uygular.
Tredlerin yaratılması ve yönetilmesi için API yi
içeren bir kütüphane ve kullanıcı tredleri
destekler.
Tredleri real time olarak düzenler.
Kullanıcı ve Kernel tredleri arası LWP lerdir.
Her proses en az bir LWP içerir.
Tred kütüphanesi, kullanıcı tredlerini proses
için olan LWP havuzunda çoklar.
Her LWP bir kernel seviyeli trede sahiptir.
Her kullanıcı tredi ise kerneldan bağımsızdır.
…






Eğer bir kernel tredi bloke olursa, işlemci başka bir kernel tredini
işletebilir.
Eğer blok olan tred bir LWP nin bir kısmında çalışıyor ise LWP de
blok olmuş olur. Buna bağlı olarak o LWP ye attach edilmiş diğer
tredler de blok olmuş olurlar.
Eğer bir proses birden çok LWP ye sahipse kernel diğer LWP yi
düzenler.
Uygulamanın en iyi performans ile çalışıyor olması için LWP
sayıları sürekli olarak kontrol edilir.
Örneğin bir prosesteki tüm LWP ler blok olmuş ise ve tredler
çalışmaya hazır ise, tred kütüphanesi otomatik olarak başka bir
LWP yi bekleyen trede attach eder.
Aynı şekilde LWP ler uzun süre kullanılmamış ise tred
kütüphaneleri bunları silebilirler.
Win- Threads






Win32 API si microsoft işletim sistemleri için birincil API dir.
Bir windows uygulaması her prosesin bir yada daha çok tred
içerebileceği birbirinden ayrı prosesleri işletir.
Windows one-to-one mimarisini kullanır. Her kullanıcı seviyeli
tred uygun bir kernel tredine map edilir.
Bundan başka windos bir fiber kütüphanesi de sunar. Bu
kütüphane many-to-many fonksiyonu sağlar.
Bir prosese ait her tred, prosesin sanal adres alanına erişebilir.
Tredin genel bileşenleri:




Tred’i belirten tekil bir tred ID
İşlemcinin durumunu belirtir bir register set
Tred kullanıcı modunda çalışırken kullanılan bir kullanıcı yığını.
Benzer olarak her tred aynı zamanda bir kernel yığınına sahiptir. Ve
bu yığın tred kernel modunda çalışırken kullanılır.
Bir çok run time kütüphane ile kullanılan özel bir depolama alanı ve
dinamik link kütüphaneleri (DLL)
Processes & Threads
Internal Data Structures
Access Token
VAD
Process
Object
VAD
VAD
Virtual Address Space Descriptors
Handle Table
object
object
Thread
Thread
Thread
...
Access Token
Kernel: Thread Priority Levels
31
16 “real-time” levels
16
15
15 variable levels
1
0
i
Used by zero page thread
Used by idle thread(s)
Windows Kernel Priorities
Win32 Process Classes
Re altime
High
Abov e
Normal
Normal
Be low
Normal
Idle
Win32
Thread
Time -critical
31
15
15
15
15
15
Highe st
26
15
12
10
8
6
Priorities
Abov e -normal
25
14
11
9
7
5
Normal
24
13
10
8
6
4
Be low-normal
23
12
9
7
5
3
Lowe st
22
11
8
6
4
2
Idle
16
1
1
1
1
1
Windows Process and Thread
Internals
Her process/thread için Data Structures:

Executive process block (EPROCESS)

Executive thread block (ETHREAD)

TEB (Thread environment block)
Thread Block
ETHREAD (executive
thread block )
KTHREAD
KTHREAD (Kernel Thread Block)
Dispatcher Header
Total User Time
Create and Exit Time
Total Kernel Time
Process ID
Kernel Stack Information
EPROCESS
System Service Table
Thread Start Address
Access Token
Thread Scheduling Information
Trap Frame
Impersonation Information
Thread Local Storage
LPC Message Information
Synchronization Information
Timer Information
Pending I/O Requests
Timer Block and Wait Blocks
List of Objects Being Waiting On
TEB (Enviroment Block)
Thread Block (!thread)
Thread ID
Process ID
Address of thread
environment block
Address of ETHREAD
Thread
state
Objects being
waited on
Stack trace
Address of system
service dispatch table
THREAD 83160f60 Cid 9f.3d Teb: 7ffdc000 Win32Thread: e153d2c8
WAIT: (WrUserRequest) UserMode Non-Alertable
808e9d60 SynchronizationEvent
Not impersonating
Actual thread start address
Owning Process 81b44880
WaitTime (seconds)
953945
Context Switch Count
2697
LargeStack
UserTime
0:00:00.0289
KernelTime
0:00:04.0664
Start Address kernel32!BaseProcessStart (0x77e8f268)
Win32 Start Address 0x020d9d98
Address of user thread function
Stack Init f7818000 Current f7817bb0 Base f7818000 Limit f7812000 Call 0
Priority 14 BasePriority 8 PriorityDecrement 6 DecrementCount 13
Kernel stack not resident.
ChildEBP
f7817bb0
f7817c50
f7817cc0
f7817d10
f7817d80
f7817df0
0012fef0
RetAddr
8008f430
de0119ec
de0123f4
de01f2f0
800bab58
77d887d0
00000000
Args to Child
00000001 00000000
00000001 00000000
00000001 00000000
00000001 00000000
00000001 00000000
00000001 00000000
00000001 00000000
Priority Information
00000000
00000000
00000000
00000000
00000000
00000000
00000000
ntoskrnl!KiSwapThreadExit
ntoskrnl!KeWaitForSingleObject+0x2a0
win32k!xxxSleepThread+0x23c
win32k!xxxInternalGetMessage+0x504
win32k!NtUserGetMessage+0x58
ntoskrnl!KiSystemServiceEndAddress+0x4
user32!GetMessageW+0x30
Thread lifetime




Tred işletim sistemine dönene kadar
ExitThread tred tarafından çağrılana
kadar
TerminateThread tred de işletilene
kadar
ExitProcess çağrısı yapılana kadar
The main Stages Windows
follows
to create a process
Open EXE and
create selection
object
Creating process
Create NT
process object
Create NT
thread object
Notify Windows
subsystem
Start execution
of the initial
thread
Return to caller
Windows subsystem
Set up for new
process and
thread
New process
Final
process/image
initialization
Start execution
at entry point to
image
Linux Threads







Proses yaratmak  fork()
Tred yaratmak  clone sistem çağrısı
Clone, fork() fonksiyonu gibi iş yapmaktadır, yalnızca prosesin kopyasını
yaratmak yerine, ilgili prosesin adres alanını kullanan ayrı bir proses yaratır.
Sistemdeki her proses için tekil bir kernel veri yapısı (struct task_struct)
mevcuttur. Bu veri yapısı task için veri depolamak yerine diğer veri yapılarına
pointer içerir (örn open file list data structure, virtual memory data structure
gibi)
Fork() çağrıldığında, parent prosesin tüm veri yapılarının bir kopyası ile yeni bir
task yaratılır
Linux tredler ve prosesler arasında ayrım yapmaz.
Clone() çağrısı ile parent ve child arasında paylaşılan veri yapıları aşağıdaki
parametrelerin geçirilmesi ile sağlanır.
Download
Related flashcards

Theory of computation

16 cards

Computer science

25 cards

ARM architecture

23 cards

X86 architecture

22 cards

Software

43 cards

Create Flashcards