Duvidasassembly

Está aparecendo alguns erros porém não estou conseguindo arrumar, se alguém conseguir me ajudar, Grata. Segue Código. # include <stdio.h> # include <stdlib.h> # include <stdbool.h> # include <math.h> # include <string.h> #include <iostream> # define MAX 1024 # define LOG2 ( valor ) ( sem sinal ) (log (valor) / log ( 2 )) static char memoria_principal [MAX] = " " ; struct caminho { bool bit_validade; tag int sem sinal; sem assinatura int sujo; void * bloco; }; typedef struct caminho; struct conjunto { Caminho * caminho; }; typedef struct conjunto Conjunto; struct cache { Conjunto * conjuntos; unsigned int size_bloco; unsigned int num_linhas; unsigned int num_conjuntos; unsigned int qtd_caminho; int cache_miss; int cache_hit; }; typedef struct cache Cache; Cache * cria_cache ( int num_linhas, int size_bloco, int qtd_caminho) { int i, j; Cache * cache = (Cache *) malloc ( sizeof (Cache)); cache-> num_linhas = num_linhas; cache-> size_bloco = size_bloco; cache-> qtd_caminho = qtd_caminho; cache-> num_conjuntos = num_linhas / qtd_caminho; cache-> conjuntos = (Conjunto *) malloc ( sizeof (Conjunto) * cache-> num_conjuntos ); cache-> cache_miss = 0 ; cache-> cache_hit = 0 ; para (i = 0 ; i < cache-> num_conjuntos; i ++) { cache-> conjuntos [i]. caminho = (Caminho *) malloc ( sizeof (Caminho) * qtd_caminho); para (j = 0 ; j < qtd_caminho; j ++) { // cache-> conjuntos [i] .caminho [j] .bloco = malloc (sizeof (char) * size_bloco); cache-> conjuntos [i]. caminho [j]. bloco = calloc (cache-> size_bloco , sizeof ( char )); cache-> conjuntos [i]. caminho [j]. bit_validade = falso ; cache-> conjuntos [i]. caminho [j]. tag = 0 ; cache-> conjuntos [i]. caminho [j]. sujo = 0 ; } } cache de retorno ; } void imprime_cache (Cache * cache) { int i = 0 , j = 0 , k = 0 ; para (i = 0 ; i < cache-> num_conjuntos ; i ++) { printf ( " --------------------------- Conjunto % d ----------------- ---------- \ n " , i); para (j = 0 ; j < cache-> qtd_caminho ; j ++) { printf ( " caminho % d : \ n " , j); para (k = 0 ; k < cache-> size_bloco ; k ++) { printf ( " | % c | " , (( char *) cache-> conjuntos [i]. caminho [j]. bloco ) [k]); } printf ( " \ n " ); } printf ( " ----------------------------------------------- ------------------- \ n " ); } } int conjuto_cheio (Cache * cache, unsigned int indice_conjunto) { int i; para (i = 0 ; i < cache-> qtd_caminho ; i ++) { if (cache-> conjuntos [indice_conjunto]. caminho [i]. bit_validade == false ) { return i; } } retorno - 1 ; } int busca_conjunto (Cache * cache, tag int , unsigned int indice_conjunto) { int i; para (i = 0 ; i < cache-> qtd_caminho ; i ++) { if (cache-> conjuntos [indice_conjunto]. caminho [i]. tag == tag && cache-> conjuntos [indice_conjunto]. caminho [i]. bit_validade ) { return i; } } retorno - 1 ; } void comum_cache (Cache * cache, unsigned int indice_caminho, unsigned int indice_conjunto, unsigned int tag, unsigned int indice_bloco, unsigned int endereco) { int i; para (i = 0 ; i < cache-> size_bloco ; i ++) { if ((i + indice_bloco) > cache-> size_bloco || (i + endereco) > MAX) { pausa ; } (( char *) cache-> conjuntos [índice_conjunto]. caminho [índice_caminho]. bloco ) [indice_bloco + i] = memoria_principal [endereco + i]; } cache-> conjuntos [indice_conjunto]. caminho [indice_caminho]. tag = tag; cache-> conjuntos [indice_conjunto]. caminho [indice_caminho]. bit_validade = verdadeiro ; cache-> conjuntos [indice_conjunto]. caminho [indice_caminho]. sujo ++; } int FIFO (Cache * cache, unsigned int indice_conjunto) { int i, sujo_aux = 0 ; para (i = 0 ; i < cache-> qtd_caminho ; i ++) { if (cache-> conjuntos [índice_conjunto]. caminho [i]. sujo <sujo_aux> cache-> conjuntos [índice_conjunto]. caminho [sujo_aux]. sujo ) { sujo_aux = i; } } return sujo_aux; } char le_cache ( unsigned int endereco, Cache * cache) { sem sinal int numBit_bloco = LOG2 (cache-> size_bloco ); sem sinal int numBit_conjunto = LOG2 (cache-> num_conjuntos ); sem sinal int numBit_tag = 32 - (numBit_bloco + numBit_conjunto); unsigned int indice_caminho = 0 ; // primeiro caminho com NULL; unsigned int indice_bloco = (cache-> size_bloco - 1 ) & endereco; // numero do bloco que eu vou acessar em alguma linha. unsigned int indice_conjunto = (((cache-> num_conjuntos - 1 ) << numBit_bloco) & endereco) >> numBit_bloco; tag int sem sinal = ((((( int sem sinal )) ( pow ( 2 , numBit_tag) - 1 )) << (numBit_bloco + numBit_conjunto)) & endereco)) >> (numBit_bloco + numBit_conjunto); / * printf ("% d \ n", indice_bloco); printf ("% d \ n", indice_linha); printf ("% d \ n", tag); * / indice_caminho = busca_conjunto (cache, tag, indice_conjunto); // printf ("% d \ n", indice_caminho); if (indice_caminho! = - 1 ) { cache-> cache_hit ++; } else { cache-> cache_miss ++; indice_caminho = conjuto_cheio (cache, indice_conjunto); // retorna primeiro caminho livre if (indice_caminho! = - 1 ) { pode_cache (cache, indice_caminho, indice_conjunto, tag, indice_bloco, endereco); } else { indice_caminho = FIFO (cache, indice_conjunto); pode_cache (cache, indice_caminho, indice_conjunto, tag, indice_bloco, endereco); } } return (( char *) cache-> conjuntos [indice_conjunto]. caminho [indice_caminho]. bloco ) [indice_bloco]; } int main () { Cache * cache = cria_cache ( 16 , 4 , 4 ); // linha, bloco tam, qtd caminho imprime_cache (cache); strcat (memoria_principal, " Arquitetura de computadores " ); para ( int i = 0 ; i < strlen (memoria_principal); i ++) { printf ( " % c " , le_cache (i, cache)); } printf ( " \ n \ n \ n ESCREVENDO NA CACHE ...... \ n \ n \ n " ); printf ( " \ n Cache perdido: % d \ n Cache atingido: % d \ n " , cache-> cache_miss , cache-> cache_hit ); imprime_cache (cache); return 0; } }

.int main() { int tabuleiro[5]; int j1,i,ant; int erro1=0; int erro2=0; tabuleiro[1]=1; tabuleiro[2]=3; tabuleiro[3]=2; tabuleiro[4]=4; tabuleiro[0]=0; while(1) { erro1=0; erro2=0; printf("player 1 faça sua jogada qual peça gostaria de mover(os impares)\n"); grafico(tabuleiro); scanf("%d",&j1); i=encontrar(j1,tabuleiro); if(i==1){ if(tabuleiro[0]==0) { ant=tabuleiro[i]; tabuleiro[i]=0; tabuleiro[0]=ant; } else if (tabuleiro[3]==0) { ant=tabuleiro[i]; tabuleiro[i]=0; tabuleiro[3]=ant; } else { printf("nao pode mexer essa peça,tente mexer a outra\n"); erro1++; } }