Sistemas Operativos. Processos e threads no Windows. Centro de Cálculo Instituto Superior de Engenharia de Lisboa

Transcrição

1 Sistemas Operativos Processos e threads no Windows Centro de Cálculo Instituto Superior de Engenharia de Lisboa João Pedro Patriarca (jpatri@cc.isel.ipl.pt)

2 Visão conceptual (simplista) de Processo e Thread Processo: 1. Objecto kernel usado pelo sistema operativo para gerir o processo 2. Espaço de endereçamento que contém o módulo executável, DLL s, stacks e heaps Thread: 1. Objecto kernel usado pelo sistema operativo para gerir a thread 2. Stack da thread onde são mantidos os parâmetros e variáveis locais das funções em execução no contexto da thread Anexos: estruturas de dados

3 Função CreateProcess Pode ter o valor NULL (o primeiro token do próximo parâmetro deverá indicar o nome da aplicação) BOOL CreateProcess( PCTSTR pszapplicationname, PTSTR pszcommandline, PSECURITY_ATTRIBUTES psaprocess, PSECURITY_ATTRIBUTES psathread, BOOL binherithandles, DWORD fdwcreate, PVOID pvenvironment, PCTSTR pszcurdir, PSTARTUPINFO psistartinfo, PPROCESS_INFORMATION ppiprocinfo); Pode ser NULL; Consultar bib: en-us/library/ms682425(v=vs.85) Indicam se os handles retornados são herdáveis por futuros processos filhos. A NULL, os handles não são herdáveis Indica se o processo filho herdará os handles herdáveis do processo pai Flags que controlam a classe de prioridade e a criação do processo Pode ter o valor NULL, herdando as variáveis de ambiente do pai A NULL, a directoria é a mesma do processo pai; caso contrário, deverá incluir a drive e directoria Inicialização mínima (consultar bib): STARTUPINFO si = { sizeof(si) }; CreateProcess(..., &si,...); typedef struct _PROCESS_INFORMATION { HANDLE hprocess; HANDLE hthread; DWORD dwprocessid; DWORD dwthreadid; } PROCESS_INFORMATION;

4 Parâmetro fdwcreateflags O valor 0 coloca a thread principal do novo processo na fila de threads Ready Controlo da criação do processo CREATE_DEBUG, CREATE_SUSPENDED, CREATE_NEW_CONSOLE, CREATE_NO_WINDOW, DETACHED_PROCESS Classes de prioridade: REALTIME_PRIORITY_CLASS, HIGH_PRIORITY_CLASS, ABOVE_NORMAL_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS, BELOW_NORMAL_PRIORITY_CLASS, IDLE_NORMAL_PRIORITY_CLASS Normalmente não é especificado: processos criados com a prioridade por omissão

5 Criação de processo passos Creating process Stage 1 Convert and validate parameters and flags Stage 2 Open EXE and create section object Stage 3 Create Windows process object Stage 4 Create Windows thread object Windows subsystem Stage 5 Perform Windows-subsystem specific process initialization Set up for new process and thread New process Start execution of the initial thread Final process/image initialization Stage 6 Stage 7 Return to caller Start execution at entry point to image

6 Terminação de um processo Cenários em que um processo pode terminar A função de entrada da thread primária retorna (forma adequada de terminar uma thread) Uma thread do processo chama a função ExitProcess (evitar este método) Uma thread noutro processo chama a função TerminateProcess (evitar este método) Todas as threads do processo terminam por si mesmas (raramente acontece)

7 Terminação de um processo A função de entrada da thread primária retorna O retorno desta forma garante: Qualquer objecto C++ criado pela thread será destruído usando o seu destrutor Libertação da memória associada ao stack da thread O sistema afecta o código de saída (mantido no objecto kernel do processo) como valor de retorno da função de entrada O sistema decrementa o contador de referências do objecto kernel processo ExitProcess

8 Terminação de um processo Função ExitProcess VOID ExitProcess(UINT fuexitcode); Termina o processo e afecta como código de saída o valor do parâmetro fuexitcode Esta função não retorna No runtime C/C++, quando a thread primária retorna da função de entrada (main), retorna para o código de startup Chama as funções registadas (atexit(pfunc)) para serem executadas na conclusão do programa Chama os destrutores dos objectos alocados estaticamente Aguarda que as threads deste processo terminem Chama a função ExitProcess Se a thread primária terminar com a função ExitThread, o processo só termina se não existirem mais threads no processo

9 Terminação de um processo Função TerminateProcess BOOL TerminateProcess(HANDLE hprocess, UINT fuexitcode); Distingue-se da função ExitProcess por poder ser chamada por qualquer thread dentro ou fora do processo Usar apenas na condição de não se conseguir terminar o processo por qualquer outro método O sistema garante que os recursos associados ao processo são completamente eliminados Acção de terminação assíncrona o que justifica a chamada da função WaitForSingleObject para determinar a conclusão do processo

10 Terminação de um processo Todas as threads do processo terminam por si mesmas Todas as thread retornam da função de entrada ou chamam a função ExitThread ou a função TerminateThread Numa situação destas, o sistema termina o processo marcando o código de saída do processo com o valor do código de saída da última thread que terminou

11 Terminação de um processo Acções realizadas Termina as threads ainda existentes no processo Todos os objectos User e GDI alocados ao processo são libertados Todos os objectos kernel são fechados e eliminados se os contadores de referências dos objectos atingiram o valor 0 O código de saída do processo altera de STILL_ACTIVE (0x103) para o valor passado na função ExitProcess ou TerminateProcess O objecto kernel processo é sinalizado (para efeitos de sincronização) O contador de referências do objecto kernel processo é decrementado BOOL GetExitCodeProcess( HANDLE hprocess, PDWORD pdwexitcode);

12 Processo filho PROCESS_INFORMATION pi; DWORD dwexitcode; // Detached child process. PROCESS_INFORMATION pi; BOOL fsuccess = CreateProcess(..., &pi); if (fsuccess) { // Spawn the child process. BOOL fsuccess = CreateProcess(..., &pi); if (fsuccess) { } CloseHandle(pi.hThread); CloseHandle(pi.hProcess); } // Close the thread handle as soon as it is no longer needed! CloseHandle(pi.hThread); // Suspend our execution until the child has terminated. WaitForSingleObject(pi.hProcess, INFINITE); // The child process terminated; get its exit code. GetExitCodeProcess(pi.hProcess, &dwexitcode); // Close the process ahndle as soon as it is no longer needed. CloseHandle(pi.hProcess);

13 demo11 Terminate process and free resources As experiências, de 1 a 5, ilustram o comportamento na libertação dos recursos alocados nas diferentes formas de terminar um processo

14 Visão conceptual (simplista) de Processo e Thread Processo: 1. Objecto kernel usado pelo sistema operativo para gerir o processo 2. Espaço de endereçamento que contém o módulo executável, DLL s, stacks e heaps Thread: 1. Objecto kernel usado pelo sistema operativo para gerir a thread 2. Stack da thread onde são mantidos os parâmetros e variáveis locais das funções em execução no contexto da thread Anexos: estruturas de dados

15 Função CreateThread HANDLE CreateThread( PSECURITY_ATTRIBUTES psa, DWORD cbstacksize, PTHREAD_START_ROUTINE pfnstartaddr, PVOID pvparam, DWORD dwcreateflags, PDWORD pdwthreadid); Pode ter o valor NULL (atributos de segurança por omissão). Pode ser usado para determinar se um objecto processo filho tem acesso ao objecto kernel thread criado por esta função Memória que ficará committed inicialmente. O valor 0 usa os valores presentes na imagem do executável. DWORD WINAPI <threadfuncname>( PVOID param); O retorno corresponde ao valor de saída (idêntico ao valor de retorno da função main) Pode ter o valor NULL Valor 0: a thread pode ser colocada de imediato em execução Valor CREATE_SUSPENDED: a thread sai do estado Suspended quando for chamada a função ResumeThread Na escrita de programas em C/C++ dever-se-á usar a função _beginthreadex em vez de CreateThread

16 CreateThread steps 1. Transforma parâmetros Windows API em flags nativas e constrói estrutura nativa que descreve os parâmetros objecto 2. Constrói lista de atributos com duas entradas: client ID e endereço TEB 3. NtCreateThread é chamada para criar o contexto do User. Depois chama PspCreateThread para criar um objecto Executive thread suspensa 4. CreateThread realiza acções associadas com o stack 5. CreateThread notifica o subsistema Windows acerca da nova thread para que realize algumas inicializações 6. O handle da nova thread e o seu ID são retornados para o chamador 7. A menos que a thread tenha sido criada com a flag CREATE_SUSPENDED activa, a thread é colocada na fila de threads ready para ser colocada em execução pelo scheduler. Nessa altura executa o passo 7 descrito na iniciação de um processo já no contexto do User

17 Terminação de uma thread Cenários em que uma thread pode terminar A função correspondente ao ponto de entrada da thread retorna (método adequado) A thread mata-se a si própria chamando a função ExitThread (evitar este método) Uma qualquer thread deste processo chama a função TerminateThread (evitar este método) O processo que contém a thread termina (evitar este método)

18 Terminação de uma thread A função correspondente ao ponto de entrada retorna O retorno desta forma garante: Todos os objectos C++ criados no âmbito da thread são destruídos apropriadamente com a chamada dos destrutores respectivos O sistema liberta a memória associada ao stack da thread O sistema afecta o código de saída (mantido no objecto kernel da thread) como valor de retorno da função de entrada O sistema decrementa o contador de referências do objecto kernel thread ExitThread

19 Terminação de uma thread Função ExitThread VOID ExitThread(DWORD dwexitcode); Termina a thread e o sistema operativo elimina todos os recursos alocados à thread Recursos correspondentes a objectos C/C++ não são devidamente destruídos Esta função não retorna Na escrita de programas em C/C++ dever-se-á usar a função _endthreadex em vez de ExitThread

20 Terminação de uma thread Função TerminateThread BOOL TerminateThread(HANDLE hthread, DWORD dwexitcode); Distingue-se da função ExitThread por poder ser chamada por qualquer thread dentro do processo Usar apenas na condição de não se conseguir terminar a thread por qualquer outro método Acção de terminação assíncrona o que justifica a chamada da função WaitForSingleObject para determinar a conclusão da thread Ao contrário da função ExitThread, o stack da thread não é eliminado com a chamada de TerminateThread Qualquer outra thread que mantenha uma referência para uma variável no stack da thread terminada não recebe excepção quando aceder a essa posição de memória Uma DLL não receberá a notificação do fim da thread

21 Terminação de uma thread Terminação de um processo As funções ExitProcess e TerminateProcess terminam todas as threads contidas no processo Todos os recursos do processo serão eliminados incluindo os stacks das threads Contudo não destrói adequadamente todos os recursos Não executa os destrutores dos objectos C++ Não despeja os buffers em memória no disco... No runtime C/C++ quando a função main da thread primária retorna é chamada a função ExitProcess

22 Terminação de uma thread Acções realizadas Liberta todos os handles de objectos User mantidos pela thread O código de saída da thread altera de STILL_ACTIVE (0x103) para o valor passado na função ExitThread ou TerminateThread O objecto kernel thread é sinalizado (para efeitos de sincronização) Se a thread for a última thread activa do processo, o sistema considera o processo terminado também O contador de referências do objecto kernel thread é decrementado BOOL GetExitCodeThread( HANDLE hthread, PDWORD pdwexitcode);

23 demo12 Terminate thread and free resources As experiências, de 1 a 5, ilustram o comportamento na libertação dos recursos alocados nas diferentes formas de terminar uma thread

24 Aspectos internos da thread quando iniciada Thread Kernel object CONTEXT SP EIP Other CPU registers Other properties and statistics Usage count = 2 Suspend count = 1 Exit code = STILL_ACTIVE Signaled = FALSE Thread stack pvparam pfnstartaddr.... NTDLL.dll High address Low address bib: Windows via C/C++, Richter, Nasarre, 5ª edição, fig. 6-1 VOID RtlUserThreadStart(...) {... } VOID RtlUserThreadStart(PTHREAD_START_ROUTINE pfnstartaddr, PVOID pvparam) { try { ExitThread((pfnStartAddr)(pvParam)); } except(unhandledexceptionfilter(getexceptioninformation())) { ExitProcess(GetExceptionCode()); } // NOTE_ We never get here }

25 Thread scheduling Dispatch Conjunto de código associado ao despacho de threads, preemptivo e baseado em prioridades Execução no âmbito do kernel Uma thread tem um tempo limite de posse do CPU (Quantum) Uma thread pode usar menos tempo que o seu Quantum Quando acontece necessidade de scheduling (context switch)? Uma nova thread ficou ready para executar A thread corrente em execução deixou o estado ready ou atingiu o seu Quantum A prioridade de uma thread alterou A afinidade de uma thread a um processador alterou O sistema Windows é preemptivo O sistema Windows lança em execução a thread com maior prioridade

26 Dispatcher database bib: Windows internals, Russinovich, Solomon, fig Process Process CPU 0 ready queues 31 Thread 1 Thread 2 Thread 3 Thread 4 CPU 1 ready queues 31 0 Ready summary Deferred ready queue Campo KPRCB ReadySummary DeferredReadyListHead Tipo Bitmask (32 bits) 0 Ready summary DispatcherReadyListHead Lista simplesmente ligada Array de 32 entradas de listas ready Deferred ready queue

27 Cenários de Scheduling Priority Running Ready Mudança voluntária Preempção Fim do quantum Priority Running Ready To wait state Priority Running Ready From Wait state

28 Níveis de prioridade Nativo versus subsistema Windows Mapeamento Noção de prioridade base e prioridade corrente (no caso de threads) Alteração da prioridade base software comando de linha start (experimentar a aplicação Notepad e observar com o Task Manager)

29 Prioridades de processos e threads Mapeamento entre sistema nativo e subsistema Windows Real-time time critical Real-time Levels Real-time idle Dynamic time critical Dynamic Levels 1-15 Dynamic idle Prioridades nativas Level 0: Used for zero page thread; not available to Win32 applications Processo: classe de prioridade Thread: Prioridade base = Fx(classe de prioridade, prioridade relativa) Prioridade corrente = prioridade base + boost priority Alteração da classe de prioridade Parâmetro fdwcreate da função CreateProcess Linha de comando, com o comando Start: > start /low notepad Após criação, com a função SetPriorityClass Relative Thread Priority Idle Below Normal Process Priority Class Normal Above Normal High Real- Time Time-critical Highest Above normal Normal Below normal Lowest Idle

30 Programação de prioridades Funções relevantes

31 Estados da thread Ready (1) Thread à espera para ser executada; O dispatcher olha para este pool de threads quando procura por uma thread para colocar em execução Deferred ready (7): threads que foram seleccionadas para execução num determinado CPU mas que ainda não foram scheduled Standby (3): thread seleccionada para ser a próxima a correr num determinado CPU; apenas uma thread neste estado por CPU no sistema Running (2) Uma thread entra no estado Running quando o dispatcher executa o Context Switch A execução continua até terminar o seu quantum, ser preemptida por outra thread com maior prioridade, terminar, ou entrar no estado Wait voluntariamente Waiting (5) Entra neste estado: por vontade própria (objectos de sincronização); o sistema operativo entrou no estado Wait no contexto da thread; entre outros Quando sai deste estado poderá ser colocada de novo em execução ou na lista de threads Ready Gate Waiting (8): entra neste estado quando espera por um objecto gate dispatcher (cap. 3) Transition (6): entra neste estado quando a thread está preparada para execução mas ainda lhe faltam recursos em memória (kernel stack) Terminated (4): entra no estado quando a thread termina a execução Initialized (0): usado internamente durante a criação da thread

32 Transição entre estados numa thread bib: Windows internals, Russinovich, Solomon, fig Ready preemption, quantum end Init preempt Standby Deferred ready Running Transition Waiting or Gate waiting voluntary switch Terminate

33 Quantum Quantidade de tempo que uma thread possui o CPU A partir do Window Vista = 2 intervalos de clock Windows Server 2008 = 12 intervalos de clock 1 intervalo de clock (aproximadamente) x86, uniprocessador = 10 ms 64bits ou multiprocessador = 15 ms Quantum boosting Quando um processo é colocado em foreground as threads têm o seu quantum triplicado

34 Afinidade a CPUs Board 1 NUMA Machine Board 2 Board 3 CPU0 CPU1 CPU4 CPU5 CPU8 CPU9 CPU2 CPU3 CPU6 CPU7 CPU10 CPU11 Memory Memory Memory

35 Linhas de cache num contexto multiprocessador Cenário: CPU1 lê 1 byte. O byte solicitado e adjacentes são carregados na cache do CPU1 CPU2 lê o mesmo byte. Os mesmos bytes são carregados na cache do CPU2 CPU1 altera o byte lido O respectivo byte na cache do CPU2 fica inválido; a arquitectura garante a marcação como inválida da linha de cache do CPU2 Boas práticas: Um CPU deverá ter as suas variáveis em memória agrupadas numa linha de cache: as variáveis de um programa que sejam acedidas num intervalo de tempo curto deverão ser declaradas próximas Evitar que dois ou mais CPU s partilhem variáveis em memória: threads que partilhem recursos deverão ter afinidade ao mesmo CPU Separar dados de leitura apenas dos dados que serão lidos e escritos Usar a directiva para o compilador C/C++ declspec(align(#)) int declspec(align(cache_align)) var;

36 Como garante o sistema justiça na distribuição do CPU Priority boost Cenários onde pode acontecer um priority boost (as unidades incrementadas dependem do cenário em causa) 1. Na conclusão de uma operação I/O completion 2. Depois de concluir uma acção de espera por eventos ou semáforos 3. Depois das threads de um processo foreground completarem uma operação de Wait 4. Quando threads GUI acordam 5. Quando uma thread está Ready há demasiado tempo sem ser colocada em execução (CPU starvation) Por cada quantum gasto em execução é decrementada a sua prioridade até atingir o valor da prioridade base Uma thread nestas condições pode ser preemptida por outra de maior prioridade; a thread não perde o seu quanto de execução com a prioridade corrente

37 Priority boost Funções relevantes BOOL SetProcessPriorityBoost( HANDLE hprocess, BOOL bdisablepriorityboost); // true: disable all // process thread s boost BOOL GetProcessPriorityBoost( HANDLE hprocess, PBOOL pbdisablepriorityboost); BOOL SetThreadPriorityBoost( HANDLE hthread, BOOL bdisablepriorityboost); // true: disable thread // boost BOOL GetThreadPriorityBoost( HANDLE hthread, PBOOL pbdisablepriorityboost);

38 Idle thread Idle thread é a thread com menor prioridade (incluindo a Zero Page thread com nível de prioridade 0) A Idle thread, na realidade, não tem prioridade Apenas é colocada em execução quando não existir nenhuma outra thread no estado Ready Só existe uma Idle thread por processador

39 Funções utilizadas na demo: SetProcessAffinityMask; SetThreadAffinityMask; SetThreadPriority; SetProcessPriorityBoost SuspendThread; ResumeThread. Threads Schuduling

40 Considerações sobre a biblioteca runtime C/C++ Preocupações com a biblioteca standard do C num cenário de programação concorrente A biblioteca na sua génese não previa execução concorrente Variáveis com alocação estática: errno, strtok, strerror,... Solução: Cada thread tem as variáveis globais da biblioteca reunidas num bloco O bloco fica alojado num espaço de endereçamento pertencente à thread (TLS Thread Local Storage) Problema: Como associar o bloco a uma thread? Solução: Chamando a função _beginthreadex em vez da função CreateThread e começa aqui a história...

41 Considerações sobre a biblioteca runtime C/C++ Função _beginthreadex (pseudocódigo) As funções _beginthreadex, _threadstartex, _callthreadstartex e _endthreadex estão definidas no módulo <Visual Studio pathname>\vc\crt\src\threadex.c O chamador deverá mapear os tipos dos argumentos da função CreateThread para a função _beginthreadex uintptr_t cdecl _beginthreadex( void* psa, unsigned cbstacksize, unsigned ( stdcall * pfnstartaddr) (void*), void* pvparam, unsigned dwcreateflags, unsigned * pdwthreadid) { _ptiddata ptd; // Pointer to thread s data block uintptr_t thdl; // Thread handles // Allocate data block for the new thread if ((ptd = (_ptiddata)_calloc_crt(1, sizeof(struct _tiddata))) ==NULL) goto error_return; initptd(ptd); // Initialize data block // Save desired thread function and parameter ptd->_initaddr = (void*)pfnstartaddr; ptd->_initarg = pvparam; ptd->handle = (uintptr_t)(-1); // Create the new thread thdl = (uintptr_t)createthread((lpsecurity_attributes)psa, cbstacksize, _threadstartex, (PVOID)ptd, dwcreateflags, pdwthreadid); if (thdl == 0) goto error_return; return (thdl); error_return: _free_crt(ptd); return ((uintptr_t)0l); }

42 Considerações sobre a biblioteca runtime C/C++ Função _threadstartex (pseudocódigo) static unsigned long WINAPI _threadstartex( void* ptd) { // Associate the tiddata block with this thread so _getptd() // will be able to find it in _callthreadstartex TlsSetValue( tlsindex, ptd); ((_ptiddata)ptd)->_tid = GetCurrentThreadId(); // save this thread ID //... initializations not relevant _callthreadstartex(); // call helper function } // The execution code should never reach here //(the thread dies in _callthreadstartex) return (0L);

43 Considerações sobre a biblioteca runtime C/C++ Função _callthreadstartex (pseudocódigo) static void _callthreadstartex( void* ptd) { _ptiddata ptd; // Pointer to thread s data block } // Get the pointer to thread data from TLS ptd = _getptd(); // Wrap desired thread function in SEH frame to handle run-time // errors and signal support try { // Call desired thread function, passing it he desired parameter // Pass thread s exit code value to _endthreadex _endthreadex( ((unsigned (WINAPI*)(void*))(((_ptiddata)ptd)->_initaddr)) (((_ptiddata)ptd)->_initarg) ); } except(_xcptfilter(getexceptioncode(), GetExceptionInformation())) { // The execution code should never reach here _exit(getexceptioncode()); }

44 Considerações sobre a biblioteca runtime C/C++ Função _endthreadex (pseudocódigo) void cdecl _endthreadex( unsigned retcode ) { _ptiddata ptd; // Pointer to thread s data block // Not relevant cleanup // Get the address of this thread s tiddata block ptd = _getptd_noexit(); // Free the tiddata block if (ptd!= NULL) _freeptd(ptd); } // Terminate the thread ExitThread(retcode);

45 Considerações sobre a biblioteca runtime C/C++ Definição de errno _CRTIMP extern int * cdecl _errno (void); #define errno (*_errno()) int * cdecl _errno(void) { _ptiddata ptd = _getptd_noexit(); if (!ptd) return &ErronoNoMem; else return (&ptd->_terrno); } int * p = &errno; if (*p == ENOMEM) {... }

46 Considerações sobre a biblioteca runtime C/C++ Bibliotecas runtime C/C++ Bibliotecas usadas com o Microsoft Visual Studio LibCMt.lib, para ligação estática LibCMtD.lib, para ligação estática com debug MSVCRt.lib, para ligação dinâmica com a DLL MSVCR80.dll (biblioteca usada por omissão na criação de um novo projecto) MSVCRtD.lib, para ligação dinâmica com a DLL MSVCR80.dll com debug MSVCMRt.lib, usada no âmbito de código managed e código nativo MSVCURt.lib, biblioteca compilada com código 100% MSIL Caminho da configuração da biblioteca a usar no Visual Studio Project Properties Configuration Properties C/C++ Code Generation Escolher uma das bibliotecas associadas ao campo Runtime Library Funções da biblioteca que nunca deverão ser usadas unsigned long _beginthread( void ( cdecl *start_address)(void *) unsigned stack_size, void * arglist); void _endthread(void);

47 Tempos associados à execução de uma thread Kernel32.dll, Windows.h ULONGLONG GetTickCount64(); // Não considera a preempção BOOL GetThreadTimes(HANDLE hthread, PFILETIME pftcreationtime, // valor absoluto desde 1 de Janeiro de 1601 PFILETIME pftexittime, // valor absoluto desde 1 de Janeiro de 1601 PFILETIME pftkerneltime, // valor relativo gasto em kernel mode PFILETIME pftusertime); // valor relativo gasto em user mode PFILETIME expresso no número de intervalos de 100 nano-segundos Funções adequadas para medir intervalos de tempo longos (fraca precisão) O tempo de CPU de uma thread é contabilizado com base num temporizador que gera ciclos entre os 10 e 15 ms BOOL GetProcessTimes(<same as GetThreadTimes>); // Tempo gasto por todas as threads do processo

48 Time Stamp Counter (contador de alta resolução) Kernel32.dll, Windows.h Time Stamp Counter: contador de 64 bits do processador que conta o número de ciclos desde que a máquina iniciou BOOL QueryThreadCycleTime(HANDLE ThreadHandle, PULONG64 CycleTime); BOOL QueryProcessCycleTime(HANDLE ProcessHandle, PULONG64 CycleTime); Número de ciclos atribuídos a uma thread ou a todas as threads de um processo (considera a preempção) #define ReadTimeStampCounter() Macro definida no WinNT.h que retorna o valor do contador TSC (usa a função intrínseca rdtsc providenciada pelo compilador C++) Funções medidoras de tempo de alta resolução BOOL QueryPerformanceFrequency(LARGE_INTEGER* plifrequency); BOOL QueryPerformanceCounter(LARGE_INTEGER* plicount); Não consideram a preempção Os diferentes valores de referência poderão perturbar os resultados

49 Bibliografia Windows internals, Russinovich e Solomon, cap. 5, 5ª edição Windows via C/C++, Richter e Nasarre, cap. 4, 6 e 7, 5ª edição MSDN - windows development

50 Anexos

51 Estrutura de dados que representa um processo Bloco EPROCESS (Executive Process Block) bib: Windows internals, Russinovich, Solomon, fig. 5-2 PsActiveProcessHead Kernel process block (or PCB) Process ID Parent process ID Exit status Create and exit times Active process link Quota block Memory management information Exception port Debugger port Device map Process environment block Image filename Image base address Process priority class EPROCESS Primary access token Handle table Windows process block Job object

52 Estrutura de dados Bloco KPROCESS (Kernel Process Block or PCB) bib: Windows internals, Russinovich, Solomon, fig. 5-3 Dispatcher header Kernel time User time Inswap/Outswap list entry Process spinlock Process affinity Resident kernel stack count Process base priority Default thread quantum Process state Thread seed Disable boost flag Process page directory KTHREAD...

53 Estrutura de dados Bloco PEB (Process Environment Block) bib: Windows internals, Russinovich, Solomon, fig. 5-4 Image base address Module list Thread-local storage data Code page data Critical section timeout Number of heaps Heap size information GDI shared handle table Operating system version number information Image version information Image process affinity mask Process heap

54 Variáveis kernel, contadores de performance e funções relacionados com processos Fica apenas a referência dado o volume de informação Windows Internals, Russinovich e Solomon, Cap. 5 Variáveis kernel: tabela 5-2 Contadores de performance: tabela 5-3 Funções relevantes: tabela 5-4

55 Estrutura de dados que representa uma thread Bloco ETHREAD (Executive thread block) bib: Windows internals, Russinovich, Solomon, fig. 5-7 KTHREAD Create and exit times Process ID Thread start address Impersonation information ALPC message information Timer information TEB EPROCESS Access token Pending I/O requests

56 Estrutura de dados Bloco KTHREAD (Kernel thread block) bib: Windows internals, Russinovich, Solomon, fig. 5-8 Dispatcher header Total user time Total kernel time Thread-scheduling information Trap frame Synchronization information List of pending APCs Timer block and wait block List of objects thread is waiting on Kernel stack information System service table Thread-local storage array TEB

57 Estrutura de dados Bloco TEB (Thread environment block) bib: Windows internals, Russinovich, Solomon, fig. 5-9 Exception list Stack base Stack limit Thread ID Active RPC handle LastError value Count of owned critical sections Current locale User32 client information GDI32 information OpenGL information TLS array Subsystem thread information block (TIB) Fiber information PEB Winstock data

58 Variáveis kernel, contadores de performance e funções relacionados com threads Fica apenas a referência dado o volume de informação Windows Internals, Russinovich e Solomon, Cap. 5 Variáveis kernel: tabela 5-11 Contadores de performance: tabela 5-12 Funções relevantes: tabela 5-13

59 Funções da Windows API que promovem scheduling Windows internals, Russinovich e Solomon, Tab. 5-15, 5ª edição

60 Prioridades de processos e threads Mapeamento entre sistema nativo e subsistema Windows Real-time time critical Real-time Levels Prioridades nativas Real-time Processo: classe de prioridade Thread: Prioridade base = Fx(classe de prioridade, prioridade relativa) Prioridade corrente Real-time idle Dynamic time critical Dynamic Levels High 10 Prioridades lógicas Above Normal Normal Below Normal Idle Dynamic idle 1 0 Used for zero page thread; not available to Win32 applications Alteração da classe de prioridade Na criação com a função CreateProcess Na criação, na linha comando com o comando Start: > start /low notepad Após criação, com a função SetPriorityClass bib: Windows internals, Russinovich, Solomon, fig. 5-13

61 Prioridades de processos e threads Mapeamento entre sistema nativo e subsistema Windows Relative Thread Priority Idle Below Normal Process Priority Class Normal Above Normal High Real- Time Time-critical Highest Above normal Normal Below normal Lowest Idle