└── memory_management
    ├── mvt.c
    ├── worst_fit.c
    ├── mft.c
    ├── best_fit.c
    ├── first_fit.c
    ├── paging.c
    └── README.md


/memory_management/mvt.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <curses.h>
 3 | 
 4 | void main(){
 5 |   int ms, mp[10], i, temp, n=0;
 6 |   char ch = 's';
 7 | 
 8 |   printf("\nInforme o total de memória disponível (em Bytes)-- ");
 9 |   scanf("%d", &ms);
10 |   temp=ms;
11 | 
12 |   for(i=0;ch=='s';i++,n++){
13 |     printf("\nInforme a quantidade de mmemória necessária para o processo %d (em Bytes) -- ", i+1);
14 |     scanf("%d", &mp[i]);
15 |     if(mp[i]<=temp){
16 |       printf("\nMemória está alocada para o Processo %d ", i+1);
17 |       temp = temp - mp[i];
18 |     }
19 |     else{
20 |       printf("\nMemória está cheia");
21 |       break;
22 |     }
23 |     printf("\nVocê deseja continuar (s/n) -- ");
24 |     scanf(" %c", &ch);
25 |   }
26 | 
27 |   printf("\n\nTotal de Memória Disponível -- %d", ms);
28 |   printf("\n\n\tPROCESSO\t\t MEMÓRIA ALOCADA ");
29 | 
30 |   for(i=0;i<n;i++)
31 |     printf("\n \t%d\t\t%d", i+1, mp[i]);
32 | 
33 |   printf("\n\nTotal de Memória Alocada é %d", ms-temp);
34 |   printf("\nTotal de Fragmentação Externa é %d", temp);
35 | }
36 | 


--------------------------------------------------------------------------------
/memory_management/worst_fit.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <curses.h>
 3 | 
 4 | #define max 25
 5 | 
 6 | void main(){
 7 |   int frag[max], b[max], f[max], i, j, nb, nf, temp;
 8 |   static int bf[max], ff[max];
 9 | 
10 |   printf("\n\tEsquema de Gerenciamento de Memória - Worst Fit\n");
11 |   printf("\nInforme o número de blocos: ");
12 |   scanf("%d",&nb);
13 |   printf("Informe o número de arquivos: ");
14 |   scanf("%d",&nf);
15 |   printf("\nInforme o tamanho dos blocos (em Bytes):\n");
16 | 
17 |   for(i=1;i<=nb;i++){
18 |     printf("Bloco %d: ", i);
19 |     scanf("%d", &b[i]);
20 |   }
21 | 
22 |   printf("Informe o tamanho dos arquivos (em Bytes): \n");
23 | 
24 |   for(i=1;i<=nf;i++){
25 |     printf("Arquivo %d: ", i);
26 |     scanf("%d", &f[i]);
27 |   }
28 | 
29 |   for(i=1;i<=nf;i++){
30 |     for(j=1;j<=nb;j++){
31 |       if(bf[j]!=1){
32 |         temp=b[j]-f[i];
33 |         if(temp>=0){
34 |           ff[i]=j;
35 |           break;
36 |         }
37 |       }
38 |     }
39 |     frag[i]=temp;
40 |     bf[ff[i]]=1;
41 |   }
42 |   printf("\nArquivo_no:\tTamanho Arquivo :\tBloco_no:\tTamanho Bloco:\tFragmento");
43 | 
44 |   for(i=1;i<=nf;i++)
45 |     printf("\n%d\t\t%d\t\t\t%d\t\t%d\t\t%d", i, f[i], ff[i], b[ff[i]], frag[i]);
46 | }
47 | 


--------------------------------------------------------------------------------
/memory_management/mft.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <curses.h>
 3 | 
 4 | void main(){
 5 |   int ms, bs, nob, ef, n, mp[10], tif=0;
 6 |   int i,p=0;
 7 | 
 8 |   printf("Informe o total de memória disponível (em Bytes) -- ");
 9 |   scanf("%d", &ms);
10 |   printf("Informe o tamanho do bloco - block size (em Bytes) -- ");
11 |   scanf("%d", &bs);
12 |   nob=ms/bs;
13 |   ef=ms - nob*bs;
14 |   printf("\nInforme o número de processos -- ");
15 |   scanf("%d", &n);
16 | 
17 |   for(i=0;i<n;i++){
18 |     printf("Informe a quantidade de mmemória necessária para o processo %d (em Bytes)-- ",i+1);
19 |     scanf("%d", &mp[i]);
20 |   }
21 | 
22 |   printf("\nNo. de blocos disponíveis em memória -- %d",nob);
23 |   printf("\n\nPROCESSO\tMEMÓRIA NECESSÁRIA\t ALOCADA\tFRAGMENTAÇÃO INTERNA");
24 | 
25 |   for(i=0;i<n && p<nob;i++){
26 |     printf("\n %d\t\t%d", i+1, mp[i]);
27 |     if(mp[i] > bs)
28 |       printf("\t\t\tNÃO\t\t\t---");
29 |     else{
30 |       printf("\t\t\tSIM\t\t%d", bs-mp[i]);
31 |       tif = tif + bs-mp[i];
32 |       p++;
33 |     }
34 |   }
35 |   if(i<n)
36 |     printf("\nMemória está cheia. Alguns processos não foram acomodados.");
37 | 
38 |   printf("\n\nTotal de Fragmentação Interna é %d", tif);
39 |   printf("\nTotal de Fragmentação Externa é %d", ef);
40 |   //getch();
41 | }
42 | 


--------------------------------------------------------------------------------
/memory_management/best_fit.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <curses.h>
 3 | 
 4 | #define max 25
 5 | 
 6 | void main(){
 7 |   int frag[max], b[max], f[max], i, j, nb, nf, temp, lowest=10000;
 8 |   static int bf[max], ff[max];
 9 | 
10 |   printf("\n\tEsquema de Gerenciamento de Memória - Best Fit\n");
11 |   printf("\nInforme o número de blocos: ");
12 |   scanf("%d",&nb);
13 |   printf("Informe o número de arquivos: ");
14 |   scanf("%d",&nf);
15 |   printf("\nInforme o tamanho dos blocos (em Bytes):\n");
16 | 
17 |   for(i=1;i<=nb;i++){
18 |     printf("Bloco %d: ", i);
19 |     scanf("%d", &b[i]);
20 |   }
21 | 
22 |   printf("Informe o tamanho dos arquivos (em Bytes):\n");
23 | 
24 |   for(i=1;i<=nf;i++){
25 |     printf("Arquivo %d: ", i);
26 |     scanf("%d", &f[i]);
27 |   }
28 | 
29 |   for(i=1;i<=nf;i++){
30 |     for(j=1;j<=nb;j++){
31 |       if(bf[j]!=1){
32 |         temp=b[j]-f[i];
33 |         if(temp>=0)
34 |           if(lowest>temp){
35 |             ff[i]=j;
36 |             lowest=temp;
37 |           }
38 |       }
39 |     }
40 |     frag[i]=lowest;
41 |     bf[ff[i]]=1;
42 |     lowest=10000;
43 |   }
44 |   printf("\nArquivo_no:\tTamanho Arquivo :\tBloco_no:\tTamanho Bloco:\tFragmento");
45 | 
46 |   for(i=1;i<=nf && ff[i]!=0;i++)
47 |     printf("\n%d\t\t%d\t\t\t%d\t\t%d\t\t%d", i, f[i], ff[i], b[ff[i]], frag[i]);
48 | }
49 | 


--------------------------------------------------------------------------------
/memory_management/first_fit.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <curses.h>
 3 | 
 4 | #define max 25
 5 | 
 6 | void main(){
 7 |   int frag[max], b[max], f[max], i, j, nb, nf, temp, highest=0;
 8 |   static int bf[max],ff[max];
 9 | 
10 |   printf("\n\tEsquema de Gerenciamento de Memória - First Fit\n");
11 |   printf("\nInforme o número de blocos: ");
12 |   scanf("%d",&nb);
13 |   printf("Informe o número de arquivos: ");
14 |   scanf("%d",&nf);
15 |   printf("\nInforme o tamanho dos blocos (em Bytes):\n");
16 | 
17 |   for(i=1;i<=nb;i++){
18 |     printf("Bloco %d: ", i);
19 |     scanf("%d", &b[i]);
20 |   }
21 | 
22 |   printf("Informe o tamanho dos arquivos (em Bytes):\n");
23 | 
24 |   for(i=1;i<=nf;i++){
25 |     printf("Arquivo %d: ", i);
26 |     scanf("%d", &f[i]);
27 |   }
28 | 
29 |   for(i=1;i<=nf;i++){
30 |     for(j=1;j<=nb;j++){
31 |       if(bf[j]!=1){ //if bf[j] is not allocated
32 |         temp=b[j]-f[i];
33 |         if(temp>=0)
34 |           if(highest<temp){
35 |             ff[i]=j;
36 |             highest=temp;
37 |           }
38 |       }
39 |     }
40 |    frag[i]=highest;
41 |    bf[ff[i]]=1;
42 |    highest=0;
43 |  }
44 |  printf("\nArquivo_no:\tTamanho Arquivo :\tBloco_no:\tTamanho Bloco:\tFragmento");
45 | 
46 |   for(i=1;i<=nf;i++)
47 |     printf("\n%d\t\t%d\t\t\t%d\t\t%d\t\t%d", i, f[i], ff[i], b[ff[i]], frag[i]);
48 | }
49 | 


--------------------------------------------------------------------------------
/memory_management/paging.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <curses.h>
 3 | 
 4 | void main(){
 5 |   int ms, ps, nop, np, rempages, i, j, x, y, pa, offset;
 6 |   int s[10], fno[10][20];
 7 | 
 8 |   printf("\nInforme o tamanho da memória: ");
 9 |   scanf("%d",&ms);
10 |   printf("\nInforme o tamanho da página: ");
11 |   scanf("%d",&ps);
12 |   nop = ms/ps;
13 |   printf("\nO no. de páginas disponíveis na memória são %d ",nop);
14 |   printf("\nInforme o número de processos: ");
15 |   scanf("%d", &np);
16 |   rempages = nop;
17 | 
18 |   for(i=1;i<=np;i++){
19 |     printf("\nInforme o número de páginas necessárias para p[%d]: ",i);
20 |     scanf("%d",&s[i]);
21 |     if(s[i] >rempages){
22 |       printf("\nMemória está cheia");
23 |       break;
24 |     }
25 | 
26 |     rempages = rempages - s[i];
27 |     printf("\nInforme a tabela de página para p[%d]: ",i);
28 | 
29 |     for(j=0;j<s[i];j++)
30 |       scanf("%d",&fno[i][j]);
31 |   }
32 | 
33 |   printf("\nInforme o endereço lógico para buscar o endereço físico ");
34 |   printf("\nInforme o no. do Processo, o número da página e o offset:");
35 |   scanf("%d %d %d",&x,&y, &offset);
36 | 
37 |   if(x>np || y>=s[i] || offset>=ps)
38 |     printf("\nProcesso Inválido ou Número da Página ou offset");
39 |   else{
40 |     pa=fno[x][y]*ps+offset;
41 |     printf("\nO endereço físico é %d",pa);
42 |   }
43 | }
44 | 


--------------------------------------------------------------------------------
/memory_management/README.md:
--------------------------------------------------------------------------------
  1 | ## Introdução
  2 | 
  3 | Este repositório contempla algumas técnicas e métodos de gestão e alocação de memória que são demonstrados através de programas que **simulam** essas técnicas.
  4 | 
  5 | ### MFT (Multiprogramming with a Fixed number of Tasks)
  6 | 
  7 | Compile e execute o programa [mft.c](https://github.com/ramonfontes/so/blob/master/memory_management/mft.c) e responda ao questionário conforme abaixo:
  8 | 
  9 | - Informe o total de memória disponível (em Bytes): 1000
 10 | - Informe o tamanho do bloco - block size (em Bytes): 300
 11 | - Informe o número de processos: 5
 12 | - Informe a quantidade de mmemória necessária para o processo 1 (em Bytes): 275
 13 | - Informe a quantidade de mmemória necessária para o processo 2 (em Bytes): 400
 14 | - Informe a quantidade de mmemória necessária para o processo 3 (em Bytes): 290
 15 | - Informe a quantidade de mmemória necessária para o processo 4 (em Bytes): 293
 16 | - Informe a quantidade de mmemória necessária para o processo 5 (em Bytes): 100
 17 | - No. de blocos disponíveis em memória: 3
 18 | 
 19 | #### Resultado da Execução:
 20 | 
 21 | ```
 22 | PROCESSO	MEMÓRIA NECESSÁRIA	ALOCADA	FRAGMENTAÇÃO INTERNA
 23 |  1		275			SIM		25
 24 |  2		400			NÃO			---
 25 |  3		290			SIM		10
 26 |  4		293			SIM		7
 27 | Memória está cheia. Alguns processos não foram acomodados.
 28 | 
 29 | Total de Fragmentação Interna é 42
 30 | Total de Fragmentação Externa é 100
 31 | ```
 32 | 
 33 | #### Perguntas:
 34 | 
 35 | 1. Houve algum processo com memória não alocada? Qual? Justifique.
 36 | 2. Houve fragmentação interna? Justifique.
 37 | 3. Houve fragmentação externa? Justifique.
 38 | 
 39 | ---
 40 | 
 41 | ### MVT (Multiprogramming with a Variable number of Tasks)
 42 | 
 43 | Compile e execute o programa [mvt.c](https://github.com/ramonfontes/so/blob/master/memory_management/mvt.c) e responda ao questionário conforme abaixo:
 44 | 
 45 | - Informe o total de memória disponível (em Bytes): 1000
 46 | - Informe a quantidade de mmemória necessária para o processo 1 (em Bytes): 400
 47 | - Memória está alocada para o Processo 1
 48 | - Você deseja continuar (s/n): s
 49 | - Informe a quantidade de mmemória necessária para o processo 2 (em Bytes): 275
 50 | - Memória está alocada para o Processo 2
 51 | - Você deseja continuar (s/n): s
 52 | - Informe a quantidade de mmemória necessária para o processo 3 (em Bytes): 550
 53 | 
 54 | 
 55 | #### Resultado da Execução:
 56 | 
 57 | ```
 58 | Memória está cheia
 59 | 
 60 | Total de Memória Disponível -- 1000
 61 | 
 62 | 	PROCESSO	MEMÓRIA ALOCADA 
 63 |  	1		400
 64 |  	2		275
 65 | 
 66 | Total de Memória Alocada é 675
 67 | Total de Fragmentação Externa é 325
 68 | ```
 69 | 
 70 | #### Perguntas:
 71 | 
 72 | 1. Informe o total de memória alocada e justifique a resposta.
 73 | 2. Houve fragmentação interna? Justifique.
 74 | 3. Quem utiliza recursos de forma mais eficiente? MFT ou MVT?
 75 | 
 76 | ---
 77 | 
 78 | ### Worst-Fit
 79 | 
 80 | Compile e execute o programa [worst_fit.c](https://github.com/ramonfontes/so/blob/master/memory_management/worst_fit.c) e responda ao questionário conforme abaixo:
 81 | 
 82 | - Informe o número de blocos: 3
 83 | - Informe o número de arquivos: 2
 84 | - Informe o tamanho dos blocos:
 85 | - Bloco 1: 5
 86 | - Bloco 2: 2
 87 | - Bloco 3: 7
 88 | - Informe o tamanho dos arquivos:
 89 | - Arquivo 1: 1
 90 | - Arquivo 2: 4
 91 | 
 92 | 
 93 | #### Resultado da Execução:
 94 | 
 95 | ```
 96 | Arquivo_no:	Tamanho Arquivo :	Bloco_no:	Tamanho Bloco:	Fragmento
 97 | 1		1			1		5		4
 98 | 2		4			3		7		3
 99 | ```
100 | 
101 | #### Perguntas:
102 | 
103 | 1. Comente o resultado observado.
104 | 
105 | ---
106 | 
107 | ### Best-Fit
108 | 
109 | Compile e execute o programa [best_fit.c](https://github.com/ramonfontes/so/blob/master/memory_management/best_fit.c) e responda ao questionário conforme abaixo:
110 | 
111 | - Informe o número de blocos: 3
112 | - Informe o número de arquivos: 2
113 | - Informe o tamanho dos blocos:
114 | - Bloco 1: 5
115 | - Bloco 2: 2
116 | - Bloco 3: 7
117 | - Informe o tamanho dos arquivos:
118 | - Arquivo 1: 1
119 | - Arquivo 2: 4
120 | 
121 | 
122 | #### Resultado da Execução:
123 | 
124 | ```
125 | Arquivo_no:	Tamanho Arquivo :	Bloco_no:	Tamanho Bloco:	Fragmento
126 | 1		1			2		2		1
127 | 2		4			1		5		1
128 | ```
129 | 
130 | #### Perguntas:
131 | 
132 | 1. Comente o resultado observado.
133 | 
134 | ---
135 | 
136 | ### First-Fit
137 | 
138 | Compile e execute o programa [first_fit.c](https://github.com/ramonfontes/so/blob/master/memory_management/first_fit.c) e responda ao questionário conforme abaixo:
139 | 
140 | - Informe o número de blocos: 3
141 | - Informe o número de arquivos: 2
142 | - Informe o tamanho dos blocos:
143 | - Bloco 1: 5
144 | - Bloco 2: 2
145 | - Bloco 3: 7
146 | - Informe o tamanho dos arquivos:
147 | - Arquivo 1: 1
148 | - Arquivo 2: 4
149 | 
150 | 
151 | #### Resultado da Execução:
152 | 
153 | ```
154 | Arquivo_no:	Tamanho Arquivo :	Bloco_no:	Tamanho Bloco:	Fragmento
155 | 1		1			3		7		6
156 | 2		4			1		5		1
157 | ```
158 | 
159 | #### Perguntas:
160 | 
161 | 1. Comente o resultado observado.
162 | 2. Faça uma análise comparativa e justifique através dos resultados obtidos em Worst-Fit, Best-Fit e First-Fit, qual deles apresentou melhor desempenho e porque.
163 | 
164 | ---
165 | 
166 | ### Paginação (Paging)
167 | 
168 | Compile e execute o programa [paging.c](https://github.com/ramonfontes/so/blob/master/memory_management/paging.c) e responda ao questionário conforme abaixo:
169 | 
170 | 
171 | - Informe o tamanho da memória: 1000
172 | - Informe o tamanho da página: 100
173 | - > O no. de páginas disponíveis na memória são 10
174 | - Informe o número de processos: 3
175 | - Informe o número de páginas necessárias para p[1]: 4
176 | - Informe a tabela de página para p[1]: 8 6 9 5
177 | - Informe o número de páginas necessárias para p[2]: 5
178 | - Informe a tabela de página para p[2]: 1 4 5 7 3
179 | - Informe o número de páginas necessárias para p[3]: 5
180 | 
181 | 
182 | #### Resultado da Execução:
183 | 
184 | ```
185 | Memória está cheia
186 | 
187 | O endereço físico é 760
188 | ```
189 | 
190 | #### Perguntas:
191 | 
192 | 1. A memória está cheia? Comente.
193 | 
194 | - Informe o no. do Processo, o número da página e o offset: 2 3 60
195 | 
196 | 2. O que seria o offset? Faça um paralelo entre o seu conceito e o resultado apresentado para o endereço físico.
197 | 


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