PROJETO

SIMULAÇÃO DE PROCESSADOR

PCS553 - Sistemas Operacionais

Alexander Cerqueira Silva 2984089

Bruno Barberi Gnecco 2968998

Escola Politécnica da Universidade de São Paulo

Engenharia Elétrica

1

ÍNDICE

1 Processador......................................................................32 Sistema operacional..........................................................63 Calculadora.......................................................................7

3.1 Modo de usuário.........................................73.2 Modo programável...................................7

4 Conclusão.........................................................................85 Código do Processador.....................................................8

2

1 Processador

O processador projetado seguiu em parte a especificação sugerida. Projetou-se uma arquitetura de 32 bits, sem ponto flutuante, facilitando o desenvolvimento sem perda de generalidade, e permitindo focar nos objetivos do projeto.

O processador é composto de:

um acumulador (acc).

uma pilha de endereços (tamanho: 128 endereços).

uma pilha de usuário (tamanho: 128 words)

memória (tamanho: 16384 posições de 32 bits cada).

um contador de programa (pc).

a memória, acumulador, pc e stack começam em zero. O índice da stack começa em -1.

Uma linguagem assembly foi desenvolvida para a programação do processador. As seguintes restrições foram adotadas:

letras sempre em minúsculas;

endereços e valores são sempre passados em decimal no programa assembly;

linhas em branco são ignoradas.

tudo o que vier depois de um # é ignorado (comentários).

3

se uma linha começa com :[número], então o código passa a ser colocado na posição [número]. Exemplo:

:100decinc

coloca a instrução dec na posição 100, a instrução inc na posição 102, etc. O formato das instruções é o seguinte:

Primeira word Segunda word Código da instrução Valor do argumento ou

zero se não houver

As seguintes instruções foram criadas:

Instrução Código da instrução (em hexadecimal)

Significado

acc valor 0000 Carrega valor no acumulador.

load address 0001 Carrega o valor em address no acumulador

loadaddr address 0002 Carrega o valor no endereço contido em address no acumulador

store address 0003 Copia o acumulador para address

storeaddr address 0004 Copia o acumulador para o valor no endereço contido em address

call valor 0005 Pula para valor e move o endereço atual+2 para a pilha de endereços

ret 0006 Retorna da sub-rotina para o endereço no topo da pilha

go address 0007 Pula para address gozero address 0008 Pula para address se o

acumulador for zerogonotzero address 0009 Pula para address se o

acumulador não for

4

zero goneg address 000A Pula para address se o

acumulador for negativo

add address 000B acc = acc + (valor em address)

sub address 000C acc = acc - (valor em address)

mul address 000D acc = acc * (valor em address)

divide address 000E acc = acc / (valor em address)

mod address 000F acc = acc % (valor em address)

and address 0010 acc = acc & (valor em address)

or address 0011 acc = acc | (valor em address)

zero 0012 acc = 0 not 0013 acc = !acc inc 0014 acc++dec 0015 acc--shr valor 0016 acc = acc >> valor shl valor 0017 acc = acc << valor stop 0018 Pára o programa. input 0019 Lê um byte para o

acumulador inputnum 001A Lê um número para o

acumuladorPush 001B Coloca um número na

pilhaPop 001C Move o topo da pilha

para o acumuladorstacksize 001D Coloca o número de

elementos da pilha no acumulador.

output 001E Escreve um byte do acumulador para a saída

outputnum 001F Escreve uma word na saída

comp address 0020 Se o valor em address for igual ao acumulador, zera o acumulador

zaddr address 0021 Zera o endereço.debug valor 0022 Imprime principais

dados (acc, memória em

5

valor, pc, etc). debugstack 0023 Mostra a pilha do

usuário, com seu tamanho, etc. usado para debugar o processador.

Estas instruções permitem desenvolver o programa da calculadora.

O processador simulado foi desenvolvido em ANSI C, segundo o fluxograma:

2 Sistema operacionalO sistema operacional foi desenvolvido de forma a retomar o controle do processo a cada N instruções. Os motivos de utilizar um número fixo de instruções, em vez de tempo de processamento são os seguintes:

Limitação do processador: sendo o foco da matéria o sistema operacional, o processador desenvolvido é extremamente simples, e não contém interrupções acionadas por timer, que adicionariam dificuldade ao projeto sem trazer benefícios didáticos

Gênero de processamento: sendo um processador simples, seu uso seria em sistemas embedded que tem pouca

6

Abre arquivo contendo o programa

Aplica o parser, decodificando as

instruções

Executa o programa

entrada/saída e não precisam aguardar dados. Considerando-se também que o processador desenvolvido utiliza um clock por instrução, a falta de bloqueio por espera de dado leva à conseqüência de um throughput constante de instruções, e portanto é equivalente a uma interrupção por timer.

Condicionamento da linguagem de simulação: tendo-se usado ANSI C para programar o processador, existem problemas de portabilidade de funções de alarme. O simulador desenvolvido considera o processador de forma realista, não utilizando meandros provenientes do uso de uma linguagem de alto nível para emular características difíceis de programar em baixo nível, como instanciação de objetos para simular o multiprocessamento.

Desta forma, o foco do sistema operacional é chavear os dados dos processos, que incluem:

Salvar o acumulador;

Salvar o PC;

Restaurar o acumulador do próximo processo;

Restaurar o PC do próximo processo.

Os processos foram distribuídos por ár4eas de memória, de forma a uniformizar o acesso e evitar problemas de alocação explícita de memória, que seriam difíceis de serem feitas em linguagem assembly. A memória foi dividida da seguinte maneira:

Área de memória Uso0000-1FFFF Sistema operacional2000-3FFFF Processo 14000-5FFFF Processo 26000-7FFFF Processo 38000-9FFFF Processo 4A000-BFFF Processo 5

7

C000-EFFF Processo 6D000-FFFFF Processo 7

3 Calculadora3.1 Modo de usuárioO modo de usuário é típico do uso de calculadoras, tendo as operações de soma, subtração, multiplicação e divisão.

3.2 Modo programávelO modo programável permite que o usuário entre com seus próprios programas. Foi escolhido um sistema RPN (reverse polish notation) semelhante ao usado em calculadoras HP da série 48/49. Assume-se que os dados foram colocados na pilha durante o modo de usuário.

Os comandos disponíveis são os seguintes:

Mnemônico Significado+ Soma os dois números do topo da pilha.,

apagando-os e colocando o resultado no topo da pilha.

- Subtrai os dois números do topo da pilha., apagando-os e colocando o resultado no topo da pilha.

* Multiplica os dois números do topo da pilha., apagando-os e colocando o resultado no topo da pilha.

/ Divide os dois números do topo da pilha., apagando-os e colocando o resultado no topo da pilha.

% Resto da divisão dos dois números do topo da pilha., apagando-os e colocando o resultado no topo da pilha.

z Coloca no topo da ilha o número de elementos da pilha.

d Duplica o elemento do topo da pilha.s Troca o primeiro elemento da pilha com o

segundo.i Se topo da pilha for zero, termina o programa.A Apaga o elemento do topo da pilha.r Reinicia programa.q Indica término do programa.

8

Exemplos de programas:

Programa Significado+q Soma os dois números no topo

da pilhad*sd*+q Calcula a soma dos quadrados

de dois números+zdd/-iarq Soma todos os números da

pilha.

4 ConclusãoO projeto desenvolvido focou nas propriedades do sistema operacional: sua capacidade de ser multitarefa, alternando entre os processos em tempo real, fazendo time-sharing do processador.

O projeto demandou o desenvolvimento de uma arquitetura de processador, e seu simulador em PC. O desenvolvimento do processador ab initio, sem o conhecimento de todas as características úteis para um sistema operacional multiprocessado levou a algumas dificuldades de projeto e limitações do sistema final. Sugere-se, para o próximo curso, a utilização de uma arquitetura popular — por exemplo, microprocessadores 8051. Existem simuladores gratuitos para essa arquitetura, que permitiriam focar todo o projeto no desenvolvimento do sistema operacional, fornecendo um maior aproveitamento didático.

O sistema operacional desenvolvido foi capaz de alternar os diversos processos

5 Código do Processador#include <stdio.h>#include <stdlib.h>#include <string.h>

9

#include <ctype.h>

enum instruction { acc = 0, load, loadaddr, store, storeaddr, call, ret, go,gozero, gonotzero, goneg, add, sub, mul, divide, mod, and, or, zero,not, inc, dec, shr, shl, stop, input, inputnum, output, outputnum, push, pop, stacksize, comp, zaddr, debug, debugstack, _total_instructions};typedef enum instruction Instruction;

struct {int memoria[1024*16];struct {int stack[128];int level;} stack_addr, stack_user;int acc;unsigned int pc;} data;

static int parse ( char *filename ) {FILE *fp;char buf[256], *p, *s;int i, number = 0, mem = 0;static const struct {Instruction inst;char *mnemonic;} inst_list [_total_instructions] = {{ acc, "acc" },{ load, "load" },{ loadaddr, "loadaddr" },{ store, "store" },{ storeaddr, "storeaddr" },{ call, "call" },{ ret, "ret" },{ go, "go" },{ gozero, "gozero" },{ gonotzero, "gonotzero" },{ goneg, "goneg" },{ add, "add" },{ sub, "sub" },{ mul, "mul" },{ divide, "divide" },{ mod, "mod" },{ and, "and" },{ or, "or" },{ zero, "zero" },{ not, "not" },{ inc, "inc" },{ dec, "dec" },{ shr, "shr" },{ shl, "shl" },{ stop, "stop" },{ input, "input" },{ inputnum, "inputnum" },{ output, "output" },

10

{ outputnum, "outputnum" },{ push, "push" },{ pop, "pop" },{ stacksize, "stacksize" },{ comp, "comp" },{ zaddr, "zaddr" },{ debug, "debug" },{ debugstack, "debugstack" } };

memset(&data, 0, sizeof(data));data.stack_addr.level = -1;data.stack_user.level = -1;fp = fopen(filename, "r");if (!fp) {printf("Arquivo nao achado.\n");return -1;}

do {fgets(buf, 256, fp);if (feof(fp))break;

p = buf;

while (isspace(*p))p++;

if (*p == '#' || *p == '\0') /* comentários ou linha vazia */continue;

if (*p == ':') {mem = atoi(p+1);continue;}if (*p == '.') {int address;p++;if (strcmp(p, "str")) {p += 3;while (isspace(*p)) p++;sscanf(p, "%d", &address);while (isdigit(*p)) p++;while (isspace(*p)) p++;if (*p++ != '\'') {printf("Erro, esperando string, linha %s\n", buf);exit(1);}while (*p != '\'')data.memoria[address++] = *p++;data.memoria[address] = 0;}else if (strcmp(p, "num")) {int number;p += 3;sscanf(p, "%d %d", &address, &number);data.memoria[address] = number;}continue;}

11

/* pega instrucao */p = strtok(buf, " \n");for ( i = 0; i < _total_instructions; i++ )if (!strcmp(p, inst_list[i].mnemonic)) {data.memoria[mem++] = inst_list[i].inst;number++;break;}

if ( i == _total_instructions ) { /* nao achou na lista */printf("Erro: instrucao %d (%s) invalida.\n", mem/2, p);return -1;}

/* pega argumento */if ((p = strtok(NULL, " \n"))) {if (*p == '$')p++;if (*p == '\'')data.memoria[mem] = (int)*(p+1);else if (isdigit(*p))data.memoria[mem] = atoi(p);

}mem++;} while (1);

printf("%d instrucoes lidas.\n", number);return 0;}

static void run ( void ) {int para = 0;int valor;int instrucao;int i;

while (!para) {so++;if (so == 250) { /* retorna para o sistema operacional */so = 0;data.pc = 0;}instrucao = data.memoria[data.pc];valor = data.memoria[data.pc+1];switch (instrucao) { case acc: /* Carrega valor no acumulador. */data.acc = valor;break; case load: /* Carrega o valor em $address no acumulador */data.acc = data.memoria[valor];break; case loadaddr: /* Carrega o valor no endereço contido em

$address no acumulador */data.acc = data.memoria[data.memoria[valor]];break; case store: /* Carrega o valor no acumulador em $address*/data.memoria[valor] = data.acc;break; case storeaddr: /* Carrega o valor no acumulador no endereço

contindo em $address*/

12

data.memoria[data.memoria[valor]] = data.acc;break; case call: /* Pula para valor e move o endereço atual+2 para a

pilha de endereços */data.stack_addr.stack[++data.stack_addr.level] = data.pc+2;data.pc = valor;continue; case ret: /* Retorna da subrotina para o endereço no topo da

pilha */data.pc = data.stack_addr.stack[data.stack_addr.level--];continue; case go: /* Pula para valor */data.pc = valor;continue; case gozero: /* Pula para valor se o acumulador for zero */if (data.acc == 0) {data.pc = valor; continue;}break; case gonotzero: /* Pula para valor se o acumulador não for

zero */if (data.acc) {data.pc = valor; continue;}break; case goneg: /* Pula para valor se o acumulador for negativo */if (data.acc < 0) {data.pc = valor; continue;}break; case add: /* acc = acc + $address */data.acc += data.memoria[valor];break; case sub: /* acc = acc - $address */data.acc -= data.memoria[valor];break; case mul: /* acc = acc * $address */data.acc *= data.memoria[valor];break; case divide: /* acc = acc / $address */data.acc /= data.memoria[valor];break; case mod: /* acc = acc / $address */data.acc %= data.memoria[valor];break; case and: /* acc = acc & $address */data.acc &= data.memoria[valor];break; case or: /* acc = acc | $address */data.acc |= data.memoria[valor];break; case zero: /* acc = 0 */data.acc = 0;break; case not: /* acc = !acc */data.acc = !data.acc;break;

13

case inc: /* acc++ */data.acc++;break; case dec: /* acc-- */data.acc--;break; case shr: /* acc = acc >> valor */data.acc >>= valor;break; case shl: /* acc = acc << valor */data.acc <<= valor;break; case stop: /* Para o programa. */para++;break; case input: /* Le um byte para o acumulador */while ((data.acc = fgetc(stdin)) == '\n');break; case inputnum: /* Le um numero para o acumulador */scanf("%d", &data.acc);break; case push: /* Push p/ a stack do usuário */data.stack_user.stack[++data.stack_user.level] = data.acc;break; case pop: /* Pop p/ a stack do usuário */if (data.stack_user.level > -1)data.acc = data.stack_user.stack[data.stack_user.level--];else {printf("Erro [pc=%d], stack vazia\n", data.pc);}break; case stacksize:data.acc = data.stack_user.level+1;break; case output: /* Escreve um byte do acumulador para a saida */putchar((char)data.acc);break; case outputnum: /* Escreve um inteiro do acumulador para a

saida */printf("%d\n", data.acc);break; case comp:if (valor == data.acc)data.acc = 0;break; case zaddr:data.memoria[valor] = 0;break; case debugstack:printf("Pilha [%d]:\n", data.stack_user.level);for (i = data.stack_user.level; i > -1; i--)printf("\t%d\n", data.stack_user.stack[i]);break; case debug: /* mostra principais dados e valor da memoria */printf("Acc = %d, pc = %d, mem[%d]= %d|%d, stack level = %d\n",data.acc, data.pc, valor, data.memoria[valor],data.memoria[valor+1], data.stack_addr.level);

break;}data.pc += 2;

14

}}

int main (int argc, char **argv) {FILE *fp;Instruction inst;int value;

if (argc < 2) {printf("Forneca o nome do arquivo do programa.\n");return 1;}

if (parse(argv[1])) {printf("Erro durante a leitura do programa.\n");return 2;}run();return 0;}

CÓDIGO DA CALCULADORA#*******************************************************************************# PCS 553 - Sistemas Operacionais - Projeto 2002 - Primeira Parte# Calculadora Programável ## Autores: Alexander Cerqueira Silva nUSP 2984089# Bruno Barberi Gnecco nUSP 2968998## Dados: 01/05/2002#*******************************************************************************

# Observações:# Devido o número de instruções reduzido, o programa foi construido da forma # objetiva, concisa e clara. Para tanto foi simplificado a interface com o # usuário.# A memória está dividida em três partes, Dados e Código Calculadora, Programa # Usuário para facilitar a programcao.# A documentação está feita durante o desenvolvimento do código.# O código esta dividido em duas grandes parte: Modos Programação e Execução

# Definicao das constantes - Dados #******************************************************************************

.str 10000 ' \n Escolha modo de operação (Execução(e) ou Programação(p):' .str 10050 ' \n Primeiro operando: ' .str 10100 ' \n Segundo operando: '.str 10150 ' \n Resultado =' .str 10200' \n Entre com a opcao desejada: Soma(+), Subracao(-),

Multiplicação(*), Divisão(/)'.str 10450 ' \n Fim '.str 10500 ' \n Modo Execução '.str 10550 ' \n Modo Programação '

.str 10600 ' \n PCS 553 - Sistemas Operacionais '

.str 10650 ' \n Projeto 2002 - Primeira Parte '

.str 10700 ' \n Calculadora Programável '

.str 10750 ' \n Para sai (q) ' # Código############################################################################### #******************************************************************************# Fuções Auxiliares#******************************************************************************

15

#Mostra String - O parametro é o endereço inicio da string, passado pelo acc:01000store 11000 # O endereco 11000 é R1

loadaddr 11000outputcomp 0gozero01050load 11000incgo 01000:01050ret

#****************************************************************************** # PROGRAMA PRINCIPAL#****************************************************************************** :0000 # Montando tela do programaacc 10600 # Cabeçalhocall 01000 # Subrotina Mostra Stringacc 10650call 01000acc 10750

call 01000 acc 10700call 01000

acc 10000call 01000

input # Le opcao de modocomp 'e' # Modo execuçãocall 2000 # Subrotina Calculacomp 'p' # Modo Programaçãocall 5000 # Subrotina Programastop #*******************************************************************************# Subrotina Calcula#******************************************************************************* # São usados registradores auxiliares nos endereços:# R1 = 11000# R2 = 11050# R3 = 11100# R4 = 11150# R5 = 11200

:02000acc 10500 # Mostra o modo de operacao (Execução)call 01000acc 10050 # Pede primeiro operandocall 01000inputstore 11050 # Guarda operando 1 em R2

acc 10050 # Pede sesgundo operandocall 01000input # Guarda operando 2 em ACCstore 11200 # Coloca opreando 2 em R5 acc 10000 # Pede a operação desejadacall 01000input 10100 # Guarda tipo de operacao em R3

# Abaixo está implementado o switch

:02100 # Switch

comp '+'gonotzero 02120

call 02300 # Somago 02200 # Exibe Resultado

:02120comp '-'gonotzero 02140call 02400 # Subtracaogo 02200 # Exibe Resultado :02140comp '*'gonotzero 02160call 02500 # Multiplicaçãogo 02200 # Exibe Resultado :02160

16

comp '/'gonotzero 02160call 02600 # Divisãogo 02200 # Exibe Resultado

#*******************************************************************************# Subrotina Exibe Resultado #*******************************************************************************

:02200 # Subrotina Exibe Resultadoacc 10150call 01000output11150 # Exibe resultado armazenado no R3go 00000 # Volta para rotina Programa Principal

#*******************************************************************************# Subrotina Soma#*******************************************************************************

:02300load 11050 # Coloca operando 1 em ACCadd 11200 # Soma ACC + R2store 11100 # Guarda resultado em R3

ret # Volta para o switch de operações

#*******************************************************************************# Subrotina Subtracao#******************************************************************************* :02400load 11050 # Coloca operando 1 em ACCsub 11200 # Soma ACC - R2store 11100 # Guarda resultado em R3

ret # Volta para o switch de operações

#*******************************************************************************# Subrotina Multiplicacao#*******************************************************************************

:02500 # Não trata overflowload 11050 # Coloca operando 1 em ACCmul 11200 # Soma ACC * R2store 11100 # Guarda resultado em R3

ret # Volta para o switch de operações

#*******************************************************************************# Subrotina Divide#*******************************************************************************

:02600load 11050 # Coloca operando 1 em ACCdiv 11200 # Soma ACC + R2store 11100 # Guarda resultado em R3

ret # Volta para o switch de operações

#*******************************************************************************# Rotina do Modo Programação#*******************************************************************************

:5000 # Inicio da área para programa usuário

# Observasões:# Dados da programacao # [13000] contador# [13001] variavel temporaria# [13003] endereco da string para ser mostrada# [13100 - ] programa do usuario

# Definicao das constanstes - Dados #******************************************************************************

.str 14000 'Digite programa:'

.str 14100 'Pilha:'

# Código############################################################################### acc 10550 # Mostra o modo de operacao (Programacao)

17

call 01000

#*****************************************************************************#Rotina Programacao da calculadora#******************************************************************************

#******************************************************************************# Subrotinas Auxiliares#******************************************************************************

acc 14000store 13003call 7000# Inicializa dadosacc 13100store 13000go 5020

:5020 # adquire e armazena programainputcomp 'q' # se q, fim do programagozero5050storeaddr 13000 # caso contrario, pega proximo comandoload 13000incstore 13000go 5020

:5050acc 113 # coloca q no finalstoreaddr 13000call 5100ret

# mostra string:7000loadaddr 13003outputcomp 0gozero7030load 13003incstore 13003go 7000

:7030 # imprime cracc 10outputret

#*****************************************************************************# Subrotina Executa Programa Usuário#*****************************************************************************

:5100# primeira instrucaoacc 13100store 13000loadaddr 13000go 5110

# checa se e' +:5110comp '+'gonotzero 5120call 6000go 5300

# checa se e' -:5120comp '-'gonotzero 5130call 6050go 5300

18

# checa se e' *:5130comp '*'gonotzero 5140call 6100go 5300

# checa se e' /:5140comp '/'gonotzero 5150call 6150go 5300

# checa se e' d (Duplica topo da pilha):5150comp 'd'gonotzero 5160call 6200go 5300

# checa se e' s (Swap dos dois primeiros valores da pilha):5160comp 's'gonotzero 5170call 6250go 5300

# checa se e' z (stack siZe):5170comp 'z'gonotzero 5180call 6300go 5300

# checa se e' a (Apaga topo da pilha):5180comp 'a'gonotzero 5190call 6350go 5300

# checa se e' i (se topo da pilha for zero, termina):5190comp 'i'gonotzero 5200call 6400gozero5274go 5300

# checa se e' r (reinicia programa):5200comp 'r'gonotzero 5210debugstackgo 5100

# checa se e' %:5210comp '%'gonotzero 5270call 6450go 5300

# checa se e' q (acabou o programa):5270comp 'q'gonotzero 5300 # ignora comando

# fim das operacoes

# mostra mensagem

acc 14100store 13003call 7000go 5286

19

# mostra pilha:5286stacksizegozero5298popoutputnumgo 5286

:5298ret

#*************************************************************************# Subrotina Busca Proxima Instrucao**************************************************************************

:5300load 13000incstore 13000loadaddr 13000

go 5110

#*************************************************************************# Subrotina Soma os dois numeros no topo da pilha#*************************************************************************

:6000popstore 13001popadd 13001push

ret

#*************************************************************************# Subrotina Subtrai os dois numeros no topo da pilha#*************************************************************************

:6050popstore 13001popstore 13002load 13001sub 13002push

ret

#*************************************************************************# Subrotina Multiplica os dois numeros no topo da pilha#*************************************************************************

:6100popstore 13001popmul 13001push

ret

#*************************************************************************# Subrotina Divide os dois numeros no topo da pilha#************************************************************************* :6150popstore 13001popstore 13002load 13001divide13002push

ret

#*************************************************************************# Subrotina Duplica o topo da pilha#*************************************************************************

20

:6200poppushpush

ret#*************************************************************************# Subrotina Swap#*************************************************************************

:6250popstore 13001popstore 13002load 13001pushload 13002push

ret

#*************************************************************************# Subrotina Tamanho do stack#*************************************************************************

:6300stacksizepush

ret

#*************************************************************************# Sub Rotina Apaga topo da pilha#*************************************************************************

:6350popret

#*************************************************************************# Subrotina Verifica Fim do Programa# se topo da pilha for zero, termina o programa#*************************************************************************

:6400poppushgonotzero 6420acc 0ret

:6420acc 1ret

#*************************************************************************# Subrotina Resto da divisao de dois numeros#*************************************************************************

:6450popstore 13001popstore 13002load 13001mod 13002pushret

21