---------------------------------------------------------------------

/*
* Program: fork-ex.c
*
* Functionalitate: demonstreaza crearea unui proces fiu
*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>

int main()
{
pid_t pid_fiu;
int nr = 0;

/* crearea unui proces fiu */

if(-1 == (pid_fiu=fork()) )
{
perror("Eroare la fork");
return 1;
}

/* ramificarea executiei */
if(pid_fiu == 0)
{ /* zona de cod executata doar de catre fiu */
printf("\nProcesul fiu cu PID-ul: %d , avand parintele cu PID-ul:
%d.\n",getpid(),getppid());
printf("In procesul fiu: dupa apelul fork, variabila nr are initial valoarea:
%d.\n", nr);
nr = 5;
printf("In procesul fiu: dupa modificarea ei, variabila nr are valoarea:
%d.\n", nr);
}
else
{ /* zona de cod executata doar de catre parinte */
printf("\nProcesul tata cu PID-ul: %d , avand parintele cu PID-ul: %d si un fiu
cu PID-ul: %d.\n",
getpid(), getppid(), pid_fiu );
sleep(2);
printf("In procesul tata, dupa 2 secunde: variabila nr are valoarea: %d.\n",
nr);
}

/* zona de cod comuna, executata de catre ambele procese */

printf("Zona de cod comuna, executata de catre %s.\n\n", pid_fiu == 0 ? "fiu" :
"parinte" );
return 0;
}

----------------------------------------------------------------------------------

/*
* Program: info-ex1.c
*
* Functionalitate: demonstreaza cateva apeluri ce ofera informatii despre procese
*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>

int main(void)
{
printf("\nProcesul curent are PID-ul: %d , iar parintele lui este procesul cu
PID-ul: %d.\n",getpid(),getppid());
return 0;
}

-----------------------------------------------------------------------------------
----

/*
* Program: info-ex2.c
*
* Functionalitate: demonstreaza apelurile ce ofera informatii despre procese
*/
#include <unistd.h>
#include <stdio.h>
#include <sys/types.h>

int main(void)
{
printf("\nProcesul curent are PID-ul: %d , iar parintele lui este procesul cu
PID-ul: %d.\n\n",getpid(),getppid());

printf("Proprietarul real al procesului curent este: UID=%d, GID=

%d.\n",getuid(),getgid());
printf("Proprietarul efectiv al procesului curent : UID=%d, GID=
%d.\n\n",geteuid(),getegid());

printf("Start of sleeping for 3 seconds...\n\n");

sleep(3);
printf("Finish of sleeping for 3 seconds!\n");
return 0;
}

-----------------------------------------------------------------------------------
---

/*
* Program: suma_files.c
*
* Functionalitate: suma distribuita cu 2 procese worker si comunicatii prin
fisiere
* {Este un exemplu de calcul paralel folosind strategia supervisor-workers (sau
master-slaves).}
*/
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <errno.h>

void master_init();
void master_finish();
void slave_work(char* fi, char* fo);

int main()
{
int pid1,pid2;

printf("\n\n\n\n\n");

/* Curata rezultatele executiilor anterioare -> necesar !!! */

remove("f1o"); remove("f2o");

/* Citire numere de la tastatura si scriere in fisierele f1i si f2i */

master_init();

/* Am citit numerele inainte de crearea fiilor deoarece este nevoie de

sincronizare (fiul trebuie sa astepte tatal sa scrie in fisier pentru a
avea ce citi), iar citirea de la tastatura poate dura oricit de mult */

/* Creare primul proces slave */

if( (pid1=fork()) == -1)
{
fprintf(stderr,"Error fork la fiul 1 !\n");
exit(2);
}

if(pid1 == 0)
{ /* sunt in procesul fiu 1 */

slave_work("f1i","f1o");
return 0;
/* sfarsit executie fiu 1 */
}
/* else sunt in procesul master, executat in paralel cu if-ul de mai sus */

/* Creare al doilea proces slave */

if( (pid2=fork()) == -1)
{
fprintf(stderr,"Error fork la fiul 2 !\n");
exit(2);
}

if(pid2 == 0)
{ /* sunt in procesul fiu 2 */

slave_work("f2i","f2o");
return 0;
/* sfarsit executie fiu 2 */
}
/* else sunt in procesul master, executat in paralel cu cei doi fii */

/* Citeste cele 2 sume partiale si afiseaza suma lor. */

master_finish();
return 0;
}

/***********************************************************************/

void master_init()
{
FILE *f1,*f2;
int nr, flag;

if( (f1=fopen("f1i","wt")) == NULL)

{
fprintf(stderr,"Error opening file f1i, err=%d\n",errno); exit(3);
}
if( (f2=fopen("f2i","wt")) == NULL)
{
fprintf(stderr,"Error opening file f2i, err=%d\n",errno); exit(3);
}

printf("Introduceti numerele (0 pentru terminare):\n");

flag=1;
do
{
scanf("%d", &nr);
fprintf( (flag==1?f1:f2), "%d ", nr);
/* Atentie: spatiul din format este necesar! */
flag=3-flag;

}while(nr!=0);

fclose(f1); fclose(f2);
}

/***********************************************************************/

void master_finish()
{
/* Aici mai apare o sincronizare: master-ul trebuie sa citeasca sumele partiale
abia dupa ce
acestea au fost calculate si scrise in fisierele f1o si f2o de catre procesele
slave.
Rezolvare: incercare repetata de citire cu pauza intre incercari.
(sau: se poate astepta terminarea celor 2 fii folosind primitiva wait)*/

FILE *f1,*f2;
int sp1,sp2, cod;

/* Citeste prima suma partiala */

cod = 0;
do
{
if( (f1=fopen("f1o","rt")) != NULL)
cod = (fscanf(f1,"%d",&sp1)==1);
if(!cod)
sleep(3);

}while(!cod);
fclose(f1);

/* Citeste a doua suma partiala */

cod = 0;
do
{
if( (f2=fopen("f2o","rt")) != NULL)
cod = (fscanf(f2,"%d",&sp2)==1);
 if(!cod)
sleep(3);

}while(!cod);
fclose(f2);

/* Afiseaza suma */
printf("Master=%d -> suma nr. introduse este: %d\n", getpid(), sp1+sp2);
}

/***********************************************************************/

void slave_work(char* fi, char* fo)

{
FILE *f1,*f2;
int nr,cod, suma_partiala;

if( (f1=fopen(fi,"rt")) == NULL)

{
fprintf(stderr,"Error opening file %s, err=%d\n",fi,errno); exit(3);
}

suma_partiala=0;
do
{
cod=fscanf(f1,"%d", &nr);
if(cod == 1)
suma_partiala += nr;

}while(cod != EOF);

fclose(f1);

if( (f2=fopen(fo,"wt")) == NULL)

{
fprintf(stderr,"Error opening file %s, err=%d\n",fo,errno); exit(3);
}
fprintf(f2,"%d",suma_partiala);
fclose(f2);
printf("Slave=%d -> suma partiala:%d\n", getpid(), suma_partiala);
}

/***********************************************************************/