Text in Compiler ausgeben

Wie willst du eine CPU-Auslastung durch Timer-Interrupts denn
zur Compile-Zeit ausgeben?  Die steht doch erst zur Laufzeit
fest.

Anyway, außer #error gibt's noch #warning, aber das gibt auch
einfach nur Text aus -- berechnete Werte kann man nicht zur
Compile-Zeit ausgeben.

Zur Compilezeit?

Das möchte ich sehen.

> Ich weiß wie oft ein Timer Interrupt ausgeführt wird, und ich weiß
> wie lage dieser jeweils dauert. Daraus kann man die benötigten Takte
> pro Sekunde ausrechnen. Da die Taktfrequenz des AVR bekannt ist,
> kann man so die Auslastung berechnen.

Und was hat das alles mit dem Compiler zu tun?  Dafür braucht man
einen Taschenrechner.  Wenn du's auf dem Computer berechnen lassen
willst, dann nimm eine Scriptsprache.  WinAVR bringt zumindest einen
AWK mit (dort gawk genannt), ach ja, Tcl ist auch dabei.  Perl oder
Python müsstest du dir selbst installieren.

awk 'END {nclk=42; freq=100; cpufreq=1000000; \
print (nclk * freq)/cpufreq}' /dev/null
=> 0.0042

Prinzipiell:

Es gibt Compiler, die auch allgemeine Meldungen während des
Compilerlaufes ausgeben können; bei MS wird das mit

   #pragma message("Meldung")

gemacht.

Bei gcc ließe sich #warning dafür missbrauchen, allerdings:

   Neither `#error' nor `#warning' macro-expands its argument.

Das sieht bei MS anders aus:


   #pragma message( messagestring )

   The messagestring parameter can be a macro that expands
   to a string literal, and you can concatenate such macros
   with string literals in any combination.
   For example, the following statements display the name
   of the file being compiled and the date and time when
   the file was last modified:

   #pragma message( "Compiling " _FILE_ )
   #pragma message( "Last modified on " _TIMESTAMP_ )


Da so etwas in gcc nicht implementiert ist, scheinen es wohl die für
gcc verantwortlichen für völlig nutzlos zu halten.

> .global SIG_OUTPUT_COMPARE1A
> SIG_OUTPUT_COMPARE1A:
> nop
> nop
> reti
>
> Dieser Code benötigt 10 Takte, das kann man erkennen, die Frequenz
> des Timerinterrupts ist auch bekannt.
> CPULOAD=(100*(FREQ_TIMERINT*10))/XTAL_CPU

Das befriedigt mich nicht wirklich.
Zum einen 'siehst du' magisch die Anzahl der Taktzyklen die
in der ISR verbaut wurden. Wie du die magisch sehen willst, wenn
ich die ISR verändere, würde mich mal interessieren. Das heist:
eigentlich interessiert es mich nicht. Was mich viel mehr
interessieren würde ist, wie der Compiler das 'sehen' will.
Denn nur dann hat es einen Sinn. In dem Moment wo der Compiler
auf Hochsprachenebene diese Anzahl nicht festellen kann, ist
das alles sinnlos geworden. Denn was man ganz sicher nicht möchte:
Diese Anzahl händisch eintragen. Da kannst du dir das Ganze auch
sparen, da es ausser fehlerhaft nur noch fehlerhaft ist.

> die Frequenz des Timerinterrupts ist auch bekannt.

Ach ja? Im folgenden (symbolischen) Code ...

 int main()
 {
   int Freq;

   printf( "Wie schnell soll der Timer laufen: " );
   scanf( "%d", &Freq );

   SetTimerToFrequency( Freq );
}

... wie hoch ist denn da die Taktfrequenz? Wie soll der Compiler
die feststellen?

(Das ich hier scanf benutzt habe, hat Einfachheitsgründe. Könnte
genausogut eine mit einer Formal ausgerechnet werden, per UART
übertragen werden, per SPI gesetzt werden, mit einem Schalter
an einem Port umgeschaltet werden, ...)

Mit anderen Worten: Du hast keine Möglichkeit zur Compilezeit
ohne zusätzliche Annahmen die Werte für deine Formel zu bestimmen.
Da du diese Annahmen ...
  * Anzahl Taktzyklen in der ISR ist bekannt und konstant
  * Aufruffrequenz der ISR ist bekannt und konstant
.. aber treffen musst um die Formel anwenden zu können, kannst
du dir die auch mit einem Taschenrechner ausrechnen und einfach
als Text mit einem #warnung ausgeben lassen. Gut, ich
gebe zu, schöner wäre es wenn der Compiler die Formel auswerten
könnte, das vermeidet Tippfehler in der Berechnung.
Allerdings: Für deinen Benutzer ist das gehupft wie gesprungen,
denn: die Anzahl der Taktzklen muss immer noch er feststellen
und wenn er die Timerfrequenz verändert (in dem er den Prescaler
umprogrammiert oder zb. einen anderen CTC-Wert setzt), muss er
drann denken den entsprechenden Wert für deine Formel ebenfalls
anzupassen.
Ergo: Der Compiler spuckt zur Compilezeit eine Zahl aus, auf die
man sich nicht verlassen kann. Da kann ich mir den ganzen Aufwand
aber auch sparen.

> Und genau diesen Wert, der von allen Parametern abhängig ist,
> möchte ich wissen.

Schreib dir ein Tool auf deinem Entwicklungsrechner, das
die diese Dinge ausrechnet. Da hast du mehr davon. Denn dieses
Tool kannst du auch benutzen um die Werte so anzupassen, dass
du eine bestimmte Auslastung nicht überschreitest. Also
die umegkehrte Fragestellung: Ich darf mit meiner Auslastung
nicht höher als x Prozent werden. Wie muss ich meine restlichen
Werte jonglieren, damit das erfüllt ist?