1

T
*
1
1
T
*
2
2
F
*
|
|
T
*
A

mutex is sufficient to produce deadlock.

thread is sufficient to produce deadlock
thread este suficient pentru a produce deadlock
threads are required to produce deadlock
thread-uri sunt necesare pentru a aparea deadlock
is an OS pipe
este un pipe al SO

client has to reserve a port number in order to be able to communicate through

sockets.
Un client trebuie sa rezerve un port pentru a putea comunica prin socket
F
*
A critical section is a memory area
O sectiune critica o zona de memorie
T
*
A critical section is a piece of code that accesses a shared resource
O sectiune critica este o secventa de cod ce acceseaza o resursa partajata
T
*
Mutex este un semafor binar
A mutex is a binary semaphore
F
*
Un pipe este o structura de tip LIFO
F
*
Un proces fiu nu ocupa niciodata mai multa memorie ca un thread
F
*
A mutex is a locking mechanism
Mutexul este un mecanism de blocare
T
*
A mutex is initially locked
Un mutex este initial blocat
F
*
A mutex is initially unlocked
Un mutex este initial deblocat
T
*
A pipe is a FIFO structure
Un pipe este o structura de tip FIFO
T
*
A pipe must be opened at both ends before data can be passed
Un pipe trebuie deschis la ambele capete inainte sa se poata comunica prin el
F
*
Un process trebuie sa inchide capatul nefolosit al unui pipe
A process has to close the unused end of a pipe

F
*
A process is a running program
Un proces este un program in executie
T
*
A process sometimes contains only one thread
Un proces uneori are doar un thread
T
*
A regular FIFO can connect any 2 processes on the same machine
Un FIFO poate conecta orice 2 procese de pe aceeasi masina
T
*
A regular pipe can connect any 2 processes
Un pipe poate conecta orice 2 procese
F
*
A regular pipe can connect any 2 processes on the same machine
Un pipe poate conecta orice 2 procese de pe aceeasi masina
F
*
A regular pipe can connect any 2 related processes
Un pipe poate conecta orice 2 procese inrudite
T
*
A semaphore is a generalized form of mutex
Un semafor este o forma generalizata de mutex
T
*
A server has to reserve a port number in order to be able to communicate through
sockets.
Un server trebuie sa rezerve un port pentru a putea comunica prin socket
T
*
A signal can be sent from a child to its parent
Un semnal poate fi trimis de la fiu la parinte
T
*
A signal can be sent from a process to itself
Un semnal poate fi transmis de la un proces la el insusi
T
*
A signal can be sent from a thread to itself
Un semnal poate fi transmis de la un thread la el insusi
F
*
A signal can't be sent from a process to itself
Un semnal nu poate fi transmis de la un proces la el insusi
F
*
A signal can't be sent from a thread to itself
Un semnal nu poate fi transmis de la un thread la el insusi
T
*
A signal can not be sent from a child to its parent
Un semnal nu poate fi trimis de la fiu la parinte
F
*
A signal is not a software interrupt

Un semnal nu este o intrerupere software.

F
*
A socket address is an IP address
Un socket este o adresa IP
F
*
A socket client has to receive data in order to be able to send information to t
he
server.
Un client socket trebuie mai intai sa primeasca date ca sa poata trimite
F
*
A socket server has to send data in order to be able to receive information from
the client.
Un server trebuie mai intai sa trimita date pentru a putea primi informatii de l
a
client
F
*
A TCP socket client has to send data in order to be able to receive information
from the server.
Un client TCP trebuie mai intai sa trimita date ca sa poata primi
F
*
A TCP socket server has to receive data in order to be able to send information
to
the client.
Un server TCP trebuie mai intai sa primeasca date ca sa poata sa trimita
F
*
A thread can exist outside a process
Un thread poate exista inafara unui process
F
*
A thread had a unique id in the process
Fiecare thread are un id unic in proces
T
*
A thread may occupy more memory than a child process
Un thread poate ocupa mai multa memorie ca un proces fiu
T
*
A UDP socket client has to receive data in order to be able to send information
to
the server.
F
*
A UDP socket client has to send data in order to be able to receive information
from the server.
T
*
A UDP socket server has to receive data in order to be able to send information
to
the client.
Un server UDP trebuie mai intai sa primeasca date ca sa poata sa trimita
T
*
accept() appears in TCP sockets
accept() apare in socketuri TCP

T
*
accept() appears in UDP sockets
accept() apare in socketuri UDP
F
*
AF_INET is the address family for TCP
AF_INET este familia de adrese pentru TCP
T
*
After bind() a TCP server can receive/send data
Dupa bind() un server TCP poate trimite/primi date
F
*
After bind() a UDP server can send data
F
*
All concurrent programs are distributed
Toate programele concurente sunt distribuite
F
*
All concurrent programs are parallel
Toate programele concurente sunt paralele
T
*
All sockets are INET
Toate socketurile sunt de tip INET
F
*
All sockets are TCP
Toate socketurile sunt de tip TCP
F
*
Amdahl's law give us the speedup of a parallel algorithm in relation to its
sequential implementation.
Legea lui Amdahl ne da cresterea in viteza a unui algoritm implementat in
paralel fata de implementarea secventiala.
T
*
An IP address is represented on 32 bits
O adresa IP se reprezinta pe 32 de biti
T
*
An IP address is represented on 4 bytes
O adresa IP se reprezinta pe 4 octeti
T
*
bind() appears in TCP sockets
bind() apare in socketuri TCP
T
*
bind() appears in UDP sockets
bind() apare in socketuri UDP
T
*bind() is used to reserve a port
bind() se foloseste pentru a rezerva un port
T
*
Concurrent programming does not require synchronisation
Programarea concurenta nu necesita sincronizare

F
*
Files can be used as IPC.
T
*
Condition variables are behaving like mutexes
Condition variables se comporta ca si mutex-urile
F
*
Deadlock is a thread synchronization problem
Deadlock este o problema de sincronizare a threadurilor
T
*Deadlock can be avoided by eliminating cycles in the resource dependence graph
Deadlock poate fi evitat prin eliminrea ciclurilor in graful de dependinta al
resurselor
T
*
Distributed programming is concurrent programming on multiple machines
Programarea distribuita este programare concurenta pe mai multe masini
T
*
Programarea distribuita nu necesita sincronizare
F
*
Distributed programming is used in Massively Multiplayer Online Games
Programarea distribuita este folosita la Massively Multiplayer Online Games
T
*
Distributed programming requires synchronisation
Programarea distribuita necesita sincronizare
T
*
Email and WWW are Internet services
Email and WWW are Internet services
T
*
Emails can be used for file transfer.
Emailurile pot fi folosite pentru transfer de fisiere.
T
*
FIFO este de obicei cel mai rapid IPC
F
*
Every Linux process has a parent process.
Fiecare proces Linux are un proces parinte.
F
*
Fiecare proces are un id unic in sistem.
T
*
Every Linux process except process 0 has a parent process
Fiecare proces Linux inafara de procesul 0 are un proces parinte
T
*
exec calls can be used to execute external programs
Aplurile exec pot fi folosite pentru a executa programe externe
T
*
FIFO can be used to communicate between 2 threads of the same process
Pentru a comunica intre 2 threaduri ale aceluiasi proces putem sa folosim FIFO.

T
*
FIFO can't be used to communicate between 2 threads of the same process
Pentru a comunica intre 2 threaduri ale aceluiasi proces nu putem sa folosim FIF
O.
F
*
Pentru a comunica intre 2 threaduri ale aceluiasi proces este necesar sa folosim
pipes
F
*
FIFO is a valid file type in linux
FIFO este un tip valid de fisier linux
T
*
FIFO is not a valid file type in linux
FIFO nu este un tip valid de fisier linux
F
*
FIFO is usually the fastest IPC
FIFO este de obicei cel mai rapid IPC
F
*
fork() is used to create a new thread
fork() se foloseste pentru a crea un thread nou
F
*
fork() returneaza 0 in procesul fiu
T
*
HTML stands for Hyper Text Markup Language
HTML=Hyper Text Markup Language
T
*
ipcrm poate fi folosit pentru a sterge o coada de mesaje
T
*
getpid() does not return 0 inside a child process
getpid() nu returneaza 0 in procesul fiu
T
*
Heap and stack grow in opposite direction in a process.
Heap si stiva cresc in directii diferite in proces
T
*
Heap and stack grow in the same direction in a process.
Heap si stiva cresc in aceeasi directie intr-un proces.
F
*
If a program that uses a FIFO ends, the FIFO is not deleted.
Daca un program ce foloseste FIFO se termina, FIFO nu va fi sters.
T
*
If a program that uses a message queue ends, the message queue is not deleted.
If a program that uses a message queue ends, the message queue is not deleted.
T
*
If a program that uses a pipe ends, the pipe is deleted.
Daca un program ce foloseste un pipe se termina, pipe va fi sters.
T

*
If a program that uses a pipe ends, the pipe is not deleted.
Daca un program ce foloseste un pipe se termina, pipe nu va fi sters.
F
*
If a program that uses a FIFO ends, the FIFO is not deleted.
Daca un program ce foloseste FIFO se termina, FIFO nu va fi sters.
T
*
In a client-server system, the client and the server always run on different mac
hines.
Intr-un system client server, clientul si serverul ruleaza intotdeauna pe masini
diferite.
F
*
In distributed programming 2 tasks run in parallel and communicate with each oth
er.
In programarea distribuita 2 taskuri sunt rulate in paralel si comunica intre el
e
T
*
In programarea paralela 2 aplicatii ruleaza in parlel si comunica intre ele.
F
*
In pipe(p) p[0] is for writing.
In pipe(p) p[0] is for writing.
F
*
In pipe(p) p[0] is for reading.
In pipe(p) p[0] este pentru citire.
T
*
In pipe(p) p[1] is for reading.
In pipe(p) p[1] este pentru citire.
F
*
IP stands for Internet Protocol.
IP inseamna Internet Protocol.
T
*
IPC stands for inter-process communication.
IPC inseamna inter-process communication.
T
*
IPC stands for inter-process cooperation.
IPC inseamna inter-process cooperation.
F
*
listen() appears in TCP sockets.
listen() apare in socketuri TCP.
T
*
Listen is performed by the TCP client.
Listen se apeleaza in clientul TCP.
F
*
Listen is performed by the UDP client.
Listen se apeleaza in clientul UDP.
F
*

Livelock is a thread synchronization problem.

Livelock este o problema de sincronizare a threadurilor.
T
*
Localhost is always 127.0.0.1.
Localhost este intotdeauna 127.0.0.1.
T
*
Message queues are FIFO structures.
Cozile de mesaje sunt structuri de tip FIFO.
F
*
Message queues can be identified by a key.
Cozile de mesaje se identifica printr-o cheie.
T
*
Message queues can be used by related processes.
Cozile de mesaje pot fi folosite de procese inrudite.
T
*
mkfifo creates a named pipe.
mkfifo creaza un pipe cu nume.
T
*
msgrcv() is used to obtain a message from a message queue.
msgrcv() se foloseste pentru a obtine mesaje dintr-o coada.
T
*
msgctl() is used to obtain a message from a message queue.
msgctl() se foloseste pentru a obtine mesaje dintr-o coada.
F
*
Mutexes are used to prevent deadlock.
Mutexurile sunt folosite pentru a preveni deadlock.
F
*
Mutual exclusion refers to a shared resource used by a single process/thread at
a given time.
Excluderea mutuala inseamna ca o resursa partajata este folosita de un singur pr
oces/thread la un moment dat.
T
*
netstat can be used to check open ports.
netstat poate fi folosit pentru a verifica porturile deschise.
T
*
Not all concurrent programs are distributed
Nu toate programele concurente sunt distribuite.
T
*
Not all distributed programs are concurrent.
Nu toate programele distribuite sunt concurente.
F
*
Not all parallel programs are concurrent.
Nu toate programele paralele sunt concurente.
T
*
Excluderea mutuala inseamna ca o resursa partajata este folosita de un singur pr
oces/thread.

F
*
Not all parallel programs are distributed.
Nu toate programele paralele sunt distribuite.
T
*
Not all sockets are INET.
Nu toate socketurile sunt de tip INET.
T
*
No thread can exist outside a process
Un thread nu poate exista infara unui proces
T
*
Not all sockets are TCP.
Nu toate socketurile sunt de tip TCP.
T
*
Only one thread can lock a mutex at a given time.
Doar un singur thread poate bloca un mutex la un moment dat.
T
*
Parallel programs are less complex than sequential ones.
Programele paralele sunt mai putin complexe decat cele secventiale.
F
*
Parallel programs are more complex than sequential ones.
Programele paralele sunt mai complexe decat cele secventiale.
T
*
Parallel programming does not require synchronisation.
Programarea paralele nu necesita sincronizare.
T
*
Parallel programming is possible on multi-core systems.
Programarea paralela este posibila pe sisteme multi-core.
T
*
Parallel programming requires synchronisation.
Parallel programming requires synchronisation.
F
*
pipe() returns -1 on error.
pipe() returneaza -1 in caz de eroare.
T
*
Pipes only exist in C.
Pipe-urile exista doar in C.
F
*
Pipes are required to communicate between 2 threads of the same process.
Pentru a comunica intre 2 threaduri ale aceluiasi proces este necesar sa folosim
pipes.
F
*
Pipes are unidirectional.
Pipe-urile sunt unidirectionale.
T
*
Pipes are not bidirectional.

Pipes are not bidirectional.

T
*
Pipes can be used from command line.
Pipe-urile pot fi folosite in linia de comanda.
T
*
Pipes can be used to communicate between 2 threads of the same process.
Pentru a comunica intre 2 threaduri ale aceluiasi proces putem sa folosim pipes.
T
*
popen() is used to create a named pipe.
popen() se foloseste pentru a crea un pipe cu nume.
F
*
popen() creates a pipe.
popen() creeaza un pipe.
T
*
popen() can be used to execute external programs
popen() poate fi folosit pentru a executa programe externe
T
*
Port 25 is reserved for SMTP.
Portul 25 este rezervat pentru SMTP.
T
*
Standard port for email service is 25
Portul standard pentru serviciul de mail este 25
T
*
The port 443 is most often used by HTTPS.
Portul 443 este de obicei folosit de catre HTTPS.
T
*
Port numbers are 16 bits unsigned integers.
Porturile sunt numere intregi fara semn reprezentate pe 16 biti.
T
*
An IP address is represented on 16 bits.
F
*
UDP is called a connectionless, unreliable transport protocol.
T
*
The port 143 is most often used by HTTPS
Portul 143 este de obicei folosit de catre HTTPS
F
*
In parallel programming 2 applications run in parallel and communicate with each
other.
In programarea paralela 2 aplicatii ruleaza in parlel si comunica intre ele
F
*
Port numbers are 2 bytes long unsigned integers.
Porturile sunt numere intregi fara semn reprezentate pe 2 octeti.
T
*
Primele 1024 de porturi sunt rezervate prin conventie, pentru a indentifica serv
icii specifice.

Primele 1024 de porturi sunt rezervate prin conventie, pentru a indentifica serv
icii specifice.
T
*
Processes can be synchronised with mutex.
Procesele pot fi sincrincronizate prin mutex.
F
*
Processes can't be synchronised with mutex.
Procesele nu pot fi sincrincronizate prin mutex.
T
*
1 thread is sufficient to produce deadlock
1 thread este suficient pentru a produce deadlock
T
*
Processes share the same heap.
Procesele partajeaza aceeasi zona de heap.
F
*
Processes share the same stack.
Procesele partajeaza aceeasi zona de stiva.
F
*
The TCP Protocol needs a permanent connection.
Protocolul TCP presupune o conexiune permanenta.
T
*
pthread_join() starts the execution ot a specified thread.
pthread_join() lanseaza in executie un anume thread.
F
*
pthread_join() waits for the specified thread to terminate.
pthread_join() asteapta terminarea unui anume thread.
T
*
pthread_join will wait for all the threads to complete before returning.
pthread_join asteapta terminarea tuturor threadurilor.
F
*
Race conditions and deadlocks occur due to same reason.
Race conditions si deadlocks au aceleasi cauze.
F
*
Race conditions can be avoided using semaphores.
Race conditions pot fi evitate folosind semafoare.
T
*
Race condition can exists in single threaded programming.
Race condition poate exista in programarea single-thread.
F
*
Race conditions can't be avoided using semaphores.
Race conditions nu pot fi evitate folosind semafoare.
F
*
Race conditions can't be avoided using mutexes.
Race conditions nu pot fi evitate folosind mutex.
F
*

Race condition exists in multithreaded programming.

Race condition exista in programarea multithread.
T
*
Race condition is a thread synchronization problem.
Race condition este o problema de sincronizare a threadurilor.
T
*
read() from a pipe will block if pipe is empty.
read() dintr-un pipe gol va astepta.
T
*
recvfrom() is used to obtain a message from a message queue.
recvfrom() se foloseste pentru a obtine mesaje dintr-o coada de mesaje.
F
*
SCP poate fi folosit pentru transfer de fisiere
T
*
recvfrom() is used to obtain a message from a socket.
recvfrom() se foloseste pentru a obtine un mesaj de pe socket.
T
*
Semafoarele sunt folosite pentru a preveni deadlock.
Semaphores are used to prevent deadlock.
F
*
Semaphores are particular cases of mutexes.
Semafoarele sunt cazuri particulare de mutex.
F
*
Semaphores can be used to avoid concurrency problems when using both processes a
nd threads.
Semafoarele pot fi folosite pentru resolvarea problemelor de concurenta ale proc
eselor si ale threadurilor
T
*
Semaphores can't be used to avoid concurrency problems when using processes.
Semafoarele nu pot fi folosite pentru resolvarea problemelor de concurenta ale p
roceselor.
F
*
semget() este folosit pentru a accesa semafoare.
semget() is used to access semaphores.
T
*
sem_post increments the value of the semaphore.
sem_post creste valoarea semaforului.
T
*
sem_wait() blocks if the value of the semaphore is positive.
sem_wait() asteapta daca valoarea semaforului este pozitiva.
F
*
sem_wait() does not block if the value of the semaphore is negative.
sem_wait() nu asteapta daca valoarea semaforului este negativa.
F
*
sem_wait() does not block if the value of the semaphore is positive.
sem_wait() nu asteapta daca valoarea semaforului este pozitiva.

T
*
Sequential programs are usually faster than parallel ones.
Programele secventiale sunt de obicei mai rapide decat cele paralele.
F
*
Serviciul HTTP ruleaza pe portul 80.
The HTTP service runs on port 80.
T
*
shmat() can be used to allocate a shared memory segment.
shmat() poate fi folosit pentru a aloca o zona de memorie partajata.
F
*
shmat() nu poate fi folosit pentru a aloca un segment shared memory.
shmat() can't be used to allocate a shared memory segment.
T
*
Shared memory can be used to communicate between 2 threads of the same process.
Pentru a comunica intre 2 threaduri ale aceluiasi proces putem sa folosim memori
e.
partajata.
T
*
shmat() ataseaza segmentul de memorie partajata la spatiul de adresare al proces
ului
T
*
Shared memory segments can only be used by related processes.
Zonele de memorie partajata pot fi folosite doar de procese inrudite.
F
*
Zonele de memorie partajata pot fi folosite de procese inrudite
T
*
shmget() creates a message queue.
shmget() creaza o coada de mesaje.
F
*
semget() is used to access semaphores.
semget() se foloseste pentru a aceesa semafoare.
T
*
shmget() nu poate fi folosit pentru a aloca o zona de memorie partajata
F
*
semget() is used to create semaphores.
semget() se foloseste penmtru a crea semafoare.
T
*
signal() is used to send a signal from one process to another. A signal is a sof
tware interrupt.
signal() is used to send a signal from one process to another. A signal is a sof
tware interrupt.
T
*
Signals are not a valid IPC mechanism.
Semnalele nu sunt un mecanism IPC valid.
F
*

Signals can be used with threads.

Semnalele pot fi folosite in threaduri.
T
*
SMTP(Simple Mail Transfer Protocol) can be used for sending files.
SMTP se poate folosi pentru a trimite fisiere.
T
*
SMTP is used for displaying web pages.
SMTP se foloseste pentru a afisa pagini de web.
F
*
SOCK_DGRAM is used for TCP.
SOCK_DGRAM se foloseste pentru TCP.
F
*
SOCK_DGRAM is used for UDP.
SOCK_DGRAM se foloseste pentru UDP.
T
*
Socket ports 0-1023 are reserved.
Porturile 0-1023 sunt rezervate.
T
*
Sockets are bidirectional.
Socketurile sunt bidirectionale.
T
*
Pentru a comunica intre 2 threaduri ale aceluiasi proces nu putem sa folosim soc
kets
F
*
Sockets are unidirectional.
Socketurile sunt unidirectionale.
F
*
Socket-urile pot fi folosite pentru comunicarea intre 2 threaduri ale aceluiasi
proces.
Sockets can be used to communicate between 2 threads of the same process.
T
*
Sockets can't be used to communicate between 2 processes on the same machine.
Socketurile nu pot fi folosite pentru a comunica intre 2 procese ce ruleaza pe a
ceeasi masina.
F
*
Some concurrent programs are parallel.
Unele programe concurente sunt paralele.
T
*
Some parallel programs are distributed.
Unele programe paralele sunt distribuite.
T
*
SSH stands for Secure Shell.
SSH=Secure Shell.
T
*
SSH stands for Secure Shell Server.
SSH=Secure Shell Server.

F
*
Standard port for email service is 80.
Portul standard pentru serviciul de mail este 80.
F
*
Standard port for web service is 80
Portul standard pentru serviciul de web este 80
T
*
Standard port for ssh service is 21.
Portul standard pentru ssh este 21.
F
*
Standard port for ssh service is 22.
Portul standard pentru ssh este 22.
T
*
Standard port for ssh service is 2222.
Portul standard pentru ssh este 2222.
F
*
Standard port for web service is 8080.
Portul standard pentru serviciul de web este 8080.
F
*
Starvation never occurs when shared resources are made unavailable for long peri
ods by greedy threads.
Cand o resursa partajata este blocata exclusiv de un thread lacom nu poate apare
a fenomenul de starvation.
F
*
Starvation occurs when shared resources are made unavailable for long periods by
greedy threads.
Cand o resursa partajata este blocata exclusiv de un thread lacom poate aparea f
enomenul de starvation.
T
*
Suspending a process means suspending all the threads of the process.
Suspendare unui proces presupune suspendarea tuturor threadurilor component.
T
*
Starvation never occurs when shared resources are made unavailable for long peri
ods by greedy threads.
Cand o resursa partajata este blocata exclusiv de un thread lacom, nu poate apar
ea fenomenul de starvation.
F
*
system() can be used to execute external programs.
system() poate fi folosit pentru a executa programe externe.
T
*
TCP allows much larger packets to be sent over the network, improving applicatio
n performance.
TCP este mai performant deoarece poate transmite packete mult mai mari.
F
*
Socket ports 0-65535 are reserved
Porturile 0-65535 sunt rezervate
F

*
TCP consumes fewer computer resources by not maintaining connection state.
TCP consuma mai putine resurse deoarece nu mentine starea conexiunii.
F
*
TCP does not guarantee that individual packets of a transmission will arrive in
order.
TCP nu garanteaza ordinea transmisiei pachetelor.
F
*
TCP does not include a retry mechanism to prevent losing packets.
TCP nu are un mecanism de retransmitere pentru a preveni pierderea de pachete.
F
*
TCP guarantees that individual packets of a transmission will arrive in order.
TCP garanteaza ordinea transmisiei pachetelor.
T
*
UDP guarantees that individual packets of a transmission will arrive in order
UDP garanteaza ordinea transmisiei pachetelor
T
*
TCP includes a retry mechanism to prevent losing packets.
TCP are un mecanism de retransmitere pentru a preveni pierderea de pachete.
T
*
TCP is a connection oriented protocol.
TCP este un protocol cu conexiune permanenta.
T
*
TCP is a connectionless oriented protocol.
TCP nu este un protocol cu conexiune permanenta.
F
*
UDP is a connectionless oriented protocol.
T
*
TCP este intotdeauna mai rapid decat UDP.
TCP is always faster than UDP.
F
*
TCP is an IPC mechanism.
TCP este un mecanism IPC.
F
*
TCP este uneori mai rapid decat UDP.
TCP is sometimes faster than UDP.
T
*
TCP isn't an encryption protocol.
TCP nu este un protocol de criptare.
T
*
TCP isn't an IPC mechanism.
TCP nu este un mecanism IPC.
T
*
TCP isn't a transport layer protocol.
TCP nu este un protocol de nivel transport.
F

*
TCP stands for Transmission Control Protocol.
TCP=Transmission Control Protocol.
T
*
The calling process does not wait for popen to finish execution.
Procesul apelant nu asteapta ca functia popen sa-ti incheie executia.
T
*
The calling process waits for popen to finish execution.
Procesul apelant asteapta ca functia popen sa-ti incheie executia.
F
*
The child process will sometimes finish before the parent process.
Procesul fiu se termina uneori inaintea procesului parinte.
T
*
The child process will never finish before the parent process.
Procesul fiu nu se termina niciodata inaintea procesului parinte.
F
*
The FIFO must be opened at both ends before data can be passed.
FIFO trebuie deschis la ambele capete inainte sa se poata comunica prin el.
T
*
The message queue may be deleted when the process ends.
Coada de mesaje poate fi stearsa la terminarea procesului.
T
*
The parent process will always finish before the child process.
Procesul parinte se termina intotdeauna inaintea procesului fiu.
F
*
The port 443 is most often used by HTTP.
Portul 443 este de obicei folosit de catre HTTP.
F
*
There is a limited number of processes that can be created on a system.
Exista un numar limitat de procese ce pot fi create pe un sistem.
T
*
There is a limited number of threads that can be created on a system.
Exista un numar limitat de threaduri ce pot fi create pe un sistem.
T
*
There is an unlimited number of processes that can be created on a system.
Exista un numar nelimitat de procese ce pot fi create pe un sistem.
F
*
Threads are independent executing entities within a same process.
Thread-urile sunt entitati de calcul independente in cadrul aceluiasi proces.
T
*
Threads can be synchronized using mutexes.
Threadurile pot fi sincronizate folosind mutex.
T
*
Threads can be synchronized using semaphores.
Threadurile pot fi sincronizate folosind semafoare.
T

*
Threads can only be synchronised using mutex.
Threadurile pot fi sincronizate doar prin mutex.
F
*
Threads can't access global data of their parent process.
Threadurile nu pot accesa variabilele globale ale procesului parinte.
F
*
Variabilele globale sunt clonate in procesul fiu?
T
*
Threads can't be synchronized using semaphores.
Threadurile nu pot fi sincronizate folosind semafoare .
F
*
Threads share the same stack.
Threadurile partajeaza aceeasi zona de stiva.
F
*
To check a mutex state, one can call pthread_mutex_trylock().
Pentru a verifica starea unui mutex se poate apela pthread_mutex_trylock().
T
*
pipe() creeaza un canal bidirectional ce poate fi folosit pentru IPC
F
*
All parallel programs are concurrent.
Toate programele paralele sunt concurente.
F
*
UDP and TCP are both network layer protocols.
UDP si TCP sunt ambele protocoale de nivel retea.
F
*
UDP can be implemented using TCP.
UDP poate fi implementat folosind TCP.
F
*
UDP consumes fewer computer resources by not maintaining connection state.
UDP consuma mai putine resurse deoarece nu mentine starea conexiunii.
T
*
UDP does error checking.
UDP verifica eventualele erori.
F
*
UDP does not include a retry mechanism to prevent losing packets.
UDP nu are un mecanism de retransmitere pentru a preveni pierderea de pachete.
T
*
UDP are un mecanism de retransmitere pentru a preveni pierderea de pachete.
UDP includes a retry mechanism to prevent losing packets.
F
*
UDP is always faster than TCP.
UDP este intotdeauna mai rapid ca TCP.
F
*
UDP is sometimes faster than TCP.

T
*
UDP is an encryption protocol.
UDP este un protocol de criptare.
F
*
UDP is an IPC mechanism.
UDP este un mecanism IPC.
F
*
UDP is never faster than TCP.
UDP nu e niciodata mai rapid ca TCP.
F
*
UDP is not always faster than TCP.
UDP nu este intotdeauna mai rapid ca TCP.
T
*
UDP isn't a transport layer protocol.
UDP nu este un protocol de nivel transport.
F
*
UDP isn't an encryption protocol.
UDP nu este un protocol de criptare.
T
*
UDP isn't an IPC mechanism.
UDP nu este un mecanism IPC.
T
*
UDP = User Data Protocol.
UDP stands for User Data Protocol.
F
*
UDP stands for User Datagram Policy.
UDP=User Datagram Policy.
F
*
UDP stands for User Datagram Protocol.
UDP=User Datagram Protocol.
T
*
Using mutexes can lead to deadlock.
Folosirea mutex-urilor poate duce la deadlock.
T
*
Using mutexes can sometimes lead to deadlock.
Folosirea mutex-urilor poate duce uneori la deadlock.
T
*
Using mutexes can never lead to deadlock.
Folosirea mutex-urilor nu poate duce la deadlock.
F
*
Using processes instead of threads can prevent deadlock.
Folosind procese in loc de threaduri poate preveni dedlock.
F
*
Using processes instead of threads can prevent livelock.
Folosind procese in loc de threaduri poate preveni livelock.

F
*
Using processes instead of threads can prevent starvation.
Folosind procese in loc de threaduri poate preveni starvation.
F
*
Using semaphores can lead to deadlock.
Folosirea semafoarelor poate duce la deadlock.
T
*
Using semaphores can never lead to deadlock.
Folosirea semafoarelor nu poate duce la deadlock.
F
*
Folosirea semafoarelor poate duce la deadlock.
Using semaphores can sometimes lead to deadlock.
T
*
wait() can be used to wait on at most one child.
wait() asteapta dupa cel mult un proces fiu.
T
*
wait() can be used to wait on one or more children.
wait() poate fi folosita pentru a astepta unul sau mai multi fii.
F
*
When a message queue is full the old messages will be overwritten.
Cand coda de mesaje este pina, mesajele vechi vor fi suprascrise.
F
*
When using FIFO, data is not written to the file system.
Cand se foloseste FIFO datele nu sunt scrise in sistemul de fisiere
T
*
write() from a pipe will block if pipe is empty.
write() intr-un pipe gol va astepta.
F
*
Zombie processes are processes in the blocked state.
Procesele zombie sunt procese in starea blocat.
F
*
Zombie processes are processes in the terminated state.
Procesele zombie sunt procese in starea terminated.
T
*
2 mutex-uri sunt necesare pentru a aparea deadlock.
F
*
pipe() returns 0 on error.
pipe() returneaza 0 in caz de eroare.
F
*
FTP can be used for file transfer.
FTP poate fi folosit pentru transfer de fisiere.
T
*
On success, bind system call returns 1.
La succes bind() returneaza 1.
F

*
La succes bind() returneaza 0
T
*
Apelul system wait() suspenda executia procesului apelant pana la terminarea unu
i fiu.
T
*
Apelul system wait() suspenda executia procesului fiu.
F
*
Cozile de mesaje nu pot fi folosite de procese inrudite.
F
*
Cozile de mesaje permit proceselor sa schimbe date sub forma de mesaje.
T
*
the end.