Zeitmessung einer Zuweisung?

Hallo,

Würde gerne wissen wie ich auf die Zeit komme wie lange eine Zuweisung dauert.
Eine Zuweisung in C/C++ braucht ja bestimmt sicher verdammt wenig zeit aber wie kann ich auf diese Zeit kommen da sie ja so kurz ist? Habe überlegt mehrere Zuweisungen zu messen am besten natürlich in einer Schleife aber ich will ja die zeit für die schleife ignorieren... wie mache ich das?
Danke schonmal

Hi,

wie sieht denn deine Zuweisung aus?
Die einzige Ahnung von der Dauer wirst du bekommen, wenn du dir das generierte Assemblerlisting anschaust. Dann kann man es abschätzen, wieviele Taktzyklen es dauert.

Aber die Sache mit den Schleifen wird jeder vernünftige Compiler wegoptimieren.

Ja einfach irgendeine Zuweisung wie zb foo = 0;
Kann man also auf die Zeit wie lange eine Zuweisung dauert nicht kommen?

Schonmal mit Time() probiert?

Ja sicher... aber die Zeit ist gleich 0.... Und wenn ich eine schleife stoppe bringt mir das ja nichts denn ich will ja nicht die Bedingungen in der Schleife mitstoppen...

Versuch doch mal, statt die Zuweisung mit 0 mit 1 zu initialisieren

Daran liegts nicht. Jede Zuweisung braucht "0" Zeit...

ZuK

dann kopiere halt viele viele zuweisungen im quelltext und stoppe die zeit.
Kurt

Das ist aber nicht gerade sehr elegant.... vorallem müsste ich dann auch wissen wie viele Zuweisungen ich hineinkopiert habe damit ich dann weiß wie lange eine braucht...

AJ

Hast du dich schon mal im Internet umgesehen, ob es Bibliotheken gibt, die im Mikro- bzw. Nanosekundenbereich die Zeit zählen können? Sowas wirst du wahrscheinlich brauchen, wenn du wirklich wissen willst, wieviel Zeit eine Zusweisung benötigt.

Wofür willst du das eigentlich wissen?

Interessehalber... Auch wundert mich warum diese Funktion überhaupt negative Werte zurückgeben kann:

double GetAllocationTime(int howManyAllocations) {
    clock_t start, finish;
    double durationLoop = 0.0f;
    double duration = 0.0f;
    int var = 0;

    start = clock();
    for(int i=0; i < howManyAllocations; i++) {
    }
    finish = clock();
    durationLoop = (double)(finish - start) / CLOCKS_PER_SEC;        
    cout << "Time needed for loop: " << durationLoop<<endl;

    start = clock();
    for(int i=0; i < howManyAllocations; i++) {
        var = 1000000;
    }
    finish = clock();
    duration = (double)(finish - start) / CLOCKS_PER_SEC;        

    return duration - durationLoop;
}

ZuK

Na ja elegant ist es natürlich nicht und wenn du beim kopieren nicht mitzählen willst dann wird dir nichts anderes übrig bleiben als den asm-code zu analysieren und taktzyklen zu zählen wie SeppSchrot schon gesagt hat.
Kurt.

net 0

hat eigentlich irgendwer die antwort von 'seppschrot' gelesen

Elegant sicher nicht nein... Aber warum können überhaupt negative Werte herauskommen..... Und geht es wirklich nicht irgendwie mit stoppen????

Ähm................

Was ähm???

sag ma, geht denn das nich einfacher?

xroads42

ähh, in der funktion wo gemessen wird wieviel zeit gebraucht wird zind bestimmt zig zuweisungen drin. Eine einzelne zuweisung zu messen is nonsence.
Aber man kann es abschätzen, indem man sich den assemblercode anschaut. Dort sieht man dann z.B. einen MOV AX, blub ( oder so ähnlich ^^). und für diesen befehl(e) kann man nachschauen wieviele takte er braucht. das rechnet man dann eben hoch.

DeSoVoDaMu

Ist jetzt zwar afaik nur unter Windows nutzbar, aber zum genauen Zeitmessen sollte es erstmal gehen:

LARGE_INTEGER nFrequency, nBegin, nEnd;

    QueryPerformanceFrequency(&nFrequency);
    printf("Frequency: \t%d Hz\n", nFrequency.QuadPart);

	QueryPerformanceCounter(&nBegin);

	///////////////////////////////////

    Sleep(1000); // <-hier code, dessen Zeit gemessen werden soll, einfügen

	///////////////////////////////////

	QueryPerformanceCounter(&nEnd);

    printf("Begin:     \t%d\n", nBegin.QuadPart);
    printf("End:       \t%d\n", nEnd.QuadPart);
    printf("Difference:\t%d\n", nEnd.QuadPart - nBegin.QuadPart);
    printf("Time:      \t%4.15f s\n", static_cast<double>(nEnd.QuadPart - nBegin.QuadPart) / nFrequency.QuadPart);

Allerdings kamen bei mir auch kein wirklich brauchbaren Werte heraus, habe es aber auch nur mit einer Zuweisung probiert.
Gruss,
DeSoVoDaMu