Dazu habe ich die folgenden 2 defines geschrieben

#define absDiff(a1,a2) (((a1)>(a2))?a1-a2:a2-a1)
#define CalculateDifference(a,b) \
 absDiff(a[0*imSizeX+0],b[0*imSizeX+0])+absDiff(a[0*imSizeX+1],b[0*imSizeX+1])+absDiff(a[0*imSizeX+2],b[0*imSizeX+2])+absDiff(a[0*imSizeX+3],b[0*imSizeX+3])\
+absDiff(a[0*imSizeX+4],b[0*imSizeX+4])+absDiff(a[0*imSizeX+5],b[0*imSizeX+5])+absDiff(a[0*imSizeX+6],b[0*imSizeX+6])+absDiff(a[0*imSizeX+7],b[0*imSizeX+7])\
+absDiff(a[1*imSizeX+0],b[1*imSizeX+0])+absDiff(a[1*imSizeX+1],b[1*imSizeX+1])+absDiff(a[1*imSizeX+2],b[1*imSizeX+2])+absDiff(a[1*imSizeX+3],b[1*imSizeX+3])\
+absDiff(a[1*imSizeX+4],b[1*imSizeX+4])+absDiff(a[1*imSizeX+5],b[1*imSizeX+5])+absDiff(a[1*imSizeX+6],b[1*imSizeX+6])+absDiff(a[1*imSizeX+7],b[1*imSizeX+7])\
+absDiff(a[2*imSizeX+0],b[2*imSizeX+0])+absDiff(a[2*imSizeX+1],b[2*imSizeX+1])+absDiff(a[2*imSizeX+2],b[2*imSizeX+2])+absDiff(a[2*imSizeX+3],b[2*imSizeX+3])\
+absDiff(a[2*imSizeX+4],b[2*imSizeX+4])+absDiff(a[2*imSizeX+5],b[2*imSizeX+5])+absDiff(a[2*imSizeX+6],b[2*imSizeX+6])+absDiff(a[2*imSizeX+7],b[2*imSizeX+7])\
+absDiff(a[3*imSizeX+0],b[3*imSizeX+0])+absDiff(a[3*imSizeX+1],b[3*imSizeX+1])+absDiff(a[3*imSizeX+2],b[3*imSizeX+2])+absDiff(a[3*imSizeX+3],b[3*imSizeX+3])\
+absDiff(a[3*imSizeX+4],b[3*imSizeX+4])+absDiff(a[3*imSizeX+5],b[3*imSizeX+5])+absDiff(a[3*imSizeX+6],b[3*imSizeX+6])+absDiff(a[3*imSizeX+7],b[3*imSizeX+7])\
+absDiff(a[4*imSizeX+0],b[4*imSizeX+0])+absDiff(a[4*imSizeX+1],b[4*imSizeX+1])+absDiff(a[4*imSizeX+2],b[4*imSizeX+2])+absDiff(a[4*imSizeX+3],b[4*imSizeX+3])\
+absDiff(a[4*imSizeX+4],b[4*imSizeX+4])+absDiff(a[4*imSizeX+5],b[4*imSizeX+5])+absDiff(a[4*imSizeX+6],b[4*imSizeX+6])+absDiff(a[4*imSizeX+7],b[4*imSizeX+7])\
+absDiff(a[5*imSizeX+0],b[5*imSizeX+0])+absDiff(a[5*imSizeX+1],b[5*imSizeX+1])+absDiff(a[5*imSizeX+2],b[5*imSizeX+2])+absDiff(a[5*imSizeX+3],b[5*imSizeX+3])\
+absDiff(a[5*imSizeX+4],b[5*imSizeX+4])+absDiff(a[5*imSizeX+5],b[5*imSizeX+5])+absDiff(a[5*imSizeX+6],b[5*imSizeX+6])+absDiff(a[5*imSizeX+7],b[5*imSizeX+7])\
+absDiff(a[6*imSizeX+0],b[6*imSizeX+0])+absDiff(a[6*imSizeX+1],b[6*imSizeX+1])+absDiff(a[6*imSizeX+2],b[6*imSizeX+2])+absDiff(a[6*imSizeX+3],b[6*imSizeX+3])\
+absDiff(a[6*imSizeX+4],b[6*imSizeX+4])+absDiff(a[6*imSizeX+5],b[6*imSizeX+5])+absDiff(a[6*imSizeX+6],b[6*imSizeX+6])+absDiff(a[6*imSizeX+7],b[6*imSizeX+7])\
+absDiff(a[7*imSizeX+0],b[7*imSizeX+0])+absDiff(a[7*imSizeX+1],b[7*imSizeX+1])+absDiff(a[7*imSizeX+2],b[7*imSizeX+2])+absDiff(a[7*imSizeX+3],b[7*imSizeX+3])\
+absDiff(a[7*imSizeX+4],b[7*imSizeX+4])+absDiff(a[7*imSizeX+5],b[7*imSizeX+5])+absDiff(a[7*imSizeX+6],b[7*imSizeX+6])+absDiff(a[7*imSizeX+7],b[7*imSizeX+7])\

also ich glaube die Namensgebung ist klar. imSizeX ist ist die Bildgröße und da das Bild in einem 1D Array gespeichert ist springe ich immer durch y*imSizeX in die nächste Zeile.

Leider ist das ziemlich langsam. ich bin davon ausgegangen das der Compiler die Berechnung von y*imSizeX+x im Vorhinein macht das müßte doch so sein. Kann ich das irgendwo nachschauen. Außerdem was haltet ihr von meinem Define absDiff sollte ich das nehmen oder abs(a-b). Ich hatte gelesen das es besser ist das so zu schreiben wie ich damit der Compiler das optimieren kann.

Ich freue mich über Meinungen

dankeschön

p.s. Äh ich meine natürlich ich ich möchte die Sum of Absolute Difference von zwei Bildern berechnen. Also Array a ist von Bild1 und Array b ist von Bild2

Warum programmierst du abs überhaupt selber und nimmst nicht std::abs?

Fragen über Fragen...

uint32_t diff=0;
for(uint16_t iy=0; iy<8*imsSizeX; iy+=imSizeX){
       for(uint16_t ix=0; ix<8; ix++){
            diff+=std::abs(image1[ix+iy]-image2[ix+iy]);
}
}

also ihr meint sowas geht schneller?

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  us/call  us/call  name    
 79.02    111.41   111.41                             FilterFlow_BrutForc_

-> das sind auf eine Kachelberechnugn runter gebrochen 1.9us pro 8*8 Kachel

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  us/call  us/call  name    
 84.74    167.09   167.09

-> 3 us

Mist!

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  us/call  us/call  name    
 79.11    112.53   112.53                             FilterFlow_BrutForc

#define CalculateDifference(a,b)\
	uint32_t ergebniss=0;\
	for(uint16_t iy=0; iy<8*imSizeX; iy+=imSizeX) { \
		for(uint16_t ix=0; ix<8; ix++) { \
			ergebniss+=std::abs(a[ix+iy]-b[ix+iy]);\
		}\
	}\

CC=g++
CFLAGS=-c -DRELEASE -UDEBUG  -Wall -g -pg -O3
LDFLAGS=-g -pg  -lgsl -lgslcblas
SOURCES=main.cpp debugOwn.cpp FeatGSLMest.cpp FilterFeature_Diff_follow.cpp \
 FilterFlow_BrutForc_follow2.cpp  FlowConstDef.cpp \
global.cpp LogModul.cpp  mathFunctions.cpp netTcp.cpp \
VideoDevice_Load.cpp VideoDevice_Caspa.cpp BaseClasses/FeatureCalcGSLBase.cpp \
BaseClasses/FeatureCalcBase.cpp

OBJECTS=$(SOURCES:.cpp=.o)
EXECUTABLE=hello

all: $(SOURCES) $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS)
	$(CC) $(LDFLAGS) $(OBJECTS) -o $@

.cpp.o:
	$(CC) $(CFLAGS) $< -o $@

clean:
	rm -rf *o hello

totalclean:

	rm -rf *o BaseClasses/*o hello

Kann ich das irgendwo nachschauen.

Guck dir die Disassembly an. Dann weisst du was für Code entsteht.

Falls kein SIMD Code draus wird, und dein Compiler SIMD-Intrinsics hat, dann kannst du mit denen vermutlich nochmal ordentlich was rausholen.

Aber wie geht das mit SIMD ich habs beim googlen nur überflogen. Also für Arm Prozessoren sollte das ja grundsätzlich funktionieren. Vielleicht kannst du mir auch ne gute stelle zum nachschauen gebn.
thx

Nexus schrieb:

Wozu das -g Compilerflag?

Ist doch ganz nuetzlich fuer den Profiler. Debugsymbole != Debugcode

Kannst du mir dabei helfen. Weisst du wie ...

Nö, sorry.
Ich bin ein Windows-Mann. Bei MSVC kann ich dir das alles ausm Stegreif erklären. GCC, GDB etc. = kein Plan. Da hab' ich inetwa nen Überblick was der so kann, aber wie man es genau anstellt müsste ich mir selbst ergoogeln.
Ebenso was ARM angeht.

Als Tip kann ich dir nur geben: möglicherweise findest du SIMD Code für verschiedene Compiler/Architekturen für sehr ähnliche oder sogar identische Sachen in der OpenCV. Oder sonstigen Bildberabeitungs-Libraries. Und wenn du ganz viel Glück hast ist die Kombination GCC/ARM dabei

The ARMv7 architecture introduced the Advanced SIMD extension (NEON) as an optional extension to 
the ARMv7-A and ARMv7-R profiles. NEON technology is a 64/128-bit hybrid SIMD architecture that 
allows up to 16 data elements to be processed in parallel, thus accelerating media and signal processing 
applications.

[url]
http://www.incubesol.com/images/Optimization of Multimedia Codecs using ARM NEON.pdf
[/url]

Schade.
Aber das klingt ja schonmal vielversprechend:

The ARMv7 architecture introduced the Advanced SIMD extension (NEON) as an optional extension to 
the ARMv7-A and ARMv7-R profiles. NEON technology is a 64/128-bit hybrid SIMD architecture that 
allows up to 16 data elements to be processed in parallel, thus accelerating media and signal processing 
applications.

[url]
http://www.incubesol.com/images/Optimization of Multimedia Codecs using ARM NEON.pdf
[/url]

prächtig.
Damit komme ich auf http://gcc.gnu.org/onlinedocs/gcc/ARM-NEON-Intrinsics.html
Damit haste ja praktisch schon gewonnen: Beim googlen der Intrinsics müssen ja Quellcodes auftauchen, die sowas benutzen.

Sicherheitshalber würde ich nochmal mit -mfpu=neon -O3 das Makro vom Threadbeginn messen.

CFLAGS=-c -DRELEASE -UDEBUG -mfpu=neon -mcpu=cortex-a8 -march=armv7-a -tune=cortex-a8  -Wall -pg -O3
LDFLAGS=-pg -O3 -lgsl -lgslcblas

leider habe ich aber gsl nicht mit den Flags compiliert. Könnte sein das dann was nich geht

Cortex-A8 and Cortex-A9 can do only two SP FP multiplications per cycle, so you may at most double the performance on those (most popular) CPUs. In practice, ARM CPUs have very low IPC, so it is preferably to unroll the loops as much as possible. If you want ultimate performance, write in assembly: gcc's code generator for ARM is nowhere as good as for x86.

I also recommend to use CPU-specific optimization options: "-O3 -mcpu=cortex-a9 -march=armv7-a -mtune=cortex-a9 -mfpu=neon -mthumb" for Cortex-A9; for Cortex-A15, Cortex-A8 and Cortex-A5 replace -mcpu=-mtune=cortex-a15/a8/a5 accordingly. gcc does not have optimizations for Qualcomm CPUs, so for Qualcomm Scorpion use Cortex-A8 parameters (and also unroll even more than you usually do), and for Qualcomm Krait try Cortex-A15 parameters (you will need a recent version of gcc which supports it).

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  us/call  us/call  name    
 77.05    101.76   101.76                             FilterFlow_BrutForc_

ich mach das übrigens über 3000 Bilder und auf jedem bild 2* 140

damit bin ich jetzt bei 1,7us

ma gucken ob da mehr geht

einmal zwei verschiedene ABS funktionen. Die zweite ist schneller gewesen

#define absDiff(a1,a2) (((a1)>(a2))?a1-a2:a2-a1)

std::abs(a[ix+iy]-b[ix+iy])

und zwei verschiedene Berchnungsarten einmal mit Define und einmal mit Schleife

#define CalculateDifference(a,b) \
 absDiff(a[0*imSizeX+0],b[0*imSizeX+0])+absDiff(a[0*imSizeX+1],b[0*imSizeX+1])+absDiff(a[0*imSizeX+2],b[0*imSizeX+2])+absDiff(a[0*imSizeX+3],b[0*imSizeX+3])\
+absDiff(a[0*imSizeX+4],b[0*imSizeX+4])+absDiff(a[0*imSizeX+5],b[0*imSizeX+5])+absDiff(a[0*imSizeX+6],b[0*imSizeX+6])+absDiff(a[0*imSizeX+7],b[0*imSizeX+7])\
+absDiff(a[1*imSizeX+0],b[1*imSizeX+0])+absDiff(a[1*imSizeX+1],b[1*imSizeX+1])+absDiff(a[1*imSizeX+2],b[1*imSizeX+2])+absDiff(a[1*imSizeX+3],b[1*imSizeX+3])\
+absDiff(a[1*imSizeX+4],b[1*imSizeX+4])+absDiff(a[1*imSizeX+5],b[1*imSizeX+5])+absDiff(a[1*imSizeX+6],b[1*imSizeX+6])+absDiff(a[1*imSizeX+7],b[1*imSizeX+7])\
+absDiff(a[2*imSizeX+0],b[2*imSizeX+0])+absDiff(a[2*imSizeX+1],b[2*imSizeX+1])+absDiff(a[2*imSizeX+2],b[2*imSizeX+2])+absDiff(a[2*imSizeX+3],b[2*imSizeX+3])\
+absDiff(a[2*imSizeX+4],b[2*imSizeX+4])+absDiff(a[2*imSizeX+5],b[2*imSizeX+5])+absDiff(a[2*imSizeX+6],b[2*imSizeX+6])+absDiff(a[2*imSizeX+7],b[2*imSizeX+7])\
+absDiff(a[3*imSizeX+0],b[3*imSizeX+0])+absDiff(a[3*imSizeX+1],b[3*imSizeX+1])+absDiff(a[3*imSizeX+2],b[3*imSizeX+2])+absDiff(a[3*imSizeX+3],b[3*imSizeX+3])\
+absDiff(a[3*imSizeX+4],b[3*imSizeX+4])+absDiff(a[3*imSizeX+5],b[3*imSizeX+5])+absDiff(a[3*imSizeX+6],b[3*imSizeX+6])+absDiff(a[3*imSizeX+7],b[3*imSizeX+7])\
+absDiff(a[4*imSizeX+0],b[4*imSizeX+0])+absDiff(a[4*imSizeX+1],b[4*imSizeX+1])+absDiff(a[4*imSizeX+2],b[4*imSizeX+2])+absDiff(a[4*imSizeX+3],b[4*imSizeX+3])\
+absDiff(a[4*imSizeX+4],b[4*imSizeX+4])+absDiff(a[4*imSizeX+5],b[4*imSizeX+5])+absDiff(a[4*imSizeX+6],b[4*imSizeX+6])+absDiff(a[4*imSizeX+7],b[4*imSizeX+7])\
+absDiff(a[5*imSizeX+0],b[5*imSizeX+0])+absDiff(a[5*imSizeX+1],b[5*imSizeX+1])+absDiff(a[5*imSizeX+2],b[5*imSizeX+2])+absDiff(a[5*imSizeX+3],b[5*imSizeX+3])\
+absDiff(a[5*imSizeX+4],b[5*imSizeX+4])+absDiff(a[5*imSizeX+5],b[5*imSizeX+5])+absDiff(a[5*imSizeX+6],b[5*imSizeX+6])+absDiff(a[5*imSizeX+7],b[5*imSizeX+7])\
+absDiff(a[6*imSizeX+0],b[6*imSizeX+0])+absDiff(a[6*imSizeX+1],b[6*imSizeX+1])+absDiff(a[6*imSizeX+2],b[6*imSizeX+2])+absDiff(a[6*imSizeX+3],b[6*imSizeX+3])\
+absDiff(a[6*imSizeX+4],b[6*imSizeX+4])+absDiff(a[6*imSizeX+5],b[6*imSizeX+5])+absDiff(a[6*imSizeX+6],b[6*imSizeX+6])+absDiff(a[6*imSizeX+7],b[6*imSizeX+7])\
+absDiff(a[7*imSizeX+0],b[7*imSizeX+0])+absDiff(a[7*imSizeX+1],b[7*imSizeX+1])+absDiff(a[7*imSizeX+2],b[7*imSizeX+2])+absDiff(a[7*imSizeX+3],b[7*imSizeX+3])\
+absDiff(a[7*imSizeX+4],b[7*imSizeX+4])+absDiff(a[7*imSizeX+5],b[7*imSizeX+5])+absDiff(a[7*imSizeX+6],b[7*imSizeX+6])+absDiff(a[7*imSizeX+7],b[7*imSizeX+7])\

#define CalculateDifference(a,b)\
	uint32_t ergebniss=0;\
	for(int16_t iy=0; iy<8*imSizeX; iy+=imSizeX) { \
		for(int16_t ix=0; ix<8; ix++) { \
			ergebniss+=std::abs(a[ix+iy]-b[ix+iy]) ;\
		}\
	}\

Ergebnis zwischen std::abs und #define absDiff(a1,a2) (((a1)>(a2))?a1-a2:a2-a1)
hat std::abs gewonnen

zwischen schleife und großem define gabs keinen Unterschied.

Deshalb würd ich wohl die schleife wegen der Lesbarkeit nehmen. Bei der schleife war's besser wenn ich inkrementiere als dekrementiere. kommisch hatte es immer anders rum gelernt.
war aber auch nur geringfügig der Unterschied