Speicherfresser finden

**SprinterSB** · 23.12.2008, 23:34

Zitat von cipher

1. Kleine Funktionen als Präprozessor-Makros schreiben. Ist für Funktionen gut, die z.B. Ports setzen oder auswerten. Ergebnis: Mehr Speicherbedarf durch Code, aber weniger durch Stack.

Wenn man es richtig mach, braucht man weniger Code

Nämlich nur zuviel, wie eben notwendig ist.

Zitat von cipher

2. Funktionen, die nur zum Strukturieren des Codes eingeführt wurden rauswerfen und alles als einen Codeblock schreiben. Ergebnis: Etwas weniger Code, da Aufrufe wegfallen, weniger Stackbedarf. Der Code wird jedoch schwerer lesbar.

Heutzutage Unsinn. Eine Funktion, die (statisch) nur 1x verwendet wird, macht man natürlich static anstatt extern. Und ein Compiler wie GCC wird die ohne groß Aufhebens zu machen inlinen. Und dies entspricht dann im Endeffekt genau deinem Spaghetti-Code...

Bei neuen avr-gcc-Versionen ist es allerdings noch weniger durchsichtig, wie er den erzeugten Code zusammenbaut. Immerhin gibt es weit über 100 Passes, und in jedem wird der Code nochmal durch die Mangel gedreht...

In meinen Projekten bekomm ich mit avr-gcc 3.4.6 rund 10% kleineren (und entsprechend auch schnelleren) Code als mit avr-gcc 4.x.

**SprinterSB** · 23.12.2008, 23:50

@Jacob2: Es ist schlecht, wenn du diese Tabellen als lokale Variablen anlegst, denn so belegen sie Flash /und/ RAM und werden beim Betreten der Funktion erst initialisiertm was Code und Zeit kostet.

Ausserdemm sollte vermieden werden, lokale Funktionen zu schreiben, also Funktionen die innerhalb einer anderen definiert werden.

Code:

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#ifndef F_CPU
/* Definiere F_CPU, wenn F_CPU nicht bereits vorher definiert
   (z.B. durch Übergabe als Parameter zum Compiler innerhalb
   des Makefiles). Zusätzlich Ausgabe einer Warnung, die auf die
   "nachträgliche" Definition hinweist */
#warning "F_CPU war noch nicht definiert, wird nun mit 1000000 definiert"
#define F_CPU 1000000     /* Quarz mit 1 Mhz */
#endif // F_CPU

#define TEMPO 1800
#define TEMPO2 2000

static uint8_t const _A[] PROGMEM = {0b00001, 0b10110, 0b10110, 0b00001};
static uint8_t const _H[] PROGMEM = {0b00000, 0b11011, 0b11011, 0b00000};
static uint8_t const _L[] PROGMEM = {0b00000, 0b01111, 0b01111, 0b01111};
static uint8_t const _O[] PROGMEM = {0b10001, 0b01110, 0b01110, 0b10001};

void B (uint8_t bb[]);

void B (uint8_t bb[])
{
	PORTC = pgm_read_byte (& bb[0]);
	_delay_us (TEMPO);
	PORTC = pgm_read_byte (& bb[1]);
	_delay_us (TEMPO);
	PORTC = pgm_read_byte (& bb[2]);
	_delay_us (TEMPO);
	PORTC = pgm_read_byte (& bb[3]);
	_delay_us (TEMPO);
	PORTC = 0b11111;
	_delay_us(TEMPO2);
}

int main (void)
{
	DDRC = 0xFF;

	while(1)
	{
		B(_H);
		B(_A);
		B(_L);
		B(_L);
		B(_O);
		_delay_ms (157);
	}
}

i) Die Funktion ist nicht mehr lokal
ii) Für die Konstanten reichen 8 Bit, sie brauchen kein int (16 Bit) zu sein.
iii) Die Konstanten bleiben in Flash und verbrauchen kein RAM (PROGMEM). Allerdings muss anders auf sie zugegriffen werden (pgm_read_...)
iv) Das Argument dieser delay-Funktionen sollte eine Compilezeit-Constante sein, weil sonst der Compiler anfängt (float)-Berechnungen zu machen. Das kostet krass Code!!! DOKUS LESEN!!!
v) Code ist ohne Garantie, hab's nur eingetippst und nicht getestet.