Was ist die schnellere Operation?

[Herbie (Gast)]

Hallo,

ich hätte da mal eine Frage zur Abarbeitung einiger Befehle.

Bits setzen per define:

#define setzen1 11001100
#define setzen2 11001011

reg1 = setzen1;
[Something to do]
reg1= setzen2;
[Something to do]
reg1 = setzen1;

bits setzen durch log. Ops:

reg1= 11001100;
[something to do]
reg1 &= ~(1<< 2);
reg1 |=11;
[something to do]
reg1 &= ~((1<<1)|(1<<0));
reg1 |= (1<<2);

oder (falls das überhaupt geht):

reg1= 11001100;
[something to do]
reg1^=((1<<2) | (1<<1) | (1<<0));

Meine Frage nun, sofern die Operationen funktionieren, welche davon 
verwendet man am Häufigsten bzw. welche ist die schnellste?
Und: Bitte um Korrektur, wenn ich Operationen falsch umgesetzt habe.

Vielen Dank für eure Hilfe.

gruß
Herbie

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Herbie schrieb:
> welche ist die schnellste?
Wofür?
Welche Zielplattform?

Z.B. ist ein Formel-1 Rennwagen der schnellste auf der Straße, aber auf 
dem Feld ist ein Traktor schneller... :-/

[Herbie (Gast)]

Oh, entschuldigung.

Ich meinte, welche Operation ist auf einem Mikrocontroller der 
ATMega-Serie (AVR) am Schnellsten durchzuführen?
Z.B. als Interrupt-Operation. Da sollen die Befehle ja möglichst schnell 
abgearbeitet werden.
In dem Register sollen halt nur ein paar Bits umgeschrieben werden.

Danke für den Hinweis.

[Herbie (Gast)]

Schreiben will ich in C mit Eclipse.

[X- R. (x-rocka)]

Kompiliere es doch mal und schau dir das listing / assembler an.
Generell ist es schneller, wenn reg = const als reg = (viele logische 
ops).
Andererseits sieht das der Compiler vielleicht und macht ne Konstante 
draus...

[Udo S. (urschmitt)]

Ich verstehe ehrlich gesagt die Frage nicht so richtig.
Die beiden Teile sind nicht äquivalent, sie machen unterschiedliche 
Dinge.
Die 3 Zuweisungen sind bestimmt nicht so zeitkritisch, daß Du hier über 
eine Optimierung nachdenken müsstest.
Interessant ist da eher der Teil [something to to]

[Herbie (Gast)]

Udo Schmitt schrieb:
> Die beiden Teile sind nicht äquivalent, sie machen unterschiedliche
> Dinge.

Die 3 Teile sollten eigentlich alle das Gleiche machen.

Herbie schrieb:
> reg1= 11001100;
> [something to do]
> reg1^=((1<<2) | (1<<1) | (1<<0));

Da habe ich noch vergessen:

 [something to do]
reg1^=((1<<2) | (1<<1) | (1<<0));

(denke ich).

Wo ist denn der Fehler, wenn die nicht alle das Gleiche machen?

[Udo S. (urschmitt)]

Sorry ich verstehs nicht, welche Teile von dem Code sollen gleich sein?
Kann jetzt aber auch nicht mehr weiter reinschauen, muss arbeiten, 
sorry.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Herbie schrieb:
> Meine Frage nun, sofern die Operationen funktionieren, welche davon
> verwendet man am Häufigsten bzw. welche ist die schnellste?
Ich würde die Variante 1 nehmen, denn dann könnte ich einfach durch ein 
Ändern des #defines definierte andere Werte auf das reg1 schreiben.
Bei den anderen beiden Versionen ist das wesentlich versteckter...

[Herbie (Gast)]

Das Setzen des Register reg1 soll am Ende immer gleich sein.

Also zwischen den [something to do]-Abschnitten.
Das erste Mal soll 11001100 in reg1 stehen. Dann kommt [something to 
do], danach soll 11001011 in reg1 stehen. Dann wieder [something to do] 
und danach soll wieder 11001100
 in reg1 stehen.

Udo Schmitt schrieb:
> Kann jetzt aber auch nicht mehr weiter reinschauen, muss arbeiten,
> sorry.

Ok, danke für deine Hilfe. Viel Spaß beim Arbeiten.

[AVR-Fan (Gast)]

Ich würde das Ganze im Simulator vom AVR-Studio ablaufen lassen.

Da gibt es für die Zeit und die Anzahl der Zyklen
eine gute Anzeige, kann man sogar rücksetzen.

[Herbie (Gast)]

Lothar Miller schrieb:
> Ich würde die Variante 1 nehmen, denn dann könnte ich einfach durch ein
> Ändern des #defines definierte andere Werte auf das reg1 schreiben.
> Bei den anderen beiden Versionen ist das wesentlich versteckter...

Danke sehr. Die andern beiden Versionen wären halt variabel; aber 
defines sind übersichtlicher.
Wäre denn die 1. Variante auch am Schnellsten oder tun die sich da alle 
nicht viel?

[Herbie (Gast)]

AVR-Fan schrieb im Beitrag #1965931:
> Ich würde das Ganze im Simulator vom AVR-Studio ablaufen lassen.

Das habe ich leider nicht. Also ich kann es nicht über die 
Entwicklungsumgebung testen.
(Zumindest momentan nicht)

[<yxcvbnm,.- (Gast)]

ein blick in die assembler-doku hilft weiter bezgl der 
ausführungszeiten.
da ein c-compiler mit unterschiedlichen optimierungs-varianten arbeiten 
kann, ist auch der generierte assembler-code unterschiedlich.

generell schlägt eine logische operation mit einem takt zu buche, 
genauso eine zuweisung. zusätzlich können noch stack-operationen 
dazukommen, da man in c nicht so viel kontrolle über die einzelnen 
register hat wie in assembler

[(prx) A. K. (prx)]

> reg1 &= ~((1<<1)|(1<<0));
> reg1 ^= ((1<<2) | (1<<1) | (1<<0));

In beiden Varianten läuft das bei reg1 = I/O-Register auf laden, 
modifizieren, speichern als 3 getrennte Operationen raus.

> reg1 |= (1<<2);

Wenn reg1 im bitadressierbaren Bereich der I/O-Ports liegt, dann ist das 
ein einziger Befehl, somit effizienter. Wenn nicht, dann lauft das genau 
wie oben.

[Peter (Gast)]

A. K. schrieb:
> In beiden Varianten läuft das auf laden, modifizieren, speichern als 3
> getrennte Operationen raus.

das muss aber nicht sein, die variable kann ja schon in einem Register 
stehen. Bzw. sie kann eine Lokale Variable sein und nur in einem 
Register vorhanden sein.

[(prx) A. K. (prx)]

Yep, ich ging davon aus, dass sich die Frage auf I/O-Ports bezieht.