Linguagem de Programação I

Transcrição

1 Linguagem de Programação I Carlos Eduardo Batista Centro de Informática - UFPB bidu@ci.ufpb.br

2 Exemplo: Explorar Templates e Exceções Incrementar com o uso de STL "2

3 Crie uma função verificarpalindromo() que recebe um vetor como parâmetro. Ela deve retornar true se ele contém um palíndromo e false caso contrário. Exemplo: Um vetor contendo 1, 2, 3, 2, 1 é um palíndromo. E um vetor contendo 1, 4, 3, 2, 1 não é um palíndromo. Crie uma mapa que associa o nome de uma pessoa a um objeto do tipo Pessoa. A classe Pessoa deve ser feita usando templates, armazenando uma variável de tipo arbitrário. Crie um programa que leia entradas e armazene utilizando a classe map. Caso o usuário tente cadastrar uma chave duplicada, uma exceção deve ser lançada. Exercícios "3

4 Processo - Um conjunto de recursos necessários para a execução duma programa. um espaço de endereçamento (virtual address space) que contêm o texto do programa e os seus dados uma tabela de descritores de arquivos abertos informação sobre processos filhos código para tratar sinais (signal handlers) informação sobre o próprio etc. Processo x thread "4

5 Uma linha ou contexto de execução, chamada Thread Uma thread tem um programa counter (pc) que guarde informação sobre a próxima instrução a executar Registadores valores das variáveis atuais Stack contem a história de execução com um frame para cada procedimento chamado mas não terminado Processo x thread "5

6 O processo filho é uma cópia exata do processo que chama a rotina fork(), sendo a única diferença um identificador de processo (pid) diferente Programa principal FORK Spawned processes FORK pid = fork() if (pid == 0) código executado pelo filho else código executado pelo pai if (pid == 0) exit (0); else wait (0); //esperar pelo filho.. JOIN pai JOIN Criação de processos filho e pai do FORK JOIN JOIN JOIN Inter Process Communication Pipes, Shared Memory, Signal etc.

7 conceito realidade context switch

8 Os dois conceitos necessários para a execução dum programa, conjunto de recursos e contexto de execução podem ser separados: Processos são usados para agrupar recursos. Threads são as entidades escalonadas para execução no CPU. O modelo de threads "8

9 Processos versus Threads Heavyweight Process: programas completamente separados com suas próprias variáveis, pilha e alocação de memória IP stack Código Heap Rotinas de interrupção Arquivos Threads: lightweight processes rotinas compartilham o mesmo espaço de memória e variáveis globais stack stack IP IP Código Heap Rotinas de interrupçã Arquivos

10 Per Thread Items Per Process Items Program Counter Address Space Stack Global Variables Register Set Open Files Child Threads Child Processes State (ready,blocked..) Timers Signals Semaphores Accounting Information Processos versus Threads

11 conceito Thread pronto para executar address space 0 common runtim x Text programa R0 Thread Em execução codigo biblioteca Environ $USER=A1 dados realidade Rn PC x SP y registers y stack context switch CPU high stack memoria

12 A criação e terminação duma thread nova é em geral mais rápida do que a criação e terminação dum processo novo. A comutação de contexto entre duas threads é mais rápido do que entre dois processos. A comunicação entre threads é mais rápida do que a comunicação entre processos - porque as threads compartilham tudo: espaço de endereçamento, variáveis globais etc. Multi-programação usando o modelo de threads é mais simples e mais portável do que multiprogramação usando múltiplos processos. Threads x processos "12

13 Existem duas abordagens principais para a implementação de threads. Kernel-level Threads -- System Calls. User-Level Threads -- Thread Libraries. Existem vantagens e desvantagens em ambos os casos. Implementação "13

14 Vantagens O kernel pode simultaneamente escalonar várias threads do mesmo processo em vários processadores (reais ou virtuais) As rotinas do próprio kernel podem aproveitar threads. Desvantagens: A troca entre threads implica ações do kernel e isto tem um custo que pode ser significativo. Kernel threads "14

15 Vantagens A troca de Threads não envolve o kernel Não há o custo adicional de execução do kernel O OS não precisa de oferecer apoio para threads portanto é mais simples. Escalonamento pode ser especifico para uma aplicação Uma biblioteca pode oferecer vários métodos de escalonamento portanto uma aplicação poderá escolher o algoritmo melhor para ele. ULTs podem executar em qualquer SO As bibliotecas de código são portáveis Desvantagens Muitas das chamadas ao sistema são bloqueantes e o kernel bloqueia processos neste caso todos as threads dum processo podem ser bloqueados. O kernel vai atribuir o processo a apenas um CPU portanto duas threads dentro do mesmo processo não podem executar simultaneamente numa arquitetura com múltiplas processadores User level threads "15

16 POSIX pthreads API para gerenciamento de threads >more /usr/include/pthread.h > man pthread_create Threads co-existem num mesmo processo, compartilhando vários recursos, mas são escalonadas separadamente pelo sistema operacional Somente o mínimo necessário de recursos é replicado entre duas threads Pthreads "16

17 Sem Threads Com Threads Visão geral

18 Interface portável do sistema operacional, POSIX, IEEE Programa principal pthread_create( &thread1, NULL, proc1, &arg); thread1 proc1(&arg); { Código da thread return(&status); } pthread_join( thread1, NULL ou *status); Pthreads

19 PThread API Prefix pthread_ pthread_attr_ pthread_mutex_ pthread_mutexattr_ pthread_cond_ pthread_cond_attr pthread_key_ Funcionality Threads themselves and miscellaneous subroutines Thread attributes objects Mutexes Mutex attributes objects Condition variables Condition attributes objects Thread-specific data keys

20 Usar #include pthread.h Compilar com a opção pthread gcc pthread ex_pthread.c o ex_pthread Como programar

21 int pthread_create(pthread_t * thread, const pthread_attr_t * attr, void * (*start_routine)(void *), void *arg); Criando uma thread

22 #include <stdio.h> #include <stdlib.h> #include <pthread.h> void *print_message_function( void *ptr ); main() { pthread_t thread1, thread2; char *message1 = "Thread 1, *message2 = "Thread 2"; int iret1, iret2; iret1 = pthread_create( &thread1, NULL, print_message_function, (void*) message1); iret2 = pthread_create( &thread2, NULL, print_message_function, (void*) message2); pthread_join( thread1, NULL); pthread_join( thread2, NULL); printf("thread 1 returns: %d\n",iret1); printf("thread 2 returns: %d\n",iret2); exit(0); } void *print_message_function( void *ptr ) { char *message; message = (char *) ptr; printf("%s \n", message); } pthread_create

23 Além da alternativa de simplesmente encerrar a função, é possível também void pthread_exit(void *retval); Encerrando uma thread

24 A rotina pthread_join() espera pelo término de uma thread específica for (i = 0; i < n; i++) pthread_create(&thread[i], NULL, (void *) slave, (void *) &arg);...thread mestre for (i = 0; i < n; i++) pthread_join(thread[i], NULL); Pthread Join

25 Pode ser que uma thread não precisa saber do término de uma outra por ela criada, então não executará a operação de união. Neste caso diz-se que o thread criado é detached (desunido da thread pai progenitor) Programa principal pthread_create(); Thread pthread_create(); Thread Término Término pthread_exit pthread_create(); Thread Término Detached Threads (desunidas)

26 Quando dois ou mais threads podem simultaneamente alterar às mesmas variaveis globais poderá ser necessário sincronizar o acesso a este variavel para evitar problemas. Código nestas condição diz-se uma seção critica Por exemplo, quando dois ou mais threads podem simultaneamente incrementar uma variável x /* codigo Seção Critica */ x = x +1 ; Uma seção crítica pode ser protegida utilizando-se pthread_mutex_lock() e pthread_mutex_unlock() Pthreads "26

27 /* Note scope of variable and mutex are the same */ pthread_mutex_t mutex1 = PTHREAD_MUTEX_INITIALIZER; int counter=0; /* Function C */ void functionc() { pthread_mutex_lock( &mutex1 ); counter++ pthread_mutex_unlock( &mutex1 ); } Mutex

28 Condição de corrida Não assuma uma ordem específica para a execução das threads Um código pode funcionar muito bem em determinados momentos e gerar sérios problemas em outros Thread safe code Use bibliotecas que possuam chamadas thread safe Várias chamadas à mesma função devem ser permitidas Deadlock Fontes de problemas

29 Biblioteca padrão STD passou a incluir suporte a threads Criação e gerência do ciclo de vida de threads #include <thread> Compilador deve suportar C++11 Opções -std=c++0x" ou "-std=c++11" no G++ para ativar suporte Threads STD (C++11)

30 #include <iostream> // std::cout #include <thread> // std::thread void foo() { std::cout << foo << endl; } void bar(int x) {std::cout << bar: << x << endl; } int main() { } std::thread first (foo); // spawn new thread that calls foo() std::thread second (bar,10); // spawn new thread that calls bar(10) std::cout << "main, foo and bar now execute concurrently...\n"; // synchronize threads: first.join(); second.join(); std::cout << "foo and bar completed.\n"; return 0; // pauses until first finishes // pauses until second finishes Threads STD (C++11)

31 class thread { public: class id; typedef /*implementation-defined*/ native_handle_type; thread() noexcept; template <class F, class...args> explicit thread(f&& f, Args&&... args); ~thread(); thread(const thread&) = delete; thread(thread&&) noexcept; thread& operator=(const thread&) = delete; thread& operator=(thread&&) noexcept; void swap(thread&) noexcept; bool joinable() const noexcept; void join(); void detach(); id get_id() const noexcept; native_handle_type native_handle(); }; static unsigned hardware_concurrency() noexcept; Threads STD (C++11)

32 this_thread yield (C++11) get_id (C++11) sleep_for (C++11) provide functions that access current the thread of execution suggests that the implementation reschedule execution of threads (function) returns the thread id of the current thread (function) stops the execution of the current thread for a specified time duration (function) sleep_until (C++11) stops the execution of the current thread until a specified time point (function) Threads STD (C++11)

33 #include <thread> #include <iostream> #include <vector> void hello(){ std::cout << "Hello from thread ; std::cout << std::this_thread::get_id() << std::endl; } int main(){ std::vector<std::thread> threads; for(int i = 0; i < 5; ++i){ threads.push_back(std::thread(hello)); } for(auto& thread : threads){ thread.join(); } return 0; } Threads STD (C++11)

34 #include <thread> #include <iostream> class TestClass { int i; public: TestClass(int n) { i = n; } void greeting(std::string const& message) const { std::cout << message << std::endl; std::cout << "My number: " << n << std::endl; } }; int main() { TestClass x(10); std::thread t(& TestClass::greeting,&x,"Hello "); t.join(); } Threads STD (C++11)

35 #include... int main() { std::shared_ptr<sayhello> p(new SayHello); std::thread t(&sayhello::greeting,p,"goodbye"); t.join(); } // What if you want to pass in a reference to an // existing object, and a pointer just won't do? // That is the task of std::ref. Threads STD (C++11)

36 #include <thread> #include <iostream> void write_sum(int x,int y) { std::cout<<x<<" + "<<y<<" = "<<(x+y)<<std::endl; } int main() { std::thread t(write_sum,123,456); t.join(); } Threads STD (C++11)

37 #include <thread> #include <iostream> #include <functional> // for std::ref class PrintThis { public: void operator()() const { std::cout<<"this="<<this<<std::endl; } }; int main() { } PrintThis x; x(); std::thread t(std::ref(x)); t.join(); std::thread t2(x); t2.join(); /* this=0x7fffb08bf7ef this=0x7fffb08bf7ef this=0x */ Threads STD (C++11)

38 #include <thread> #include <iostream> #include <functional> void increment(int& i) { ++i; } int main() { int x=42; std::thread t(increment,std::ref(x)); t.join(); std::cout<<"x="<<x<<std::endl; } Threads STD (C++11)

39 Leitura complementar threads-and-fork-think-twice-before-usingthem Threads STD (C++11)

40 Notas de aula Claudio Esperança e Paulo Cavalcanti (UFRJ) Notas de aula Allan Lima (citi/ufpe) Referências "40

41 Linguagem de Programação I Carlos Eduardo Batista Centro de Informática - UFPB bidu@ci.ufpb.br