Kategorie: Betriebssysteme

Konsolenbefehle Windows <-> Linux

Dateien auflisten

Linux: ls

Windows: dir

 

Inhalt einer Datei ausgeben

Linux: cat

Windows: type

 

Suchen nach einem gewissen Inhalt in einer Datei

Linux: grep

Windows: find (mit Hochkomma)

find „arduino.h“  *

 

Booten

Notwendige Dateien

preloadImage.bin                 // falls doppel-Boot
fpgaSystem.rbf                     // binäre Systemdatei
socfpga.dtb                           // device Tree
U-Boot.scr                            // script bootloader
zImage                                  // Yocto-Ergänzungen

Die Images können z.B. mit Bitbake (yocto) erstellt werden.

Build-System

Für ein eigenes Linux, muss im

Minimum

  • Files-System mit von Hand kompilierten Programmen für das Target

oder im Normalfall für ein

Kleines Linux

  • Bibliotheken (uCLib)
  • Bootlaoder
  • Sytemprogramme (Busybox) oder Kernel
  • Applikationsprogramme

Für das Target kompilieren und dort zum Laufen (Booten) bringen.

Diese Schritte können von Hand, oder mit der Hilfe eine Build-Systems getan werden.

Vorteil Build-System

Bei der Installation wird die korrekte Reihenfolgen durch die Automatisation eingehalten. Abhängigkeiten sind bekannt und das Build-System zeigt Inkompatibilitäten an.

 

Bekannte Build-Systeme

  • Buildroot
  • OpenWRT (basiert auf Buildroot)
  • Yocto

 

Build Programme

  • bitbake (Yocto):
    In Yocto wird für den bootloader (+ preloader), den kernel mit dem dazugehörendem device tree und für das file System ein separates Image gebildet.  Alle Images und Zusatzdateien zusammen führen zu einer grossem Image.bin.

 

 

 

Bootloader

Notwendige Dateien zum Booten

  • BSP (Board Support Packet)
  • Buildsystem

Das BSP wird oft vom Hersteller mitgelierfert (oder kann bei FPGAs über Quartus generiert werden.) Wesentliche Dateien im BSP sind der Device Tree, der die Grundeinstellungen der Komponenten beschreibt.

Das Buildsystem fügt die Komponenten

  • BSP
  • Treiber
  • Bibliotheken
  • Software (Kernel und Applikationen)
     

     

zusammen zu einem Image, und definiert  das File System. Zum Buildsystem gehört die Definition des Bootloader, der den ganzen Prozess ausführt.

Aufgabe des Bootloaders
Es ist der Bootloader, der den Startvorgang kennt. Er lädt die Dateien  (als Image) aus einem festen Speicher in das static RAM.

Mit dem Befehlt mkimage -h  kann der Inhalt des u-boot images angesehen werden.

Starten des bootens  boot.script
Das Build-System (z.B. Yocto) erzeugt über ein Build-Programm (z.B.  u-boot) ein boot.script. Das Script liegt an einem nicht flüchtigen Speicher. Beim Booten weiss das System, wo das Skript liegt und startet den Prozess automatisch.

Datenarten
Konzeptionell unterscheidet man zwischen zwei Dateitypen:
– Das Betriebsystem (Image, DeviceTree)
– Die Applikationssoftware

Gestaffeltes Booten
Booten heisst, unter anderem die Startadresse aller Vektoren für die Interrupts setzen.
Detaillierte technische Beschreibung zum Booten in http://stackoverflow.com/questions/31244862/what-is-the-use-of-spl-secondary-program-loader

Primary boot (Programm U-boot)
Der primary boot lädt die notwendigen Betriebsdateien ins RAM.

Secondary Programm loader (SPL)
Wird gebraucht, wenn das RAM nicht das ganze Image speichern kann und ein Teil des Boots, in ein externer Speicher abgelegt wird.

yocto: Konzept und Literatur

Yocto ist ein Build-System und hilft, ein embedded Linux-System aufzubauen.

 

Konzept

  • Yocto stellt eine Referenz-System (Poky), durch das viele Tools und Projekte leicht einbaubar sind zur Verfügung.
  • Unter den Cores besteht eine offene Struktur (Metadaten). Dadurch besteht Kompatibilität unter diversen Projekten
  •  Einfaches Buildprogramm (Bitbake), dass mit dieser offenen Struktur umgehen kann und Images buildet.

Wegen dieser Offenheit, können viele BSP (Board Support Packets) der Hersteller eingebunden und weiterentickelt werden. Dadurch muss das Build-System nicht neu erfunden werden.
BSP: Altera stellt über Quartus BSP für FPGAs her. Diese können relativ einfach in Yocto integriert werden. (Device Tree generieren, aus Datei.sof -> Datei.rbf und einen Preloader hinzufügen.)

 

Notwendige Grundlagen-Dateien
Auf dem Speichermedium, vom dem aus gebootet wird, liegen neben dem Yocto-Image weitere Dateien. Yocto ergänzt nur diese Dateien (mit seinem zImage), bzw. hilft, die Grundlagen-Dateiene zu einem funktionstüchtigen Gebilde zusammenzufügen.

  • Bootloader (Image)
  • Bootscript  -> nur so ist das System startfähig
  • Kernel mit Devicetree
  • File System (Image)

 

Struktur Yocto Projekt
-> Ordner build/
conf/                                          layers einstellen,
….

-> ordner pocky/
bitbake/
documentation/
meta/
meta-yocto/
meta-yocto-bsp/                               scripts/                                      um neue Projekte beizufügen
(layers)

Image builden

cd build
bitbake virtual/bootloader
bitbake virtual/kernel
bitbake core-image-minimale     // root file System

 

Vorteile

Die Vorteile von Yocto liegen laut der Linux Foundation darin, dass viele Vorlagen für die Unterstützung spezifischer Hardware (Board Support Packages) vorhanden sind und es einfach ist, das System auf neue Hardware zu portieren. Auch in Lizenzfragen ist man mit Yocto auf der sicheren Seite.

Bücher

  • Embedded Linux Projects Using Yocto Project Cookbook, March 2015
    By Alex González

https://www.packtpub.com/application-development/embedded-linux-development-yocto-project

Board Support Package (BSP)

Normalerweise genügt eine Distribution, um ein Linux laufen lassen zu können. Im Embedded Bereich jedoch sind die Komponenten stark optimiert, so dass spezifischen Treiber, zusätzliche Bibliothekten etc. eingebaut werden (Überblick bei Linutronix.)

Eine gute Unterstützung beim Erstellen eines BSP bietet Yocto.

Die modernere Methode dieser Konfiguration ist der Device Tree.

CUDA Introduction: Sprache

Cuda ist von Nvidia eine Sprache wie auch Architektur zur GPU-Verarbeitung. Die Sprache wird im Buch CUDA_by_Example. ausführlich beschrieben. Einen ersten Üblick gibt folgender Vortrag, der vom Autor desselben Buches ebd. über Cuda_Introduction gegeben wurde.

Kompiler
nvcc

Trennung: Ablage in GPU – CPU
Der nvcc-Kompiler trennt den Code in CPU-Speicher und GPU-Speicher.
– Device-Funktionen werden im kernel()  bearbeitet und im GPU-Speicher abgelegt.
– Normale Funktionen werden im der CPU (host) im main()  bearbeitet und ihre Variablen liegen im Speicher der CPU. Kompiliert wird mit  gcc.

int main( void) {
    kernel <<< 1, 1 >>> ();
    printf("hallo \n");
    return 0;
}


Von CPU auf GPU
__global__ :             cuda Schlüssewort für Funktionen die auf GPU laufen,
.                                    Diese Funktionen müssen  von CPU – im main() – aufgerufen
.                                    werden
<funktion> <<< :     Befehl zum Ausführen der Funktion auf der GPU
>>> <parameter> :   Mitgabe der Argumente für die GPU-Funktion.

Bsp.

__global__ void kernel( void ) { 
} 

__global__ void add (int *a, int *b, int *c)
{
 *c = *a + *b;
}

Dies funktioniert nur, wenn man im main() die Funktion auf die GPU verschiebt.

int main( void) {
    int a, b, c;
    int *dev_a, *dev_b, *dev_c;

    // Funktion auf GPU   // Argumente mitgeben
    add <<< 1, 1 >>> (dev_a, dev_b, dev_c);
    printf("hallo \n");
    return 0;
}

CPU (host) ruft GPU (device) auf. Ist notwendig, um eine Funktion auf der GPU aufzurufen.

GPU Introduction

GPU ist ein Grafikprozessor. Also ein Prozessor, mit spezifischem Profil. Hersteller sind Intel, AMD und Nvidia.

CPU <-> GPU
Wird von einem Host gesprochen, meint man damit die CPU (inkl. Memory). Ein C-Programm läuft auf dem Host.

Cuda <-> Metal
Cuda ist das Framework und die Sprache von Nvidio. Will man eine GPU für ein iOS konfigurieren, so braucht man metal als Framework und swift als Sprache.

Python to exe

Programm         pyinstaller      fasst python pakete zusammen zu einem executable
Installation:       git clone   https://github.com/pyinstaller/pyinstaller

Von Python zu Exe
pyinstaller  test.py                     Befehl ausführen
.                                                         Es wird automatisch ein Ordner dist/  bebildet,
.                                                         in dem das exe liegt

Disk-Image auf Speichermedium

Unterschied Image <-> Datei
Ein image (speicherabbild) wird nicht, wie eine Datei, kopiert, sondern bitweise in das Medium geschrieben. Das Image liest auch die Rohdaten (wie Startadresse) und Filesystem und nicht nur Dateiinhalte.
Beim Kopieren findet man denselben Dateiname am Zielort. Beim Einschreiben kommt die Image-Datei nicht mehr vor, sondern sie ist nun physich vorhanden

Programme zum Einschreiben von Image
– dd
– bmaptool