2. Semesterarbeit 2012

2. Semesterarbeit
Moderne Website-Erstellung
Heisinger Maximilian
Atzwanger Simone
Prozessorarchitekturen
Gaisberger Andreas
Kuri Nikolaus
Inhaltsangabe
1 Moderne Website-Erstellung.............................................................................................................4
1.1 Geschichte..................................................................................................................................4
1.2 Neue Technologien, neue Herausforderungen...........................................................................4
1.3 Erstellung einer Website............................................................................................................5
1.3.1 HTML & CSS Grundgerüst...............................................................................................5
1.3.2 CSS Klassen.......................................................................................................................6
1.3.3 Vererbung von Eigenschaften............................................................................................7
1.3.4 Identifier versus Klassen....................................................................................................8
1.3.5 Das CSS Box-Model & Positionierung.............................................................................9
1.3.6 Benützung eines CSS-Frameworks..................................................................................10
1.3.6.1 960 Grid System.......................................................................................................10
1.3.6.2 Blueprint...................................................................................................................10
1.3.6.3 Twitter Bootstrap......................................................................................................11
1.3.7 CSS Erweiterungen..........................................................................................................11
1.3.7.1 LESS.........................................................................................................................12
1.3.7.2 SASS........................................................................................................................12
1.3.8 JavaScript.........................................................................................................................13
1.3.9 Serverseitige Programmierung.........................................................................................13
2 Prozessorarchitekturen....................................................................................................................15
2.1 Grundbegriff............................................................................................................................15
2.2 Prozessorarchitekturen nach Wortbreite..................................................................................15
2.2.1 1-Bit Architekturen..........................................................................................................15
2.2.2 4-Bit-Architekturen..........................................................................................................16
2.2.3 8-Bit Architekturen..........................................................................................................16
2.2.4 16-Bit Architekturen........................................................................................................16
2.2.5 32-Bit-Architektur............................................................................................................17
2.2.6 64-Bit-Architektur............................................................................................................17
2.3 Prozessorarchitekturen nach Befehlssatzaufbau......................................................................19
2.3.1 CISC.................................................................................................................................19
2.3.2 EPIC.................................................................................................................................20
2.3.3 NISC.................................................................................................................................21
2.3.4 RISC.................................................................................................................................21
Seite 2
2.3.5 VLIW...............................................................................................................................22
2.3.6 Mikroarchitektur .............................................................................................................23
2.4 Geschichte................................................................................................................................23
2.4.1 Auflistung der Prozessoren bis 1999................................................................................24
2.4.2 Intel 4004.........................................................................................................................26
2.5 Prozessorarchitekturen mit Optimierung für Einsatzzwecke...................................................27
2.5.1 Grafikprozessor................................................................................................................27
2.5.2 Soundprozessor................................................................................................................27
3 Literaturverzeichnis.........................................................................................................................28
4 Bilderverzeichnis.............................................................................................................................28
Seite 3
1 Moderne Website-Erstellung
Der Stil und die Technik von Websites hat sich in den letzten Jahren massiv gewandelt. Früher
verwendete man zum Beispiel ausschließlich Tabellen zum Anordnen des Inhalts und der
Navigation und ging dann über Frames als Zwischenschritt bis zur heute aktuellen Kombination aus
HTML für den Inhalt und CSS für das Aussehen.
1.1
Geschichte
Tim Bernes-Lee hat das World Wide Web 1989 erfunden. Das WWW ist allerdings nicht das
Internet an sich, es ist lediglich ein großer Service der über das Internet gesendet wird. Es ist
allerdings neben E-Mail der größte Anwendungsbereich des Netzes. Tim erfand damals alle
Grundlagen des modernen Webs, nämlich HTML (HyperText Markup Language), den URI
(Uniform Ressource Identifier) und HTTP (HyperText Transfer Protocol). 1994 gründete er das
W3C (World Wide Web Consortium) und setzte damit die Standards des Webs mittels klar
definierten Regeln fest.
Seitdem sind die Technologien keineswegs stillgestanden. HTML ist heute in der neuesten Version
5 in Gebrauch, HTTP hat seit 1999 die Version 1.1 und neben HTML haben sich andere Sprachen
wie JavaScript und CSS hinzugesellt, die weitere Möglichkeiten eröffneten und mit den immer
schneller werdenden Browsern heute auch immer mehr Möglichkeiten bieten. [Wikipedia:
Geschichte des Internets]
1.2
Neue Technologien, neue Herausforderungen
Durch diesen ständigen Fortschritt im Gebiet der Website-Gestaltung und -Programmierung haben
früher aktuelle und allgemein angewendete Methoden schnell ausgedient. 2000 war es noch in,
wenn man möglichst viele Effekte und blinkende Lichter in die Dokumente einbauen konnte, heute
hat sich der Fokus auf Klarheit und extreme Einfachheit gewandelt. Man kann an den alljährlichen
Designänderungen der großen, marktbestimmenden Websites wie Google, YouTube und Facebook
schnell aktuelle Trends ablesen. Das Problem hinter diesem ständigen Voranschreiten ist jetzt, das
ältere Programmierer noch andere Vorgangsweisen oder Sprachen gewohnt waren. Im aktuellen
Lehrplan an Schulen werden auch nicht die neuesten Technologien wie Javascript und CSS 3
gelehrt, sondern die Schüler werden mit statischen Layouts konfrontiert die mit verschachtelten
Frame-Konstrukten realisiert wurden und deshalb oft nur in einer Vergrößerung gut aussehen, bei
Seite 4
etwas größerem Zoom aber vollkommen an Lesbarkeit und Benutzerfreundlichkeit verlieren.
Man darf aber kein alter Fortschrittsverweigerer sein, denn Fortschritt ist im Web keinesfalls etwas
schlechtes. Er revolutionierte unsere Lebensweise schon einige Male, zuerst mit Wikipedia, dann
mit Videoportalen und Sozialen Netzwerken. Früher war das Web statisch und Websites konnten nur
von ihren Eigentümern editiert werden. Heute allerdings kann man Artikel Kommentieren oder
Direkt und praktisch ohne Verzögerung mit Leuten auf der ganzen Welt chatten.
1.3
Erstellung einer Website
1.3.1
HTML & CSS Grundgerüst
HTML ist eine Auszeichnungssprache. Das heißt: Sie beschreibt den Inhalt eines Dokuments. Allein
durch diese Spezifikation wird schon ausgedrückt, dass man keine Programme oder Abläufe in
HTML beschreiben kann. Die Sprache dient ausschließlich zur Beschreibung eines Dokuments
mitsamt seiner Struktur und seinem Inhalt. Das Aussehen dieser Struktur wird heutzutage nicht
mehr direkt in HTML beschrieben, sondern in CSS (Cascading Style Sheets). HTML ist in seinen
Grundzügen wie folgend aufgebaut:
<!-- Dies ist ein HTML-Kommentar. Dieser text hat keinen Einfluss auf die spätere
Formatierung.-->
<!DOCTYPE html>
<html>
<head>
<!-- Titel des Dokuments -->
<title>Ein HTML5 Dokument</title>
<!--
Kodierung
des
Dokuments
(korrekte
Zeichenausgabe
bei
z.B.
Umlauten)-->
<meta http-equiv="content-type" content="text/html; charset=utf-8">
</head>
<body>
<p>
Hier steht der Seiteninhalt.
Er steht in einem „p“ Tag → es ist ein Text-Paragraph.
</p>
</body>
</html>
Dieses Grundgerüst lässt sich dann immer weiter ausbauen. Jeder einzige Unterpunkt wird als
HTML-Tag bezeichnet. Ein <p> Tag wird standardmäßig nicht gerade schön dargestellt, deshalb
kann man als weiteren Schritt innerhalb des <head> Bereichs eine CSS-Datei einbinden. Dies lässt
sich durch folgenden hinzugefügten Tag realisieren:
<link rel="stylesheet" type="text/css" href="style.css">
Jetzt wird in der HTML-Datei eine zusätzliche CSS Datei eingebunden. Diese kann vom Browser
Seite 5
voreingestellte Formate ändern und so das Aussehen der Website an die Wünsche des Erstellers
anpassen. Standardmäßig baut sich eine CSS Datei wie folgt auf:
/* Das ist ein CSS-Kommentar. Dieser Text hat keinen Einfluss auf die spätere
Fromatierung. */
p {
font-family: Arial; /* Setzt die Schriftart auf das weit verbreitete Arial /*
font-size: 0.8em;
/* Setzt die Größe des Textes auf die 0,8 Fache Standardgröße*/
}
In dieser CSS-Datei werden nun in allen HTML-Dokumenten die sie eingebunden haben, alle <p>
Elemente mit den festgelegten Eigenschaften ausgestattet: In diesem Fall mit der Schriftart Arial
und der Text-Größe 0,8em. Die Einheit em ist zuerst nicht gerade leicht zu verstehen, da sie keine
direkte Größe darstellt. Sie bezieht sich auf die eingestellte Größe im Browser des Benutzers. Wenn
der Benutzer jetzt also schlechter sieht, oder sich eine Website genauer ansehen will, skalieren alle
Texte der Website mit der neuen Einstellung des Benutzers nach oben oder nach unten. Man kann
mithilfe dieser Einheit auch die Höhe der eingestellten Schriftart herausfinden und so die
Zeilenabstand auf die eigenen Wünsche anpassen. Will man zum Beispiel einen Zeilenabstand von
1,5 mal der Höhe der Schriftart haben, fügt man einfach folgenden Code in das gewollte CSSElement ein:
line-height: 1,5em;
Hiermit kann man schon Eigenschaften zu allen möglichen HTML Elementen zuweisen. Eine gute,
deutsche Auflistung von CSS-Eigenschaften1 findet man auf SelfHTML, wo man auch gleich eine
Auflistung von allen HTML-Elementen2 bekommt.
1.3.2
CSS Klassen
Jetzt hat man schon sein HTML-Dokument vor sich und kann es via auch schon CSS recht gut
gestalten. Will man jetzt aber die selben Eigenschaften auf mehrere Elemente zuweisen, zum
Beispiel ein roter Hintergrund, müsste man den nötigen CSS-Code 2 mal schreiben. Natürlich gibt
es eine Alternative zu diesem nicht gerade dynamischen Vorgang, was auch der Vorteil der
Gestaltung von HTML via Style Sheets gegenüber der Gestaltung über das Dokument an sich
ausmacht: Klassen.
1
http://de.selfhtml.org/css/eigenschaften/index.htm
2
http://de.selfhtml.org/html/referenz/elemente.htm
Seite 6
HTML-TEXT
<p class=“red_background“>
Lustiger Text der einen roten Hintergrund haben soll.
</p>
<table class=“red_background“>
<tr>
<th>Lustige Tabelle</th>
<th>die einen roten Hintergrund</th>
<th>haben soll</th>
</tr>
</table>
CSS-TEXT
.red_background {
/* Der . kennzeichnet den Namen einer Klasse */
background-color: red; /* Der Hintergrund wird auf Rot gesetzt. /*
}
Alle HTML-Tags die mit dem Attribut class=“red_background“ ausgezeichnet werden, erhalten die
in der CSS-Datei unter dem Punkt „red_background“ definierten Eigenschaften. Man kann diese
Klasse auch direkt in den Body-Tag schreiben, dann wird die ganze Website mit einem roten
Hintergrund dargestellt.
Der Punkt vor dem Namen de Klasse in der CSS-Datei muss nur bei Klassennamen gemacht
werden. Wenn man ein normales HTML-Element verändern will, muss man es ohne jedes
Vorzeichen ins CSS reinschreiben.
Die Klassen in CSS haben sehr viele Anwendungsmöglichkeiten, man kann mit ihnen nicht nur
solche roten Hintergründe zusammenbasteln, sondern auch Elementen eine besondere, immer
gleichbleibende Auszeichnung verpassen, wie zum Beispiel ein größerer Abstand vom
umschließenden Text, eine andere Größe und ein eine andere Farbe (diese Klasse könnte dann zum
Beispiel .important heißen).
1.3.3
Vererbung von Eigenschaften
Alle HTML-Elemente vererben ihre Style-Eigenschaften von der Ebene über ihnen. Die oberste
Instanz ist immer der Browser, er legt alles schon vorher fest. Wenn man jetzt zum Beispiel
folgenden Code schreibt:
<p class=“red_background“>
Text mit etwas <b>fettem</b>.
</p>
Hier werden auf den fett geschriebenen Text die Eigenschaften des p Elements (roter Hintergrund &
Schriftart) mit übertragen. Wenn man diesen <b> Tag an einer anderen Stelle einfügt, wird er die
Eigenschaften von dort vererben.
Man kann schnell in die Situation kommen, das ein Fetter Text in einem normalen Absatz anders
Seite 7
aussehen soll als in einer Tabelle. Jetzt könnte man eine eigene Klasse schreiben die man immer in
den gewünschten Bereichen einsetzt. Obwohl das in manchen Situationen die beste Methode ist,
gibt das allerdings wieder recht viel Fummelarbeit und wieder schenkt uns CSS eine kluge
Alternative:
p b {
color: red;
}
.important b {
color: blue;
}
Da die .important Klasse einen roten Hintergrund hat, wäre unser roter, fett geschriebener Text dort
überhaupt nicht lesbar. Deshalb definieren wir den fetten Text mit einer roten Schriftfarbe wenn er
in einem Paragraphen steht, und mit einem blauen Text wenn er innerhalb der .important Klasse
steht. Dieses Muster lässt sich natürlich auch auf Klassen in Elementen anwenden.
1.3.4
Identifier versus Klassen
Ein Identifier (ID) darf nur einmal an ein Element vergeben werden. Dies klingt zuerst sinnlos, da
man ja immer Eigenschaften auf mehrere Elemente legen können möchte. Wenn man aber genauer
drüber nachdenkt und sich JavaScript ansieht, dann kann man die Vorteile von IDs erkennen.
Identifier sind exklusiv nur einem einzelnen Element vergeben, man kann also in JavaScript per
Document.getElementById(„Id-Name“) auf das gewollte Element zugreifen und zum Beispiel den
enthaltenen Text oder die zugewiesenen Klassen ändern. IDs haben aber noch einen weiteren Vorteil
gegenüber Klassen, nämlich eine andere Strukturelle Sicht. Man weißt dem Seitenkopf
(normalerweise Header genannt) normalerweise die ID #header zu, da man ja nur einen Seitenkopf
hat.
Man kann im Allgemeinen aber sagen, das Klassen für die Meisten Anwendungen um einiges
besser geeignet sind als IDs, da man sie im ganzen Dokument wiederverwenden kann und im Falle
des Falles nicht den halben Code umschreiben muss weil man ein Element mit einer ID statt einer
Klasse definiert hat. Wenn man einen neuen Abschnitt in seinem Dokument beginnen will, sollte
man ihn meistens über eine Klasse definieren, und dann sollte man noch überlegen, ob nicht doch
alle Abschnitte gleich sind und nur ein paar kleine Unterschiede haben, die sich dann wieder über
Klassen, IDs und Vererbung definieren lassen.
Anders als bei Klassen definiert man IDs im CSS-Code nicht über Punkte, sondern über ein HashZeichen (#). Das sieht dann so aus:
Seite 8
#header {
background-color: grey;
text-align: right;/* Rechtsgestellter Text (Um den header vom Inhalt abzuheben) */
}
1.3.5
Das CSS Box-Model & Positionierung
Das CSS Box-Model ist der wohl schwierigste Teil von CSS, da man hier einige Faktoren
berücksichtigen muss und schnell den Überblick verlieren kann.
Wenn man beispielsweise bereits einen Rahmen in einem Übergeordneten element gesetzt hat und
dann im darunterliegenden Element eine größere Weite zuweist als das obere Element aufgrund des
Rahmens überhaupt bieten kann, kommt man schnell zu seltsamen Verschiebungen im gesamten
Layout. Deshalb gibt es auch zahlreiche CSS-Frameworks 3 die einem die Arbeit mit dem Layout
um einiges erleichtern.
Die grundlegende Funktionsweise kann man
schnell beschreiben: Das Element selbst wird
durch die Weite und Höhe bestimmt. Dazu
addiert wird dann der Innenabstand (padding).
Dieser ist der Abstand zwischen dem Element
und dem Rahmen darum. Danach kommt der
Rahmen (border) der natürlich auch wieder
einen eigenen Hintergrund und Dicke haben
kann. Am Ende kommt der Außenabstand
(margin), der den Abstand zu den anderen
Abbildung 1: CSS Box Model
Elementen angibt, jedoch selber nicht mehr zum Element an sich gehört (zum Beispiel sichtbar
wenn man einen Hintergrund zugewiesen hat).
Zusätzlich zum Box Model gibt es dann die verschiedenen Positions Modi die ein Element haben
kann:
position:
psotiion:
position:
position:
static
fixed
relative
absolute
/*
/*
/*
/*
Normales Element – Normaler textfluss */
Bleibt immer an einem Punkt – Scrollt nicht mit */
Verschiebt das Element relativ zur eigentlichen Position */
Positionierung relativ zum nächsten Element das nicht static ist */
Außerdem gibt es noch einige weitere Möglichkeiten wie man das Verhalten von Elementen, zum
Beispiel wenn der Inhalt größer wird als das Element selbst, beeinflussen kann. Eine sehr genaue
Erklärung zu allen möglichen Optionen gibt es wieder auf SelfHTML 4. Ich kann hier nicht weiter
3
z.B. http://960.gs/, http://www.blueprintcss.org & http://twitter.github.io/bootstrap/
4
http://de.selfhtml.org/css/eigenschaften/positionierung.htm
Seite 9
ins Detail zu diesem Thema gehen, da es mehrere Seiten verschlingen würde und mehr einer
Dokumentation gleich wäre. [SelfHTML]
1.3.6
Benützung eines CSS-Frameworks
Ein Framework bietet einige Vorteile gegenüber reinem CSS, vor allem aber einen Zeitlichen. Wenn
man Erfahrung mit einem Framework hat lässt sich eine Website mit einem komplexen Layout
recht schnell realisieren ohne das man sich sehr lange mit den verschiedenen Eigenheiten der Style
Sheets wie zum Beispiel Floats und Overflows aufhält. Bekannte Frameworks sind das 960 Grid
System, Blueprint & Bootstrap von Twitter. Bootstrap gleicht an Umfang schon eher einem CSS
Toolkit, enthält aber ein sehr gutes Grid-Framework, weshalb ich auch darauf eingehen will.
Ein Grid-System beschreibt sich eigentlich selbst, es bietet eine leicht zu verwendende GitterStruktur zum schnellen erstellen eines Layouts. Man muss sich keine Pixel merken und keine
dreckigen Hacks anwenden um die Navigation einer Website gleich breit zu bekommen wie die 2.
Sidebar auf der anderen Seite, sondern muss sich einfach nur merken das die beiden jeweils 2 Grid
Slots einnehmen, weshalb bei einem 12er Grid dann noch 8 für den Textkörper bleiben. Man kann
so sehr leicht die Übersicht bewahren und verfällt in keine Depression wenn es mal nicht so läuft
wie es soll, weil man den Fehler schnell finden kann. Die Frameworks sind in ihrer Anwendung
zwar sehr ähnlich, haben aber dennoch ein paar Unterschiede.
1.3.6.1
960 Grid System
Dieses Framework ist schon etwas angestaubt, bleibt aber ein sehr gutes Gitter zur Gestaltung von
Websites. Der Name kommt von der Standardmäßigen Breite von 960 Pixeln, was als ideale Breite
wegen der guten Teilbarkeit angesehen wurde. Heute sind relative (frei relativ zur Fensterbreite)
Systeme beliebter, da sie einen nicht so stark begrenzen und große Bildschirme ihre Vorteile besser
ausspielen können.
Man definiert zuerst ob man ein 12er (60px pro Spalte) oder ein 16er (40px pro Spalte) Layout
haben will und stattet dann einfach seine Elemente mit der Klasse grid_XX aus. Am Ende sieht die
Seite dann sehr gut strukturiert und harmonisch aus. [960 Grid System]
1.3.6.2
Blueprint
Blueprint hat normalerweise ein 24 Spalten Layout 5 und bietet einiges an zusätzlichen Funktionen
verglichen mit dem 960gs. Man kann beispielsweise Elemente in Spalten hinein und hinaus ziehen
5
http://blueprintcss.org/tests/parts/grid.html
Seite 10
und hat einiges an Typographischen Funktionen 6 die nicht nur Überschriften, sondern auch Tabellen
und Auflistungen betreffen. Außerdem bietet Blueprint mehrere CSS-Generatoren7, die einem den
benötigten Code (fixe Breite, dynamisch, ...) schnell generieren kann. [Blueprint Homepage]
1.3.6.3
Twitter Bootstrap
Dieses Framework ist das umfangreichste von den dreien, es beinhaltet auch einiges an JavaScript
Funktionen, genial aussehende Button Styles und sogar eigene jQuery Addons. Die Qualität und
Vielseitigkeit dieses Frameworks hat allerdings auch ein neues Problem mitgebracht: Die
Monotonität. Früher musste jeder Entwickler das komplette Design übernehmen, außer er hatte
einen zusätzlichen Gestalter zur Seite. Heute ist es bei einem Großteil der Websites der Fall, das sie
einfach Bootstrap hernehmen, die genialen Features benutzen und so eine eigentlich wunderschöne,
aber nicht von tausenden anderen Seiten unterscheidbare Website erstellen. Da man häufig nicht
mal mehr die voreingestellten Standard-Farben verändert sondern einfach das blaue Bootstrap so
wie es ist her nimmt, wird das Internet wirklich etwas monotoner.
Diese Monotonie wird aber bereits diskutiert und es erheben sich einige Stimmen (z.B. auf Reddit 8)
gegen den Bootstrap Wahn, oder wenigstens für mehr Veränderungen zu den eigenen Bedürfnissen.
Das System ist deshalb allerdings keinesfalls schlecht, es ist einfach zu komfortabel zum schnellen
Website-Erstellen, dass Entwickler von Internet-Anwendungen nicht wieder extra ein neues Layout
aus dem Boden stampfen wollen, sondern eben einfach das praktische Bootstrap verwenden.
In Bootstrap gibt es neben dem normalen Grid auch noch Kopfzeilen, Typographische Styles die
einem Traum gleichkommen und Buttons für die man sonst 4 Stunden bräuchte. [Bootstrap
Homepage]
1.3.7
CSS Erweiterungen
Vielen Leuten reicht CSS allein nicht, da die Sprache keine Variablen bietet und recht statisch ist.
Deshalb haben einige Leute Erweiterungen zu CSS erstellt, die sich beim speichern in normales
CSS umwandeln lassen. Man verwendet zum Beispiel in der Erweiterung Variablen, die dann beim
Umwandeln durch die gesetzten Werte ersetzt werden. Bekannte Erweiterungen sind zum Beispiel
LESS und SASS.
6
http://blueprintcss.org/tests/parts/elements.html
7
https://github.com/joshuaclayton/blueprint-css/wiki/Tools-and-Resources
8
http://www.reddit.com/r/webdev/comments/1bbpx3/bootstrap_overdose/
Seite 11
1.3.7.1
LESS
LESS9 wird von Bootstrap verwendet und ist deshalb relativ weit verbreitet. Man kann Variablen
einsetzen und mathematische Berechnungen durchführen, um Größenverhältnisse und farben
auszurechnen.
@base: #f938ab;
.box-shadow(@style, @c) when (iscolor(@c)) {
box-shadow:
@style @c;
-webkit-box-shadow: @style @c;
-moz-box-shadow:
@style @c;
}
.box-shadow(@style, @alpha: 50%) when (isnumber(@alpha)) {
.box-shadow(@style, rgba(0, 0, 0, @alpha));
}
.box {
color: saturate(@base, 5%);
border-color: lighten(@base, 30%);
div { .box-shadow(0 0 5px, 30%) }
}
Es gibt eine Vielzahl an bereitgestellten Funktionen, mit denen man einiges an dynamischen CSS
ohne viel Schreibarbeit erstellen kann, und man kann auch „Klassen Funktionen“ erstellen, die
sogar Argumente haben können und dadurch ohne viel Tippen einen variablen Style einem Element
zuweisen können. Außerdem kann man Vererbung direkt in den geschwungenen Klammern ({})
betreiben und muss nicht jedes Element einzeln anschreiben. [LESS CSS Homepage]
1.3.7.2
SASS
SASS10 ist ebenfalls eine Erweiterung von CSS3 und bietet ähnliche Features wie LESS. Die Syntax
ist etwas anders als bei LESS, allerdings auch größtenteils gleich.
@mixin table-base
th
text-align: center
font-weight: bold
td, th
padding: 2px
@mixin left($dist)
float: left
margin-left: $dist
#data
@include left(10px)
@include table-base
9
http://lesscss.org/
10 http://sass-lang.com/
Seite 12
Ein großer Vorteil von SASS ist allerdings, dass man die geschwungenen Klammern weglassen
kann und wie in Python nur mit Einrückungen arbeiten kann, was einem wiederum recht viele
Zeilen erspart. [Sass Homepage]
1.3.8
JavaScript
function myFunction(a,b)
{
return a*b;
}
document.getElementById("demo").innerHTML=myFunction(4,3);
Javascript ist ein sehr vielschichtiges Thema und bietet sehr viele Möglichkeiten für WebProgrammierer. Man kann dynamische Anwendungen erstellen, die den Benutzer durch die Website
begleiten, ansprechende Dropdown-Menüs für Navigationsleisten oder gar ganze Spiele im
Browserfenster. Es läuft lokal im Browser und kommuniziert, wenn man es darauf programmiert,
mit dem Server per HTTP Anfragen. Es gibt auch noch einen speziellen Webserver, der JavaScript
auch serverseitig ausführt und so recht praktisch ist wenn man recht viel Code hat den man gerne
wiederverwenden würde, ohne ihn zuerst auf eine serverseitige Sprache wie PHP zu übersetzen.
Es gibt auch noch viele Pakete die sich auf die Fahne schreiben, das sie einen leichteren Umgang
mit JavaScript ermöglichen und dies auch meistens tun. Das wohl bekannteste unter ihnen ist
jQuery11, das von einigen großen Web-Präsenzen verwendet wird und auch zum Beispiel in
Bootstrap seinen Platz findet.
JavaScript hat allerdings auch seine Tücken, man kann damit zum Beispiel die Größe des
Browserfensters ändern, den Benutzer mit Popups zumüllen oder penetrante Werbung einblenden
lassen. Das Script ist allerdings nicht mehr aus dem Web wegzudenken, da es den Anwendungen
trotzdem sehr viele Möglichkeiten eröffnet die man nicht missen will (zum Beispiel das direkte
Suchen von Begriffen auf Google während man tippt, oder die Suchvorschläge). [SelfHTML]
1.3.9
Serverseitige Programmierung
Man beschränkt sich bei modernen Websites nicht nur auf die Ausgabe im Browser des Benutzers,
sondern verarbeitet auch eingegebene Informationen und speichert diese in einer Datenbank ab.
Meistens wird dafür PHP verwendet (78,9 %12 der Websites), es gibt jedoch auch andere Sprachen
11 http://jquery.com/
12 http://w3techs.com/technologies/details/pl-php/all/all
Seite 13
wie zum Beispiel Ruby on Rails13 oder Perl14 die den Entwicklungsprozess vereinfachen sollen und
eigentlich auch tun. Die meisten Webserver stellen allerdings nur PHP zur Verfügung, außerdem ist
PHP die am weitesten verbreitete Sprache bei größeren Projekten (zum Beispiel MediaWiki,
PhpBB, MantisBT, ...) und wird auch von vielen kommerziellen Websites verwendet (zum Beispiel
Facebook). Es wurde sogar von Facebook ein PHP zu C++ Compiler entwickelt, der den
vergleichsweise nicht sehr effektiven PHP Code in sehr effektiven C++ Code umwandelt
(HipHop15).
13 http://rubyonrails.org/
14 http://www.perl.org/
15 https://github.com/facebook/hiphop-php
Seite 14
2 Prozessorarchitekturen
2.1
Grundbegriff
Prozessorarchitektur ist die Art des Prozessoraufbaus. Ein Prozessor ist eine elektronische
Schaltung, welche bestimmte Bedingungen erfüllen muss. Diese wären: eine Arithmetisch-logische
Einheit (ALU), ein Steuerwerk zur Programmsteuerung, ein Speicherwerk und ein BusSystem(=System zur Datenübertragung mit mehreren Teilnehmern) zur Kommunikation. Bei
modernen PCs und Servern werden heutzutage als Hauptprozessoren nur noch Prozessoren mit 32-,
oder 64-Bit verwendet. Die Prozessorarchitekturen weisen Unterschiede in diesen Aufbau und
Umfang dieser Einheiten auf. Die Prozessorarchitekturen können nach verschiedenen
Gesichtspunkten unterteilt sein, wie nach Wortbreite
(=
Grundverarbeitungsdatengröße bei einem Computer), Befehlsaufbau, und Einsatzzwecke. Innerhalb
dieser Architekturen kann es auch viele verschieden Prozessoren geben.
2.2
Prozessorarchitekturen nach Wortbreite
Die Einteilung verschiedener Architekturen nach ihrem Grunddatenvermögen
2.2.1
1-Bit Architekturen
Die 1-Bit Architekturen sind EDV Systeme, die nur 1 Bit in ihrem Arbeitstakt verarbeiten. Eine
echte 1-Bit-Architektur, welche wirklich auch als CPU (=Hauptprozessor) vermarktet wurde, ist die
MC14500 Industrial Control Unit von Motorola. Häufige Vertreter der 1-Bit-Architektur sind
speicherprogrammierbaren Steuerungen (SPS) (= Gerät zur Steuerung einer Maschine/Anlage,
welches auf digitaler Basis programmiert wurde). Die Bezeichnung sagt nichts über die
Prozessorplattform aus. Die sogenannte Anweisungsliste kann durch Optimierung, Parallelisierung
und Wandlung in der Hardware stark Abweichend zur Lösung der SPS-Arbeitsaufgabe von 1-Bit
sein. Zum Beispiel kann ein Programm mit 1-Bit-Logik mit einem Compiler für einen 32-BitProzessor übersetzt werden. Ein Programm für eine 1-Bit-Architekturkann so aufgebaut sein:
•
lade digitalen Eingang 1 in das 1-Bit-Register
•
(oder-)verknüpfe den Wert im 1-Bit-Register mit Eingang 2, das Resultat bleibt im Register
Seite 15
•
schreibe den Wert im 1-Bit-Register auf Ausgang 1
2.2.2
4-Bit-Architekturen
Unter 4-Bit-Architektur versteht man eine der 3 Prozessor-Architekturen:
•
Intel; Modell 4004
•
NEC; die Prozessorfamilie uPD75X
•
Texas Instruments; die Serie TMS1000
Es gibt zwar auch noch andere, welche aber äußerst selten sind. Bei dieser Architektur können 4 Bit
(=1/2 Byte, =1Nibble) gleichzeitig verarbeitet werden. Das sind z.B. Ausführung des
Registersatzes, Recheneinheiten und interne und externe Gestaltung von Adressbussen. 4-BitArchitekturen werden oft in Taschenrechnern, Waschmaschinen, Fernsehern und Videorekordern
verwendet. Heute haben billige Prozessoren aus der Prozessorfamilie uPD75X von NEC die früher
verwendeten 4-Bit Prozessoren 4004 von Intel abgelöst.
2.2.3
8-Bit Architekturen
In der 8-Bit-Architektur gibt es schon viel mehr bekannte Versionen von Prozessor bzw.
Mikrocontroller-Architekturen, als bei der 4-Bit Reihe. Einige von ihnen sind z.B. von Intel die
8008- und 8080-Modelle, von MOS die 6502-Serie und von NEC die 78K0-Serie.
Bei den 8-Bit-Architekturen ist das Design so ausgelegt, dass 8 Bit (=1Byte) gleichzeitig ausgeführt
werden können. Der Speicherbereich kann durch Memory-Mapping noch erweitert werden, weil
Adressbus und Register oft 16 Bit breit sind. 8-Bit-Prozessoren sind die bis heute am häufigsten
eingesetzten Prozessoren. Nicht als CPU, sondern als Mikrocontroller. Großteile von Computer und
dessen Zubehör, wie Maus, Tastatur und Motherboard im Monitor sind mit 8-Bit-Prozessoren
ausgestattet. Außerdem werden sie auch noch bei USB-Geräten verwendet.
2.2.4
16-Bit Architekturen
In der 16-Bit-Architektur können jeweils 2 Byte gleichzeitig ausgeführt werden. Wichtig bei diesen
Architekturen ist auch die Programmiersprache C. In dieser schlägt sich die Anzahl der Bits nieder.
Zu der Zeit als die Programmiersprache C entstand, gab es auch schon 32-Bit-Prozessoren, darum
verwendete man statt dem Int-Typ auf 16 Bit den Long-Typ, welcher 32-Bit hat und nannte ihn
Seite 16
IP16.
Zuerst arbeiteten die Betriebssysteme, wie DOS mit IP16 (small-Model), doch dann wechselte man
auf 32-Bit-Architektur, da diese effektiver ist.
2.2.5
32-Bit-Architektur
Durch das ALU-Design (ALU ist die Abkürzung für arithmetische logische Einheit und ist ein
elektronisches Rechenwerk. Sie wird vor allem in Prozessoren angewendet) können gleichzeitig 4
Byte verarbeitet werden, und bietet dadurch eine höhere Leistung.
32 Bit sind ein Binärcode aus 32 Ziffern. (Nur 0 und 1)
Hochbittige Prozessoren haben den Vorteil, dass man zum Beispiel große Integer-Werte leicht
berechnen kann, und dies somit Vorteile bei Verschlüsselungsalgorithmen und graphischen
Berechnungen schafft.
Dass ein Vorteilhafter Wechsel von 16- auf 32-Bit-Prozessoren vorhanden ist, braucht man
allerdings ein speziell angepasstes Betriebssystem. Außerdem braucht man für einen 32-Bit breiten
Datenpfad auch einen 32-Bit breiten Adresspfad, welcher aber nicht immer vorhanden ist. In
manchen Systemen kann es auch vorkommen, dass der Adresspfad schmaler oder größer als 32-Bit
ist.
Für diese Architektur und auch bei der 16-Bit-Architektur wurde speziell eine eigene
Programmiersprache entwickelt. Die Programmiersprache C (Eine Programmierstelle, welche in
den 1970er Jahren vom Informatiker Dennis Ritchie für Unix entwickelt wurde).
2.2.6
64-Bit-Architektur
Bei dieser Architektur beträgt die Wortbreite 64-Bit (= 8 Byte)
Viele der Computer, welche 64-Bit-Prozessoren besaßen, wurden Supercomputer genannt. Einige
Beispiele dafür sind: IBM 7030 Stretch mit 64-Bit Wortbreite und 32- oder 64-Bit Befehlsbreite
(1961), CDC STAR-100 Vektorrechner, Nachfolger der 60-Bit-Rechner der Control Data
Corporation (1974), Cray-1, der erste 64-Bit-Vektorrechner, Vorläufer der Cray Supercomputerlinie
(1976), Elxsi 6400 sogenannter „Minisupercomputer“ mit 64-Bit-Datenpfaden, aber 32-Bit-
Seite 17
Adressraum (1983).
Aber auch moderne Universalcomputer sind auf 64-Bit ausgerichtet, wie zum Beispiel von Sun
Microsystems die UltraSPARC-Serie (32 und 64 Bit) (ab 1995), von IBM die System z-Serie
(vormals S/390) (ab 2000), von Intel die IA-64-Familie (ab 2001) und von ARM Limited die
ARMv8-Architektur (für 2014 angekündigt).
Eine 64-Bit-Architektur war von Power PC (ein Konsortium aus Apple, IBM und Motorola,
welches heute Freescale heißt, auch kurz AIM genannt) – im Gegensatz zu x86- von Anfang an
Vorgesehen. Diese CPUs stammten nämlich Ursprünglich aus den Großrechnern, welche eine IBM
Power-Architektur besitzen. Eine 64-Bit Erweiterung war auch für MIPS.Architektur vorgesehen.
Beidess wurde dann auch umgesetzt, was aber erst einige Jahre darauf folgte.
Die Vorteile dieser Architektur liegen darin, dass man, wie schon bei der 32-Bit-Architektur,
einfacher große Integer-Werte berechnen kann, und somit auch leichteren Zugang zu
Verschlüsselungsalgorithmen bekommt. Außerdem können bei den 64-Bit-CPUs 4Gigabyte
Arbeitsspeicher direkt adressiert werden. Wirklich wichtig werden die 64-Bit-Prozessoren erst beim
sogenannten intelligenten Management, welches vor allem von der Befehlssatzarchitektur Very
Long Instruction Word (VLIW) gehandhabt wird und man hierbei sogar auf 128- oder 256- BitProzessoren setzen konnte.
Nachteile der 64-Bit-Architektur sind, dass es vor allem bei kleinen Programmen zu schwindender
Schnelligkeit und Effizienz führt. Außerdem sind alle Adresswerte dieser Architektur doppelt so
breit wie die der 32-Bit-Architektur, und verbrauchen dadurch im RAM natürlich mehr
Speicherplatz.
Eine Schwierigkeit dieser Architektur ist die Anpassung, da man dies ganz speziell machen muss,
und auch extra dafür ausgelegte Betriebssysteme benötigt. Genauso enthält nicht jedes System,
welches 64-Bit-Datenpfade hat, auch 64-Bit-Adresspfade. In manchen Fällen können diese auch 32Bit bleiben.
Unter der Programmiersprache C schlägt sich die Anzahl der Bits sowohl bei der Größe der ZeigerTypen (z. B. void *) als auch Integer-Typen (insbesondere int und long) nieder. Beim Übergang von
einer 32-Bit-Architektur verbreitert man in der Regel Zeiger und long auf 64 bit, während der int
auf 32 bit verbleibt. Dieses nennt man dann abgekürzt LP64. Heute drücken alle, auf UNIX
Seite 18
basierenden Betriebssysteme ihre 64-Bit-Architektur in einem LP64-Typenmodell aus. Windows
verwendet das LLP64-Modell. Es wurde das ILP64-Datenmodell eingeführt, da Quellcode von
alter Software häufig unter der unzulässigen Annahme entwickelt wurde, dass ein int einen Zeiger
halten kann
64-bit
Datenmodelle[6]
Datenmodell
2.3
short (integer)
int
long (integer)
long long
pointer
LLP64
16
32
32
64
64
LP64
16
32
64
64
64
ILP64
16
64
64
64
64
SILP64
64
64
64
64
64
Prozessorarchitekturen nach Befehlssatzaufbau
Es gibt sechs verschiedene Versionen in der Einteilung nach Befehlsaufbau: CISC, EPIC, NISC,
RISC, VLIW, Mikroarchitektur
2.3.1
CISC
CISC
heißt
Complex
Computerprozessoren.
Instruction
Set
Computer
Der bekanntesten Vertretern
ist
dieses
eine
Designphilosophie
Konzepts
ist
die
für
Intel-x86-
Prozessorfamilie (bis einschließlich 80386).
Die Befehlssätze für Prozessoren sollten Anfangs immer umfangreicher und leistungsfähiger
werden. Dadurch wurde aber auch eine Weiterentwicklung immer schwieriger. Viele Hersteller
setzten dann auf Mikroprogrammierung der Rechenwerke, da dadurch Fehler leichter zu beheben
waren.
Seite 19
Die Bezeichnung CISC geht auf IBM aus dem Jahre 1970 zurück.
Früher waren fast alle CISC CPUs mikroprogrammiert. Solche findet man aber heutzutage kaum
noch.
2.3.2
EPIC
EPIC heißt Explicitly Parallel Instruction Computing, und ist eine Eigenschaft einer
Befehlsarchitektur und der Verarbeitungsstruktur von Mikroprozessoren.
Man entwickelte EPIC, um Logikgatter (ein elektronisches Bauelement für die Realisierung einer
Booleschen Funktion) zu reduzieren, und so freien Platz für funktionale Einheiten zu schaffen, um
diese in die CPU zu integrieren.
EPIC funktioniert dadurch, dass dem Prozessor beim Programmieren signalisiert wird, welche
Instruktionen (=Handlungsanweisung)
man parallel ausführen kann. Diese parallelisierbaren
Instruktionen werden in sogenannten instruction groups zusammengefasst.
Das Optimierungsziel von EPIC ist, die nötigen instruction groups in ihrer Anzahl so zu
minimieren, weil dadurch die durchschnittliche Anzahl der Instruktionen pro instruction group
erhöht werden.
Durch Anwendung von EPIC werden nötige Mittel gespart, welche bei nicht-EPIC Prozessoren
dazu dienen, die Instruktion während einer Ausführung auf die parallel arbeitenden Einheiten des
Prozessors aufzuteilen.
Berechnungen, welche für die Parallelisierung notwendig sind, können mehr Rechenzeit für diese in
Anspruch nehmen, weil sie unabhängig von der Ausführung erfolgen.
Ein Verfahren Befehle abhängig von einer Bedingung auszuführen, ohne Sprungbefehle zu
benutzen, nennt man in EPIC Predication.
Außerdem gibt es noch Speculation, das wurde entwickelt, weil es bei größeren, und schnelleren
Prozessoren einen Verlust der Daten im Speicheraufbau gibt. Das Ziel von Speculation ist also,
Befehle im Programmaufbau früher auszuführen, damit die benötigten Daten gleich von vornherein
vorhanden sind.
Seite 20
2.3.3
NISC
NISC ist der Name für No Instruction Set Computing, und ist eine Computer Architektur für
Hardware –Beschleuniger und eine Entwicklung hocheffizienter benutzerdefinierte Prozessoren.
Es ist eine statisch-geplante (Prozessorausführung und Fehlerkontrolle liegen in der Hand des
Compilers) horizontale nano-codierende (es wird kein vordefinierten Befehlssatz oder Mikrocode
benutzt) Architektur (SSHNA).
Einige Vorteile von NISC sind: es gibt einen sogenanntenSimple Kontroller, bei welchem keine
Hardware-Scheduler, und keine Instruktionsdecoder verwendet werden; eine bessere Performance,
die flexiblere Architekturen und bessere Ressourcenauslastung bietet; und ein einfacheres Design,
bei dem es keine Notwendigkeit gibt, Befehlssätze zu entwerfen.
Das Konzept im Kern von NISC ist, leistungsfähige FPGAs (integrierter Schaltkreis der
Digitaltechnik) durch intelligente Compiler dazu zu bringen, Programme die z. B. in Hochsprachen
wie der Programmiersprache C geschrieben wurden, in Echtzeit in FPGA verständliche
Hardwarebeschreibungssprachen zu übersetzen.
2.3.4
RISC
Der Name ist die Abkürzung von Reduced Instruction Set Computer (Rechner mit reduziertem
Befehlssatz). Diese Technologie wird für Computerprozessoren, welche einfache Maschinenbefehle
bevorzugen verwendet. Der Begriff RISC wurde 1980 von David A. Patterson und Carlo H. Séquin
geprägt, welche das Berkeley-RISC-Projekt starteten, was zum Ursprung von RISC führte.
Wie der Name schon sagt, wird bei RISC auf komplexe Befehle, vor allem auf solche, die
Speicherzugriffe (langsam) mit arithmetischen Operationen (schnell) kombinieren, verzichtet.
RISC wurde Anfang der 60er und 70er Jahre zuerst entwickelt, und erlebte durch David A:
Patterson und Carlos H. Séquin in den 1980ern ihre Blütezeit.
RISC Prozessoren sind das richtige Gegenstück zu CISC Prozessoren. Doch heute können RISC
Prozessoren auch die Grenzen der engen Definition und komplexere Befehle überschreiten.
Die wahrscheinlich wichtigste, und am öftesten vorhandene
RISC Architektur, ist ARM. Sie
Seite 21
kommt vor allem bei Systemen mit hoher Leistung und geringen Kosten vor(typisch: 100–500 MHz
2008). Die ARM Ltd, welche diese Systeme konstruiert, baut allerdings selbst keine Prozessoren,
sondern verkauft lediglich Lizenzen für das Design an ihre Kunden. Zur Zeit sollen 10 Milliarden
ARM-CPUs im Umlauf sein, welche in Tablets, Digitalkameras, grafikfähigen Taschenrechnern,
NAS, Routern, Spielkonsolen, PDAs, Smartphones und verschiedenen Mobiltelefonen vorkommen.
Für die Zukunft sind auch energiesparende Server angestrebt, deshalb hat ARM erste Pläne für eine
64-Bit-Architektur vorgestellt.
2.3.5
VLIW
VLIW heißt eigentlich Very Long Instruction Word, und ist die Eigenschaft einer Befehlsarchitektur
in einer Familie von Mikroprozessoren. Als Ziel wurde die schnellere Abarbeitung sequentieller
Programme gesetzt.
Während der Übersetzungszeit überprüft der Compiler eines Programms, welche Instruktionen
parallel ausgeführt werden können. Alle Instruktionen eines Befehls, werden durch die
Ausführungseinheiten zur Laufzeit des Programms parallel verarbeitet.
Bei VLIW gibt es ein sehr breites Befehlsformat, in welchem mehrere Instruktionen enthalten sind.
Die Parallelität auf der Befehlsebene kann aber nicht immer vollständig genutzt werden. Das kann
sein, wenn zum Beispiel in einem Takt nur ein Befehl ausgeführt werden kann. Eine Lösung für
dieses Problem fand Texas Instruments, welche die VelociTI-Technikentwickelten. Dies ist eine
Technologie, bei welcher mehrere Befehle in aufeinander folgenden Takten in ein Befehlswort
gepackt werden können. Intel in seiner IA-64-Architektur verwendet ein ziel ich ähnliches System.
Die Vorteile von VLIW sind, dass es mehr Platz für die Funktionseinheitengibt, es ist ein Einfacher
Kontrollpfad vorhanden und es besteht eine gute Ausnutzung durch Compiler-Techniken wie
Software-Pipelining.
Ein Nachteil von VLIW ist, dass sich der Code nicht unbedingt ohne größere Änderung auf andere
Prozessoren portieren lässt.
Seite 22
2.3.6
Mikroarchitektur
Die Mikroarchitektur ist ein Rechenwerk, das die konkrete, prozessorinterne Realisierung einer
CPU mit vorgegebener Befehlssatzarchitektur bezeichnet. Begriffe wie VLIW und EPIC sind nur
verschiedene Paradigmen bei Entwurf- und Befehlsarchitektur.
Die implementierte Befehlssatzarchitektur eines Prozessors lässt nicht unbedingt Rückschlüsse auf
die verwendete Mikroarchitektur zu. Meistens werden Mikroarchitekturen mit Blick auf eine
vorgegebene Befehlssatzarchitektur entworfen, da man somit die Kompatibilität der Vorgänger CPU
wahren kann. Dabei können die Unterschiede zur Mikroarchitektur des Vorgängermodells erheblich
sein. Ein Beispiel sind die x86-CPUs Pentium und Pentium Pro genannt, deren Befehlssätze sich
kaum unterscheiden, aber ihre Mikroarchitekturen sind von Grund auf verschieden.
Bei der Weiterentwicklung der Mikroarchitektur können sehr viele vielfältige Ziele gesetzt werden.
Normalerweise spielt der spätere Einsatzzweck der CPU eine Rolle, doch manchmal hängt dies
auch vom Marketing ab. Die möglichst schnelle Ausführung eines Programms, steht in den meisten
Fällen im Vordergrund.
Ein anderes Entwurfsziel können auch
Kostengünstige Fertigung,
Energieverbrauch, Skalierbarkeit, Erweiterbarkeit und Wartbarkeit sein.
2.4
Geschichte
Die ersten Prozessoren gab es bereits 1971,
Intel
begann
mit
der
Entwicklung
von
Prozessoren sogar schon 1969. Damals wurde
ein solcher Prozessor von der japanischen
Firma Busicom in Auftrag gegeben, um Chips
für eine Rechenmaschine für einen Supermarkt
zu erhalten. Heraus kam Intel 4004, der erste
Mikroprozessor
mit
dem
die
ganze Abbildung 2: Intel 4004 Prozessor
Prozessorszenerie begann.
Schnell erkannte man die unbegrenzten Möglichkeiten und die zahlreichen Anwendungsgebiete des
Mikroprozessors. Heutzutage sind Computer nicht mehr aus dem Alltag wegzudenken und der
Prozessormarkt scheint unerschöpflich zu sein. Immer aufwendigere Aufgaben und komplexere
Anwendungen erfordern immer schnellere Prozessoren, was die Entwicklung der Prozessoren stark
Seite 23
antreibt.
2.4.1
Auflistung der Prozessoren bis 1999
Jahr
Hersteller
Model
Transistoren
Takt
Bemerkung
197
Intel
4004
2.300
108
Dieser Prozessor war der Urvater aller Prozessoren und somit der erste
kHz
Mikroprozessor. Die 4-Bit Datenbreite reichte für den Einsatz in
1
Taschenrechnern und zur Steuerung von elktronischen Geräten.
197
Intel
8008
3.500
3
197
Motorola
6800
4.100
200
Der Intel 8008 unterstützte nun die 8-Bit Datenbreite und konnte erstmals
kHz
programmiert werden.
1,0
Konkurrenz-Produkt zum Intel-Prozessor mit eigenem Befehlssatz, der
4
nicht mit dem Intel-Prozessor kompatibel war. Dieser Prozessor galt erste
vollwertige CPU.
197
Intel
8080
6.000
2,0
5
mit 8-Bit-Datenbreite, aber weiterhin ohne Co-Prozessor.
197
MOS
5
Technology
197
Zilog
6502
Z 80
4.000
8.500
6
197
Motorola
6809
7
197
1,0-
Diese CPU kam im Apple II zum Einsatz und war schneller als der Intel
2,0
8080. Ebenfalls mit 8-Bit Datenbreite.
2,5-
8-Bit-Prozessor, der einen effizienteren und besseren Befehlssatz als der
8,0
Intel 8080 besaß und somit leitungsmäßig überlegen war.
5,0-
8- Bit Mikroprozessor aus dem Hause Motorola. Sehr leistungsstark.
8,0
Intel
8086
29.000
8
198
Erste vollprogrammierbare CPU aus dem Hause Intel. Wie der Vorgänger
Intel
8088
29.000
0
4,0-
Erste CPU mit 16-Bit-Technologie, auf der viele Prozessoren basierten.
8,0
Selbst moderne Prozessoren basieren auf dieser Architektur.
4,0-
Günstige Alternative zum Intel 8086. Hatte nur einen externen 8-Bit-
8,0
Datenbus und konnte somit billiger produziert, was sich aber letztendlich
negativ auf die Performance auswirkte.
198
Zilog
Z 8000
17.500
Konkurrenzprodukt zum Intel 8086, welche ebenfalls ein 16-Bit-Datenbus
0
198
hatte.
Motorola
68000
68.000
20
16-Bit-CPU von Motorola. Schneller als der Intel-Prozessor.
198
MOS
6510
11.500
1,0
Erweiterte 6502-CPU, welche im Commodore C 64 zum Einsatz kommt.
1
Technology
198
Intel
80286
124.000
6,0-20
Nachfolger des Intel 8086. Der Intel 80286 (in der Regel einfach nur 286er
0
2
198
genannt) basierte weiterhin auf der 16-Bit-Technologie.
Motorola
68010
190.000
4
198
5
Intel
80386
275.000
8,0-30
Erste CPU, welche die 32-Bit-Technologie unterstützte. Kam in den
Mhz
Rechnern Apple-LISA und Macintosh zum Einsatz.
12-30
Mit dem 386er zog Intel Motorola nach und veröffentlichte den ersten
Mhz
hauseigenen 32-Bit-Prozessor. Dieser war erstmals auch Multitasking fähig,
konnte also mehrere Programme gleichzeitig ausführen.
Seite 24
198
Zilog
Z 80000
198
MOS
65816
5
Technology
198
Motorola
91.000
32-Bit-CPU von Zilog. Letzter Prozessor aus dieser Prozessorschmiede.
5
68030
Weitere 32-Bit-CPU der 65x-Baureihe.
273.000
10-50
7
198
CPU aus dem Hause Motorola mit 32-Bit-Technologie. Besitzt eine externe
Fließ-Komma-Einheit , was dem Prozessor deutlich beschleunigt.
Intel
80486
1.180.000
9
16-
Mit dem Intel 486er und Windows 95 begann der Aufschwung der Privat-
100
PC's. Der 486er hatte erstmals einen integrierten Co-Prozessor und war
deutlich schneller als der Vorgänger. Die Taktraten betrugen bis zu 100
Mhz.
198
Motorola
68040
1.200.000
10-50
9
199
dem Chip integriert. Dadurch deutlich schneller.
IBM
Power 1
492.000
Erste eigenständige IBM-CPU, aber deutlich langsamer als die Prozessoren
0
199
Nachfolger der 68030-CPU . Dieses mal war die Fließ-Komma-Einheit in
von Intel und Motorola.
AMD
386 DX
200.000
16-40
1
AMD entwickelt den ersten Klon-Prozessor. Dieser ist technisch gesehen
dem Intel 386er unterlegen, aber die höheren Taktraten machten diesen
Prozessor trotzdem interessant, da er auch günstiger war.
199
IBM
386 SLC
815.000
16-25
1
199
blieb.
Cyrix
486 SLC
600.000
2
199
IBM
486 SLC
1.400.000
2
199
20-
Cyrix steigt in den Prozessormarkt ein und veröffentlicht den 486 SLC.
100
Dies ist ein Klon des 386, aber ohne mathematischen Co-Prozessor.
20-
IBM-Variante zur 80486-Intel-CPU.
100
Motorola
68060
1.500.000
2
199
Versuch von IBM, den 386er bzw. 486er zu imitieren. Was aber ohne Erfolg
50-
Letzter Prozessor aus dem Hause Motorola.
100
Intel
Pentium
3.100.000
3
60-
Der Pentium löst den 486er und kann trotz geringerer Taktraten den 486er
166
schlagen. Anfangs auch unter 80586 bürgerte sich der Name Pentium
schnell ein.
199
Cyrix
486 DX
1.100.000
3
199
Cyrix-Klon zum Intel 486, der zudem auch Pin-kompatibel war.
100
AMD
486
930.000
3
199
33-
Intel
5
Pentium
5.500.000
Pro
33-
AMD-Klon des Intel 486. Dieses Mal mit offizieller Lizenzierung, dass
100
AMD denselben Sockel benutzen darf.
150-
Server-Prozessor, der deutlich größer war als der herkömmliche Pentium.
200
Mit insgesamt 256 KB integriertem L2-Cache war der Pentium Pro ein
teurer und schneller Rechenknecht.
199
Cyrix
6x86
3.300.000
5
199
5
AMD
K5
4.300.000
100-
Billiger Konkurrent zum Pentium Pro, der in Zusammenarbeit mit IBM
200
hergestellt wurde. Ist teilweise sogar schneller als der Pentium Pro.
100-
Die K5-Prozessoren traten den Kampf gegen die Pentium-Prozessoren an.
120
Dabei legte AMD eher Wert auf günstige Preise als auf Leistung. Trotzdem
waren die K5-Prozessoren ziemlich flott. Pin-Kompatibel zu den Pentium-
Seite 25
Prozessoren.
199
Nexgen
Nx6x86
5.100.000
5
199
IBM
PowerPC
5.100.000
604e
Intel
Pentium II
7.500.000
7
199
Letzte CPU von Nexgen.
133
6
199
75-
AMD
K6
5.500.000
7
166-
Weiterentwickelte CPU der 6. Generation. Vergleichbar mit dem Pentium
250
Pro. Wird von IBM jedoch nicht in den eigenen PC's eingesetzt.
233-
Der Nachfolger des Pentium-Prozessors wurde erstmals in einer Prozessor-
350
Box gefertigt, also der Prozessor an sich befand ich auf einer Cartridge.
166-
Der AMD K6 wurde weiterhin in der Sockel 7 Bauweise produziert und
300
stand in Konkurrenz zum Pentium MMX und Pentium 2, gegen die er sich
nie richtig durchsetzen konnte und als günstige Alternative galt.
199
AMD
K6-2
9.300.000
8
199
Intel
Celeron
8
450-
Verbesserter K6-Prozessor, dem nun auch der Befehlssatz 3DNow!
533
implementiert wurde, um Multimedia-Anwendungen zu beschleunigen.
266-
Intel führt erstmals den Celeron-Prozessor ein, um eine günstige Alternative
533
zu den teuren Pentium-Prozessoren anbieten zu können. Dieser wird in der
Regel etwas abgespeckt und verliert dadurch etwas an Leistung, ist dafür
aber günstiger.
199
PowerPC
8
199
6.350.000
750
Intel
9
199
PowerPC
Pentium
9.500.000
III
AMD
K7 Athlon
22.000.000
9
200-
Motorola / IBM-CPU der 7. Generation. Kommt in den Apple-iMacs zum
500
Einsatz.
450-
Der Nachfolger des Pentium 2 kommt mit höheren Taktraten, einer
650
verbesserten Architektur und neuen Befehlssätzen (SSE) daher.
500-
AMD führt den Athlon Prozessor für den Slot A ein, der dem Pentium III in
1000
allen Belangen überlegen ist. Mit dem Athlon-Prozessor gewinnt die Firma
AMD deutlich an Prestige!
199
Intel
Celeron 2
21.000.000
9
2.4.2
500-
Der Celeron bekommt einen neuen Prozessorkern. Der Coppermine-Kern
1000
wird ebenfalls im Pentium 3 verbaut. So sind höhere Taktraten möglich.
Intel 4004
Intel 4004 ist ein 4-Bit-Mikroprozessor der 1971 vom Hersteller Intel auf den Markt kam und heute
zu den begehrtesten Objekten für Chipsammler zählt. Er ist zwar der erste Ein-ChipMikroprozessor, der in Serie produziert wurde, allerdings nicht der allererste Mikroprozessor
überhaupt denn Texas Instruments gab bereits 1968 einen Mikroprozessor in Auftrag, der allerdings
nie in Serie ging.
Seite 26
2.5
Prozessorarchitekturen
mit
Optimierung
für
Einsatzzwecke
2.5.1
Grafikprozessor
Der Grafikprozessor (GPU) sorgt dafür, dass die Zahlen und Daten aus der Computerwelt als Bilder
und Texte auf dem Bildschirm zu sehen sind. Der Grafikprozessor sitzt auf der Hauptplatine oder
einer eingebauten Grafikkarte. Viele Grafikprozessoren stammen heute von AMD, Intel oder
Nvidia.
2.5.2
Soundprozessor
Der Soundprozessor (SPU) sorgt dann dafür, dass man auch einen Ton beim Computer hat. Heute
wird er zusehends von Soundkarten ersetzt, sie sind oft schon Bestandteil der Hauptplatine.
Soundkarten sind aber nicht nur für Computer, es gibt sie auch bei Spielkonsolen oder in Autos.
[Wikipedia: Prozessorarchitekturen]
Seite 27
3 Literaturverzeichnis
Wikipedia: Geschichte des Internets: http://de.wikipedia.org/wiki/Geschichte_des_Internets - 2013
Wikipedia: Prozessorarchitekturen (Alle Unterkapitel):
http://de.wikipedia.org/wiki/Prozessorarchitektur - 2013
Sass Homepage: http://sass-lang.com/ - 2013
LESS CSS Homepage: http://lesscss.org/ - 2013
Twitter Bootstrap: http://twitter.github.io/bootstrap/index.html - 2013
Blueprint CSS: http://www.blueprintcss.org/ - 2013
960.gs: http://960.gs/ - 2013
SelfHTML Homepage: http://de.selfhtml.org/ - 2013
4 Bilderverzeichnis
Abbildung 1: CSS Box Model.............................................................................................................9
Abbildung 2: Intel 4004 Prozessor.....................................................................................................23
Seite 28