main index Le mie pagine sulla Beagleboard cominciano qui!

Le ultime notizie sono invece contenute nel blog.


Compilazione di qualche programmino di prova

Per compilare software che funzioni sulla Beagleboard abbiamo due possibilità:

  1. compilazione "nativa" (sulla Beagleboard deve esserci già il compilatore C/C++ e le sue librerie, i suoi file di #include, etc); questa sarà possibile quando esisteranno distribuzioni specifiche complete per la Beagleboard;
  2. "cross-compiling", cioè avere un PC su cui ci sono dei compilatori che generano codice ARMv7. Questo è più comodo e generalmente più veloce, e perciò consigliato nel 99% dei casi (c'è infatti un 1% di casi in cui è preferibile usare la compilazione nativa, ma per fortuna ora questo problema non si pone).

La soluzione più comoda, al momento in cui scrivo, è prendere una "toolchain" già pronta per l'uso. La CodeSourcery mette gratis a disposizione delle toolchain da command-line (loro guadagnano con l'assistenza e la vendita di ambienti integrati di sviluppo). La toolchain, basata sugli strumenti gnu, è disponibile nella loro sezione di Download (sottosezione GNU/Linux). Per lavorare sul mio tablet PC (che è architettura Intel a 32 bit) ho prelevato la versione ia32 GNU/Linux TAR che ha data di rilascio "2007q3". Con questa, su un sistema Linux x86, si possono compilare software per la Beagleboard (che è un sistema armv7). So che in giro esistono anche versioni per ia64 e per Mac/intel.

Nota bene: ad aprile 2009 è ancora consigliabile usare la 2007q3 perché le versioni successive hanno qualche fastidioso bug qua e là. La 2007q3 è per il momento quella più stabile.
Si tratta di un download di poco meno di cento megabytes. Una volta preso il file, scompattarlo da qualche parte con:
tar xjf arm-2*bz2

Verrà creata una directory arm-2007q3 contenente tutto il malloppo.

Per utilizzare tali compilatori occorre prima settare un po' di variabili nell'environment. Per esempio, assumendo di aver creato la directory arm-2007q3 sotto /home/pinguino avremo:
export ARMHOME=/home/pinguino/arm-2007q3
export CROSS_COMPILE=arm-none-linux-gnueabi-
export PATH=$ARMHOME/bin:$PATH

Tali export possono essere comodamente sistemate nel .bashrc (o equivalente) in modo che dal prossimo login saranno già pronte a portata di mano.


Consideriamo questo programmino trullallero.c:
#include <stdio.h>
int main() { printf("trullallero trullallà"); return 0; }

Anzitutto compiliamolo su Linux:
cc trullallero.c -o trullallero

Dopodiché lo possiamo provare lanciandolo con ./trullallero e vedere cosa ha da dirci.

Bene, ora lo vogliamo compilare per la Beagleboard. Con le export sopra citate, ci basta utilizzare:
$ARMHOME/bin/$CROSS_COMPILE"gcc" -march=armv7-a trullallero.c -o trullallero

A questo punto avremo un eseguibile (di cinque kilobytes circa) compilato con target ARMv7-A (cioè per Cortex-A8), che si aspetta di trovare le libc sulla Beagleboard (compilato "dinamicamente").

Per trasferirlo sulla Beagleboard... non c'è niente di più facile che copiarlo sulla memory card che abbiamo utilizzato per la validation. Una volta fatto il boot di quella Angstrom, ci ritroveremo nella directory /media/mmcblk0p1 il nostro eseguibile. Il quale, lanciato con ./trullallero dalla bash aperta sulla Beagleboard (a cui accediamo per esempio tramite minicom), ci restituirà un inaudito messaggio.

Dato che la mini-versione della Angstrom per la validazione è contenuta nella sua ramdisk (15Mb circa, anche se al boot veniva dimensionata da 32Mb), è possibile "smontare" la card (con il consueto umount /dev/mmcblk0p1), passarla al computer per caricarvi altri dati, e poi rimetterla nello slot della Beagleboard; l'automount ce la farà ritrovare come al solito già montata nella directory /media/mmcblk0p1 (come prima).

Nota bene: gli smanettoni più esperti sapranno già creare un makefile per la compilazione. L'unico problemuccio con la Angstrom della validazione è che non contiene la libreria stdc++ per cui, sebbene si possano compilare software in C++, con quella Angstrom non si potranno provare.

Nella compilazione si possono ovviamente aggiungere gli altri flag consueti (-c per compilare un object-file anziché un eseguibile, -O2 oppure -O3 per aumentare l'ottimizzazione del codice in caso di sorgenti molto corposi, etc).

Importante: quel toolchain della Codesourcery, essendo stato rilasciato due anni fa, fa ovviamente riferimento ad una versione di Linux più vecchiotta (2.6.14 o giù di lì). Nella maggioranza assoluta dei casi non dovrebbe essere un problema.


Si è sempre detto che la Beagleboard ha a parità di megahertz una potenza di calcolo pressoché equivalente a quella di un Pentium III.

Ho voluto verificare di persona scrivendo un orrendo programmino in C che va a stressare il processore con:

Ecco il codice (bruttissimo, scritto di getto). Per vedere quanto tempo è passato, ci basta guardare /proc/uptime che contiene il tempo macchina effettivamente passato (secondi punto centesimi) e il tempo macchina passato in "idle" (anche questo è in formato "secondi punto centesimi" ma è un dato globale che non ci interessa). In tal modo all'inizio e alla fine del programma si può vedere quanti centesimi di secondo sono passati.


// --- super_trullallero.c 

#include <stdio.h>

int clocka()
{
  int s1=0, s2=0, n;
  FILE *fp=fopen("/proc/uptime", "r");
  n=fscanf(fp, "%d.%d", &s1, &s2);
  fclose(fp);
  return s2 + s1*100;
}


int modifica(int i)
{
  static int u=1;
  i += (i>>3) + (i%57);
  return i+(u++)+3;
}


int main()
{
  int c = clocka();
  printf("-- start\n");

  int n, i, j=0, q=1, k=0;
  for(n=0; n<12345; n++)
  {
    for(i=0; i<23456; i++)
    {
      j += ++q;
      k += modifica(j+i+n-q);
    }
  }

  printf("-- rst: %d,%d -- %x,%x,%x\n",n,i,j,q,k);

  c = clocka()-c;
  printf("-- end: runtime = %d clocks\n", c);
  return 0;
}

// ---

Compilato ed eseguito sul Pentium-M (poco meglio di un Pentium III) clockato a 1100 MHz, dà il risultato in circa 6,90 secondi.

Se abbassassimo il clock a 500 MHz, tale Pentium-M andrebbe il 55% più lento, cioè impiegherebbe gli undici quinti del tempo, ossia impiegherebbe circa 15,20 secondi.

Compilato ed eseguito sull'OMAP3530 (che ha un core ARM Cortex-A8) clockato a 500 MHz, otteniamo il risultato in circa 12,20 secondi: tre secondi in meno di un Pentium-M a 500 MHz.

Dunque, a parità di clock, il processore della Beagleboard è circa il 25% più veloce di un Pentium-M. Veloce, non scalda, non consuma. Non sarà un Nehalem, ma è già potenza sufficiente per un desktop Linux. E ha un consumo microscopico: appena due watt quando va a pieni giri...

Per umiliare ulteriormente il Pentium-M in questione, devo dire che quest'ultimo scalda in maniera considerevole (tant'è che ha bisogno di una ventola, e non appena il processore va "a regime" per più di qualche secondo, la ventola attacca a girare...).


Projecting the Xorg+GPE screen

home page - send e-mail