prototipos.txt

//////////////////////////////////////////     main.c            //////////////////////////////////////////

//Definição da estrutura PCB
typedef struct PCB
{
    char nome_processo[15];
    int start;
    int variavel;
    int PC;
    int PID;
    int PPID;
    int prioridade;
    int estado;
    int tempo_chegada;
    int tempo_burst;
    int tempo_cpu;
} PCB;

//Definição da estrutura memoria
typedef struct Memory
{
    char instrucao[1];
    int valor;
    char nome[15];
} Memory;

//Definição da estrutura plan
typedef struct plan
{
    char programa[15];
    int tempo_chegada;
} plan;

//definição da estrutura control
typedef struct control
{
    char programa[1];
} control;

//criação da estrutura do Gestor de processos
typedef struct Gestor
{
    int tempo;
    int RunningState;    //indice do PCB do processo em execussao
    int PC;              //PC do processo em execução
    PCB *PCBtabela;      //apontador para o PCB
    int *Prontos;        //array de inteiros com os PID dos processos em execussao
    int prontos_size;    //tamanho do array prontos
    int *Bloqueados;     //array de inteiros com os PID dos processos bloqueados
    int bloqueados_size; //tamanho do array bloqueados

} Gestor;

//Função para carregar o novo programa aos proximos lugares na memoria
void adicionarProgramaRAM(Memory *RAM, int *RAM_size, Memory *novoPrograma, int novoPrograma_size);

//Função que lista os processos existentes no PCB
void mostrarPCB(PCB *ProcessCB, int PCB_size);

//mostra o conteudo da RAM
void mostrarRAM(Memory *RAM, int RAM_size);

//cria o processo do escalonador
void inicializarPCB(PCB *ProcessCB, int *PCB_size);

int adicionarProcessoPCB(PCB *ProcessCB, int *PCB_size, char *nome[15], int primeiroElementoMemoria, int tempo_chegada, int tempo_burst);

//Função para listar processos prontos no gestor
void mostrarProcessosReady(Gestor *gest);

//Função para listar processos bloqueados no gestor
void mostrarProcessosBlocked(Gestor *gest);

//Move os processos blocked para a lista ready
void EscalonadorLPrazo(PCB *ProcessCB, int *PCB_size, Gestor *gest);


//////////////////////////////////////////     escalonadores.c            //////////////////////////////////////////

//Encontra a hora do ultimo processo a chegar
int ultimoProcesso(PCB *arr_processos);

//First Come First Served
PCB *FCFS(PCB *arr_processos, int arr_processos_size); 

//troca 2 elementos PCB*
void swap(PCB *xp, PCB *yp);

//Ordena pelo tempo de burst para uso no SVF
void bubbleSort(PCB *arr, int n);

//Shortest-Job-First Não Preemptivo
PCB *SJF(PCB *arr_processos, int arr_processos_size);

//////////////////////////////////////////     execute.c            //////////////////////////////////////////


//função irá incorporar o PCBtabela e inicializar os restantes campos
Gestor *inicializarGestor(PCB *PCBtabela, int PCB_size);

//Função para executar o programa
void executarPrograma(Memory *RAM, int *RAM_size, int PID, PCB *ProcessCB, int *PCB_size, int *TIME, Gestor *gest, int N_instrucoes);

//////////////////////////////////////////     ficheiros.c            //////////////////////////////////////////

Memory *lerProcesso(char *nomePrograma, int *programaSize);

int lerPlan(plan *Plano);

int lerControl(control *Controlo);

//////////////////////////////////////////     operacoes.c            //////////////////////////////////////////


void M(PCB *ProcessCB, int PCB_size, int PID, int valor);

void A(PCB *ProcessCB, int PCB_size, int PID, int valor);

void S(PCB *ProcessCB, int PCB_size, int PID, int valor);

void C(PCB *ProcessCB, int *PCB_size, int PID, int valor);

void T(PCB *ProcessCB, int *PCB_size, int PID);

void L(PCB *ProcessCB, int *PCB_size, int PID, char *filho, Memory *RAM, int *RAM_size);

void B(PCB *ProcessCB, int *PCB_size, int PID, Gestor *gest);

int PesquisaExaustiva(PCB X, PCB *L, int N);

PCB *Remover(PCB X, PCB *L, int *N);

int *RemoverProntos(int *L, int pos, int *N);

int *RemoverBloqueados(int *L, int pos, int *N);