Nachrichten

1

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 31. December 2010, 12:04 »

Gruß, Svenska
(Bildschirmtastatur und Touchscreen sind für Forenpostings irgendwie ungeeignet)

PS: Die Diskussion sollte in einen neuen Thread verlagert werden.

Bin ich mit Touchscreen gemeint? Bin mir nicht sicher Weil ich ständig mit einem anderen Gerät hier im Forum Unterwegs und gerade beim iPhone das versucht ab und zu Wörter kaputt zu korrigieren.

Ja, auf die Diskussion mit EFI und BIOS werd ich jedenfalls noch einmal zurück kommen.

Ansonsten bin ich immer noch gerade dabei viel über ByteCode zu lesen mal schauen wann ich die erste Demos hier posten kann, mit Source usw.

2

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 21:10 »

Ach recht goldig das MacBookAir.. nur die Lautsprecher sind nicht so gut, naja bei der Größe nicht verwunderlich, aber ruhe zustand und aufwachen ist dank des Flash speicher richtig schnell... mal schauen wie es mit einem Virtuellen Ubuntu zurecht kommt, sollte klappen mit den 4GB ram. Aufjedenfall brauch ich ein Linux zum OS entwickeln.

Na klasse... Was meint ihr? Sollte ich mich erstmal nur auf BIOS konzentrieren und es immer im Emulator testen und später die EFI Methoden nachliefern?

Geht es überhaupt das ich den Kernel in C schreibe und einfach eine Quellcode Datei für EFI und eine für BIOS erstelle und diese nur austausche, wenn es BIOS bzw. EFI spezifische Methoden sind.


Gruß
Remake

3

OS-Design / BIOS und EFI

« am: 30. December 2010, 19:36 »

xD Jetzt bin ich mir nicht mehr sicher ob ich Heuteabend zum Entwickeln komme... Hab Heute ein neues MacBook Air vom Chef geschenkt bekommen, als danke schön. Und gleich zum Thema passend hab ich eine frage und zwar haben Macs kein BIOS mehr sondern EFI... hat da jemand ahnung von? Ändert sich da einiges wenn ich das OS vom Mac Booten möchte und nicht in einer Virtuellen Maschiene?

Gruß
Remake

4

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 18:16 »

  Das meinte ich doch ^^
Wie auch immer, ich werd noch einmal gründlich nachdenken und eventuell mal einen kleinen Test Kernel dann bereit stellen... Multiboot Kernel den man einfach in QEMU nutzen kann, sollte sich schnell in C realisieren lassen. So ne Art Überraschung für Euch Aber wohl nicht mehr Pünktlich zum neuen Jahr... Obwohl. habe morgen Frei... vielleicht fang ich mal ein kleines projekt an.

So mal am Rande... Find es cool das so viele hier beim Thema mit diskutieren und das mit wirklich guten Informationen, gibt viele Foren wo so etwas anders abläuft.

Gruß

5

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 17:47 »

Hast du schon mal mit Floats im x86-Assembler programmiert? Für floats gibt es eine komplett eigenen Befehlssatz. Und zwischen 'long' und 'char' wird selbstverständlich auch unterschieden. Wo du recht haben könntest ist das ne cpu nicht zwischen 'char' und 'Byte' unterscheidet.

Vielen Dank, aber das wusste ich jetzt wirklich nicht. Oder meinst du einfach nur das die Register 8,16 oder halt 32 Bit lang sind!?!? usw.
Assembler hab ich bis jetzt immer nur kleinere Dinge entwickelt. Hauptsächlich Programmiere ich in C++ seit neusten jetzt fürs Unternehmen auch ObjectiveC damit unsere Anwendungen auch im AppStore vertreten sind. Ansonsten halt Jahrelang .Net (naja solange gibt es das ja noch nicht), PHP, Java usw.
Aber trotz das ich Java und .Net entwickelt habe, hatte ich nie wirklich mir den Bytecode beider Sprachen/Frameworks angeschaut.

Gruß

6

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 17:16 »

@taljeth: Danke

*hust* Wieder mal einiges gelernt... Also werd ich mir mal den JavaBytecode sowie den von .Net mal genauer unter die Lupe nehmen und mit dann noch einmal Gedanken machen.

xD Aber mein Code wäre auch gelaufen, wenn auch nicht so performant ^^ Aber da wird das ja nicht wollen, werd ich mir mal weiter Dokumentationen über Bytecode durchlesen und dann noch einmal das Planen angehen.

Gruß
Remake

7

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 17:10 »

Für solche Operationen muss zur Laufzeit kein Code ausgeführt werden, sondern das Ganze kann zur Compilezeit bzw. beim Laden abgehandelt werden. Bei dir hingegen sind diese Deklarationen gleichrangig mit Operationen im Code verteilt und dein Interpreter muss diese Abschnitte überspringen. Alternativ kann er ein Verzeichnis mit diesen Methodendefinitionen aufstellen. Aber es ist Zeitverschwendung, das beim Laden zu machen, weil der Compiler es bereits hätte machen können. Dann bräuchte der Compiler diese Opcodes auch nicht mehr generieren. Und dann bist du wieder einen Schritt näher an Java/.Net.

Stimmt, könnte man machen. Eine liste aller Methoden während des compilieren sammeln und am Anfang der auszuführenden Datei eine Verzeichnis schreiben, aber auch dann müsste ich die funktionen "deklarieren"... Naja mal schauen.

Klar gibt es da IF-Konstrukte im Assembler, aber es gibt kein ENDIF, und was hat da nichts mit Nativem Maschinencode(für echte CPUs) tun? Dass ist alles recht nah am echten Befehlssatz dran, welche CPU hat denn keine load, store, jump und/oder call, compare, und if befehle?

Ja klar gibt es jump befehle usw. aber keine CPU unterscheidet wirklich zwischen float, long, char usw. und das wird im JavaBytecode getan... Man wirft dort einen Float wert anders auf dem Stack als einen Integer Wert.

Das meine IF Anweisung einen Sprungpunkt zum code bekommt könnte man ja bewerkstelligen, damit bleibt das endif dann auch weg.

8

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 16:59 »

Desto mehr ich über den Java Bytecode lese, desto interessanter wird es.
Also bei .Net sowie bei Java wird auf Register und Speicherzugriff im Bytecode verzichtet, stattdessen wird alles mit Stacks gemacht. Werte an Methoden übermitteln, sowie Rückgabewerte und viel mehr läuft über einen Stack ab.

Das lass ich mal in meine planung einfließen.

Gruß

9

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 16:43 »

Zwischen Assemblercode und Maschinencode liegt eben doch nochmal eine Verarbeitungsstufe. Globale Variablen werden sicher in keinem vernünftigen Maschinencode mitten im Code "deklariert".

Und wie gesagt, kein Maschinencode hat ein if...endif-Konstrukt, das ist nicht effizient umsetzbar. Anstatt einfach einen vom Assembler vorherberechneten Sprung zu machen, musst du jetzt alle Befehle anschauen und ignorieren bis du das endif findest. Das ist einfach die falsche Abstraktionsstufe für Maschinencode.

Ähm ja ^^ Langsam weiß man nicht mehr wer was meint bei den ganzen Begriffen, Maschienencode, Assembler, Bytecode usw. usw.

Ich möchte keinen Maschienencode heraus bekommen, der direkt auf der Hardware läuft... Das sollte später dann ein Interpreter oder der Just In Time(kurz JIT-) Compiler übernehmen. Sonst ist das nicht mehr Plattform unabhängig. Das die befehle ähnlich wie bei Assembler sind.. naja das ist halt so ^^ MS hat mit MSIL ja auch scheinbar bei Assembler abgeschaut.

Hier ein Java Bytecode der durch einen "disassembler" geschickt wurde um leserlich darzustellen:

Code: [Auswählen]

0:   iconst_2
  1:   istore_1
  2:   iload_1
  3:   sipush  1000
  6:   if_icmpge       44
  9:   iconst_2
  10:  istore_2
  11:  iload_2
  12:  iload_1
  13:  if_icmpge       31
  16:  iload_1
  17:  iload_2
  18:  irem
  19:  ifne    25
  22:  goto    38
  25:  iinc    2, 1
  28:  goto    11
  31:  getstatic       #84; //Field java/lang/System.out:Ljava/io/PrintStream;
  34:  iload_1
  35:  invokevirtual   #85; //Method java/io/PrintStream.println:(I)V
  38:  iinc    1, 1
  41:  goto    2
  44:  return

wie man da sehen kann gibt es auch dort if, goto usw. seltsame Dinge die nichts mit Assembler oder Nativen Maschinencode zu tun haben... Aber es ist halt der Bytecode den die JavaEntwickler sich ausgedacht haben und dieser kann später mit einem Interpreter ausgeführt werden oder mit einem JIT-Compiler für die jeweilige Hardware in richtigen Maschinencode umgewandelt werden.


Edit:
Gerade noch was gefunden... hier sieht man schön den leserlichen code sowie er als Hex dargestellt wird:
// Bytecode stream: 03 3b 84 00 01 1a 05 68 3b a7 ff f9
// Disassembly:
iconst_0      // 03
istore_0      // 3b
iinc 0, 1     // 84 00 01
iload_0       // 1a
iconst_2      // 05
imul          // 68
istore_0      // 3b
goto -7       // a7 ff f9

Gruß
Remake

10

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 16:30 »

Und so wie ich remake verstanden habe hat er das auch vor, auch wenn da dann von einer eigenen Sprache zu sprechen irreführend ist.

Nein ^^ Ich möchte den code erstmal nicht in Assembler übersetzen...
Ich stelle es mir so vor...

Code: [Auswählen]


Basic }--------------\                                                                                             /--> {ARM}
C }------------------+--->[kompilieren]---> {"Managed Bytecode"} ---> [Interpretieren] ---+--> {x86}
Eigene Sprache }----/                                                                                             \--> {Sonstige..}



11

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 16:07 »

Das ist nicht der Bytecode, sondern eine Art Assemblersprache, die in Bytecode übersetzt wird.

Ja, das ist der Bytecode in klartext...
Bei mir sieht der Bytecode in einem klartext dann auch so aus

Code: [Auswählen]

mov 01,02
if 01 < 04
usw.
Aber bei MS ist genau dieses MSIL die Sprache welche halt in bytecode komprimiert dargestellt wird.

Wollte damit nur sagen, das der Bytecode von MSIL (.net) viel komplexer ist und einen viel komplexeren Parser und Interpreter oder JIT-Compiler benötigt als die von mir überlegten Befehle.

Ah ja es gab Singularity, total vergessen, hatte ich mir vor einigen Jahren mal Just4fun angesehen, aber das ist halt pure .net Wollte irgendwie was anderes entwickeln, einfacher und offener ^^

12

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 15:23 »

Du solltest dir wirklich mal ein paar echte Architekturen und Java/.Net anschauen. Dein Bytecode ist mehr oder weniger nutzlos - da könntest du auch gleich den Quellcode direkt interpretieren. Der eigentliche Sinn von Bytecode ist ja, dass eine relativ komplexe Hochsprache in eine simple hardwarenahe Form gebracht wird, die effizient und leicht in die Zielsprache (also z.B. x86-Maschinencode) übersetzt werden kann. Diese Vereinfachung hast du nicht, dein Bytecode ist genauso schwer zu parsen wie der ursprüngliche Quelltext.

Also ich hab mir mal den Bytecode (Die zwischensprache von .Net angeschaut) MSIL...

http://www.fh-wedel.de/~si/seminare/ws02/Ausarbeitung/5.msil/MSIL4.htm

Code: [Auswählen]

// Metadata version: v2.0.50215
.assembly extern mscorlib
{
  .publickeytoken = (B7 7A 5C 56 19 34 E0 89 )                         // .z\V.4..
  .ver 2:0:0:0
}
.assembly sample
{
  .custom instance void [mscorlib]System.Runtime.CompilerServices.CompilationRelaxationsAttribute::.ctor(int32) = ( 01 00 08 00 00 00 00 00 )
  .hash algorithm 0x00008004
  .ver 0:0:0:0
}
.module sample.exe
// MVID: {A224F460-A049-4A03-9E71-80A36DBBBCD3}
.imagebase 0x00400000
.file alignment 0x00000200
.stackreserve 0x00100000
.subsystem 0x0003       // WINDOWS_CUI
.corflags 0x00000001    //  ILONLY
// Image base: 0x02F20000


// =============== CLASS MEMBERS DECLARATION ===================

.class public auto ansi beforefieldinit Hello
       extends [mscorlib]System.Object
{
  .method public hidebysig static void  Main(string[] args) cil managed
  {
    .entrypoint
    // Code size       13 (0xd)
    .maxstack  8
    IL_0000:  nop
    IL_0001:  ldstr      "Hello World!"
    IL_0006:  call       void [mscorlib]System.Console::WriteLine(string)
    IL_000b:  nop
    IL_000c:  ret
  } // end of method Hello::Main

  .method public hidebysig specialname rtspecialname
          instance void  .ctor() cil managed
  {
    // Code size       7 (0x7)
    .maxstack  8
    IL_0000:  ldarg.0
    IL_0001:  call       instance void [mscorlib]System.Object::.ctor()
    IL_0006:  ret
  } // end of method Hello::.ctor

} // end of class Hello

Ich weiß ja nicht wo die einfacher sein sollte!?!?
Also da ist meine Sprache schneller zu richtigen x86 befehlen übersetzt.

13

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 14:40 »

Der Bytecode ist in der Informatik eine Sammlung von Befehlen für eine virtuelle Maschine. Bei Kompilierung eines Quelltextes mancher Programmiersprachen oder Umgebungen – wie beispielsweise Java – wird nicht direkt Maschinencode, sondern ein Zwischencode, der Bytecode, erstellt. Dieser Code ist in der Regel unabhängig von realer Hardware und im Vergleich zum Quelltext oft relativ kompakt.

Ansonsten wäre es nett mir zu erklären wo du den Unterschied siehst!?

Die Hochsprachen die später zu diesen Bytecode kompilieren sollen sehen ganz anders aus, bzw. gibt es nicht für alles einen Opcode, so dass bestimmte Befehle und auch spätere Objekt Orientiertung irgendwie anders und komplexer im Bytecode dargestellt werden.

Gruß
Remake

14

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 13:24 »

Also if/endif usw. finde ich ganz nützliche Befehle, und da alles eh von einer VM interpretiert wird gibt es weniger gründe es weg zulassen als gründe es einzubauen.
Kann mir vorstellen das wenn die Bytecode sprache diese Befehle schon unterstützt es einfacher ist dafür eine Hochsprache zu entwickeln.

Hab mir nochmal Gedanken bezüglich Methoden und Variablen gemacht...
Das ist der erste Entwurf..

Code: [Auswählen]

;managed bytecode
0x24 Variable deklarieren
0x25 Methode deklarieren
0x26 End Methode

;Datentypen
0x01 byte
0x02 int
0x03 float
0x04 string
usw. usw...


;Eine Variable vom Type Byte mit der ID 1 deklarieren
0x24(opcode) 0x01(Datentype) 0x01(id)

;Eine  Variable vom Type Byte mit der ID 257 deklarieren
0x24(opcode) 0x01(Datentype) 0xFF(id) 0x01(id)

;Eine Methode mit der ID 1 deklarieren, welche ein Byte als Rückgabewert liefert
;Parameter könnte man über einen Stack der Methode mit geben
0x25(opcode) 0x01(Datentype 0x01(id) ... 0x26(opcode)


15

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 11:46 »

Nichts für ungut, aber dieser "Sprache" fehlt alles interessante. In vierzig Registern kriegst du unmöglich die gesamten Daten unter. Zumindest sowas wie Arbeitsspeicher wäre als Konzept noch ganz nett.

Ach quatsch xD Sowas nimm ich doch nicht böse auf Du hast ja auch Recht mit deinen Aussagen, wie in meinem letzten Post schon gesagt sollte ich die Idee mit den Virtuellen Registern verwerfen und stattdessen variablen mit Typen integrieren die von der VM verwaltet werden.

Ja, wegen funktionen muss ich mir noch genau Gedanken machen, da habe ich etwas im Kopf aber das ist noch total unausgereift. Aber mit dem funktionen Mechanismus soll man dann auch mit dem Kernel/Hardware kommunizieren.

Ja, ein Opcode für if/endif usw. ist merkwürdig hat in meiner Überlegung seinen Sinn und wüsste auch schon wie man dies gut umsetzen könnte.

16

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 10:35 »

Morgen nochmal,
eventuell sollte ich die virtuellen Register rauswerfen und lieber eine Möglichkeit einbauen um Variablen mit Typen zu deklarieren. Somit könnte wie VM ordentlich den Arbeitsspeicher Managen... und es gäbe keine 32 bzw. 64 bit probleme bzw. keine unterschiede bei der Programmierung (außerhalb des Kernels).

Mit dem Befehlssatz von Post vorher sollte sich schon ein einfaches Basic realisieren lassen das zu diesen Managed Bytecode kompilieren kann... Was klar fehlt sind String, Text sowie Grafikausgabe. Da bei diesen Managedcode kein direkter zugriff auf dem Speicherstatt finden soll, muss ich mir noch eine Art und Weise ausdenken wie man methoden implementieren könnte.

So das die Kernel funktionen usw. per methode irgendwie aufgerufen werden kann.

Gruß
Remake

17

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 30. December 2010, 09:25 »

Guten Morgen,
hab gerade mal einwenig im Zug an der Idee gearbeitet. Was dabei heraus kam ist folgendes. Die Programmiersprache soll Anlehnungen an Assembler, Basic und BrainFuck haben. Der Interpreter soll ähnlich wie ein Brainfuck interpreter in C programmiert sein oder wie eine einfache Virtuelle Maschine (einfach mal in den Bochs Quelltext hineinschauen).

Es soll eine Art managed Assembler entstehen das in einer VM läuft und Basic ähnliche befehle bietet.

Hab mir überlegt verschiedene Virtuelle Register mit unterschiedlichen größen bereit zustellen, aber eventuell sollte ich diese Idee verwerfen... das sollte vll. doch die VM alles lösen.

Hier meine groben Überlegungen zu der Bytecodesprache:

Code: [Auswählen]

;register
0x00 to 0x09 10x 8  bit register
0x10 to 0x19 10x 16 bit register
0x20 to 0x29 10x 32 bit register
0x30 to 0x39 10x 64 bit register


;relational operator
0x00 >
0x01 <
0x02 >=
0x03 <=
0x04 ==
0x05 !=



;managed bytecode
0x00 close programm
0x01 to 0x10 reserved
0x11 add (register, value)
0x12 sub (register, value)
0x13 mul (register, value)
0x14 div (register, value)
0x15 inc (register)
0x16 dec (register)
0x17 mov (register, egister)
0x18 for (operator, register"value left", register"value right", register"step")
0x19 endfor
0x20 if (operator, register"value left", register"value right")
0x21 elseif (operator, register"value left", register"value right")
0x22 else
0x23 endif

Beispiele:

IF reg0 >= reg1 THEN ... ENDIF
{0x20, 0x02, 0x00, 0x01, ..., 0x23}

FOR reg0 < reg1 STEP reg2 ... ENDFOR
{0x18, 0x01, 0x00,0x01,0x02, ..., 0x19}



Gruß
Remake

18

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 29. December 2010, 23:04 »

Ja C# ist mir schon wieder ein tick zu weit von der Hardware entfernt. Naja ich werd mir die Tage mal einen kleinen Befehlssatz usw. einfallen lassen und davon hier berichten. Eine Compiler werde ich wohl in c++ zusammen mit qt schreiben, damit es leichter zu Portieren ist ^^ wird wohl eine Asm ähnliche Sprache, aber auch Basic Sprachen sollte man leicht zu diesem bytecode compilieren lassen. Muss mir das ganze mal morgen nach Feierabend anschauen und schauen was ich da zu Stande bekomme.

gruß
Remake

19

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 29. December 2010, 22:16 »

Ja genau, so weit wie möglich sollte auf C verzichtet werden.
Naja, dass ganze war jetzt erstmal nur eine grobe Idee, ich muss das ganze noch mal ein paar Tage im Kopf auswachsen lassen und schauen was das Ergebnis meiner Überlegung dann sein wird.

Vielleicht habt ihr noch Ideen oder Anregungen?
Oder habt Tipps für die Umsetzung?

Gruß
Remake

20

OS-Design / Re:Idee OS mit eigener Managed Sprache

« am: 29. December 2010, 21:20 »

So viele Gedanken wegen der Datenstruktur habe ich mir noch nicht gemacht.
Das sind alles erstmal nur grobe Gedanken...

Das später ein JIT Pflicht ist, ist klar.. aber für die ersten Tests sollte ein Interpreter ausreichen Und dann wird optimiert, ähnlich wie Google es macht, dort wird auch nachträglich V8 immer weiter optimiert.

Ja klar Bochs ist lahm, aber das auch ein kompletter Computer Emulator...
Aber Interpretersprachen wie PHP sind Performance mäßig auch akzeptabel


Gruß
Remake