Skip to content

MARS_GUIDE.md

Latest commit

 

History

History
200 lines (148 loc) · 5.94 KB

MARS_GUIDE.md

File metadata and controls

200 lines (148 loc) · 5.94 KB
Raw

Guia de uso — MARS / RARS / perf

Arquivos entregues

  • vm_dispatch_compare.asm — comparador principal em MIPS Assembly para MARS
  • vm_dispatch_compare.c — benchmark complementar em C para perf stat

O que o ASM faz

  • Executa as duas arquiteturas no mesmo arquivo:
    • switch_dispatch: cadeia centralizada de beq
    • thread_dispatch: jump table + jr
  • Faz dois passes de demo:
    • uma passada curta do switch
    • uma passada curta do threading
  • Faz o benchmark real com ITERATIONS = 1000
  • Imprime:
    • enderecos de loops, handlers, pilha virtual e jump table
    • contagem de bytecodes executados ($s7)
    • contagem de branches de dispatch ($s6)
    • resultado funcional final (vm_mem[0] e topo da pilha)

Guia de apresentacao no MARS

1. Abrir e montar

  1. Abra vm_dispatch_compare.asm
  2. Use Run -> Assemble
  3. Confirme que Delayed branching esta desabilitado para a demonstracao ficar visualmente limpa

2. Mostrar o layout de memoria

  1. Execute o programa uma vez com Go
  2. Observe no console:
    • Base da pilha virtual
    • Base da memoria virtual
    • Switch dispatch loop
    • Base da jump table
    • thread_table[0..5] slot
    • enderecos dos handlers
  3. Abra o painel Data Segment
  4. Localize thread_table e mostre que as entradas ficam lado a lado em memoria

3. Demo visual do switch dispatch

  1. Reinicie (Run -> Reset)
  2. Coloque breakpoint em switch_dispatch
  3. Use Step / F7
  4. Mostre o fluxo para um opcode simples:
    • PUSH: o PC chega em switch_dispatch, passa pelo primeiro beq e entra no handler
    • ADD: o PC passa por mais comparacoes antes de chegar ao handler
    • STORE e HALT: o PC atravessa ainda mais comparacoes
  5. No painel Registers, destaque:
    • $s7: sobe 1 por bytecode interpretado
    • $s6: sobe a cada comparacao do dispatch

4. Demo visual do direct threading

  1. Reinicie (Run -> Reset)
  2. Coloque breakpoint em thread_dispatch
  3. Use Step / F7
  4. Mostre o fluxo:
    • fetch do opcode
    • indexacao em thread_table
    • jr diretamente para o handler
  5. Compare com o switch:
    • o PC nao percorre uma cadeia de beq
    • o dispatch distribuido volta para thread_dispatch depois de cada handler

5. Instruction Counter do MARS

  1. Abra Tools -> Instruction Counter
  2. Resete o contador
  3. Coloque breakpoints em:
    • switch_benchmark_start
    • switch_benchmark_end
    • thread_benchmark_start
    • thread_benchmark_end
  4. Rode ate switch_benchmark_start, zere o contador e continue ate switch_benchmark_end
  5. Anote o total de instrucoes MIPS
  6. Repita para thread_benchmark_start -> thread_benchmark_end

Leitura correta para a defesa:

  • o contador do MARS mede instrucoes MIPS simuladas, nao branch miss real
  • ele serve para mostrar o formato do fluxo de controle
  • a tese de equivalencia pratica em CPU moderna deve ser sustentada com o binario C e perf

Roteiro no RARS

Este ASM foi escrito para MIPS/MARS. Se voce portar a ideia para RISC-V/RARS:

  • use o painel Execution Statistics
  • compare principalmente:
    • instructions
    • instrucoes de branch/jump
  • use o painel Memory para mostrar a jump table e a pilha virtual

O dado mais forte no RARS continua sendo estrutural: menos branches no threading. O argumento completo ainda depende de medir CPU real com perf.

Relatorio estatico esperado do ASM

Programa de teste por iteracao:

PUSH 10 / PUSH 20 / ADD / PUSH 5 / SUB / STORE 0 / LOAD 0 / HALT

Total de bytecodes por iteracao: 8

Custo de dispatch por opcode no switch

Com a ordem de comparacao PUSH, ADD, SUB, LOAD, STORE, HALT:

Opcode Comparacoes no switch
PUSH 1
ADD 2
SUB 3
LOAD 4
STORE 5
HALT 6

Para a sequencia usada:

  • PUSH 10 -> 1
  • PUSH 20 -> 1
  • ADD -> 2
  • PUSH 5 -> 1
  • SUB -> 3
  • STORE -> 5
  • LOAD -> 4
  • HALT -> 6

Total por iteracao no switch: 23 branches de dispatch

Total por iteracao no threading: 8 branches de dispatch

Benchmark com ITERATIONS = 1000

Metrica Switch Threading Delta
Bytecodes executados 8000 8000 0
Branches de dispatch 23000 8000 15000
Resultado final vm_mem[0] 25 25 0
Topo final da pilha 25 25 0

Leitura correta desses numeros

  • o threading claramente usa menos branches no ponto de dispatch
  • isso prova diferenca estrutural
  • isso nao prova, por si so, um ganho material de tempo em CPU moderna
  • a sua tese entra aqui: com ISA minima, o ganho pratico tende a encolher; se o tempo final empata, o switch vence por engenharia

Benchmark em C com perf stat

Compilar

Switch:

gcc -O3 -std=gnu11 -fno-jump-tables -DSWITCH vm_dispatch_compare.c -o vm_switch

Threading:

gcc -O3 -std=gnu11 -DTHREADING vm_dispatch_compare.c -o vm_threading

Se quiser uma execucao curta para sanity check:

gcc -O3 -std=gnu11 -fno-jump-tables -DSWITCH -DITERATIONS=1000 vm_dispatch_compare.c -o vm_switch
gcc -O3 -std=gnu11 -DTHREADING -DITERATIONS=1000 vm_dispatch_compare.c -o vm_threading

Medir

perf stat -r 5 -e instructions,branches,branch-misses ./vm_switch
perf stat -r 5 -e instructions,branches,branch-misses ./vm_threading

O que defender

  • branches: tende a cair no threading
  • branch-misses: em hardware moderno pode nao cair de forma dramatica
  • instructions: pode ficar proximo
  • se tempo total e miss rate ficarem proximos, sua conclusao fica defensavel:
    • para ISA pequena, a vantagem do threading nao se converte em ganho relevante
    • portanto switch e a opcao melhor de engenharia por portabilidade e simplicidade

Validacao recomendada

No caso do binario SWITCH, inspecione rapidamente o assembly gerado para confirmar que o compilador nao transformou o switch em jump table:

objdump -d ./vm_switch | less

Se o compilador ainda gerar um lowering que descaracterize a comparacao, reduza a otimizacao para -O2 e reinspecione.