4. GPU ansprechen

GPU ansprechen

  • D

    Guten Tag, nachdem ich meine ersten "Test" OS geschreiben habe um Themen wie Paging bzw. Tasks besser zu verstehen habe ich angefangen ein wenig mit Grafik rumzuspielen. Ich benutze dazu VBE (VESA BIOS Extensions) zum zeichnen auf den Bildschrim, dies ist leider besonders beim zeichnen von vielen Objekten(Rechtecke,Dreiecke) relative langsam. Also habe ich mich nach einer guten Lösung dafür umgeschaut, die beste die ich gefunden habe wäre den GPU mal arbeiten zu lassen. Im Internet finde ich nicht mal eine Möglichkeit die GPU anzusprechen. Gibt es dort einen Port zum ansprechen der GPU oder wie kann ich die GPU ansprechen/arbeiten. Falls jemand andere Einfälle zum optimieren des Zeichnens von Dreiecken hat wäre dies auch erwünscht.

    0
  • K

    Fuer dein Spielzeug-OS? Nein, nur wenn du die Interna von nVidia bzw. ATI zur Grafikkarte bekommst.

    0

  • Du kannst dir ja z.B. mal hier und hier umschauen...

    0
  • D

    Vielen Dank für die schnellen Antworten, ich werde mich mit dem Thema mal genauer befassen. Danke dir dot deine Links sind sehr hilfreich 😉

    Fuer dein Spielzeug-OS? Nein, nur wenn du die Interna von nVidia bzw. ATI zur Grafikkarte bekommst.

    Ich denke das kaum ein OS Programmierer glaubt auch nur annähernd eine Chance gegen Windows etc. zu haben, fast jeder hat einfach Spaß alles von Grund auf selbst zu schreiben. Aber jetzt habe ich ein eigenes "OS" dank Dr. Erhard Henkes, welcher ein wirklich sehr gutes Tutorial veröffentlicht hat. Nun will ich auch mal die Hardware ansprechen an die ich auf Windows nicht selbst drankomme.

    0
  • D

    Nachdem ich etwas nachgeforscht habe, wollte ich mal fragen ob man nicht die Grafikkarte über PCI oder PCI Express "anpingen" kann, soweit ich weiß sind diesen PCI Slots I/O Ports zugeteilt über wlche man sie ansprechen könnte, oder täusche ich mich da?

    0
  • E
    Mod 

    jetzt habe ich ein eigenes "OS" dank Dr. Erhard Henkes, welcher ein wirklich sehr gutes Tutorial veröffentlicht hat.

    Danke für das positive Feedback! Freut mich, wenn es auch anderen hilft. Wir haben in PrettyOS inzwischen Grafik implementiert, können sogar bitmaps (bmp-Format) darstellen. Das ist ein komplexes Thema, für das man z.B. vm86 und VESA kennen sollte, alles im Code von PrettyOS gut einsehbar.

    0
  • D

    Danke ich werde mir den Code von PrettyOS mal näher zu Gemüte führen vielleicht wird meine Frage dort ja beantwortet.

    0
  • B

    Hier hast du ein Code Beispiel von mir welches den CPU Hersteller Namen und das Prozessor Stepping ausgibt. Aber erwarte hier jetzt nicht top Assembler Code zu sehen da kann man bestimmt einiges dran verbessern. ^^ 😃

    Ansonsten schau mal nach den Intel bzw. AMD developer manuals da wirst du auch einiges interessantes drin finden. ( Auch die Code Kommentare sind vielleicht nicht ganz korrekt )

    Aber ich denke damit kannst du trotzdem ein bisschen was anfangen.

    Verwendeter Assembler: MASM

    .686p                                   
.model flat, stdcall                     
option casemap :none 

include \masm32\include\windows.inc  
include \masm32\include\kernel32.inc
includelib \masm32\lib\kernel32.lib

.data 

ProcessorManufacturer db "Processor name: ",0
ProcessorStepping db "Processor Stepping: ",0

SteppingBuf db 0,0
ProcessorManufacturerBuf db 12 dup(0),0

endl db 10,13

.code 
start:

			mov ebx,offset ProcessorManufacturer
			mov ecx,16							; Der String "Processor name: " ist 16 Zeichen lang (Dezimal)
			call PrintText						;  Gibt aus: Processor name: 

			call PrintManufacturerName 			; Rufe PrintManufacturer auf ( Hinweis: ein call verringert den Stackpointer um 4 )

			mov ebx,offset endl
			mov ecx,2
			call PrintText						; Macht einen Zeilenumbruch

			mov ebx,offset ProcessorStepping
			mov ecx,20							; Der String "Processor Stepping: " ist 20 Zeichen lang (Dezimal)
			call PrintText						; Gibt aus: Prozessor Stepping:

			call PrintProcessorStepping

			push 1000
			call Sleep

			push 0
			call ExitProcess

PrintText proc near

			push STD_OUTPUT_HANDLE        ; Schiebe STD_OUTPUT_HANDLE auf den Stack      
			call GetStdHandle             ; Rufe GetStdHandle auf

			push 0                        ; Reserviert laut MSDN, muss immer Null sein
			push 0                        ; Sagt aus wie viele Zeichen geschrieben wurde, ist hier unwichtig deswegen push 0
			push ecx                      ; Anzahl der zu schreibenden Zeichen
			push ebx                      ; Adresse der Lokal angelegten Variable
			push eax                      ; Handle
			call WriteConsoleA            ; Rufe WriteConsoleA auf

			ret	
PrintText endp

GetRegisterLength proc near   ; Anzahl der Zeichen in AX ermitteln, das Ergebniss steht im ecx Register
			mov ebx,10
			xor ecx,ecx
		j:
			xor edx,edx
			div ebx          
			inc ecx
			cmp eax,0
			jne j
			ret 
GetRegisterLength endp

PrintManufacturerName proc near		   	    ; Anfang der Funktion (Prozedur) PrintManufacturer

			xor eax,eax                     ; eax auf 0 setzen um die CPUID Funktion aufrufen zu können welchen den Hersteller Namen der CPU in
										    ; die Register ebx,edx und ecx lädt	
			cpuid 
			mov esi, offset ProcessorManufacturerBuf   ; Adresse von ProcessorManufacturerBuf nach esi

			mov [esi   ] ,ebx 			    ; ebx enthält die ersten   4 Buchstaben des CPU Herstellers. bsp. Genu
			mov [esi+4h],edx			    ; edx enthält die nächsten 4 Buchstaben des CPU Herstellers. bsp. ineI	
			mov [esi+8h],ecx			    ; ecx enthält die letzten  4 Buchstaben des CPU Herstellers. bsp. ntel	

			lea ebx, [esi]           	    ; ebx enthält die Adresse der Variable auf die esi zeigt also in diesem Fall auf: ProcessorManufacturerBuf	
			mov ecx,0ch                     ; Anzahl der Zeichen welche PrintText ausgeben soll
			call PrintText

			ret                             ; Funktion verlassen, es wird an die Adresse zurück gesprungen auf die der esp (extended stack pointer) zeigt.
PrintManufacturerName endp        		    ; Ende der Funktion (Prozedur) PrintManufacturer

PrintProcessorStepping proc near 

			mov eax,1h                      ; Wir wollen auf Funktion 1h des CPUID Befehls zugreifen
			cpuid                           ; CPUID Befehl aufrufen 
			and  eax,1111b                  ; Belegt die entsprechenden Bits um über CPUID das Prozessor Stepping ausgeben zu können                   

			push eax	                    ; eax auf dem Stack sichern
			call GetRegisterLength          ; Wie viel Zeichen lang ist das Stepping? 
			mov edi, offset SteppingBuf 

			pop eax                         ; eax vom Stack wiederherstellen  
			mov esi,offset SteppingBuf      ; Adresse von SteppingBuf nach esi  
			cmp ecx,1                       ; ecx = 1 ?

			jng continue     			    ; Wenn das Prozessor Stepping höher als 9 ist dann bedeutet das dass im eax Register eine Zahl steht die länger als 1 
											; Zeichen ist wenn dies zutrift so wird das esi Register um die Anzahl der Zeichen aus dem eax Register erhöht
			add esi,ecx		 				; esi um ecx erhöhen	

		continue:							; Ein Label
			mov ebx,10	     				; ebx = 10    		
		i:
			xor edx,edx      				; edx = 0
			div ebx         			    ; Dividiere eax / ebx der Rest der Division steht in dl
			add dl,30h       			    ; dl + 30h ( Wir wollen eine ASCII Zahl erhalten) 
			mov [esi],dl			        ; Schreibe den Wert aus dl in die Variable auf welche esi zeigt also in diesem Fall in die Variable SteppingBuf
			dec esi                         ; esi - 1  
			cmp eax,0                       ; Ist eax = 0 ?
			jne i                           ; Wenn nein springe nach label i  

			mov ebx, offset SteppingBuf     ; Adresse der Variable SteppingBuf nach ebx
			call PrintText                  ; PrintText Funktion aufrufen

			ret

PrintProcessorStepping endp	

end start
    0
  • D

    Vielen Dank, die Syntax ist ja sehr einfach auf nasm zu übertragen. Mit deinem Code könnte ich ja meinen info DOS Befehl erweitern.
    MfG Dezimiert

    0
Anmelden zum Antworten