Translated subjects to English
This commit is contained in:
parent
0a91d2dabd
commit
24da1f174c
@ -5,18 +5,18 @@ pthread_detach, pthread_join, pthread_mutex_init, pthread_mutex_destroy,
|
||||
pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
------------------------------------------------------------------------
|
||||
|
||||
Implementa o problema completo dos filósofos com parsing de argumentos:
|
||||
Implement the complete philosophers problem with argument parsing:
|
||||
|
||||
Argumentos: `number_of_philosophers time_to_die time_to_eat time_to_sleep [number_of_times_must_eat]`
|
||||
Arguments: `number_of_philosophers time_to_die time_to_eat time_to_sleep [number_of_times_must_eat]`
|
||||
|
||||
Comportamento:
|
||||
- Cada filósofo alterna: pensar → tentar pegar forks → comer → largar forks → dormir
|
||||
- Se um filósofo não comer dentro de `time_to_die`, morre e programa termina
|
||||
- Se `number_of_times_must_eat` especificado, programa termina quando todos comeram esse número de vezes
|
||||
- Thread monitor verifica mortes a cada 1ms
|
||||
Behavior:
|
||||
- Each philosopher alternates: thinking → trying to grab forks → eating → dropping forks → sleeping
|
||||
- If a philosopher doesn't eat within `time_to_die`, they die and the program terminates
|
||||
- If `number_of_times_must_eat` is specified, the program terminates when all have eaten that many times
|
||||
- Monitor thread checks for deaths every 1ms
|
||||
|
||||
Uso: `./philosophers_args 5 800 200 200` ou `./philosophers_args 5 800 200 200 7`
|
||||
Usage: `./philosophers_args 5 800 200 200` or `./philosophers_args 5 800 200 200 7`
|
||||
|
||||
Hint: Este é praticamente o projeto Philosophers completo.
|
||||
Implementa parsing robusto de argumentos, validação de inputs, e cleanup adequado de recursos.
|
||||
A thread monitor é crítica - deve detectar morte rapidamente sem afetar performance.
|
||||
Hint: This is practically the complete Philosophers project.
|
||||
Implement robust argument parsing, input validation, and proper resource cleanup.
|
||||
The monitor thread is critical - it must detect death quickly without affecting performance.
|
||||
@ -5,20 +5,20 @@ pthread_join, pthread_mutex_init, pthread_mutex_destroy,
|
||||
pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
----------------------------------------------------------------------------------------
|
||||
|
||||
Cria uma versão do problema dos filósofos que:
|
||||
1. Detecta e reporta possíveis data races
|
||||
2. Testa diferentes estratégias de otimização:
|
||||
- Estratégia A: mutex global para todas as operações
|
||||
- Estratégia B: mutex por fork + mutex para impressão
|
||||
- Estratégia C: minimizar lock time
|
||||
Create a version of the philosophers problem that:
|
||||
1. Detects and reports possible data races
|
||||
2. Tests different optimization strategies:
|
||||
- Strategy A: global mutex for all operations
|
||||
- Strategy B: mutex per fork + mutex for printing
|
||||
- Strategy C: minimize lock time
|
||||
|
||||
Inclui stress test: roda 100 iterações com diferentes configurações e reporta:
|
||||
- Número de data races detectadas
|
||||
- Performance (tempo total)
|
||||
- Número de mortes
|
||||
Include stress test: run 100 iterations with different configurations and report:
|
||||
- Number of data races detected
|
||||
- Performance (total time)
|
||||
- Number of deaths
|
||||
|
||||
Uso: `./race_detector 4 410 200 200`
|
||||
Usage: `./race_detector 4 410 200 200`
|
||||
|
||||
Hint: Use ferramentas como `valgrind --tool=helgrind` para detectar data races.
|
||||
No projeto real, qualquer data race resulta em nota 0.
|
||||
Testa com números ímpares e pares de filósofos, e com time_to_die muito próximo de time_to_eat.
|
||||
Hint: Use tools like `valgrind --tool=helgrind` to detect data races.
|
||||
In the real project, any data race results in a grade of 0.
|
||||
Test with odd and even numbers of philosophers, and with time_to_die very close to time_to_eat.
|
||||
@ -5,20 +5,20 @@ pthread_create, pthread_detach, pthread_join, usleep, gettimeofday,
|
||||
waitpid, sem_open, sem_close, sem_post, sem_wait, sem_unlink
|
||||
-------------------------------------------------------------------------
|
||||
|
||||
Implementa a versão bonus do Philosophers:
|
||||
- Cada filósofo é um processo separado (não thread)
|
||||
- Usa semáforos POSIX nomeados para coordenação
|
||||
- Processo pai monitora todos os processos filhos
|
||||
- Se um filósofo morre, mata todos os outros processos
|
||||
Implement the bonus version of Philosophers:
|
||||
- Each philosopher is a separate process (not thread)
|
||||
- Use named POSIX semaphores for coordination
|
||||
- Parent process monitors all child processes
|
||||
- If a philosopher dies, kill all other processes
|
||||
|
||||
Funcionalidades adicionais:
|
||||
- Cleanup adequado de semáforos nomeados
|
||||
- Handling de sinais (SIGINT, SIGTERM)
|
||||
- Relatório final com estatísticas
|
||||
Additional features:
|
||||
- Proper cleanup of named semaphores
|
||||
- Signal handling (SIGINT, SIGTERM)
|
||||
- Final report with statistics
|
||||
|
||||
Uso: `./philosophers_bonus 5 800 200 200 7`
|
||||
Usage: `./philosophers_bonus 5 800 200 200 7`
|
||||
|
||||
Hint: Bonus part usa processos em vez de threads.
|
||||
Semáforos POSIX nomeados permitem comunicação entre processos.
|
||||
Usa fork() para criar processos filhos e waitpid() para monitorizar.
|
||||
O cleanup de semáforos é crucial - usa sem_unlink() e handling de sinais para cleanup em caso de interrupção.
|
||||
Hint: Bonus part uses processes instead of threads.
|
||||
Named POSIX semaphores allow communication between processes.
|
||||
Use fork() to create child processes and waitpid() to monitor.
|
||||
Semaphore cleanup is crucial - use sem_unlink() and signal handling for cleanup in case of interruption.
|
||||
@ -4,16 +4,16 @@ Allowed functions: memset, printf, malloc, free, write, pthread_create,
|
||||
pthread_detach, pthread_join, usleep, gettimeofday
|
||||
-------------------------------------------------------------------------------
|
||||
|
||||
Cria um programa que lance 2 threads. Cada thread deve imprimir o seu ID e uma mensagem diferente.
|
||||
O programa principal deve esperar que ambas as threads terminem antes de sair.
|
||||
Create a program that launches 2 threads. Each thread should print its ID and a different message.
|
||||
The main program must wait for both threads to finish before exiting.
|
||||
|
||||
Thread 1 deve imprimir: "Thread 1: Hello from thread 1"
|
||||
Thread 2 deve imprimir: "Thread 2: Hello from thread 2"
|
||||
Thread 1 should print: "Thread 1: Hello from thread 1"
|
||||
Thread 2 should print: "Thread 2: Hello from thread 2"
|
||||
|
||||
O programa deve aceitar como argumento o número de mensagens que cada thread deve imprimir.
|
||||
The program must accept as an argument the number of messages each thread should print.
|
||||
|
||||
Uso: `./thread_basics 5`
|
||||
Usage: `./thread_basics 5`
|
||||
|
||||
Hint: Este exercício ensina-te a base de pthread_create e pthread_join.
|
||||
Lembra-te de verificar os valores de retorno das funções pthread.
|
||||
Usa uma estrutura para passar argumentos às threads.
|
||||
Hint: This exercise teaches you the basics of pthread_create and pthread_join.
|
||||
Remember to check the return values of pthread functions.
|
||||
Use a structure to pass arguments to threads.
|
||||
|
||||
@ -5,14 +5,14 @@ pthread_join, pthread_mutex_init, pthread_mutex_destroy
|
||||
pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
--------------------------------------------------------------------------------------
|
||||
|
||||
Cria um programa com uma variável global `counter` inicializada a 0.
|
||||
Lança 4 threads que incrementam esta variável 1000 vezes cada uma.
|
||||
Usa um mutex para proteger o acesso à variável.
|
||||
Create a program with a global variable `counter` initialized to 0.
|
||||
Launch 4 threads that increment this variable 1000 times each.
|
||||
Use a mutex to protect access to the variable.
|
||||
|
||||
O programa deve imprimir o valor final de `counter` (deve ser 4000) e o tempo total de execução.
|
||||
The program should print the final value of `counter` (should be 4000) and the total execution time.
|
||||
|
||||
Uso: `./mutex_basics`
|
||||
Usage: `./mutex_basics`
|
||||
|
||||
Hint: Sem mutex, vais ver valores incorretos devido a race conditions.
|
||||
O mutex garante que apenas uma thread acede à variável de cada vez.
|
||||
Este é o conceito fundamental para o projeto Philosophers.
|
||||
Hint: Without a mutex, you will see incorrect values due to race conditions.
|
||||
The mutex ensures that only one thread accesses the variable at a time.
|
||||
This is the fundamental concept for the Philosophers project.
|
||||
@ -5,19 +5,19 @@ pthread_join, pthread_mutex_init, pthread_mutex_destroy,
|
||||
pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
---------------------------------------------------------------------------------------
|
||||
|
||||
Implementa as seguintes funções:
|
||||
- `long long get_current_time()` - retorna o tempo atual em milissegundos
|
||||
- `void precise_sleep(int ms)` - dorme por exatamente X milissegundos
|
||||
- `long long time_diff(long long start, long long end)` - calcula diferença entre tempos
|
||||
Implement the following functions:
|
||||
- `long long get_current_time()` - returns the current time in milliseconds
|
||||
- `void precise_sleep(int ms)` - sleeps for exactly X milliseconds
|
||||
- `long long time_diff(long long start, long long end)` - calculates difference between times
|
||||
|
||||
Cria um programa que testa estas funções:
|
||||
1. Mede o tempo de início
|
||||
2. Dorme por 100ms usando precise_sleep
|
||||
3. Mede o tempo de fim
|
||||
4. Imprime a diferença (deve ser ~100ms)
|
||||
Create a program that tests these functions:
|
||||
1. Measure start time
|
||||
2. Sleep for 100ms using precise_sleep
|
||||
3. Measure end time
|
||||
4. Print the difference (should be ~100ms)
|
||||
|
||||
Uso: `./precise_timing`
|
||||
Usage: `./precise_timing`
|
||||
|
||||
Hint: gettimeofday() é crucial no projeto Philosophers.
|
||||
usleep() não é sempre preciso, por isso tens de verificar o tempo periodicamente.
|
||||
No Philosophers, o timing preciso é essencial para detectar mortes.
|
||||
Hint: gettimeofday() is crucial in the Philosophers project.
|
||||
usleep() is not always precise, so you need to check the time periodically.
|
||||
In Philosophers, precise timing is essential for detecting deaths.
|
||||
|
||||
@ -1,23 +1,23 @@
|
||||
**Assignment name**: state_monitor
|
||||
**Expected files**: state_monitor.c
|
||||
**Allowed functions**: memset, printf, malloc, free, write, pthread_create,
|
||||
Assignment name: state_monitor
|
||||
Expected files: state_monitor.c
|
||||
Allowed functions: memset, printf, malloc, free, write, pthread_create,
|
||||
pthread_detach, pthread_join, pthread_mutex_init, pthread_mutex_destroy,
|
||||
pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Cria um programa com 3 threads "worker" e 1 thread "monitor":
|
||||
Create a program with 3 "worker" threads and 1 "monitor" thread:
|
||||
|
||||
**Worker threads**: Cada thread alterna entre 3 estados:
|
||||
- WORKING (2 segundos)
|
||||
- RESTING (1 segundo)
|
||||
- THINKING (1.5 segundos)
|
||||
Worker threads: Each thread alternates between 3 states:
|
||||
- WORKING (2 seconds)
|
||||
- RESTING (1 second)
|
||||
- THINKING (1.5 seconds)
|
||||
|
||||
Cada mudança de estado deve ser impressa com timestamp: `[timestamp] Worker X is WORKING`
|
||||
Each state change should be printed with timestamp: `[timestamp] Worker X is WORKING`
|
||||
|
||||
**Monitor thread**: Verifica se algum worker está no mesmo estado há mais de 3 segundos.
|
||||
Se sim, imprime: `[timestamp] WARNING: Worker X stuck in STATE`
|
||||
Monitor thread: Checks if any worker has been in the same state for more than 3 seconds.
|
||||
If so, prints: `[timestamp] WARNING: Worker X stuck in STATE`
|
||||
|
||||
**Uso**: `./state_monitor`
|
||||
Usage: `./state_monitor`
|
||||
|
||||
**Hint**: Use enums para os estados. O monitor thread simula a verificação de morte no Philosophers,
|
||||
tens de verificar continuamente sem interferir com os workers. Usa mutex para proteger o acesso aos estados.
|
||||
Hint: Use enums for the states. The monitor thread simulates death checking in Philosophers,
|
||||
you need to check continuously without interfering with workers. Use mutex to protect access to states.
|
||||
|
||||
@ -5,19 +5,19 @@ pthread_detach, pthread_join, pthread_mutex_init, pthread_mutex_destroy,
|
||||
pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
---------------------------------------------------------------------------
|
||||
|
||||
Implementa o problema clássico Producer-Consumer:
|
||||
- 2 threads Producer: produzem items (números de 1 a 100) e colocam num buffer
|
||||
- 2 threads Consumer: consomem items do buffer e processam-nos
|
||||
- Buffer partilhado com capacidade limitada (10 items)
|
||||
Implement the classic Producer-Consumer problem:
|
||||
- 2 Producer threads: produce items (numbers from 1 to 100) and place them in a buffer
|
||||
- 2 Consumer threads: consume items from the buffer and process them
|
||||
- Shared buffer with limited capacity (10 items)
|
||||
|
||||
Regras:
|
||||
- Producers devem esperar se buffer estiver cheio
|
||||
- Consumers devem esperar se buffer estiver vazio
|
||||
- Não deve haver race conditions
|
||||
- Imprime quando items são produzidos/consumidos
|
||||
Rules:
|
||||
- Producers must wait if buffer is full
|
||||
- Consumers must wait if buffer is empty
|
||||
- There should be no race conditions
|
||||
- Print when items are produced/consumed
|
||||
|
||||
Uso: `./producer_consumer`
|
||||
Usage: `./producer_consumer`
|
||||
|
||||
Hint: Este exercício ensina-te a coordenação entre múltiplas threads com recursos limitados.
|
||||
É similar ao problema dos forks no Philosophers.
|
||||
Usa mutexes para proteger o buffer e condition variables ou sleep para coordenação.
|
||||
Hint: This exercise teaches you coordination between multiple threads with limited resources.
|
||||
It's similar to the forks problem in Philosophers.
|
||||
Use mutexes to protect the buffer and condition variables or sleep for coordination.
|
||||
@ -3,22 +3,21 @@ Expected files: deadlock_demo.c
|
||||
Allowed functions: memset, printf, malloc, free, write, pthread_create, pthread_detach,
|
||||
pthread_join, pthread_mutex_init, pthread_mutex_destroy, pthread_mutex_lock,
|
||||
pthread_mutex_unlock, usleep, gettimeofday
|
||||
---------------------------------------------------------------------------------------
|
||||
|
||||
---
|
||||
Create a program that demonstrates deadlock and then shows how to solve it:
|
||||
|
||||
Cria um programa que demonstra deadlock e depois mostra como o resolver:
|
||||
|
||||
Parte 1 - Deadlock:
|
||||
Part 1 - Deadlock:
|
||||
2 threads, 2 mutexes (mutex_a, mutex_b)
|
||||
- Thread 1: lock mutex_a → sleep 100ms → lock mutex_b → unlock ambos
|
||||
- Thread 2: lock mutex_b → sleep 100ms → lock mutex_a → unlock ambos
|
||||
- Thread 1: lock mutex_a → sleep 100ms → lock mutex_b → unlock both
|
||||
- Thread 2: lock mutex_b → sleep 100ms → lock mutex_a → unlock both
|
||||
|
||||
Parte 2 - Solução: Ambas threads fazem lock dos mutexes na mesma ordem.
|
||||
Part 2 - Solution: Both threads lock the mutexes in the same order.
|
||||
|
||||
O programa deve aceitar um argumento: 0 para deadlock, 1 para solução.
|
||||
The program must accept an argument: 0 for deadlock, 1 for solution.
|
||||
|
||||
Uso: `./deadlock_demo 0` (demonstra deadlock)
|
||||
Uso: `./deadlock_demo 1` (demonstra solução)
|
||||
Usage: `./deadlock_demo 0` (demonstrates deadlock)
|
||||
Usage: `./deadlock_demo 1` (demonstrates solution)
|
||||
|
||||
Hint: Deadlock é um risco real no Philosophers quando filósofos tentam pegar forks em ordens diferentes.
|
||||
A solução mais comum é ordenar os recursos (forks com IDs mais baixos primeiro).
|
||||
Hint: Deadlock is a real risk in Philosophers when philosophers try to grab forks in different orders.
|
||||
The most common solution is to order the resources (forks with lower IDs first).
|
||||
|
||||
@ -1,23 +1,23 @@
|
||||
**Assignment name**: limited_resources
|
||||
**Expected files**: limited_resources.c
|
||||
**Allowed functions**: memset, printf, malloc, free, write, pthread_create, pthread_detach,
|
||||
pthread_join, pthread_mutex_init, pthread_mutex_destroy, pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
Assignment name: limited_resources
|
||||
Expected files: limited_resources.c
|
||||
Allowed functions: memset, printf, malloc, free, write, pthread_create, pthread_detach,
|
||||
pthread_join, pthread_mutex_init, pthread_mutex_destroy, pthread_mutex_lock,
|
||||
pthread_mutex_unlock, usleep, gettimeofday
|
||||
---------------------------------------------------------------------------------------
|
||||
|
||||
---
|
||||
Simulate a library with 3 computers shared among 10 students:
|
||||
- Each student (thread) wants to use a computer for 2-5 seconds (random time)
|
||||
- Only 3 students can use computers simultaneously
|
||||
- Implement a "semaphore" using mutexes and a counter variable
|
||||
|
||||
Simula uma biblioteca com 3 computadores partilhados entre 10 estudantes:
|
||||
- Cada estudante (thread) quer usar um computador por 2-5 segundos (tempo aleatório)
|
||||
- Apenas 3 estudantes podem usar computadores simultaneamente
|
||||
- Implementa um "semáforo" usando mutexes e uma variável contador
|
||||
Print when students:
|
||||
- Arrive at the library
|
||||
- Get a computer
|
||||
- Finish using the computer
|
||||
- Leave the library
|
||||
|
||||
Imprime quando estudantes:
|
||||
- Chegam à biblioteca
|
||||
- Conseguem um computador
|
||||
- Terminam de usar o computador
|
||||
- Saem da biblioteca
|
||||
Usage: `./limited_resources`
|
||||
|
||||
**Uso**: `./limited_resources`
|
||||
|
||||
**Hint**: Como POSIX semáforos não são permitidos no mandatory part,
|
||||
implementa o teu próprio semáforo com mutex + contador + condition logic.
|
||||
Este exercício simula a limitação de recursos como no Philosophers com forks.
|
||||
Hint: Since POSIX semaphores are not allowed in the mandatory part,
|
||||
implement your own semaphore with mutex + counter + condition logic.
|
||||
This exercise simulates resource limitation like in Philosophers with forks.
|
||||
@ -4,16 +4,16 @@ Allowed functions: memset, printf, malloc, free, write, pthread_create, pthread_
|
||||
pthread_join, pthread_mutex_init, pthread_mutex_destroy, pthread_mutex_lock, pthread_mutex_unlock, usleep, gettimeofday
|
||||
---
|
||||
|
||||
Implementa uma versão simplificada do problema dos filósofos:
|
||||
- 3 filósofos sentados numa mesa circular
|
||||
- 3 forks (um entre cada par de filósofos)
|
||||
- Cada filósofo alterna entre: pensar (1s) → pegar forks → comer (1s) → largar forks → repetir
|
||||
- Programa corre por 10 segundos e depois pára
|
||||
Implement a simplified version of the dining philosophers problem:
|
||||
- 3 philosophers seated at a circular table
|
||||
- 3 forks (one between each pair of philosophers)
|
||||
- Each philosopher alternates between: thinking (1s) → grabbing forks → eating (1s) → dropping forks → repeat
|
||||
- Program runs for 10 seconds and then stops
|
||||
|
||||
Cada ação deve ser impressa: `[timestamp] Philosopher X is thinking/eating`
|
||||
Each action should be printed: `[timestamp] Philosopher X is thinking/eating`
|
||||
|
||||
Uso: `./simple_philosophers`
|
||||
Usage: `./simple_philosophers`
|
||||
|
||||
Hint: Este é o núcleo do projeto Philosophers. Cada fork é protegido por um mutex.
|
||||
Para evitar deadlock, implementa uma ordem consistente para pegar forks (fork com ID menor primeiro).
|
||||
Usa uma thread monitor para parar após 10s.
|
||||
Hint: This is the core of the Philosophers project. Each fork is protected by a mutex.
|
||||
To avoid deadlock, implement a consistent order for grabbing forks (fork with lower ID first).
|
||||
Use a monitor thread to stop after 10s.
|
||||
@ -3,19 +3,19 @@ Expected files: death_monitor.c
|
||||
Allowed functions: memset, printf, malloc, free, write, pthread_create, pthread_detach,
|
||||
pthread_join, pthread_mutex_init, pthread_mutex_destroy, pthread_mutex_lock,
|
||||
pthread_mutex_unlock, usleep, gettimeofday
|
||||
---
|
||||
---------------------------------------------------------------------------------------
|
||||
|
||||
Cria um sistema com:
|
||||
- 4 threads "worker" que fazem trabalho por períodos variados (1-4 segundos)
|
||||
- 1 thread monitor que verifica se algum worker não dá "sinal de vida" há mais de 3 segundos
|
||||
- Workers devem atualizar `last_activity_time` a cada iteração
|
||||
- Monitor verifica a cada 100ms e imprime aviso se detectar worker "morto"
|
||||
Create a system with:
|
||||
- 4 "worker" threads that do work for varied periods (1-4 seconds)
|
||||
- 1 monitor thread that checks if any worker hasn't given a "sign of life" for more than 3 seconds
|
||||
- Workers must update `last_activity_time` at each iteration
|
||||
- Monitor checks every 100ms and prints warning if it detects a "dead" worker
|
||||
|
||||
Simula "morte" fazendo um worker parar aleatoriamente.
|
||||
Simulate "death" by making a worker stop randomly.
|
||||
|
||||
Uso: `./death_monitor`
|
||||
Usage: `./death_monitor`
|
||||
|
||||
Hint: Este exercício simula a detecção de morte no Philosophers.
|
||||
O monitor thread deve verificar continuamente sem bloquear os workers.
|
||||
Usa mutex para proteger `last_activity_time`.
|
||||
A detecção deve ser rápida (dentro de 10ms no projeto real).
|
||||
Hint: This exercise simulates death detection in Philosophers.
|
||||
The monitor thread must check continuously without blocking the workers.
|
||||
Use mutex to protect `last_activity_time`.
|
||||
Detection must be fast (within 10ms in the real project).
|
||||
74
README.md
74
README.md
@ -1,62 +1,62 @@
|
||||
# Exercícios Preparatórios — Projeto Philosophers
|
||||
# Preparatory Exercises — Philosophers Project
|
||||
|
||||
Bem-vindo ao repositório de exercícios práticos desenhados para construir, passo a passo, todos os conceitos necessários para dominar o projeto Philosophers da 42. Aqui vais encontrar desafios progressivos sobre threads, mutexes, deadlocks, sincronização, semáforos, timing, e muito mais em C.
|
||||
Welcome to the repository of practical exercises designed to build, step by step, all the concepts necessary to master the 42 Philosophers project. Here you will find progressive challenges about threads, mutexes, deadlocks, synchronization, semaphores, timing, and much more in C.
|
||||
|
||||
## Objetivo
|
||||
## Objective
|
||||
|
||||
A proposta deste repositório é guiar estudantes pela aprendizagem real de programação concorrente, partindo do absoluto básico até à implementação de sistemas completos e robustos capazes de resolver o clássico problema dos Filósofos, incluindo as regras e desafios da bonus part.
|
||||
The purpose of this repository is to guide students through real concurrent programming learning, starting from the absolute basics up to the implementation of complete and robust systems capable of solving the classic Dining Philosophers problem, including the rules and challenges of the bonus part.
|
||||
|
||||
## Estrutura dos Exercícios
|
||||
## Exercise Structure
|
||||
|
||||
Cada exercício segue uma estrutura clara e normalizada, incluindo:
|
||||
Each exercise follows a clear and standardized structure, including:
|
||||
|
||||
- **Assignment name**
|
||||
- **Expected files**
|
||||
- **Allowed functions**
|
||||
- **Descrição do problema**
|
||||
- **Sugestão/Hint para a resolução**
|
||||
- **Problem description**
|
||||
- **Hint/Suggestion for resolution**
|
||||
|
||||
### Lista de Exercícios
|
||||
### Exercise List
|
||||
|
||||
| Nº | Nome | Conteúdo-chave |
|
||||
| No | Name | Key Content |
|
||||
|----|---------------------------|---------------------------------------------|
|
||||
| 1 | thread_basics | Threads, pthread_create, pthread_join |
|
||||
| 2 | mutex_basics | Mutexes, race conditions |
|
||||
| 3 | precise_timing | gettimeofday, usleep, timing |
|
||||
| 4 | state_monitor | Monitorização, enums, padrões monitor |
|
||||
| 5 | producer_consumer | Sincronização, coordination problems |
|
||||
| 6 | deadlock_demo | Deadlock, prevenção de deadlock |
|
||||
| 7 | limited_resources | Semáforo manual, acesso limitado |
|
||||
| 8 | simple_philosophers | Problema dos filósofos simplificado |
|
||||
| 9 | death_monitor | Monitorização de vida, threads watchdog |
|
||||
| 10 | philosophers_args | Implementação 'full', argumentos |
|
||||
| 11 | race_detector | Data races, otimização de locks |
|
||||
| 12 | philosophers_bonus | Processos, semáforos POSIX, bonus part |
|
||||
| 4 | state_monitor | Monitoring, enums, monitor patterns |
|
||||
| 5 | producer_consumer | Synchronization, coordination problems |
|
||||
| 6 | deadlock_demo | Deadlock, deadlock prevention |
|
||||
| 7 | limited_resources | Manual semaphore, limited access |
|
||||
| 8 | simple_philosophers | Simplified philosophers problem |
|
||||
| 9 | death_monitor | Life monitoring, watchdog threads |
|
||||
| 10 | philosophers_args | Full implementation, arguments |
|
||||
| 11 | race_detector | Data races, lock optimization |
|
||||
| 12 | philosophers_bonus | Processes, POSIX semaphores, bonus part |
|
||||
|
||||
## Como usar
|
||||
## How to Use
|
||||
|
||||
1. **Cada exercício é independente.** Recomenda-se seguir pela ordem, para garantir a aprendizagem progressiva.
|
||||
2. **Compilar cada exercício:**
|
||||
1. **Each exercise is independent.** It is recommended to follow them in order to ensure progressive learning.
|
||||
2. **Compile each exercise:**
|
||||
```sh
|
||||
gcc -Wall -Wextra -Werror -pthread <nome_ficheiro>.c -o <programa>
|
||||
gcc -Wall -Wextra -Werror -pthread <filename>.c -o <program>
|
||||
```
|
||||
3. **Executar cada binário** seguindo as instruções e exemplos do cabeçalho do exercício.
|
||||
3. **Run each binary** following the instructions and examples in the exercise header.
|
||||
|
||||
## Requisitos Técnicos
|
||||
## Technical Requirements
|
||||
|
||||
- Compilador C (ex: gcc)
|
||||
- Ambiente POSIX (Linux ou Mac OS X recomendado)
|
||||
- Bibliotecas pthreads standard
|
||||
- C Compiler (e.g., gcc)
|
||||
- POSIX environment (Linux or Mac OS X recommended)
|
||||
- Standard pthreads libraries
|
||||
|
||||
## Recomendações
|
||||
## Recommendations
|
||||
|
||||
- Não uses funções externas às permitidas.
|
||||
- Lê atentamente os hints fornecidos para cada exercício.
|
||||
- Analisa erros de race condition e deadlocks usando ferramentas como `valgrind --tool=helgrind`.
|
||||
- Consulta [The Little Book of Semaphores](https://greenteapress.com/wp/semaphores/) para cimentar conceitos.
|
||||
- Don't use external functions beyond those allowed.
|
||||
- Carefully read the hints provided for each exercise.
|
||||
- Analyze race condition and deadlock errors using tools like `valgrind --tool=helgrind`.
|
||||
- Consult [The Little Book of Semaphores](https://greenteapress.com/wp/semaphores/) to solidify concepts.
|
||||
|
||||
## Créditos e Referências
|
||||
## Credits and References
|
||||
|
||||
- Inspirado no livro open-source **The Little Book of Semaphores** por Allen B. Downey.
|
||||
- Estrutura e avaliação baseadas no formato dos projetos 42.
|
||||
- Problema clássico dos Filósofos por Edsger W. Dijkstra.
|
||||
- Inspired by the open-source book **The Little Book of Semaphores** by Allen B. Downey.
|
||||
- Structure and evaluation based on the 42 project format.
|
||||
- Classic Dining Philosophers problem by Edsger W. Dijkstra.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user