scusate qualcuno sa dirmi come fare un programma in assembler 68000 che chiede di trovare il massimo in un vettore ed eliminarlo?
Grazie e scusate per il disturbo

freddy ha scritto:
scusate qualcuno sa dirmi come fare un programma in assembler 68000 che chiede di trovare il massimo in un vettore ed eliminarlo?
Grazie e scusate per il disturbo
Si possono realizzare due cicli di loop. Il primo serve a trovare il valore massimo, il secondo a scrivere il nuovo vettore (non è possibile sovrascrivere quello vecchio), il quale deve avere stessi valori del precedente, tranne il valore massimo.


Per prima cosa si caricano gli indirizzi effettivi iniziali del vettore d'ingresso e di quello d'uscita (con le istruzioni MOVEA.L oppure LEA), in modo da poter poi usare l'indirizzamento indiretto di memoria (con o senza auto-incremento). Per esempio, carichiamo l'indirizzo del vettore di ingresso in A0 e quello che ospiterà il vettore d'uscita in A1.

Ripulisci due registri di dati con CLR
1) Uno va usato come buffer temporaneo in cui memorizzare di volta in volta il valore maggiore finora acquisito (facciamo che sia D1)
2) L'altro va usato come contatore per segnalare l'indice del valore nel vettore esaminato, in modo poi da incrementarlo ad ogni ciclo di loop e confrontarlo col valore (facciamo che sia D2)

All'interno del ciclo di loop, usa l'istruzione di comparazione CMP (magari con l'autoincremento su A0) in modo da confrontare il valore corrente del vettore (puntato tramite il modo di indirizzamento indiretto) con il contenuto del registro di buffer (che inizialmente dovrà essere 0, avendolo resettato con CLR per sicurezza). Realizza quindi un "costrutto if", tale che, se il valore del vettore risulta maggiore di quello di D1:
1) il valore puntato del vettore viene spostato proprio all'interno di D1.
2) Sposta il valore dell'indice finora raggiunto (ovvero il contenuto di D2) in un altro registro dati (supponiamo che sia D3). In questo modo si tiene memoria dell'indice del valore maggiore finora trovato e spostato in D1.

Ad ogni ciclo di loop si incrementa l'indice D2, quindi lo si confronta con il numero dei valori contenuti nel vettore per capire se il ciclo deve finire.

Alla fine di tutto questo, quindi, il valore massimo del vettore sarà scritto in D1 (anche se non interesserà più, a meno che il problema non richieda di conoscerlo) e la sua posizione in D3.

A questo punto, carichiamo nuovamente un registro d'indirizzo col valore del vettore d'ingresso, visto che nel ciclo precedente abbiamo già usato l'autoincremento. Resettiamo anche D2, per usarlo nuovamente come contatore a partire da 0.

Facciamo un nuovo ciclo di loop (anche usando opportunatamente DBRA o altro), stavolta in modo da comparare il contenuto del contatore D2 con D3 (il quale a questo punto dovrebbe puntare alla posizione del massimo che vogliamo eliminare). Sfruttiamolo per realizzare un costrutto if else:
1) Se D2 è diverso da D3, sposta semplicemente il contenuto del vettore d'ingresso nel vettore d'uscita, magari sfruttando l'autoincremento su entrambi.
2) Se D2=D3 non spostare il contenuto del vettore d'ingresso a quello d'uscita, visto che corrisponde al massimo da eliminare

PS: Uhm, a ben pensarci forse avrei fatto prima a risolverlo direttamente XD

sono molto scocciante vero se ti chiedessi di scrivermelo??grazie

oltre quello che ti ho appena chiesto,volevo farti una domanda riguardante la parte sequenziale..quando mi dice sequenze di bit parzialmente sovrapposte,vuol dire non sovrapposte?cioè mi spiego:la sequenza 1011 all ultimo stato D arriva la sequenza 101 ora devo vedere che succede se l'ingresso è 0 oppure 1
-se è 1 potrei tornare allo stato B se le sequenze fossero sovrapposte(cioè lo stato B che contiene il bit 1 potrebbe essere l inizio di una nuova sequenza),ma dato che il testo mi dice sequenze parzialmente sovrapposte torno allo stato iniziale A,è giusto come ragionamento?

collegandomi a quello che ti ho appena detto mi puoi far vedere come fai il grafo di riconoscitore di queste 2 sequenze parzialmente sovrapposte?1000 e 1010 contemporaneamente però..grazie

Per favore, evita di fare post multipli.

L'esercizio assembly almeno prova a scriverlo e a mostrarmelo (se non ti convince), te l'ho anche spiegato chiaramente, poi se hai proprio difficoltà vedremo.


Quando l'esercizio chiede di considerare le sequenze d'ingresso sovrapposte, s'intendono due cose:
1) l'ingresso è seriale, quindi i bit d'ingresso non sono da considerare assegnati,
2) l'uscita può portarsi ad 1 anche dopo aver ricevuto due sequenze adatte ma in parte sovrapposte, senza dover aspettare di considerare altri n bit. Ciò vuol dire che non bisogna necessariamente tornare allo stato iniziale dopo aver ottenuto un'uscita alta (dipende dal problema).

Se invece non sono permesse sequenze parzialmente sovrapposte, una volta fornita la prima uscita alta bisogna tornare sempre allo stato iniziale


Riporto qui l'esempio spiegato chiaramente di una traccia d'esame.
Riconoscimento di ogni sequenza del tipo 1-x-0, dove il simbolo x è da intendere come un valore booleano qualsiasi. Ovvero, la macchina deve riconoscere sia 110 che 100.
Si noti che la macchina deve poter riconoscere anche sequenze parzialmente sovrapposte. Ad esempio, la sequenza di ingresso 1-1-0-0 produce in uscita due impulsi in corrispondenza del terzo e del quarto ciclo, uno per il riconoscimento della stringa 1-1-0 e l’altro per la stringa 1-0-0.

Nel caso del riconoscitore a sequenze sovrapposte da te richiesto, in grado di riconoscere 1000 e 1010, se l'ingresso è ad esempio 101000 l'uscita sarà 0001001, perchè ha riconosciuto prima 1000 e poi 1010.

Il grafo dovrebbe essere il seguente.
https://www.dropbox.com/s/r2qduqxnzj39yms/2014-02-23%2019.45.39.jpg

In pratica, per accertarti di scriverlo correttamente, riporta ad ogni stato i valori riconosciuti fino a quel momento e considera quale sarà l'ultima sequenza utile che si otterrà col prossimo ingresso.
Oppure, semplicemente, considera tutte le possibili transizioni, anche se escono fuori molti stati, tanto poi dovrai comunque minimizzare in seguito.

ma non ho capito una cosa..qual'è la differenza tra parzialmente e totalmente sovrapposte??nel testo mi diceva parzialmente,quindi ciò vuol dire che all ultimo stato devo tornare per forza allo stato iniziale,perchè non devono sovrapporsi no?

Non mi risulta esista il caso di sequenze "totalmente" sovrapposte °° (non avrebbe senso, due ingressi davvero sovrapposti per funzionare dovrebbero essere uguali). L'hai trovato scritto in qualche problema o ti è solo venuto il dubbio, visto che a volte è richiesto che siano "parzialmente sovrapposte"?

nel testo mi diceva parzialmente,quindi ciò vuol dire che all ultimo stato devo tornare per forza allo stato iniziale,perchè non devono sovrapporsi no?
Veramente è il contrario, rileggi meglio la mia spiegazione.
Se il problema richiede esplicitamente che le sequenze d'ingresso possono essere "parzialmente sovrapposte", nel caso si arrivi ad ottenere uscita 1 potrebbe non essere necessario tornare allo stato iniziale (dipende dal caso in esame).
Se invece non è richiesto che siano parzialmente sovrapposte e i bit di ingresso non sono assegnati, cioè l'ingresso è seriale (non c'è un nome specifico per questo caso generico), una volta che si arriva all'uscita 1 bisogna tornare sempre e comunque allo stato iniziale, perchè non è ammesso che la nuova sequenza d'ingresso possa essere sovrapposta alla precedente per ottenere il nuovo risultato.


Chiedo scusa, ho notato solo ora che nell'esempio di prima sui risultati ho confuso l'ordine degli ingressi, lo riscrivo.
"Nel caso del riconoscitore a sequenze sovrapposte da te richiesto, in grado di riconoscere 1000 e 1010, se l'ingresso è ad esempio 101000 l'uscita sarà 000101, perchè ha riconosciuto prima 1010 e poi 1000"

Nel caso invece non fosse stato a sequenze sovrapposte, ricevendo in ingresso 101000, l'uscita sarebbe stata 000100, perchè riconosce solo 1010 e poi torna allo stato iniziale (in cui in questo caso rimane, visto che poi riceve altri due 0 che non lo fanno passare allo stato successivo).

ok grazie....