Da computere er en fysisk del af denne verden, og samtidig, et matematisk ”vidunder”, følger der selvfølgelig også nogle love og systemer, som man har prøvet at visualisere ved hjælp af modeller. Jeg vil på denne side Forsøge at forklare nogle af disse modellers opbygning.
Når man taler om lageret på en computer, er det hverdagstro at det kun handler om harddisken. Denne del er godt nok den største, og derfor mest omtalte lagerdisk, men computeren eksisterede før harddisken, så det er ikke den eneste lager-form vi har at gøre godt med.
Ud over Harddisken, har vi også RAM, Cache og Registers.
Der er to ting der er i fokus når man taler om lager, plads og hastighed.
For selv om Harddisken er klart den største af disse fire lagertyper,
så er det også den mest langsomme. Den hurtige hukommelse der ligger
på computeren er Registers, denne er til gengæld også den mindste.
Det gælder som standart for disse fire lagertyper, at jo hurtigere de er,
jo mindre plads har de at gøre godt med. Det samme er det omvendt,
at des mere plads, des langsommere er lageret til at modtage
og sende data.
Lager modellen (håber den taler for sig selv)
En anden meget grundlæggende model, denne gang for computerens arkitektur, er en af Neumann's mange computer modeller. Det der er specielt ved Von Neumann's modeller er at de stadig, efter at det er så mange år siden han lavede dem (omtrent 50-70år ), er de stadig ”fuldt” ud anvendelige, til analysering af computere i dag.
En af hans mere simple modeller er denne model:
Som viser at der grundlæggende findes 3 ting i en computer. Processoren, som beregner data, lageret, som opbevarer data, og busserne, som forbinder de to.
En af hans andre modeller, er denne lidt mere specifikke model:
Som viser hvordan al computerens hardware er bygget op omkring processoren.
En trejde af hans modeller er denne model:
Som viser computerens forskellig hardware's placering i forhold til nord- og sydbroen, og deres forbindelse.
Denne model, er dog blevet lavet lidt om, som tiden er gået, hvor grafikkortet først blev rykket fra syd- til nordbroen. Derefter blev RAM rykket over på den modsatte side af processoren, så den ingenting har med nordbroen at gøre, og nu er det et spørgsmål om hvorvidt grafikkortet ikke er ved at ryge samme vej. Det kan meget vel være at grafikkortet kommer over på samme side af nordbroen som processoren og Rammene.
Den originale af Neumanns firkant modeller.
efter at grafikkortet kom op på nordbroen.
Rammene emigrerer, over til CPU'en
Som det ellers er meget almindeligt at tro, kan man ikke bare skille hardware og software ad, og behandle dem som to separate enheder.
Når man ser på softwaren i forbindelse med hardwaren, er der nemlig
7 niveauer at arbejde med, hvor det laveste trin er selve hardwaren.
Hardwaren, er styret af elektriske kredsløb, og alt hvad der sker på
skærmen er som følge af disse.
Modellen for de syv niveauer i computeren. Den stiblede streg imellem den tredje og den anden nederste boks, indikerer hvor man regner grænsen imellem hardware og software går.
Det næste skridt på trappen, er mikroprogrammering.
Mikroprogrammeringskode er en samling instruktioner i cpu'en som
bliver brugt til fortolkning/oversættelse af maskinkoden til hardwaren.
Det er altså en slags ”manual” for hardwaren så den kan forstå hvad
vi skriver til den, og bliver derfor anset som værende på hardwarens
niveau.
Det næste vi kommer til er maskinsprog, og er den laveste form for
programmering, som brugeren kan få adgang til. Maskinsprog foregår
i binær kode (1'er og 0'er), og er så uhyre stor en opgave at
programmere i, at det kan sammenlignes med at bygge et molekyle op
atom for atom.
de tre niveauer i modellen, som er stillet lidt kryptisk op, for hvor styresystemer bliver skrevet i programmer højere end det selv, så lægger styresystemet stadig de grundlæggende regler for hvordan kode på computeren skal fungere, på niveau med maskinsprog.
De næste to trin ifølge modellen, er operativ niveau, og Assembler
niveau, men modellen er her lidt kryptisk, for de to smelter lidt ind
i hinanden, da flere operativsystemer faktisk er skrevet i assembler.
Den fortæller dog meget godt, at operativsystemet er grundpillen
(platformen) for alt hvad der foregår på computeren.
Assembler er den tætteste måde man symbolsk kommer på at skrive
nogenlunde præcis maskinkode. Assemblersprog er et programmør
sprog, som bliver oversat til maskinkode via en assembler.
Assembler, er et lav-niveau sprog, og er derfor et meget præcist sprog,
og understøtter derfor ikke mange af de mere flydende instrukser man
finder i mange høj-niveausprog.
Assemblerkoden afhænger også, til forskel fra høj-niveausprogene,
af processoren. En assembler streng kan derfor betyde det ene på én
computer, og noget helt andet på en anden computer, hvis en anden
type processor er i.
Næste trin på stigen er ”Høj-niveau sprog”. Blandt disse, er de mest
kendte nok c-trilogien, C, C++ og C#, Java, Pascal osv. Disse sprog,
er et sæt standard instruktioner, som fortæller den tilhørende
kompiler (program til oversættelse) Hvad den skal skrive i
assemblerkode. Instruktionerne skrives i en fil af en bestemt type,
og kompiles så til assembler kode.
Høj-niveausprog kan også fortolkes, hvilket gøres af en fortolker. En fortolker er bare et program, som forholder sig til koden, i forhold til sit instruktionssæt, og så udfører handlingerne (koden) uden at bekymre sig om at kompile den.
Et meget-høj-niveausprog, er de sidste sprog, som kun udføres ved hjælp af en fortolker. Det er altså en række instrukser designet til fortolkeren som så udfører instrukserne ud fra sin fortolkning. To gode eksempler på sådanne sprog er HTML og CSS.
Grunden til de mange forskellige niveauer, ses på denne model, som symboliserer kode på deres respektive niveau.
På ovenstående model, ser vi hvordan en kommando skrevet i et høj-niveausprog, f.eks. har seks egenskaber i sin respektive assemblerkode. Hver af disse assemblerkode-udtryk har så hver tre egenskaber i deres maskinkode. Dette fortsætter hele vejen ned på hardware-niveau, hvor et enkelt udtryk i høj-niveau kode kan gå hen og have 100+ egenskaber på mikroprogrammerings-niveauet. Dette er selvfølgelig fint med små programmer, problemet er bare at når man skriver et udtryk, er udtrykket skabt til at understøtte en bred vifte af forskellige sammenhænge (de eksempelvis fem udtryk), hvoraf man måske kun skal bruge én.
Ved større programmer, som f.eks. styresystemer og meget krævende spil, skal der bruges utroligt meget processorkraft, hvis det hele skal skrives i høj-niveaukode, fordi alle udtrykkene hele vejen ned igennem de forskellige niveauer- skal tages stilling til, også selvom de slet ikke skulle bruges.
Vi ender altså med en hel masse overflødig kode, som ikke gør andet end at optage processorkraft. Problemet løser man ved at skrive koden i assembler, eller derunder. På denne måde får man skrevet meget præcis kode, som kun har med hvad der skal bruges, og dermed øges kodens effektivitet vanvittigt meget.
Det eneste problem ved dette er at vores hjerner ikke er bygget som en computers, og at det hele derfor bliver mere og mere uoverskueligt, jo tættere på maskinkoden vi kommer. Især det faktum at ting der ligger i fortiden, er os sværere tilgængeligt, end ting vi lige har lavet, gør det til en enorm udfordring for os, at skulle finde fejl i vores kode, for overhovedet at tale om senere at skulle udvikle den, opdatere den og bare finde rundt i den generelt.
Så godt nok giver maskinkode, og assembler os vanvittig effektiv kode, men det der sætter grænsen, er altså hvor meget den menneskelige brugers hjerne kan overskue.
til toppen
