Implementar na forma de simulação o funcionamento do pipeline em um sistema computacional. Exemplos: Fig. 1 e Fig.2.
Deverá conter UCP; fila com “n instruções”; possibilidade de criação de novas instruções; divisão de um pipeline em 7 tarefas diferentes; contador de tempo das instruções.
Após a implementação, faça um relato sobre: às dificuldades encontradas; como o a técnica de pipeline auxilia na concorrência de um sistema computacional.
Observações: utilize uma linguagem de programação de sua preferência. As principais linhas codificadas devem possuir comentários. O código deverá ser apresentado ao professor da disciplina.
Figura1: slide 05 – Aula 07.
Figura 2: slide 08 – Aula 07.
Cole o código do desafio proposto no comentário.
ANDRÉ PRZYBYSZ 
#include <stdio.h>
int main() {
int processos, n;
char *etapas[] = {“Buscando”, “Decodificando”, “Computando”, “Compactando”, “Fazendo Backup”, “Enviando”, “Concluido”};
}
CurtirCurtir
Arthur Henrique Caron – RA 2564297
Link para código e relatório: https://drive.google.com/drive/folders/1Bg8ulq84JrFUmcmn4-P77j8uypustJ_K?usp=drive_link
CurtirCurtir
#include <stdio.h>
#include <string.h>
char tarefa[7][20];
void declaracao_das_tarefas(void){
strcpy(tarefa[0],”Busca”);
strcpy(tarefa[1],”Decodificação”);
strcpy(tarefa[2],”Calculando”);
strcpy(tarefa[3],”Execução”);
strcpy(tarefa[4],”Memória”);
strcpy(tarefa[5],”Saída”);
strcpy(tarefa[6],”Conclusão”);
}
int main(){
declaracao_das_tarefas();
int qtd_intruçoes; //quantidade de instruções
int matriz[100][100];
int i, j;
int x;
}
CurtirCurtir
#include <stdio.h>
// EXEMPLOS DE 7 TAREFAS A SEREM REALIZADAS (em sequencia)
void Tarefa_1(void){
// ex: ler
printf(“| Neste tempo o programa está lendo…\n”);
}
void Tarefa_2(void){
// ex: interpretar
printf(“| Neste tempo o programa esta interpretando os dados recebidos…\n”);
}
void Tarefa_3(void){
// ex: deduzir
printf(“| Neste tempo o programa está deduzindo um método apropriado…\n”);
}
void Tarefa_4(void){
// ex: calcular
printf(“| Neste tempo o programa está calculando com base nos dados e no método…\n”);
}
void Tarefa_5(void){
// ex :verificar
printf(“| Neste tempo o programa está verificando…\n”);
}
void Tarefa_6(void){
// ex: comparar
printf(“| Neste tempo o programa está comparando os resultados…\n”);
}
void Tarefa_7(void){
// ex: apresentar
printf(“| Neste tempo o programa está apresetando os resultados ao usuário…\n”);
}
//FUNCOES
void funcao_tipo1(void){
Tarefa_1();
}
void funcao_tipo2(void){
Tarefa_2();
Tarefa_1();
}
void funcao_tipo3(void){
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo4(void){
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo5(void){
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo6(void){
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo7(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo8(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
}
void funcao_tipo9(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
}
void funcao_tipo10(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
}
void funcao_tipo11(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
}
void funcao_tipo12(void){
Tarefa_7();
Tarefa_6();
}
void funcao_tipo13(void){
Tarefa_7();
}
//FUNCAO PRINCIPAL
int main()
{
int contador_tempo;
int num;
int a;
printf(” Digite o número de instrucoes que deseja executar: “);
scanf(“%d”,&num);
a=num-7;
if(num>6){
//TEMPO 1:
contador_tempo++;
printf(“__________________________________________________________”);
printf(“\n| TEMPO: %d\n”,contador_tempo);
funcao_tipo1();
}
1 – Faça um relato sobre: às dificuldades encontradas; como o a técnica de pipeline auxilia na concorrência de um sistema computacional.
RELATÓRIO:
São duas principais dificuldades encontradas. A primeira é que a linguagem C executa os comandos de linha em linha, então mesmo que várias tarefas estejam sendo chamadas simultaneamente no meu programa, de qualquer jeito elas serão executadas uma por uma. Portanto, o programa feito é um protótipo de Pipeline, mas para realmente servir como um, precisariam existir mais máquinas operando simultaneamente, aí cada “função” seria executada em uma máquina diferente, no tempo certo, visto que nenhuma tarefa se repete no mesmo instante de tempo.
A segunda dificuldade é que eu só consegui projetar um programa que servisse apenas para um número grande de “instruções”, no caso um número maior que 6. Ou seja, caso o usuário deseje repetir poucas “instruções”, o programa não irá rodar.
CurtirCurtir
#include
#include <stdio.h>
//variável global
int continuar = 1;
int qntd = 0;
//protótipo de função
void apresentarPipeline();
void apresentarSemPipeline();
void menu();
void novaInstrucao();
//funções
void menu(){
int operacao = 0;
printf(“\n(1) Sistema computacional com Pipeline\n(2) Sistema computacional sem Pipeline\n(3) Inserir nova instrução\nInsira a opção que você deseja visualizar…:”);
scanf(“%d”, &operacao);
}
void novaInstrucao(){
char confirmar;
printf(“Se você deseja inserir uma nova instrução digite S, se não quiser digite N…:”);
getchar();
scanf(“%c”, &confirmar);
if(confirmar == ‘S’){
if(qntd == 0){
apresentarPipeline();
printf(“\nInstrução 5: | | | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7| |\n”);
qntd++;
}else if(qntd == 1){
apresentarPipeline();
printf(“\nInstrução 5: | | | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7| |”);
printf(“\nInstrução 6: | | | | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7|\n”);
qntd++;
}else if(qntd == 2){
printf(“\nQuantidade máxima de instruções atingidas, tente novamente mais tarde!\n”);
}
}
}
void apresentarPipeline(){
printf(“\n | Tempo 1| Tempo 2| Tempo 3| Tempo 4| Tempo 5| Tempo 6| Tempo 7| Tempo 8| Tempo 9|Tempo 10|Tempo 11|Tempo 12|”);
printf(“\n ————————————————————————————————————-“);
printf(“\nInstrução 1: |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7| | | | | |”);
printf(“\nInstrução 2: | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7| | | | |”);
printf(“\nInstrução 3: | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7| | | |”);
printf(“\nInstrução 4: | | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|tarefa 5|tarefa 6|tarefa 7| | |”);
}
void apresentarSemPipeline(){
printf(“\n | Tempo 1| Tempo 2| Tempo 3| Tempo 4| Tempo 5| Tempo 6| Tempo 7| Tempo 8| Tempo 9|Tempo 10|Tempo 11|Tempo 12|”);
printf(“\n ————————————————————————————————————-“);
printf(“\nInstrução 1: |tarefa 1|tarefa 2|tarefa 3|tarefa 4| | | | | | | | |”);
printf(“\nInstrução 2: | | | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4| | | | |”);
printf(“\nInstrução 3: | | | | | | | | |tarefa 1|tarefa 2|tarefa 3|tarefa 4|”);
}
//função Principal
int main(){
}
CurtirCurtir
import threading
import time
def pipe1():
for i in range(5):
print(“pipe 1 – ” + str(i))
time.sleep(1)
def pipe2():
for i in range(5):
print(” pipe 2 – ” + str(i))
time.sleep(1)
def pipe3():
for i in range(5):
print(” pipe 3 – ” + str(i))
time.sleep(1)
def pipe4():
for i in range(5):
print(” pipe 4 – ” + str(i))
time.sleep(1)
def pipe5():
for i in range(5):
print(” pipe 5 – ” + str(i))
time.sleep(1)
def pipe6():
for i in range(5):
print(” pipe 6 – ” + str(i))
time.sleep(1)
def pipe7():
for i in range(5):
print(” pipe 7 – ” + str(i))
time.sleep(1)
if name ==”main“:
pipe_line1 = threading.Thread(target=pipe1)
pipe_line2 = threading.Thread(target=pipe2)
pipe_line3 = threading.Thread(target=pipe3)
pipe_line4 = threading.Thread(target=pipe4)
pipe_line5 = threading.Thread(target=pipe5)
pipe_line6 = threading.Thread(target=pipe6)
pipe_line7 = threading.Thread(target=pipe7)
CurtirCurtir
#include <stdio.h>
#include <string.h>
#include <locale.h>
// Matriz para armazenar as tarefas
char tarefa[7][20];
// Função para inicializar as tarefas na matriz
void declaracao_das_tarefas(void) {
strcpy(tarefa[0], “Busca”);
strcpy(tarefa[1], “Decodificação”);
strcpy(tarefa[2], “Calculando”);
strcpy(tarefa[3], “Execução”);
strcpy(tarefa[4], “Memória”);
strcpy(tarefa[5], “Saída”);
strcpy(tarefa[6], “Conclusão”);
}
int main() {
// Configuração da localização para lidar com caracteres acentuados
setlocale(LC_ALL, “Portuguese”);
}
Relato sobre as Dificuldades Encontradas:
Durante o desenvolvimento do programa simulando um pipeline de execução, encontraram-se desafios significativos. A manipulação da matriz para representar o pipeline exigiu atenção especial na inicialização e preenchimento adequado. Garantir uma apresentação clara da matriz e da lista de instruções, juntamente com a legenda, foi outro aspecto crucial, demandando uma formatação cuidadosa para facilitar a compreensão do usuário.
Importância da Técnica de Pipeline na Concorrência de um Sistema Computacional:
A técnica de pipeline desempenha um papel crucial na melhoria da eficiência de sistemas computacionais, especialmente em ambientes concorrentes. Permite o aproveitamento eficiente de recursos, a redução do tempo de execução ao possibilitar a sobreposição de operações, o aumento da taxa de instruções por ciclo (IPC) e o suporte à execução concorrente de tarefas. Em ambientes multicore, a técnica escala de maneira eficaz, tornando-se fundamental para lidar com a demanda crescente por processamento paralelo em sistemas computacionais modernos.
CurtirCurtir
#include
#include <stdlib.h>
//declaração de variáveis:
int pipe[5][16]; // vetor que mostra uma simulação de pipeline em formato de processo(linha) por tempo(coluna)
int a1, b1, c1, d1; // números que o usuário quer processar
//declaração das funções:
void scan(); // lê os números digitados pelo usuário
void mostrar(int coluna); // mostra o vetor “pipe” até a coluna atual
void def(); // coloca os valores digitados pelo usuário no vetor
int main (){
}
void scan(){
printf(“digite o primeiro numero: “); // pede um número
scanf(“%d”, &a1); // lê o número digitado
printf(“digite o segundo numero: “);
scanf(“%d”, &b1);
printf(“digite o terceiro numero: “);
scanf(“%d”, &c1);
printf(“digite o quarto numero: “);
scanf(“%d”, &d1);
}
void mostrar(int coluna){
}
void def(){
}
Pipeline é uma técnica utilizada para melhorar a eficiência na execução de instruções, o que resulta em mais processos executados por tempo. Essa técnica consiste em fazer a máquina processar diversos dados ao mesmo tempo, ou seja, sem esperar um processo acabar para só então começar outro.
A linguagem de programação utilizada foi C. Em C, cada linha é executada em sequência, da primeira até a última. Tendo em vista essa limitação, não foi possível desenvolver um código que de fato realizasse diversos processos ao mesmo tempo. O código apresentado, portanto, é apenas uma simulação de como o pipeline funciona.
O código conta com uma matriz de processo (linha) por período de tempo (coluna) que mostra, a cada “Enter” do usuário, novas informações, decorrentes do processamento dos dados fornecidos previamente pelo usuário. O código funciona da seguinte forma: primeiramente lê-se quatro números. Depois, toda vez que o usuário pressionar uma tecla qualquer, será incrementado 1 aos números das linhas 1 e 2 da matriz e serão multiplicados por 2 os números das linhas 3 e 4 da matriz. Entretanto, os resultados dessas operações são mostrados na coluna que vem imediatamente após àquela de onde os dados foram inicialmente obtidos para a efetuação da operação. Ou seja, toda vez que uma tecla for pressionada ter-se-á uma nova coluna com novos números, estes decorrentes dos números da coluna anterior mais uma operação matemática. Sendo que a coluna inicial é definida pelo usuário.
Assim, cada linha da matriz é como um processo diferente que, devido a rapidez do computador em atualizar essa matriz, aparentam ser executados todos ao mesmo tempo, qual seja a proposta do pipeline, porém simulada e não definitivamente precisa.
CurtirCurtir
#include
#include
#define tam 100
int fazAlgo(int a[], int min, int max) {
int pivo = min;
int comp = max;
int aux;
}
void particao(int a[], int min, int max) {
if (min < max) {
int pivo = fazAlgo(a, min, max);
}
void apresentar(int a[], int min, int max) {
printf(“\n”);
for (int i = min; i <= max; i++)
printf(“%d, “, a[i]);
printf(“\n”);
}
int main() {
}
Tive dificuldade até conseguir fazer ele executar duas tarefas ao mesmo tempo, após conseguir isso utilizando os threads consegui fazer esse código de quicksort que rodava sequencialmente agora executar paralelamente
CurtirCurtir
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
void *pipeline1(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 1 – %d\n”, i);
sleep(1);
}
return NULL;
}
void *pipeline2(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 2 – %d\n”, i);
sleep(1);
}
return NULL;
}
void *pipeline3(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 3 – %d\n”, i);
sleep(1);
}
return NULL;
}
void *pipeline4(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 4 – %d\n”, i);
sleep(1);
}
return NULL;
}
void *pipeline5(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 5 – %d\n”, i);
sleep(1);
}
return NULL;
}
void *pipeline6(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 6 – %d\n”, i);
sleep(1);
}
return NULL;
}
void *pipeline7(void *arg) {
for (int i = 0; i < 5; i++) {
printf(“pipeline 7 – %d\n”, i);
sleep(1);
}
return NULL;
}
int main() {
pthread_t thread1, thread2, thread3, thread4, thread5, thread6, thread7;
}
CurtirCurtir
import threading
import time
Funções para as threads
def func1():
for i in range(5):
print(“pipeline 1 -“, i)
time.sleep(1)
def func2():
for i in range(5):
print(“pipeline 2 -“, i)
time.sleep(1)
def func3():
for i in range(5):
print(“pipeline 3 -“, i)
time.sleep(1)
def func4():
for i in range(5):
print(“pipeline 4 -“, i)
time.sleep(1)
def func5():
for i in range(5):
print(“pipeline 5 -“, i)
time.sleep(1)
def func6():
for i in range(5):
print(“pipeline 6 -“, i)
time.sleep(1)
def func7():
for i in range(5):
print(“pipeline 7 -“, i)
time.sleep(1)
if name == “main“:
Criação de objetos das threads para cada função
Iniciando cada thread com um atraso de 1 segundo
Aguardando cada thread finalizar
CurtirCurtir
//George Oliveira (2312557)
#include <stdlib.h>
#include <stdio.h>
void tarefa(int qtd){
int lav=1; //lavagem
int mol=0; //molho
int enx=-1; //enxague
int cen=-2; //centrifuga
int sec=-3; //secagem
int pas=-4; //passagem a ferro
int dob=-5; //dobragem
int i=1;
for(i=1; i<qtd+7; i++){
printf(“— %dº Ciclo —\n”,i);
if(lav>0 && lav<=qtd) printf(“Lavagem [%d]\n”,lav);
if(mol>0 && mol<=qtd) printf(“Molho [%d]\n”,mol);
if(enx>0 && enx<=qtd) printf(“Enxague [%d]\n”,enx);
if(cen>0 && cen<=qtd) printf(“Centrifuga [%d]\n”,cen);
if(sec>0 && sec<=qtd) printf(“Secando [%d]\n”,sec);
if(pas>0 && pas<=qtd) printf(“Passando [%d]\n”,pas);
if(dob>0 && dob<=qtd) printf(“Dobrando [%d]\n”,dob);
lav++;
mol++;
enx++;
cen++;
sec++;
pas++;
dob++;
}
printf(“\nTODOS OS PROCESSOS FINALIZADOS EM %d CICLOS\n\n”,i-1);
}
int main(int argc, char** argv){
int qtd;
printf(“\nDigite a quantidade de instrucoes a serem simuladas: “);
scanf(“%d”,&qtd);
tarefa(qtd);
return 0;
}
CurtirCurtir
Nome: Andrei Rezende Ono
RA: 2143038
Implementação em python
Representa uma instrução no simulador do pipeline
class Instrucao:
def init(self, operacao, operandos):
self.operacao = operacao
self.operandos = operandos
self.tempo = 0 # Contador de tempo da instrução
Simula o processamento de uma instrução em cada estágio do pipeline, chamando o método executar_estagio
para cada estágio.
class Pipeline:
def init(self):
self.estagios = [‘Busca’, ‘Decodificacao’, ‘Execucao’, ‘AcessoMemoria’, ‘EscritaDeVolta’]
self.instrucao_atual = None
self.tempo_total = 0
Representa a Unidade Central de Processamento. Os métodos adicionar_instrucao e executar_pipeline
são utilizados para adicionar instruções à fila e executar o pipeline, respectivamente.
class UCP:
def init(self):
self.pipeline = Pipeline()
self.fila_instrucoes = []
Exemplo de UCP com pipeline
ucp = UCP()
Adiciona algumas instruções à fila
ucp.adicionar_instrucao(Instrucao(‘ADD’, [‘R1’, ‘R2’, ‘R3’]))
ucp.adicionar_instrucao(Instrucao(‘SUB’, [‘R4’, ‘R1’, ‘R5’]))
ucp.adicionar_instrucao(Instrucao(‘LOAD’, [‘R6’, ‘Endereco’]))
Executa o pipeline
ucp.executar_pipeline()
CurtirCurtir
#include <stdio.h>
#include <string.h>
#include <locale.h>
// Matriz para armazenar as tarefas
char tarefa[7][20];
// Função para inicializar as tarefas na matriz
void declaracao_das_tarefas(void) {
strcpy(tarefa[0], “Busca”);
strcpy(tarefa[1], “Decodificação”);
strcpy(tarefa[2], “Calculando”);
strcpy(tarefa[3], “Execução”);
strcpy(tarefa[4], “Memória”);
strcpy(tarefa[5], “Saída”);
strcpy(tarefa[6], “Conclusão”);
}
int main() {
// Configuração da localização para lidar com caracteres acentuados
setlocale(LC_ALL, “Portuguese”);
// Chamada para inicializar as tarefas
declaracao_das_tarefas();
// Declaração de variáveis
int qtd_instrucoes;
int matriz[100][100];
int i, j;
int x;
// Solicita ao usuário que insira a quantidade de execuções
printf(“Digite a quantidade de execuções: “);
scanf(“%d”, &qtd_instrucoes);
// Inicializa a matriz com 0 abaixo da diagonal principal
for (i = 0; i < qtd_instrucoes; i++) {
for (j = 0; j < 6 + qtd_instrucoes; j++) {
if (i > j) {
matriz[i][j] = 0;
}
}
}
// Preenche a matriz para simular um pipeline
for (i = 0; i < qtd_instrucoes; i++) {
for (j = 0; j < 6 + qtd_instrucoes; j++) {
if (i == j) {
matriz[i][j] = 1;
matriz[i][j + 1] = 2;
matriz[i][j + 2] = 3;
matriz[i][j + 3] = 4;
matriz[i][j + 4] = 5;
matriz[i][j + 5] = 6;
matriz[i][j + 6] = 7;
}
}
}
// Solicita ao usuário que escolha entre visualizar a matriz ou a lista
printf(“- Visualização – \n1 – matriz\n2 – lista\n”);
scanf(“%d”, &x);
// Exibe a matriz ou a lista com base na escolha do usuário
if (x == 1) {
// Exibe a matriz
printf(“\nMatriz de Instruções:\n”);
for (i = 0; i < qtd_instrucoes; i++) {
printf(“\nInstrução %-2d |”, i + 1);
for (j = 0; j < 6 + qtd_instrucoes; j++) {
printf(“%d “, matriz[i][j]);
}
}
// LEGENDA
printf(“\n+——————–+”);
printf(“\n| %-19s|”, “1-Busca”);
printf(“\n| %-21s|”, “2-Decodificação”);
printf(“\n| %-19s|”, “3-Calculando”);
printf(“\n| %-21s|”, “4-Execução”);
printf(“\n| %-20s|”, “5-Memória”);
printf(“\n| %-20s|”, “6-Saída”);
printf(“\n| %-20s|”, “7-Conclusão”);
printf(“\n+——————–+”);
} else {
// Exibe a lista
printf(“\nLista de Instruções:\n”);
for (i = 0; i < qtd_instrucoes; i++) {
printf(“\nInstrução %-2d |”, i + 1);
for (j = 0; j < 6 + qtd_instrucoes; j++) {
if (matriz[i][j] != 0) {
printf(” %s “, tarefa[(matriz[i][j]) – 1]);
} else {
printf(“%d “, matriz[i][j]);
}
}
}
}
return 0;
}
Relato sobre as Dificuldades Encontradas:
Ao longo do desenvolvimento do programa que simula um pipeline de execução,
nos deparamos com desafios significativos. A manipulação da matriz para
representar o pipeline demandou atenção especial, especialmente durante a
inicialização e o preenchimento adequado. Assegurar uma apresentação clara da
matriz, juntamente com a lista de instruções e a legenda, emergiu como outro
aspecto crucial, exigindo formatação cuidadosa para facilitar a compreensão do
usuário.
Importância da Técnica de Pipeline na Concorrência de um Sistema
Computacional: A técnica de pipeline desempenha um papel vital na melhoria da
eficiência dos sistemas computacionais, sobretudo em ambientes concorrentes.
Ela possibilita a utilização eficaz de recursos, reduz o tempo de execução ao
permitir a sobreposição de operações, aumenta a taxa de instruções por ciclo (IPC)
e oferece suporte à execução simultânea de tarefas. Em ambientes multicore, essa
técnica escala de maneira eficiente, tornando-se essencial para lidar com a
crescente demanda por processamento paralelo nos sistemas computacionais
modernos.
CurtirCurtir
Atividade 12
Aluno: Mateus Bernardi Alves.
Código implementado em C:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char tarefa[7][20];
void declaracaoTarefas(){
strcpy(tarefa[0],”Busca”);
strcpy(tarefa[1],”Decodificação”);
strcpy(tarefa[2],”Calculando”);
strcpy(tarefa[3],”Execução”);
strcpy(tarefa[4],”Memória”);
strcpy(tarefa[5],”Saída”);
strcpy(tarefa[6],”Conclusão”);
}
int main(){
}
CurtirCurtir
#include <stdio.h>
#define MAX_INSTRUCTIONS 10
#define PIPELINE_STAGES 7
// Uma estrutura para representar uma instrução
typedef struct {
char name[10];
int stages[PIPELINE_STAGES];
} Instruction;
// Função para copiar uma string (substitui strcpy)
void copy_string(char dest, const char *src) {
while (src) {
*dest++ = *src++;
}
*dest = ‘\0’;
}
// Função para inicializar uma instrução
void init_instruction(Instruction *instr, const char *name) {
copy_string(instr->name, name);
for (int i = 0; i < PIPELINE_STAGES; i++) {
instr->stages[i] = 0; // 0 significa que a etapa não foi executada
}
}
// Pipeline
void simulate_pipeline(Instruction instructions[], int num_instructions) {
int pipeline_active = 1; // substitui bool
int clock_cycle = 0;
}
int main() {
Instruction instructions[MAX_INSTRUCTIONS];
int num_instructions = 0;
}
CurtirCurtir
#include <stdio.h>
#define MAX_INSTRUCTIONS 10
#define PIPELINE_STAGES 7
// Uma estrutura para representar uma instrução
typedef struct {
char name[10];
int stages[PIPELINE_STAGES];
} Instruction;
// Função para copiar uma string (substitui strcpy)
void copy_string(char dest, const char *src) {
while (src) {
*dest++ = *src++;
}
*dest = ‘\0’;
}
// Função para inicializar uma instrução
void init_instruction(Instruction *instr, const char *name) {
copy_string(instr->name, name);
for (int i = 0; i < PIPELINE_STAGES; i++) {
instr->stages[i] = 0; // 0 significa que a etapa não foi executada
}
}
// Pipeline
void simulate_pipeline(Instruction instructions[], int num_instructions) {
int pipeline_active = 1; // substitui bool
int clock_cycle = 0;
}
int main() {
Instruction instructions[MAX_INSTRUCTIONS];
int num_instructions = 0;
}
CurtirCurtir
#include <stdio.h>
#define MAX_PROCESSOS 100
#define MAX_FASES 7
int main() {
int numeroDeProcessos, contadorDeClocks = 0;
char *nomesDasFases[] = {“Buscando”, “Decodificando”, “Computando”, “Compactando”, “Fazendo Backup”, “Enviando”, “Concluído”};
int matrizDeProcessos[MAX_PROCESSOS][MAX_PROCESSOS] = {0}; // Inicializa a matriz com zeros
return 0;
}
CurtirCurtir
#include <stdio.h>
#define MAX_PROCESSOS 100
#define MAX_FASES 7
int main() {
int numeroDeProcessos, contadorDeClocks = 0;
char *nomesDasFases[] = {“Buscando”, “Decodificando”, “Computando”, “Compactando”, “Fazendo Backup”, “Enviando”, “Concluído”};
int matrizDeProcessos[MAX_PROCESSOS][MAX_PROCESSOS] = {0}; // Inicializa a matriz com zeros
return 0;
}
CurtirCurtir
#include <stdio.h>
// EXEMPLOS DE 7 TAREFAS A SEREM REALIZADAS (em sequencia)
void Tarefa_1(void){
// ex: ler
printf(“| Neste tempo o programa está lendo…\n”);
}
void Tarefa_2(void){
// ex: interpretar
printf(“| Neste tempo o programa esta interpretando os dados recebidos…\n”);
}
void Tarefa_3(void){
// ex: deduzir
printf(“| Neste tempo o programa está deduzindo um método apropriado…\n”);
}
void Tarefa_4(void){
// ex: calcular
printf(“| Neste tempo o programa está calculando com base nos dados e no método…\n”);
}
void Tarefa_5(void){
// ex :verificar
printf(“| Neste tempo o programa está verificando…\n”);
}
void Tarefa_6(void){
// ex: comparar
printf(“| Neste tempo o programa está comparando os resultados…\n”);
}
void Tarefa_7(void){
// ex: apresentar
printf(“| Neste tempo o programa está apresetando os resultados ao usuário…\n”);
}
//FUNCOES
void funcao_tipo1(void){
Tarefa_1();
}
void funcao_tipo2(void){
Tarefa_2();
Tarefa_1();
}
void funcao_tipo3(void){
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo4(void){
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo5(void){
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo6(void){
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo7(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
Tarefa_1();
}
void funcao_tipo8(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
Tarefa_2();
}
void funcao_tipo9(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
Tarefa_3();
}
void funcao_tipo10(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
Tarefa_4();
}
void funcao_tipo11(void){
Tarefa_7();
Tarefa_6();
Tarefa_5();
}
void funcao_tipo12(void){
Tarefa_7();
Tarefa_6();
}
void funcao_tipo13(void){
Tarefa_7();
}
//FUNCAO PRINCIPAL
int main()
{
int contador_tempo;
int num;
int a;
printf(” Digite o número de instrucoes que deseja executar: “);
scanf(“%d”,&num);
a=num-7;
if(num>6){
//TEMPO 1:
contador_tempo++;
printf(“__________________________________________________________”);
printf(“\n| TEMPO: %d\n”,contador_tempo);
funcao_tipo1();
//TEMPO 2:
contador_tempo++;
printf(“__________________________________________________________”);
printf(“\n| TEMPO: %d\n”,contador_tempo);
funcao_tipo2();
}
printf(“__________________________________________________________”);
printf(“\n\nTEMPO TOTAL: %d”,contador_tempo);
}
RELATÓRIO (Lucas):
O programa identifica duas barreiras principais. A primeira está relacionada à natureza sequencial da linguagem C, que processa comandos um após o outro. Isso significa que, embora o meu programa possa iniciar múltiplas tarefas ao mesmo tempo, na prática, elas são executadas sequencialmente. Dessa forma, o programa atual funciona mais como um protótipo de um sistema de Pipeline. Para uma operação de Pipeline efetiva, seria necessário o uso de múltiplas máquinas trabalhando em paralelo, permitindo que cada “função” ocorra em uma máquina distinta, no momento adequado, já que as tarefas não se sobrepõem temporalmente.
A segunda questão encontrada diz respeito à limitação do programa em lidar com um pequeno número de “instruções”. O design atual só é eficaz para um número relativamente grande de instruções, superior a seis. Portanto, em situações onde o usuário precisa executar um número menor de “instruções”, o programa não funcionará conforme esperado.
CurtirCurtir
#include <stdio.h>
int main() {
// Número de processos e contador de clocks
int processos, clocks = 0;
}
Dificuldades:
Durante a criação do software que simula o pipeline de execução, enfrentamos desafios consideráveis. A manipulação da matriz para representar o pipeline foi uma tarefa que exigiu cuidados especiais, especialmente ao inicializá-la e preenchê-la de maneira apropriada. Garantir uma apresentação clara da matriz, acompanhada pela lista de instruções e legenda, destacou-se como um aspecto fundamental. Isso demandou formatação meticulosa para tornar a compreensão do usuário mais fácil.
Como a técnica de pipeline auxilia na concorrência de um sistema computacional:
Em resumo, a técnica de pipeline desempenha um papel vital ao melhorar a eficiência, o desempenho e a escalabilidade dos sistemas computacionais, promovendo uma execução mais eficiente e rápida das instruções.
CurtirCurtir
#include <stdio.h>
int main() {
// Número de processos e contador de clocks
int processos, clocks = 0;
}
Dificuldades:
Durante a criação do software que simula o pipeline de execução, enfrentamos desafios consideráveis. A manipulação da matriz para representar o pipeline foi uma tarefa que exigiu cuidados especiais, especialmente ao inicializá-la e preenchê-la de maneira apropriada. Garantir uma apresentação clara da matriz, acompanhada pela lista de instruções e legenda, destacou-se como um aspecto fundamental. Isso demandou formatação meticulosa para tornar a compreensão do usuário mais fácil.
Como a técnica de pipeline auxilia na concorrência de um sistema computacional:
Em resumo, a técnica de pipeline desempenha um papel vital ao melhorar a eficiência, o desempenho e a escalabilidade dos sistemas computacionais, promovendo uma execução mais eficiente e rápida das instruções.
CurtirCurtir
/******************************************************************************
ALUNO
Mateus de Melo Camargo RA: 2564548
DISCIPLINA E TURMA
Organização de Computadores – EC42B, C21
DOCENTE
André Luiz Przybysz
INSTITUIÇÃO
Universidade Tecnologica Federal do Paraná (UTFPR)
Câmpus Cornélio Procóprio
*******************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
//—– TABELA ANSI E INDENTAÇÃO—–\
#define MAX_TEXT_WIDTH 50
#define IDENT_SIZE 3
//Regular text
#define BLK “\e[0;30m”
#define RED “\e[0;31m”
#define GRN “\e[0;32m”
#define YEL “\e[0;33m”
#define BLU “\e[0;34m”
#define MAG “\e[0;35m”
#define CYN “\e[0;36m”
#define WHT “\e[0;37m”
//Regular bold text
#define BBLK “\e[1;30m”
#define BRED “\e[1;31m”
#define BGRN “\e[1;32m”
#define BYEL “\e[1;33m”
#define BBLU “\e[1;34m”
#define BMAG “\e[1;35m”
#define BCYN “\e[1;36m”
#define BWHT “\e[1;37m”
//Regular background
#define BLKB “\e[40m”
#define REDB “\e[41m”
#define GRNB “\e[42m”
#define YELB “\e[43m”
#define BLUB “\e[44m”
#define MAGB “\e[45m”
#define CYNB “\e[46m”
#define WHTB “\e[47m”
//Reset
#define reset “\e[0m”
#define CRESET “\e[0m”
#define COLOR_RESET “\e[0m”
typedef struct {
int id;
int stage;
} Instruction;
int NUM_STAGES = 0;
int NUM_INSTRUCTIONS = 0;
//—– FUNÇÕES DE IDENTAÇÃO —–//
void ident() {
for (int i = 0; i < IDENT_SIZE; i++) {
printf(” “);
}
}
void printf_ident(const char* format, …) {
for (int i = 0; i < IDENT_SIZE; i++) {
printf(” “);
}
}
void scanf_ident(const char* format, …) {
ident();
}
void separator(char c) {
ident();
for (int i = 0; i < MAX_TEXT_WIDTH; i++) {
printf(“%c”, c);
}
}
void nl(int num) {
for (int i = 0; i < num; i++) {
printf(“\n”);
}
}
void centralize_text(const char* str, int sep1, int sep2, int space, char c) {
}
//—– FUNÇÕES —–//
void processInstruction(Instruction *instruction) {
if (instruction->stage < NUM_STAGES) {
printf(“| Processing ” BCYN “INSTRUCTION %02d ” reset “at ” BCYN “STAGE %02d ” reset “|\n”, instruction->id + 1, instruction->stage + 1);
instruction->stage++;
} else {
printf(“| Instruction %02d completed\n”, instruction->id + 1);
}
}
int main() {
printf(“Informe o numero de estagios: “);
scanf(“%d”, &NUM_STAGES);
}
CurtirCurtir
Aluno: Bryan Oliveira Faria
RA:a2768291
#include <stdio.h>
int main() {
int processos, n;
char *etapas[] = {“Buscando”, “Decodificando”, “Computando”, “Compactando”, “Fazendo Backup”, “Enviando”, “Concluido”};
// Solicita ao usuário o número de processos printf("Digite o número de processos: "); scanf("%d", &processos); // Garante que o número de processos seja no máximo 100 if (processos > 100) { printf("O número de processos não pode ser maior que 100.n"); return 1; } int table[100][100]; // Inicializando a matriz com zeros for (int i = 0; i < 100; i++) { for (int j = 0; j < 100; j++) { table[i][j] = 0; } } // Preenchendo a matriz for (int i = 0; i < processos; i++) { for (int j = 0; j < 100; j++) { if(i == j){ while(n <= 7){ table[i][j + n - 1] = n; n++; } } } n = 1; } // Imprimindo a tabela for (int i = 0; i < processos + 7; i++) { for (int j = 0; j < 100; j++) { if(table[j][i] != 0){ printf("Processo %2d - %sn", j + 1, etapas[table[j][i] - 1]); } } printf("n"); } return 0;}CurtirCurtir
Nome: Tiago Facimoto Dozzo Ra:2678420
include include include define MAX_INSTRUCOES 10 define ESTAGIOS 7
// Nomes dos estágios
const char *estagios[ESTAGIOS] = {“BI”, “DI”, “CO”, “BO”, “EI”, “EO”, “FI”};
// Representa uma instrução no pipeline
typedef struct {
int id;
int tempo_inicio;
} Instrucao;
// Função para imprimir o pipeline
void imprimirPipeline(char pipeline[MAX_INSTRUCOES][50][5], int instrucoes, int ciclos) {
printf(“Simulação do Pipeline:nn “);
for (int t = 0; t < ciclos; t++)
printf(“%3d “, t + 1);
printf(“n”);
for (int i = 0; i < instrucoes; i++) { printf("I%-3d", i + 1); for (int t = 0; t < ciclos; t++) { printf("%3s ", pipeline[i][t]); } printf("n"); }}
int main() {
int n;
printf(“Digite o número de instruções (máx %d): “, MAX_INSTRUCOES);
scanf(“%d”, &n);
if (n > MAX_INSTRUCOES || n <= 0) { printf("Número inválido de instruções.n"); return 1; } Instrucao instrucoes[MAX_INSTRUCOES]; char pipeline[MAX_INSTRUCOES][50][5]; // pipeline[instrução][tempo][estágio] int ciclos = n + ESTAGIOS; // tempo total estimado // Inicializa pipeline vazio for (int i = 0; i < n; i++) for (int j = 0; j < ciclos; j++) strcpy(pipeline[i][j], " "); // Preenche o pipeline com os estágios for (int i = 0; i < n; i++) { instrucoes[i].id = i + 1; instrucoes[i].tempo_inicio = i; // instrução entra uma por ciclo for (int e = 0; e < ESTAGIOS; e++) { int ciclo = instrucoes[i].tempo_inicio + e; strcpy(pipeline[i][ciclo], estagios[e]); } } // Imprimir resultado imprimirPipeline(pipeline, n, ciclos); return 0;}
CurtirCurtir
Gabriel Cotrim Miron | RA: 2768356
Código do Desafio proposto:
1-)
#include <stdio.h>
#include <locale.h>
#include <string.h>
// Define o limite máximo de instruções e o número de estágios do pipeline
#define MAX_INSTRUCOES 100
#define ESTAGIOS 7
// Array de strings com os nomes dos estágios do pipeline
const char *estagios[ESTAGIOS] =
{
“Busca”,
“Decodificacao”,
“Calculo”,
“Execucao”,
“Memoria”,
“Saida”,
“Conclusao”
};
int main()
{
// Define a localização para permitir acentuação em português
setlocale(LC_ALL, “Portuguese”);
// Declara variáveis
int qtdInstrucoes; // Quantidade de instruções a serem simuladas
int matriz[MAX_INSTRUCOES][MAX_INSTRUCOES] = {0}; // Matriz que representa o pipeline
int i, j; // Contadores
int ciclos = 0; // Contador de ciclos (clock)
// Entrada do usuário: quantidade de instruções
printf(“Digite a quantidade de instruções: “);
scanf(“%d”, &qtdInstrucoes);
// Valida se a quantidade excede o limite definido
if (qtdInstrucoes > MAX_INSTRUCOES)
{
printf(“Quantidade de instruções excede o limite (%d).n”, MAX_INSTRUCOES);
return 1; // Encerra o programa com erro
}
// Preenche a matriz com os estágios de cada instrução
// Cada instrução entra em momentos diferentes (pipeline escalonado)
for (i = 0; i < qtdInstrucoes; i++)
{
for (j = 0; j < ESTAGIOS; j++)
{
matriz[i][i + j] = j + 1; // Preenche com o valor correspondente ao estágio
}
}
// Simula o ciclo de clock: imprime a evolução de cada instrução em cada ciclo
printf(“n— Simulação do Pipeline —nn”);
for (int tempo = 0; tempo < qtdInstrucoes + ESTAGIOS; tempo++)
{
for (int inst = 0; inst < qtdInstrucoes; inst++)
{
int fase = matriz[inst][tempo];
if (fase != 0)
{
// Imprime qual estágio a instrução está executando neste ciclo
printf(“Instrução %2d – %sn”, inst + 1, estagios[fase – 1]);
}
}
ciclos++; // Incrementa o número de ciclos
printf(“n”);
}
// Exibe o total de ciclos utilizados para concluir todas as instruções
printf(“Quantidade total de ciclos (clocks): %dn”, ciclos – 1);
return 0;
}
2-) Na hora de fazer essa simulação, o mais complicado foi entender como representar os estágios da instrução ao longo do tempo. No começo parecia difícil fazer instruções diferentes andarem ao mesmo tempo, mas com a matriz ficou mais fácil de visualizar cada uma em sua fase. Depois que entendi a lógica do escalonamento, consegui montar o pipeline igual ao exemplo da aula, com cada instrução passando pelos 7 estágios e entrando em tempos diferentes. O jeito que o resultado aparece ajuda a ver claramente como tudo funciona .A técnica de pipeline é útil porque permite que várias instruções sejam executadas ao mesmo tempo, cada uma em um estágio. Isso deixa o processador mais eficiente e rápido, porque não precisa esperar uma terminar pra começar outra.
CurtirCurtir
Gabriel Cotrim Miron | RA: 2768356
Código do Desafio proposto:
1-)
#include <stdio.h>
#include <locale.h>
#include <string.h>
// Define o limite máximo de instruções e o número de estágios do pipeline
#define MAX_INSTRUCOES 100
#define ESTAGIOS 7
// Array de strings com os nomes dos estágios do pipeline
const char *estagios[ESTAGIOS] =
{
“Busca”,
“Decodificacao”,
“Calculo”,
“Execucao”,
“Memoria”,
“Saida”,
“Conclusao”
};
int main()
{
// Define a localização para permitir acentuação em português
setlocale(LC_ALL, “Portuguese”);
// Declara variáveis
int qtdInstrucoes; // Quantidade de instruções a serem simuladas
int matriz[MAX_INSTRUCOES][MAX_INSTRUCOES] = {0}; // Matriz que representa o pipeline
int i, j; // Contadores
int ciclos = 0; // Contador de ciclos (clock)
// Entrada do usuário: quantidade de instruções
printf(“Digite a quantidade de instruções: “);
scanf(“%d”, &qtdInstrucoes);
// Valida se a quantidade excede o limite definido
if (qtdInstrucoes > MAX_INSTRUCOES)
{
printf(“Quantidade de instruções excede o limite (%d).n”, MAX_INSTRUCOES);
return 1; // Encerra o programa com erro
}
// Preenche a matriz com os estágios de cada instrução
// Cada instrução entra em momentos diferentes (pipeline escalonado)
for (i = 0; i < qtdInstrucoes; i++)
{
for (j = 0; j < ESTAGIOS; j++)
{
matriz[i][i + j] = j + 1; // Preenche com o valor correspondente ao estágio
}
}
// Simula o ciclo de clock: imprime a evolução de cada instrução em cada ciclo
printf(“n— Simulação do Pipeline —nn”);
for (int tempo = 0; tempo < qtdInstrucoes + ESTAGIOS; tempo++)
{
for (int inst = 0; inst < qtdInstrucoes; inst++)
{
int fase = matriz[inst][tempo];
if (fase != 0)
{
// Imprime qual estágio a instrução está executando neste ciclo
printf(“Instrução %2d – %sn”, inst + 1, estagios[fase – 1]);
}
}
ciclos++; // Incrementa o número de ciclos
printf(“n”);
}
// Exibe o total de ciclos utilizados para concluir todas as instruções
printf(“Quantidade total de ciclos (clocks): %dn”, ciclos – 1);
return 0;
}
2-) Na hora de fazer essa simulação, o mais complicado foi entender como representar os estágios da instrução ao longo do tempo. No começo parecia difícil fazer instruções diferentes andarem ao mesmo tempo, mas com a matriz ficou mais fácil de visualizar cada uma em sua fase. Depois que entendi a lógica do escalonamento, consegui montar o pipeline igual ao exemplo da aula, com cada instrução passando pelos 7 estágios e entrando em tempos diferentes. O jeito que o resultado aparece ajuda a ver claramente como tudo funciona. A técnica de pipeline é útil porque permite que várias instruções sejam executadas ao mesmo tempo, cada uma em um estágio. Isso deixa o processador mais eficiente e rápido, porque não precisa esperar uma terminar pra começar outra.
CurtirCurtir
Aluno: Pedro Ian Basílio Machado
RA: 2768518
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
char etapas[7][20];
void inicializaEtapas(){
strcpy(etapas[0], “Busca”);
strcpy(etapas[1], “Decodificação”);
strcpy(etapas[2], “Calculando”);
strcpy(etapas[3], “Execução”);
strcpy(etapas[4], “Memória”);
strcpy(etapas[5], “Saída”);
strcpy(etapas[6], “Conclusão”);
}
int main() {
setlocale(LC_ALL, “Portuguese”);
inicializaEtapas();
int numInstrucoes;
int pipeline[100][100];
int i, j;
int opcao;
printf(“Informe a quantidade de instruções: “);
scanf(“%d”, &numInstrucoes);
// Inicializa a matriz com zeros para posições inválidas
for(i = 0; i < numInstrucoes; i++) {
for(j = 0; j < 6 + numInstrucoes; j++) {
if(i > j) {
pipeline[i][j] = 0;
} else {
pipeline[i][j] = 0; // Garante que o resto da matriz começa zerada
}
}
}
// Preenche a matriz simulando o avanço das instruções pelo pipeline
for(i = 0; i < numInstrucoes; i++) {
for(j = 0; j < 6 + numInstrucoes; j++) {
if(i == j) {
pipeline[i][j] = 1;
pipeline[i][j + 1] = 2;
pipeline[i][j + 2] = 3;
pipeline[i][j + 3] = 4;
pipeline[i][j + 4] = 5;
pipeline[i][j + 5] = 6;
pipeline[i][j + 6] = 7;
}
}
}
printf(“==== Visualização ====n”);
printf(“1 – Matriz numérican2 – Lista de etapasn”);
scanf(“%d”, &opcao);
if(opcao == 1) {
for(i = 0; i < numInstrucoes; i++) {
printf(“nInstrução %-2d | “, i + 1);
for(j = 0; j < 6 + numInstrucoes; j++) {
printf(“%d”, pipeline[i][j]);
}
}
// Legenda das etapas
printf(“n==========================”);
printf(“n| %-19s |”, “1 – Busca”);
printf(“n| %-21s |”, “2 – Decodificação”);
printf(“n| %-19s |”, “3 – Calculando”);
printf(“n| %-21s |”, “4 – Execução”);
printf(“n| %-20s |”, “5 – Memória”);
printf(“n| %-20s |”, “6 – Saída”);
printf(“n| %-20s |”, “7 – Conclusão”);
printf(“n==========================n”);
} else {
for(i = 0; i < numInstrucoes; i++) {
printf(“nInstrução %-2d | “, i + 1);
for(j = 0; j < 6 + numInstrucoes; j++) {
if(pipeline[i][j] != 0) {
printf(” %s “, etapas[(pipeline[i][j]) – 1]);
} else {
printf(“0”);
}
}
}
printf(“n”);
}
return 0;
}
Relato:
No desenvolvimento do código, a maior dificuldade foi entender como fazer as instruções passarem pelas etapas do pipeline de forma organizada. Foi complicado pensar em como usar a matriz para mostrar cada passo no tempo certo. Depois que consegui entender esse processo, ficou mais fácil escrever o programa.
CurtirCurtir
Aluna:Júlia Bagnara Mattar
ra:2768763
#include <stdio.h>
int main(){
int proc,clock=0;
int m[100][100]={0};
//Matriz para as fases do peocessos ao longo do tempo
int i,f,p,t;
//f=fases,p=processos,t=tempo
char*fases[]={
“Busca da instrução”,
“Decodificação da instrução”,
“Cálculo de operandos”,
“Busca de perandos”,
“Execução da instrução”,
“Escrita do operando”,
“Concluído”
};//Lista das fases
do{
printf(“nDigite o número de processos (até 100):”);
scanf(“%d”,&proc);
if(proc>100){
printf(“nNúmero inválido. Tente novamente”);
}
}while(proc>100);
//Obriga a pessoa a digitar um número menor do que 100
//Verifica se digitou, se caso sim o código continua
//Caso o contário a pessoa tem que digitar novamente
for(i=0;i<proc;i++){
for(f=0;f<7;f++){
m[i][i + f] = f + 1;//Guarda a fase
}
}//Preenche a matris de acordo com as fases(f) de cada processo(p)
//E guarda cada processo começando em um tempo diferente, como o conceito de pipeline
for(t=0;t<proc+7;t++){//Simula os processos (p) cada clock/tempo(t)
for(p=0;p<proc;p++){
if(m[p][t]!=0){//Se existir uma fase ativa para o processo neste clock ele apresenta
printf(“Processo %2d : %sn”, p + 1, fases[m[p][t] – 1]);
}
}
clock++;//Guarda no clock
printf(“n”);
}
printf(“Quantidade de clocks: %dn”, clock – 1);//Exibe o total de clocks
return 0;
}
Relatório júlia bagnara mattar:
Durante a criação do código em C do desafio da pipeline as dificuldades encontradas foram a de manipular a matriz para que ela seja executada corretamente, principalmente em partes de inicialização e de preenchimento correto. A apresentação dessa (a matriz) de forma adequada também foi uma grande dificuldade, poi para o código ficar “limpo” e de apresentação apresentável para os outros usuários foi preciso manipular o código.
Técnica pipeline :ela é essencial , pois permite o processador executar várias tarefas de uma vez em tempos diferentes, o que torna p processo mais rápido e minimiza o tempo.
CurtirCurtir
Aluna:Júlia Bagnara Mattar
RA:2768763
#include <stdio.h>
int main(){
int proc,clock=0;
int m[100][100]={0};
//Matriz para as fases do peocessos ao longo do tempo
int i,f,p,t;
//f=fases,p=processos,t=tempo
char*fases[]={
“Busca da instrução”,
“Decodificação da instrução”,
“Cálculo de operandos”,
“Busca de perandos”,
“Execução da instrução”,
“Escrita do operando”,
“Concluído”
};//Lista das fases
do{
printf(“nDigite o número de processos (até 100):”);
scanf(“%d”,&proc);
if(proc>100){
printf(“nNúmero inválido. Tente novamente”);
}
}while(proc>100);
//Obriga a pessoa a digitar um número menor do que 100
//Verifica se digitou, se caso sim o código continua
//Caso o contário a pessoa tem que digitar novamente
for(i=0;i<proc;i++){
for(f=0;f<7;f++){
m[i][i + f] = f + 1;//Guarda a fase
}
}//Preenche a matris de acordo com as fases(f) de cada processo(p)
//E guarda cada processo começando em um tempo diferente, como o conceito de pipeline
for(t=0;t<proc+7;t++){//Simula os processos (p) cada clock/tempo(t)
for(p=0;p<proc;p++){
if(m[p][t]!=0){//Se existir uma fase ativa para o processo neste clock ele apresenta
printf(“Processo %2d : %sn”, p + 1, fases[m[p][t] – 1]);
}
}
clock++;//Guarda no clock
printf(“n”);
}
printf(“Quantidade de clocks: %dn”, clock – 1);//Exibe o total de clocks
return 0;
}
Relatório:
Durante a criação do código em C do desafio da pipeline as dificuldades encontradas foram a de manipular a matriz para que ela seja executada corretamente, principalmente em partes de inicialização e de preenchimento correto. A apresentação dessa (a matriz) de forma adequada também foi uma grande dificuldade, poi para o código ficar “limpo” e de apresentação apresentável para os outros usuários foi preciso manipular o código.
Técnica pipeline :ela é essencial , pois permite o processador executar várias tarefas de uma vez em tempos diferentes, o que torna p processo mais rápido e minimiza o tempo.
CurtirCurtir
include include
int main() {
setlocale (LC_ALL,"Portuguese");const char* etapas[7] = { "IF", "ID", "EX", "MEM", "WB", "PC", "COMMIT" };// Capacidade máxima de 100 instruçõesint etapa_atual[100];int tempo_inicio[100];int tempo_fim[100];int concluida[100];int total_instr = 0;int ciclo = 0;int opcao;do {printf("n[1] Criar nova instruçãon[2] Simular ciclon[3] Ver relatório finaln[0] SairnEscolha: ");scanf("%d", &opcao);getchar();// limpa o n do bufferif (opcao == 1) {if (total_instr >= 100) {printf("Fila cheia!n"); }else {etapa_atual[total_instr] = 0;tempo_inicio[total_instr] = ciclo;tempo_fim[total_instr] = -1;concluida[total_instr] = 0;printf("Criada instrução ID %d no ciclo %dn", total_instr + 1, ciclo);total_instr++; } }else if (opcao == 2) {printf("n--- Ciclo %d ---n", ciclo);for (int i = 0; i < total_instr; i++) {if (!concluida[i]) {printf("Instrucao %d -> Etapa: %sn", i + 1, etapas[etapa_atual[i]]); etapa_atual[i]++;if (etapa_atual[i] >= 7) {concluida[i] = 1;tempo_fim[i] = ciclo;printf("Instrucao %d concluída no ciclo %dn", i + 1, ciclo); } } }ciclo++; }else if (opcao == 3) {printf("n===== RELATÓRIO FINAL =====n");for (int i = 0; i < total_instr; i++) {printf("Instrucao %d - Início: %d | Fim: %d | Duração: %d ciclosn", i + 1, tempo_inicio[i], tempo_fim[i], tempo_fim[i] - tempo_inicio[i] + 1); } }else if (opcao == 0) { printf("Encerrando...n"); } else { printf("Opção inválida.n"); } } while (opcao != 0);return 0;}
Relato:
Foi um desafio consideravelmente difícil por se tratar de Pipeline, técnica da qual ouvi falar recentemente e apenas no sentido teórico do assunto de forma abstrata. Conhecia os conceitos básicos, porém esses conceitos aplicados a um algoritmo que execute uma determinada tarefa em prática foram desafiadores. Existem muitas maneiras de desenvolver esse algoritmo, mas escolhi um método que seja de melhor entendimento para mim.
Tive problemas para entender o que cada passo da técnica de pipeline executaria
CurtirCurtir
Arthur Antônio Jofre Morera
RA: 2649632
#include <stdio.h>
#include <string.h>
#include <locale.h>
#define MAX_INSTRUCOES 10
#define N_ESTAGIOS 7
#define MAX_TEMPO 25
#define TAM_INSTR 50
// Nomes dos 7 estágios do pipeline
const char* estagios[N_ESTAGIOS] = {“BI”, “DI”, “CO”, “BO”, “EX”, “EO”, “GR”};
void simular_pipeline(char instrucoes[MAX_INSTRUCOES][TAM_INSTR], int qtd) {
char pipeline[MAX_INSTRUCOES][MAX_TEMPO][4];
// Inicializa o pipeline com espaços em branco
for (int i = 0; i < qtd; i++) {
for (int t = 0; t < MAX_TEMPO; t++) {
strcpy(pipeline[i][t], ” “);
}
}
// Preenche o pipeline com os estágios para cada instrução escalonada
for (int instr = 0; instr < qtd; instr++) {
for (int estagio = 0; estagio < N_ESTAGIOS; estagio++) {
int tempo = instr + estagio;
if (tempo < MAX_TEMPO) {
strcpy(pipeline[instr][tempo], estagios[estagio]);
}
}
}
// Imprime o cabeçalho de tempo (ciclos)
printf(“nSimulação do Pipeline (com %d instruções)nn”, qtd);
printf(“Tempo -> “);
for (int t = 0; t < MAX_TEMPO; t++) {
printf(“%3d “, t + 1);
}
printf(“n”);
// Imprime a tabela do pipeline
for (int instr = 0; instr < qtd; instr++) {
printf(“Inst %2d: “, instr + 1);
for (int t = 0; t < MAX_TEMPO; t++) {
printf(“%s “, pipeline[instr][t]);
}
printf(“n”);
}
// Imprime as instruções completas digitadas pelo usuário
printf(“nInstruções digitadas:n”);
for (int i = 0; i < qtd; i++) {
printf(“Inst %2d: %sn”, i + 1, instrucoes[i]);
}
// Mostra o total de ciclos (último tempo utilizado)
printf(“nTotal de ciclos (clocks): %dn”, qtd + N_ESTAGIOS – 1);
}
int main() {
setlocale(LC_ALL, “Portuguese”);
int n;
char instrucoes[MAX_INSTRUCOES][TAM_INSTR];
printf(“Quantas instruções você deseja simular (máx %d)? “, MAX_INSTRUCOES);
scanf(“%d”, &n);
getchar(); // Limpa o n do buffer
if (n <= 0 || n > MAX_INSTRUCOES) {
printf(“Número inválido. Deve ser entre 1 e %d.n”, MAX_INSTRUCOES);
return 1;
}
// Recebe as instruções digitadas pelo usuário
printf(“nDigite as instruções (ex: ADD R1, R2, R3):n”);
for (int i = 0; i < n; i++) {
printf(“Instrução %d: “, i + 1);
fgets(instrucoes[i], TAM_INSTR, stdin);
instrucoes[i][strcspn(instrucoes[i], “n”)] = ”; // Remove o n do final
}
simular_pipeline(instrucoes, n);
return 0;
}
Durante a implementação do simulador de pipeline, a principal dificuldade foi entender como representar várias instruções sendo executadas ao mesmo tempo, mas em estágios diferentes. Também deu um pouco de trabalho montar a tabela certinha, organizar o tempo de cada instrução e fazer a entrada de dados funcionar sem erros.
Apesar disso, o projeto ajudou bastante a entender como o pipeline funciona de verdade. Em vez de executar uma instrução inteira de uma vez, o processador divide em etapas e começa a próxima instrução antes de terminar a anterior. Isso faz com que várias instruções estejam sendo processadas ao mesmo tempo, aumentando a velocidade geral do sistema.
Com isso, deu pra ver na prática como o pipeline melhora o desempenho de um computador, aproveitando melhor o tempo e os recursos da CPU.
CurtirCurtir
Aluno: Hugo Rafael Pessoni Batista.
RA: 2768380
Código do Desafio:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#define LIMITE_INSTRUCOES 100
#define FASES_PIPELINE 7
// Lista de nomes para os estágios do pipeline
const char *nomes_fases[FASES_PIPELINE] = {
“Busca”,
“Decodificacao”,
“Calculo”,
“Execucao”,
“Memoria”,
“Saida”,
“Conclusao”
};
// Estrutura de dados para representar uma instrução
typedef struct {
int identificador;
int fluxo[FASES_PIPELINE + LIMITE_INSTRUCOES];
} Tarefa;
// Inicializa as instruções com seus respectivos estágios escalonados
void configurarInstrucoes(Tarefa *lista, int total) {
for (int linha = 0; linha < total; linha++) {
lista[linha].identificador = linha + 1;
for (int fase = 0; fase < FASES_PIPELINE; fase++) {
lista[linha].fluxo[linha + fase] = fase + 1;
}
}
}
// Executa a simulação do pipeline ciclo a ciclo
void executarSimulacao(Tarefa *tarefas, int total) {
int tempo_total = total + FASES_PIPELINE;
printf(“n— Execucao do Pipeline —nn”);
for (int tempo = 0; tempo < tempo_total; tempo++) {
printf(“Ciclo %d:n”, tempo + 1);
for (int linha = 0; linha < total; linha++) {
int fase_atual = tarefas[linha].fluxo[tempo];
if (fase_atual >= 1 && fase_atual <= FASES_PIPELINE) {
printf(” Instrucao %2d – %sn”, tarefas[linha].identificador, nomes_fases[fase_atual – 1]);
}
}
printf(“n”);
}
printf(“Ciclos totais consumidos: %dn”, tempo_total – 1);
}
int main() {
setlocale(LC_ALL, “Portuguese”);
int numero_instrucoes;
printf(“Informe a quantidade de instruções (limite: %d): “, LIMITE_INSTRUCOES);
scanf(“%d”, &numero_instrucoes);
if (numero_instrucoes <= 0 || numero_instrucoes > LIMITE_INSTRUCOES) {
printf(“Valor inválido para instruções.n”);
return 1;
}
Tarefa pipeline[LIMITE_INSTRUCOES] = {0};
configurarInstrucoes(pipeline, numero_instrucoes);
executarSimulacao(pipeline, numero_instrucoes);
return 0;
}
Relato:
Durante a implementação do simulador de pipeline, a principal dificuldade encontrada foi organizar a lógica de escalonamento das instruções, garantindo que cada uma seguisse corretamente os 7 estágios sem conflitos e sem sobreposição indevida. A solução foi usar uma estrutura que mapeia os ciclos de tempo em que cada estágio ocorre para cada instrução. A técnica de pipeline é extremamente útil em sistemas computacionais porque permite a execução concorrente de várias instruções, aumentando significativamente a eficiência do processador. Enquanto uma instrução está em um estágio, outra pode ocupar outro, utilizando melhor os recursos da UCP.
CurtirCurtir
Nome: Daniella Lima de Oliveira RA: 2678080
#include <stdio.h>
#include <string.h>
#include <locale.h>
#define MAX_INSTRUCOES 10
#define N_ESTAGIOS 7
#define MAX_TEMPO 25
#define TAM_INSTR 50
// Nomes dos 7 estágios do pipeline (simulando uma UCP – Unidade Central de Processamento)
const char* estagios[N_ESTAGIOS] = {“BI”, “DI”, “CO”, “BO”, “EX”, “EO”, “GR”};
// Função que simula o pipeline da UCP
void simular_pipeline(char instrucoes[MAX_INSTRUCOES][TAM_INSTR], int qtd) {
char pipeline[MAX_INSTRUCOES][MAX_TEMPO][4];
// Inicializa o pipeline com espaços em branco
for (int i = 0; i < qtd; i++) {
for (int t = 0; t < MAX_TEMPO; t++) {
strcpy(pipeline[i][t], ” “);
}
}
// Escalonamento das instruções no pipeline da UCP
for (int instr = 0; instr < qtd; instr++) {
for (int estagio = 0; estagio < N_ESTAGIOS; estagio++) {
int tempo = instr + estagio;
if (tempo < MAX_TEMPO) {
strcpy(pipeline[instr][tempo], estagios[estagio]);
}
}
}
// Imprime o cabeçalho de tempo (ciclos de clock)
printf(“nSimulação do Pipeline da UCP (com %d instruções)nn”, qtd);
printf(“Tempo -> “);
for (int t = 0; t < MAX_TEMPO; t++) {
printf(“%3d “, t + 1);
}
printf(“n”);
// Imprime a tabela do pipeline (Fig. 1 e Fig. 2 do enunciado)
for (int instr = 0; instr < qtd; instr++) {
printf(“Inst %2d: “, instr + 1);
for (int t = 0; t < MAX_TEMPO; t++) {
printf(“%s “, pipeline[instr][t]);
}
printf(“n”);
}
// Imprime as instruções digitadas pelo usuário
printf(“nInstruções digitadas:n”);
for (int i = 0; i < qtd; i++) {
printf(“Inst %2d: %sn”, i + 1, instrucoes[i]);
}
// Mostra o total de ciclos (último tempo utilizado)
printf(“nTotal de ciclos (clocks): %dn”, qtd + N_ESTAGIOS – 1);
}
int main() {
setlocale(LC_ALL, “Portuguese”);
int n;
char instrucoes[MAX_INSTRUCOES][TAM_INSTR];
char opcao;
do {
// Pergunta quantas instruções serão simuladas
printf(“nQuantas instruções você deseja simular (máx %d)? “, MAX_INSTRUCOES);
scanf(“%d”, &n);
getchar(); // Limpa o n do buffer
if (n <= 0 || n > MAX_INSTRUCOES) {
printf(“Número inválido. Deve ser entre 1 e %d.n”, MAX_INSTRUCOES);
continue; // volta ao menu
}
// Recebe as instruções digitadas pelo usuário
printf(“nDigite as instruções (ex: ADD R1, R2, R3 ou SUB R4, R5, R6):n”);
for (int i = 0; i < n; i++) {
printf(“Instrução %d: “, i + 1);
fgets(instrucoes[i], TAM_INSTR, stdin);
instrucoes[i][strcspn(instrucoes[i], “n”)] = ”; // Remove o n do final
}
// Chama a função de simulação do pipeline
simular_pipeline(instrucoes, n);
// Pergunta se o usuário quer adicionar mais instruções e simular novamente
printf(“nDeseja criar novas instruções e simular novamente? (S/N): “);
scanf(” %c”, &opcao);
getchar(); // Limpa o n do buffer
} while (opcao == ‘S’ || opcao == ‘s’);
printf(“nEncerrando a simulação do pipeline.n”);
return 0;
}
Relato: Durante a implementação da simulação do pipeline de uma UCP , algumas dificuldades foram encontradas, principalmente relacionadas ao controle dos tempos de execução e à visualização da tabela de execução. Também foi necessário garantir que a escalonagem das instruções respeitasse o número máximo de ciclos e que as instruções fossem exibidas corretamente ao longo dos estágios. Além disso, foi importante padronizar o uso de strings e caracteres especiais, já que a linguagem C exige um cuidado extra com o tratamento de strings e de entradas do usuário.
A técnica de pipeline contribui para a concorrência ao permitir que várias instruções sejam executadas ao mesmo tempo, cada uma em uma fase diferente. Isso aumenta a eficiência do processador, reduz o tempo médio por instrução e garante melhor aproveitamento dos recursos internos, como memória, registradores e unidades de execução.
CurtirCurtir
Aluno: João Francisco Martins Simão
Desafio de Programação
Observação: Utilizei Matrizes e Vetores (Além de todo o conteúdo mais básico aprendido em C) para fazer o código
O programa possui 120 linhas de código
Estarei deixando um link para acesso a uma pasta no Google Drive contendo o arquivo em C e sua versão em arquivo de texto:
https://drive.google.com/drive/folders/1axlJFN1ATElETGEFGsTRrsma5qM-JiIP?usp=sharing
Durante e após a construção do código pude perceber que a parte mais complicada de ser implementada seria realizar a interpretação de como simular uma Pipeline dentro do contexto computacional utilizando linguagem de programação (Nesse caso, linguagem C) e como fazer os ajustes para que o código atenda tudo que foi solicitado. Nesse sentido, além do conhecimento da linguagem C, a interpretação e a montagem de uma linha de raciocínio clara neste desafio foram as coisas mais importantes.
Respondendo o segundo questionamento, posso dizer que a utilização da técnica de Pipeline assim como outras técnicas de otimização, como algoritmos de otimização por exemplo, é de suma importância para a arquitetura computacional. Isso se configura a partir da definição de Pipeline, sendo uma técnica de processamento que visa fazer uma divisão de tarefas para que elas sejam executadas em paralelo, ou seja, de maneira simultânea, consequentemente aumentando seu desempenho geral e resultando em uma maior eficiência.
CurtirCurtir
Rafael Henrique de Oliveira da Silva
RA= 2768526
Código do Desafio:
include include include include include define MAX_INSTRUCOES 100 define NUM_ESTAGIOS 7
// Estágios do pipeline
const char *estagios[NUM_ESTAGIOS] = {
“Busca (IF)”, “Decodificação (ID)”, “Busca Operando (OF)”,
“Execução (EX)”, “Memória (MEM)”, “Escrita Resultado (WB)”,
“Finalização (END)”
};
// Estrutura para instrução
typedef struct {
int id;
int tempoNoSistema;
int estagioAtual;
int finalizada;
} Instrucao;
// Fila de instruções
Instrucao fila[MAX_INSTRUCOES];
int totalInstrucoes = 0;
int proximaID = 1;
// Adiciona uma nova instrução
void adicionarInstrucao() {
if (totalInstrucoes >= MAX_INSTRUCOES) {
printf(“Fila cheia! Não é possível adicionar mais instruções.n”);
return;
}
Instrucao nova; nova.id = proximaID++; nova.tempoNoSistema = 0; nova.estagioAtual = 0; nova.finalizada = 0; fila[totalInstrucoes++] = nova; printf("Instrução ID %d adicionada à fila.n", nova.id);}
// Simula uma etapa do pipeline para todas as instruções
void simularCiclo() {
printf(“n[CICLO DE RELOGIO] ———————-n”);
for (int i = 0; i < totalInstrucoes; i++) { if (!fila[i].finalizada) { printf(“Instrução %2d -> %sn”, fila[i].id, estagios[fila[i].estagioAtual]);
fila[i].tempoNoSistema++;
fila[i].estagioAtual++; if (fila[i].estagioAtual >= NUM_ESTAGIOS) { fila[i].finalizada = 1; printf("Instrução %d finalizada em %d ciclos.n", fila[i].id, fila[i].tempoNoSistema); } } }}
// Mostra o status atual de todas as instruções
void mostrarStatus() {
printf(“nStatus Atual das Instruções:n”);
for (int i = 0; i < totalInstrucoes; i++) {
printf(“ID: %2d | Estágio: %-20s | Ciclos: %d | Finalizada: %sn”,
fila[i].id,
fila[i].finalizada ? “Finalizada” : estagios[fila[i].estagioAtual],
fila[i].tempoNoSistema,
fila[i].finalizada ? “Sim” : “Não”);
}
}
void menu() {
int opcao;
do {
printf(“n— Simulador de Pipeline —n”);
printf(“1. Adicionar nova instruçãon”);
printf(“2. Executar ciclon”);
printf(“3. Mostrar statusn”);
printf(“0. Sairn”);
printf(“Escolha: “);
scanf(“%d”, &opcao);
switch (opcao) { case 1: adicionarInstrucao(); break; case 2: simularCiclo(); break; case 3: mostrarStatus(); break; case 0: printf("Encerrando simulação.n"); break; default: printf("Opção inválida.n"); } } while (opcao != 0);}
int main() {
setlocale(LC_ALL, “Portuguese”);
menu();
return 0;
}
Realto: A realização desse desafio foi complicada, principalmente por se tratar de um tema novo para mim. Pipeline é um conceito que eu só havia estudado de forma teórica, então aplicar isso em código foi um verdadeiro exercício de interpretação e adaptação. Tive dificuldades para entender o papel de cada estágio no fluxo da instrução e como representá-los em um algoritmo. Foi um aprendizado importante sobre como a execução paralela melhora o desempenho da UCP.
CurtirCurtir
ALUNO João Felipe Pansanato Tonini
RA: a2768399
include
int main() {
int processos;
char *etapas[] = {“Buscando”, “Decodificando”, “Computando”, “Compactando”, “Fazendo Backup”, “Enviando”, “Concluido”};
int etapas_qtd = 7;
// solicita ao usuário o número de processos printf("Digite o número de processos: "); scanf("%d", &processos); //número de processos seja no máximo 100 if (processos > 100) { printf("O número de processos não pode ser maior que 100.n"); return 1; } int table[100][200] = {0}; // preenchendo a matriz for (int i = 0; i < processos; i++) { for (int j = 0; j < etapas_qtd; j++) { table[i][i + j] = j + 1; // j+1 pois 0 é 'sem etapa' } } // imprimindo a tabela // percorrendo o tempo máximo necessário int tempo_max = processos + etapas_qtd - 1; for (int t = 0; t < tempo_max; t++) { printf("Tempo %2d:n", t + 1); for (int p = 0; p < processos; p++) { if (table[p][t] != 0) { int etapa_index = table[p][t] - 1; printf(" Processo %2d - %sn", p + 1, etapas[etapa_index]); } } printf("n"); } return 0;}
CurtirCurtir
Aluno: Maria Gabriely dos Santos RA:2706679
1 – Desafio de programação da disciplina de Organização de Computadores:
Implementar na forma de simulação o funcionamento do pipeline em um sistema computacional. Exemplos: Fig. 1 e Fig.2.
Deverá conter UCP; fila com “n instruções”; possibilidade de criação de novas instruções; divisão de um pipeline em 7 tarefas diferentes; contador de tempo das instruções.
R: #include
#include <stdlib.h>
#include <string.h>
#include <locale.h>
#define MAX_INSTRUCOES 15
#define ESTAGIOS 7
int main() {
setlocale(LC_ALL, “Portuguese”);
const char *estagios[ESTAGIOS] = {
“Busca”,
“Decodificacao”,
“Emissao”,
“Execucao”,
“Backup”,
“Resultado”,
“Conclusao”
};
char nomes_instrucoes[MAX_INSTRUCOES][30];
int estagio_atual[MAX_INSTRUCOES];
int finalizada[MAX_INSTRUCOES];
int total_instrucoes;
int ciclo_clock = 0;
int todas_finalizadas = 0;
printf(“Digite o número de instruções (máximo %d): “, MAX_INSTRUCOES);
scanf(“%d”, &total_instrucoes);
if (total_instrucoes > MAX_INSTRUCOES || total_instrucoes <= 0) {
printf(“Número inválido de instruções.n”);
return 1;
}
// Limpar o buffer do teclado
getchar();
// Receber o nome de cada instrução
for (int i = 0; i < total_instrucoes; i++) {
printf(“Digite o nome da instrução %d: “, i + 1);
fgets(nomes_instrucoes[i], sizeof(nomes_instrucoes[i]), stdin);
nomes_instrucoes[i][strcspn(nomes_instrucoes[i], “n”)] = ”;
estagio_atual[i] = 0;
finalizada[i] = 0;
}
// Loop do pipeline até todas as instruções finalizarem
while (!todas_finalizadas) {
printf(“nCiclo de Clock: %dn”, ciclo_clock);
for (int i = 0; i < total_instrucoes; i++) {
if (!finalizada[i]) {
printf(“Instrução: %s – Estágio: %sn”, nomes_instrucoes[i], estagios[estagio_atual[i]]);
estagio_atual[i]++;
if (estagio_atual[i] >= ESTAGIOS) {
finalizada[i] = 1;
printf(“Instrução %s finalizada!n”, nomes_instrucoes[i]);
}
}
}
ciclo_clock++;
// Verificar se todas as instruções finalizaram
todas_finalizadas = 1;
for (int i = 0; i < total_instrucoes; i++) {
if (!finalizada[i]) {
todas_finalizadas = 0;
break;
}
}
}
printf(“nTodas as instruções foram processadas em %d ciclos de clock.n”, ciclo_clock);
return 0;
}
Após a implementação, faça um relato sobre: às dificuldades encontradas; como o a técnica de pipeline auxilia na concorrência de um sistema computacional.
R: Durante o desenvolvimento da simulação de pipeline em C, as principais dificuldades foram controlar os diferentes estágios das instruções em cada ciclo de clock e implementar um sistema de tempo que garantisse o avanço sincronizado das instruções. Também foi desafiador organizar a execução paralela respeitando as dependências entre elas. A técnica de pipeline melhora a concorrência ao permitir que várias instruções sejam processadas simultaneamente em diferentes estágios, aumentando a eficiência e reduzindo o tempo total de execução.
CurtirCurtir
nome: Gabriel Rodrigues Pereira de Jesus RA: 2706628
————————————————————————————————
*(Linguagem utilizada –> “C++”)
Código Pipeline em C++
Relato:
Ao criar o código, a maior dificuldade se encontrou nos diversos comandos e bibliotecas que eu não conhecia até o momento, porém foi divertido poder aprender a como fazer eu mesmo uma simulação de pipeline. Essa técnica auxilia na concorrência de sistemas computacionais, pois permite um número maior de instruções em execução com menor ociosidade e maior eficiência, tem um aumento de throughput (número de instruções concluídas por unidade de tempo) e gera respostas mais rápidas do sistema.
CurtirCurtir
nome: Gabriel Rodrigues Pereira de Jesus RA: 2706628
————————————————————————————————
*(Linguagem utilizada –> “C++”)
#include <iostream>
#include <vector>
#include <string>
#include <iomanip>
#include <sstream>
using namespace std;
// Número de estágios do pipeline e seus nomes
const int NUM_ESTAGIOS = 7;
const string estagios[NUM_ESTAGIOS] = {“IF”, “ID”, “EX1”, “EX2”, “MEM”, “WB1”, “WB2”};
// Representa uma instrução com ID, tempo de início e vetor com os estágios
struct Instrucao {
int id;
int tempoInicio;
vector<string> pipeline;
Instrucao(int _id, int inicio) : id(_id), tempoInicio(inicio) {
pipeline.resize(NUM_ESTAGIOS, ” “);
}
};
// Classe que simula a Unidade de Controle e Pipeline (UCP)
class UCP {
private:
vector<Instrucao> instrucoes; // Lista de instruções
int tempoAtual; // Contador de ciclos simulados
// Converte inteiro para string
string intParaString(int valor) {
ostringstream ss;
ss << valor;
return ss.str();
}
public:
UCP() : tempoAtual(0) {}
// Adiciona nova instrução ao pipeline
void adicionarInstrucao() {
int id = (int)instrucoes.size() + 1;
int inicio = id – 1; // Desloca início de cada instrução em 1 ciclo
Instrucao nova(id, inicio);
instrucoes.push_back(nova);
}
// Simula os estágios do pipeline para N ciclos
void simular(int ciclos) {
cout << “Simulando ” << ciclos << ” ciclos de clock…n”;
for (int t = 0; t < ciclos; ++t) {
for (int i = 0; i < (int)instrucoes.size(); ++i) {
int inicio = instrucoes[i].tempoInicio; int desloc = t – inicio;
if (desloc >= 0 && desloc < NUM_ESTAGIOS) {
instrucoes[i].pipeline[desloc] = estagios[desloc];
}
}
tempoAtual++;
}
}
// Imprime tabela final com a execução do pipeline
void imprimirResultado() {
cout << “n=== Tabela de Execução do Pipeline ===nn”;
// Cabeçalho com os ciclos cout << setw(10) << “Instrucao”;
for (int t = 0; t < tempoAtual; ++t) {
cout << setw(6) << “T” + intParaString(t + 1);
}
cout << “n”;
// Linha separadora
cout << string(10 + 6 * tempoAtual, ‘-‘) << “n”;
// Exibe linha por linha da execução de cada instrução
for (size_t i = 0; i < instrucoes.size(); ++i) {
Instrucao instr = instrucoes[i];
cout << setw(10) << “I” + intParaString(instr.id);
for (int t = 0; t < tempoAtual; ++t) {
int desloc = t – instr.tempoInicio;
if (desloc >= 0 && desloc < NUM_ESTAGIOS) {
cout << setw(6) << estagios[desloc];
}
else {
cout << setw(6) << ” “;
}
}
cout << “n”;
}
}
};
int main() {
UCP ucp; // Instancia simulador
int opcao, ciclos;
cout << “=== Simulador de Pipeline ===n”;
// Menu principal de interação
while (true) {
cout << “n1 – Adicionar nova instruçãon”
<< “2 – Simular ciclosn”
<< “3 – Ver resultadon”
<< “4 – Sairn” << “Escolha: “;
cin >> opcao;
// Trata cada opção do menu
if (opcao == 1) {
ucp.adicionarInstrucao(); // Adiciona nova instrução
cout << “Instrução adicionada.n”;
}
else if (opcao == 2) {
cout << “Quantos ciclos deseja simular? “;
cin >> ciclos;
ucp.simular(ciclos); // Simula os ciclos informados
}
else if (opcao == 3) {
ucp.imprimirResultado(); // Exibe a tabela com os estágios
}
else if (opcao == 4) {
break; // Encerra o programa
}
else { cout << “Opção inválida.n”; // Trata entradas inválidas
}
}
return 0;
}
Relato:
Ao criar o código, a maior dificuldade se encontrou nos diversos comandos e bibliotecas que eu não conhecia até o momento, porém foi divertido poder aprender a como fazer eu mesmo uma simulação de pipeline. Essa técnica auxilia na concorrência de sistemas computacionais, pois permite um número maior de instruções em execução com menor ociosidade e maior eficiência, tem um aumento de throughput (número de instruções concluídas por unidade de tempo) e gera respostas mais rápidas do sistema.
CurtirCurtir
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
char tarefa[7][20];
void declaracao_das_tarefas(void){
strcpy(tarefa[0],”Buscar”);
strcpy(tarefa[1],”Decodificar”);
strcpy(tarefa[2],”Calcular”);
strcpy(tarefa[3],”Executar”);
strcpy(tarefa[4],”Memória”);
strcpy(tarefa[5],”Saída”);
strcpy(tarefa[6],”Conclusão”);
}
int main(){
declaracao_das_tarefas();
int qtd_intrucoes; //quantidade de instruções
int matriz[100][100];
int i, j;
int x;
setlocale(LC_ALL, “Portuguese”);
printf(“Digite a quantidade de execuções: “);
scanf(“%i”, &qtd_intrucoes);
//0 nas posições abaixo da diagonal principal
for(i = 0; i < qtd_intrucoes; i++){ for(j = 0; j < 6 + qtd_intrucoes; j++){ //delimitar tamanho da coluna if(i > j){
matriz[i][j] = 0;
}
}
}
//pipeline
for(i = 0; i < qtd_intrucoes; i++){
for(j = 0; j < 6 + qtd_intrucoes; j++){ //delimitar tamanho da coluna
if(i == j){
matriz[i][j] = 1;
matriz[i][j + 1] = 2;
matriz[i][j + 2] = 3;
matriz[i][j + 3] = 4;
matriz[i][j + 4] = 5;
matriz[i][j + 5] = 6;
matriz[i][j + 6] = 7;
}
}
}
printf(“Organização:n1 – matrizn2 – listan”);
scanf(“%i”, &x);
if(x == 1){
for(i = 0; i < qtd_intrucoes; i++){
printf(“ninstrução %-2d |”, i + 1);
for(j = 0; j < 6 + qtd_intrucoes; j++){ //delimitar tamanho da coluna
printf(“%i”, matriz[i][j]);
}
}
printf(“nn %-19s”, “1-Buscar”);
printf(“n %-21s”, “2-Decodificar”);
printf(“n %-19s”, “3-Calcular”);
printf(“n %-21s”, “4-Executar”);
printf(“n %-20s”, “5-Memória”);
printf(“n %-20s”, “6-Saída”);
printf(“n %-20s”, “7-Conclusãon”);
}else{
for(i = 0; i < qtd_intrucoes; i++){
printf(“ninstrução %-2d “, i + 1);
for(j = 0; j < 6 + qtd_intrucoes; j++){ //delimitar tamanho da coluna
if(matriz[i][j] != 0){
printf(” %s “,tarefa[(matriz[i][j]) – 1]);
}else{
printf(“%i”, matriz[i][j]);
}
}
}
}
return 0;
}
A principal dificuldade foi entender e implementar o avanço paralelo das instruções no pipeline. Organizar a lógica de ciclos e estágios exigiu cuidado.O pipeline melhora a concorrência no sistema ao permitir que várias instruções sejam executadas simultaneamente em diferentes etapas, aumentando a eficiência do processador.
CurtirCurtir
Felipe Nunino Scalice
RA: 2768348
include include include define MAX_INSTR 10 define ESTAGIOS 7 define LIMITE_TEMPO 25 define TAMANHO 50
// Estágios da UCP representando as fases do pipeline
const char* fases[ESTAGIOS] = {“BI”, “DI”, “CO”, “BO”, “EX”, “EO”, “GR”};
// Simulação da execução das instruções no pipeline
void executar_pipeline(char comandos[MAX_INSTR][TAMANHO], int total) {
char simulacao[MAX_INSTR][LIMITE_TEMPO][4];
// Inicializa a matriz de simulação com espaços for (int i = 0; i < total; i++) { for (int j = 0; j < LIMITE_TEMPO; j++) { strcpy(simulacao[i][j], " "); } } // Posiciona os estágios para cada instrução for (int i = 0; i < total; i++) { for (int f = 0; f < ESTAGIOS; f++) { int tempo = i + f; if (tempo < LIMITE_TEMPO) { strcpy(simulacao[i][tempo], fases[f]); } } } // Cabeçalho de tempo printf("nSimulação do Pipeline (Total de %d instruções)nn", total); printf("Tempo: "); for (int t = 0; t < LIMITE_TEMPO; t++) { printf("%3d ", t + 1); } printf("n"); // Impressão da tabela de execução for (int i = 0; i < total; i++) { printf("Inst %2d: ", i + 1); for (int t = 0; t < LIMITE_TEMPO; t++) { printf("%s ", simulacao[i][t]); } printf("n"); } // Lista das instruções informadas printf("nInstruções fornecidas:n"); for (int i = 0; i < total; i++) { printf("Inst %2d: %sn", i + 1, comandos[i]); } // Ciclos totais computados printf("nCiclos totais utilizados: %dn", total + ESTAGIOS - 1);}
int main() {
setlocale(LC_ALL, “Portuguese”);
char comandos[MAX_INSTR][TAMANHO]; int quantidade; char resposta; do { printf("nInforme a quantidade de instruções (máximo %d): ", MAX_INSTR); scanf("%d", &quantidade); getchar(); // limpa o buffer do enter if (quantidade < 1 || quantidade > MAX_INSTR) { printf("Valor inválido. Escolha de 1 a %d.n", MAX_INSTR); continue; } printf("nDigite suas instruções (ex: ADD R1, R2, R3):n"); for (int i = 0; i < quantidade; i++) { printf("Instrução %d: ", i + 1); fgets(comandos[i], TAMANHO, stdin); comandos[i][strcspn(comandos[i], "n")] = ''; // remove quebra de linha } executar_pipeline(comandos, quantidade); printf("nDeseja simular novamente? (S/N): "); scanf(" %c", &resposta); getchar(); } while (resposta == 'S' || resposta == 's'); printf("nSimulação encerrada.n"); return 0;}
DESAFIOS:
Durante a implementação da atividade, tive algumas dificuldades, principalmente com o controle da matriz que simula o pipeline e o posicionamento correto dos estágios no tempo. Pequenos erros nos índices atrapalhavam o alinhamento das instruções, o que exigiu alguns testes para ajustar. Outra parte que exigiu atenção foi o tratamento da entrada das instruções pelo usuário, especialmente para evitar problemas com o caractere de nova linha que vem do fgets. A atividade ajudou a visualizar como o pipeline permite que várias instruções sejam processadas ao mesmo tempo, cada uma em uma etapa diferente da UCP. Isso torna o sistema mais eficiente, pois reduz o tempo de espera entre uma instrução e outra, aproveitando melhor os recursos do processador. No geral, o desafio foi útil para entender melhor o funcionamento do pipeline e reforçar os conceitos vistos na disciplina.
CurtirCurtir
Aluno: Lucas Godoy Martins
RA: 2649560
#include <stdio.h>
#include <stdlib.h>
#define MAX_INSTRUCOES 10
#define ESTAGIOS 6
typedef struct {
int id;
int tempo_inicio[ESTAGIOS];
int tempo_fim[ESTAGIOS];
} Instrucao;
void simular_pipeline(int n) {
Instrucao instrucoes[MAX_INSTRUCOES];
int tempo_atual = 1;
for (int i = 0; i < n; i++) {
instrucoes[i].id = i + 1;
for (int j = 0; j < ESTAGIOS; j++) {
int depende_instru_prev = (i > 0) ? instrucoes[i – 1].tempo_inicio[j] + 1 : tempo_atual;
int depende_etapa_prev = (j > 0) ? instrucoes[i].tempo_fim[j – 1] + 1 : tempo_atual;
instrucoes[i].tempo_inicio[j] = (depende_instru_prev > depende_etapa_prev) ? depende_instru_prev : depende_etapa_prev;
instrucoes[i].tempo_fim[j] = instrucoes[i].tempo_inicio[j];
}
}
printf(“Simulação do Pipeline (%d instruções):n”, n);
printf(“Tempo de execução por estágio:nn”);
for (int i = 0; i < n; i++) {
printf(“Instrução %d: “, instrucoes[i].id);
for (int j = 0; j < ESTAGIOS; j++) {
printf(“[E%d: %2d] “, j + 1, instrucoes[i].tempo_inicio[j]);
}
printf(“n”);
}
}
int main() {
int num_instr;
printf(“Digite o número de instruções a simular (até %d): “, MAX_INSTRUCOES);
scanf(“%d”, &num_instr);
if (num_instr > 0 && num_instr <= MAX_INSTRUCOES) {
simular_pipeline(num_instr);
} else {
printf(“Número inválido!n”);
}
return 0;
}
Relatório
Durante o desenvolvimento da simulação do pipeline em C, uma das maiores dificuldades foi coordenar corretamente os diferentes estágios das instruções ao longo dos ciclos de clock. Também foi desafiador criar um sistema de controle de tempo que garantisse o avanço ordenado e sincronizado das instruções no pipeline. Além disso, a implementação da execução paralela, respeitando as dependências entre estágios e instruções, exigiu atenção especial. A técnica de pipeline se mostrou eficiente por permitir a execução simultânea de várias instruções em estágios distintos, o que contribui para a redução do tempo total de processamento e para o aumento do desempenho da UCP.
CurtirCurtir
Lucas Fares Corrêa Auad Pereira | RA: 2706652
import time
estagios = [“IF”, “ID”, “EX”, “MEM”, “WB”]
instructions = [
“LOAD R1, 0(R2)”,
“ADD R3, R1, R4”,
“SUB R5, R3, R6”,
“STORE R5, 0(R2)”,
“NOP” # No Operation, usada para simular bolhas ou espera
]
pipeline_state = {}
def print_pipeline_state(cycle):
print(f”Ciclo {cycle}:”)
for instr, stage in pipeline_state.items():
print(f” {instr}: {stage}”)
print(“-” * 40)
def pipeline_simulation(instructions):
total_cycles = len(instructions) + len(estagios) – 1 # ciclos necessários para completar todas
for cycle in range(total_cycles):
# Atualiza o estágio de cada instrução
for i in range(len(instructions)):
instr = instructions[i]
stage_index = cycle – i # define em que estágio a instrução está
if 0 <= stage_index < len(estagios):
pipeline_state[instr] = estagios[stage_index]
elif stage_index >= len(estagios):
pipeline_state[instr] = “Concluído”
print_pipeline_state(cycle + 1)
time.sleep(1) # Simula o tempo de clock (remover se quiser mais rápido)
pipeline_simulation(instructions)
Minhas dificuldades foram em volta, da dinâmica única em paralelo das instruções, especialmente sobre a lógica de ciclos (e a implementação do clock). O pipeline melhora a concorrência no sistema ao permitir que várias instruções sejam executadas simultaneamente em diferentes etapas.
CurtirCurtir
Aluna: Thainá Tamiris Souza Dionisio | RA: 2768810
Olá, professor!
Segue o link da minha atividade referente ao Desafio de Pipeline da disciplina de Organização de Computadores:
🔗 https://colab.research.google.com/drive/1J-B9V8GRQ95TQ9qSzC-jqskrZoGJkRvy?usp=sharing
A simulação foi feita com um pipeline de 7 estágios, instruções dinâmicas e contagem de ciclos conforme solicitado.
No final do notebook está o relato sobre as dificuldades encontradas e como o pipeline contribui com a concorrência nos sistemas computacionais.
Agradeço a atenção!
CurtirCurtir
Aluno: João Victor Monteiro | RA: 2706644
Segue o link dos testes em Windowns e Linux e relatório:
relatório e testes
Considerações :
A implementação desenvolvida demonstra com sucesso os conceitos fundamentais de pipeline, incluindo o tratamento básico de hazards e a execução paralela de instruções. O código atende a todos os requisitos especificados, proporcionando uma base sólida para estudos mais avançados sobre arquitetura de processadores. Ainda que há pontos de melhoria no código, como representar de forma fidedigna um processamento paralelo em um código que é interpretado sequencialmente e transformar os parâmetros de mudança de cor em constantes.
Dificuldades:
• Criação de funções assertivas para a simulação;
• Debugging conforme a complexidade aumentava;
• Implementar um looping sem estragar a lógica;
• Visualização clara do estado do pipeline;
• Simular e resolver os Hazards;
• Padronizar UT-8 BR;
• Identificar redundâncias.
CurtirCurtir
#include <stdio.h>
#include <string.h>
// relat�rio ao final do c�digo
// Array global para armazenar os nomes das tarefas (est�gios do pipeline)
char tarefa[7][20];
// Fun��o para inicializar os nomes das tarefas
void declaracao_das_tarefas(void) {
strcpy(tarefa[0], “Busca”);
strcpy(tarefa[1], “Decodificacao”);
strcpy(tarefa[2], “Calculando”);
strcpy(tarefa[3], “Execucao”);
strcpy(tarefa[4], “Memoria”);
strcpy(tarefa[5], “Saida”);
strcpy(tarefa[6], “Conclusao”);
}
int main() {
declaracao_das_tarefas();
int qtd_instrucoes;// Vari�vel para armazenar a quantidade de instru��es a serem simuladas.
int pipeline_matriz[100][106]; // Cada linha � uma instru��o, cada coluna um ciclo de clock.
int i, j; // Vari�veis de controle para os loops
int tipo_visualizacao; // Vari�vel para escolher o tipo de visualiza��o (matriz de n�meros ou lista de nomes)
printf(“— Simulador de Pipeline (7 Estagios) —n”);
printf(“Digite a quantidade de instru��es a serem simuladas (max 100): “);
scanf(“%d”, &qtd_instrucoes);
// Valida��o b�sica da entrada para evitar estouro de buffer na matriz
if (qtd_instrucoes <= 0 || qtd_instrucoes > 100) {
printf(“Quantidade de instrucoes invalida. Digite um valor entre 1 e 100.n”);
return 1; // Retorna com erro
}
// — Inicializa��o da Matriz —
int num_colunas = 6 + qtd_instrucoes;
for (i = 0; i < qtd_instrucoes; i++) {
for (j = 0; j < num_colunas; j++) {
pipeline_matriz[i][j] = 0;
}
}
// — Preenchimento do Pipeline na Matriz —
for (i = 0; i < qtd_instrucoes; i++) {
for (j = 0; j < 7; j++) {
// pipeline_matriz[instrucao_atual][ciclo_de_clock] = numero_do_estagio
pipeline_matriz[i][i + j] = j + 1;
}
}
printf(“n— Escolha o modo de visualizacao —n”);
printf(“1- Visualizacao numerica da matrizn”);
printf(“2- Visualizacao com nomes das tarefasn”);
printf(“Escolha: “);
scanf(“%d”, &tipo_visualizacao);
// — Apresenta��o dos Resultados —
if (tipo_visualizacao == 1) {
printf(“n— Visualizacao Num�rica da Matriz (Estagios) —n”);
// Imprime o cabe�alho dos ciclos de clock
printf(“Inst\Ciclo|”);
for (j = 0; j < num_colunas; j++) {
printf(“%3d”, j + 1); // N�mero do ciclo
}
printf(“n———–“);
for (j = 0; j < num_colunas; j++) {
printf(“—“);
}
printf(“n”);
for (i = 0; i < qtd_instrucoes; i++) {
printf(“Instrucao %-2d |”, i + 1); // R�tulo da instru��o
for (j = 0; j < num_colunas; j++) {
printf(“%3d”, pipeline_matriz[i][j]); // Imprime o n�mero do est�gio ou 0
}
printf(“n”);
}
// LEGENDA para a visualiza��o num�rica
printf(“n+——————–+”);
printf(“n| %-19s|”, “1-Busca”);
printf(“n| %-19s|”, “2-Decodificacao”);
printf(“n| %-19s|”, “3-Calculando”);
printf(“n| %-19s|”, “4-Execucao”);
printf(“n| %-19s|”, “5-Memoria”);
printf(“n| %-19s|”, “6-Saida”);
printf(“n| %-19s|”, “7-Conclusao”);
printf(“n+——————–+”);
} else if (tipo_visualizacao == 2) {
printf(“n— Visualizacao com Nomes das Tarefas —n”);
// Imprime o cabe�alho dos ciclos de clock
printf(“Inst\Ciclo|”);
for (j = 0; j < num_colunas; j++) {
printf(“%-15d”, j + 1); // N�mero do ciclo
}
printf(“n———–“);
for (j = 0; j < num_colunas; j++) {
printf(“—————“);
}
printf(“n”);
for (i = 0; i < qtd_instrucoes; i++) {
printf(“Instrucao %-2d |”, i + 1); // R�tulo da instru��o
for (j = 0; j < num_colunas; j++) {
if (pipeline_matriz[i][j] != 0) {
// Se a c�lula n�o for 0, imprime o nome da tarefa correspondente
printf(“%-15s”, tarefa[pipeline_matriz[i][j] – 1]);
} else {
// Se for 0, imprime um espa�o ou “0” para indicar que n�o tem tarefa
printf(“%-15s”, “—“); // Ou apenas “0”
}
}
printf(“n”);
}
} else {
printf(“Op��o de visualizacao invalida.n”);
}
return 0;
}
pois s� � executada uma linha de codigo por vez, sendo realmente uma simula��o, demonstra��o de um pipeline e n�o uma representa��o verdadeiramente funcional */
/* A dificuldade encontrada vou no alinhamento e organiza��o das tarefas nos loops for, outra dificuldade foi pensar como simular um pipelina em na linguagem C
CurtirCurtir
Aluno: Gabriel Henrique Ferreira Pirolo RA: a2768364
Boa noite, Segue abaixo o link do código final do desafio:
https://drive.google.com/drive/folders/149P65iBb5f5m8B6CfhTKB3jjoY9Y__hY?usp=drive_link
Considerações do desenvolvimento:
Uma forma que facilitou o desenovlvimento, foi levar em conta o exemplo do processo de lavagem de roupas, os PIPELINE_STAGES, seriam 4 estágios, no caso: lavar, secar, dobrar e guardar, e o “adicionarInstrucao” seria Roupas brancas e roupas coloridas por exemplo, dessa forma facilita o método de desenvolvimento do desafio de pipeline.
O código foi feito utilizando javascript e possui o principal auxilio de uma pipeline, a execução múltipla e paralela de tarefas. Alguns desafios foram encontrados no desenvolvimento, primeiramente o entendimento geral do conceito da
própria pipeline e estágios dentro da arquiterura de computadores, também é importante falar sobre o gerenciamento dos estágios da pipeline, se preocupando com o correto desenvolvimento lógico, e garantir que nenhum estágio subscreva outro. Mais um fator de dificuldade importante é o controle de conflitos que podem acontecer durante o processo, como por exemplo garantir que o avanço de uma instrução não afete as outras.
CurtirCurtir
GUSTAVO TUDELA FRUSSA
2612240
RELATO:
As principais dificuldades encontradas foram encontrar o tamanho necessário da matriz que simularia o funcionamento da pipeline, e ajustar o próprio para que ele não estourasse a pilha de memória, alterando o valor da variável “num_instruções”.
CÓDIGO (em c++):
#include <iostream>
//////////Gustavo Tudela Frussa RA: 2612240
int main()
{
int num_instru;
int i;
int j;
printf(“Digite a quantidade de instruçõesn”);
scanf(“%d”, &num_instru);
printf(“n”);
int mat[num_instru][6+num_instru]; //// cria uma matriz de tamanho i = número de instruções; e j = número de deslocamentos + numero de tarefas
for(i=0;i<num_instru;i++){ /////////// preenche a matriz com zeros
for(j=0;j<6+num_instru;j++){
mat[i][j] = 0;
}
}
for(i=0;i<num_instru;i++){ //////////// altera os zeros de acordo com o deslocamento das instruções
for(j=0;j<7;j++){
mat[i][j+i] = j+1;
}
}
for(i=0;i < num_instru; i++){ //////// apresenta a matriz que simula a pipeline para o usuário
for(j=0;j< num_instru+6;j++){
printf(“%d”,mat[i][j]);
}
printf(“n”);
}
printf(“n”);
printf(“Tarefas: n”);
printf(“1: Buscar n”);
printf(“2: Codificar n”);
printf(“3: Calcular n”);
printf(“4: Executar n”);
printf(“5: Armazenar n”);
printf(“6: Apresentar n”);
printf(“7: Encerrar n”);
return 0;
}
CurtirCurtir
Antonio Totti Goncalves RA: 2706571
1 – Desafio de programação da disciplina de Organização de Computadores:
Implementar na forma de simulação o funcionamento do pipeline em um sistema computacional. Exemplos: Fig. 1 e Fig.2.
Deverá conter UCP; fila com “n instruções”; possibilidade de criação de novas instruções; divisão de um pipeline em 7 tarefas diferentes; contador de tempo das instruções.
R:d#include
#include <string.h>
#define MAX_INST 10
#define N_ESTAGIOS 7
#define MAX_TEMPO 25
#define TAM_INST 50
const char* estagios[N_ESTAGIOS] = {“BI”, “DI”, “CO”, “BO”, “EX”, “EO”, “GR”};
void simular_pipeline(char instrucoes[MAX_INST][TAM_INST], int qtd) {
char pipeline[MAX_INST][MAX_TEMPO][4];
for (int i = 0; i < qtd; i++) {
for (int t = 0; t < MAX_TEMPO; t++) {
strcpy(pipeline[i][t], ” “);
}
}
for (int inst = 0; inst < qtd; inst++) {
for (int estagio = 0; estagio < N_ESTAGIOS; estagio++) {
int tempo = inst + estagio;
if (tempo < MAX_TEMPO) {
strcpy(pipeline[inst][tempo], estagios[estagio]);
}
}
}
printf(“nSimulacao do Pipeline (com %d instrucoes)nn”, qtd);
printf(“Tempo -> “);
for (int t = 0; t < MAX_TEMPO; t++) {
printf(“%3d “, t + 1);
}
printf(“n”);
for (int inst = 0; inst < qtd; inst++) {
printf(“Inst %2d: “, inst + 1);
for (int t = 0; t < MAX_TEMPO; t++) {
printf(“%s “, pipeline[inst][t]);
}
printf(“n”);
}
printf(“nInstrucoes digitadas:n”);
for (int i = 0; i < qtd; i++) {
printf(“Inst %2d: %sn”, i + 1, instrucoes[i]);
}
printf(“nTotal de ciclos (clocks): %dn”, qtd + N_ESTAGIOS – 1);
}
int main() {
int n;
char instrucoes[MAX_INST][TAM_INST];
printf(“Quantas instrucoes voce deseja simular (max %d)? “, MAX_INST);
scanf(“%d”, &n);
setbuf(stdin,NULL);
if (n <= 0 || n > MAX_INST) {
printf(“Numero invalido. Deve ser entre 1 e %d.n”, MAX_INST);
return 1;
}
printf(“nDigite as instrucoes (ex: ADD R1, R2, R3):n”);
for (int i = 0; i < n; i++) {
printf(“Instrucao %d: “, i + 1);
fgets(instrucoes[i], TAM_INST, stdin);
instrucoes[i][strcspn(instrucoes[i], “n”)] = ”; // Remove o n do final
}
simular_pipeline(instrucoes, n);
return 0;
}
Após a implementação, faça um relato sobre: às dificuldades encontradas; como o a técnica de pipeline auxilia na concorrência de um sistema computacional.
R: Implementar o simulador de pipeline apresentou como principal desafio a visualização da execução simultânea de diversas instruções em diferentes estágios. A organização da tabela, o controle temporal de cada instrução e a implementação de uma entrada de dados livre de falhas também demandaram atenção considerável.
Apesar dessas dificuldades, o projeto foi fundamental para a compreensão prática do funcionamento de um pipeline. Ao invés da execução sequencial de cada instrução em sua totalidade, o processador as divide em etapas, iniciando o processamento da instrução seguinte antes da conclusão da anterior. Essa sobreposição permite que múltiplas instruções sejam processadas concorrentemente, otimizando a velocidade global do sistema.
Através da implementação, foi possível observar concretamente o ganho de desempenho proporcionado pelo pipeline, que utiliza de forma mais eficiente o tempo e os recursos da unidade central de processamento (CPU).
CurtirCurtir