Frage zu for Schleife

Demnach müsste eigentlich der 1. Fall schneller sein, ist aber genau anders herum.

CStoll

10 Minuten? Wie groß sind denn die Schleifengrenzen m bzw. n? (btw, ist es Absicht, daß du zwar die Index-Variablen ausgetauscht hast, aber nicht die Grenzen?)

m = n = 100

Da sollte der Unterschied '(wenn es einen gibt) wenige Sekunden betragen (auf einem C64).

Bei dir ist irgend etwas anders faul.

CStoll

Und das Array hat wirklich 100*100 Elemente?
(ich hätte da einen Verdacht, den ich allerding nur mit mehr ausführlicherem Code erhärten oder widerlegen könnte)

cooky451

Die Schleifen sollten exakt gleich lange brauchen. Zeig mal bitte ausführbaren Code. (Zudem sind 10 Minuten völlig unrealistisch.)

#include <stdio.h>
#include "sys/alt_timestamp.h"

int n = 100;
    int m = 100;
    unsigned int time;
    int j;
    int k;

void program1()
{
	char p[n][m];

    alt_timestamp_start();
	for (k = 0; k < m; k++)
	{
		for (j = 0; j < n; j++) p[j][k] = 3;
	}
	time = alt_timestamp();

	printf("Time program 1: %d\n", time);
}

void program2()
{
	char p[n][m];

    alt_timestamp_start();
	for (j = 0; j < n; j++)
	{
		for (k = 0; k < m; j++) p[j][k] = 3;
	}
	time = alt_timestamp();

	printf("Time program 2: %d\n", time);
}

int main()
{
	program1();
    program2();
}

Ich muss dazu sagen, dass das alles über ein FPGA läuft. Ich hatte schon die Vermutung das es an dem Aufbau von dem FPGA liegen. Weil der auch einfach mal angefangen hat rumzufahren..

Blub123 schrieb:

Ich muss dazu sagen, dass das alles über ein FPGA läuft.

Na gerade noch rechtzeitig gesagt.

Ne, doch nicht.

berniebutt

Blub123 schrieb:

ok. aber was uch nciht verstehe.

ich habe jetzt 2 verschiedene möglichkeiten.
for (j=0; j<n; j++)
{
  for (k=0; k<m; k++)
  p[j][k] = 5;
}
und
for (k=0; k<n; k++)
{
  for (j=0; j<m; j++)
  p[j][k] = 5;
}
wieso läuft dann die zweite variante viel schneller durch ?

100 x 100 = 10000 Elemente in der Matrix. Das sollte kaum nennenswert Laufzeit beanspruchen. p[j][k] wird aber nicht als Matrix gespeichert, sondern als fortlaufender Array. Der Compiler rechnet
p[j][k] um. Der erste Paramter läuft vor dem zweiten Parameter. Richtet man die Laufvarablen j und k der beiden Schleifen darauf ein, werden Sprünge im Zugriff vermieden.

Bei 10000 Elementen von integer dürfte es noch keine gewaltigen Laufzeitunterschiede geben!

in program2 steht in der inneren Schleife j++ da muss k++ hin.