#lost · 2017-02-17
1,087 Nachrichten · Seite 6 von 6 · Original-CSV herunterladen
- Godwinealso ich habe einen treiber und der erstellt einen thread der bei handler() anfangen soll
- Svenskanaja, du baust eine kette aus threads, die nacheinander ausgefuehrt werden
- Svenskaund wo jeweils ein thread auf den nächsten verweist
- Svenskaund in diese kette musst du jetzt einen beliebigen, wichtigen thread reinfummeln
- Godwineöhm
- Svenskadu könntest einen thread *unterbrechen* ;)
- Godwinene also der init task macht praktisch sowas wie while(1){ sys_schedule(pid1, pid1_main_thread_id, 100ms); sys_schedule(pid2, pid2_main_thread_id, 100ms);}
- Godwinewobei jeder dieser tasks wieder das gleiche mit seinen threads oder denen seiner eigenen kindprozesse tun könnte
- Svenskadas sind timeouts, richtig?
- Svenskadh du unterbrichst einen thread nach X zeiteinheiten
- Godwinejoa also jeder thread bekommt eine 100ms zeitscheibe
- Svenskaaber wer *startet* den handler?
- Godwinealso der treiber erstellt jetzt einen thread z.B mit sys_new_thread(handler_function(), blabla thread status);
- Godwinebekommt die tid seines neuen threads
- Godwineund gibt die seinem parentthread der ihn scheduled
- Svenskaund die wird dann regelmäßig vom parent aufgerufen und guckt, ob sie was zu tun hat?
- Svenska...aka du willst interrupts *pollen* ?? ;)
- Godwinenein xD
- Godwinedieser thread ist ja inaktiv bis der irq kommt
- Godwineder wird nicht scheduled
- Godwineder init task macht das gleiche btw für den ist der "parent" praktisch der kernel selbst
- Godwinewenn jetzt irq1 kommt dann unterbricht der kernel und führt den irq1 thread vom init task aus
- Svenskaund geht dann wieder zurueck in den unterbrochenen thread?
- Godwineder kann dann den handlerthread im treiber entweder in die schedulingliste aufnehmen oder gleich selbst aufrufen
- Godwineund wenn der irq handler im init task yielded geht der kernel wieder zu dem thread zurück der vor dem irq ausgeführt wurde
- Godwinedas ganze ist komplizierter als nötig das sehe ich ein xD
- Svenskaok^^
- Svenskaund alles geht in die irq-latenz
- Godwineprinzipiell schon aber daher war meine überlegung der scheduler kann ja schon im vorraus definieren welcher thread die kontrolle bekommt bei dem irq -> der kann direkt den treiber angeben der den irq bearbeiten soll
- Svenskawelcher scheduler? :D
- Godwineheißt dann ist es wieder irq->kernel_handler->treiber_handler->kernel->...
- Godwinealso der init task sagt ja seinem parent also dem kernel dass bei einem irq1 der thread x von prozess y ausgeführt wird
- Godwinealso auch direkt den treiber
- Godwinewürde dir der sourcecode helfen? xD
- Svenskanee xD
- Godwineim grunde soll das ganze letztendlich dazu führen dass es für einen task nicht weiter relevant ist wo in der hirachie er sich befindet
- Svenskaklingt nach systemd's cgroups
- Svenskawo die gesamte ressourcenverteilung hierarchisch aufgeteilt wird
- Svenskaallerdings in deinem inklusive der interrupts
- Godwineoh ich hab noch große pläne ich will tasks die möglichkeit geben neue syscalls für ihre kindprozesse zu definieren und das virtuelle speicherlayout bis auf ein paar kb ganz oben zu verändern damit die eigene abis abbilden können
- Godwinewas das ganze am ende bringen soll weiß ich selbst noch nicht so ganz xD
- Svenskasyscalls verändern?
- Godwinenaja ein userspace host könnte z.B einen handler für int 0x80 bereitstellen und ein paar linux syscalls abbilden ^^
- Svenskanaja, und wie kommst du an deinen eigenen kernel ran, wenn du jeden syscall ueberschreiben kannst? :D
- Godwinenaja welcher task den handler bereitstellt ist ja kontextabhängig
- Godwinewenn ein kindprozess diesen int 0x80 ausführt ist das ein impliziter yield zum syscall handler des parent tasks
- Godwineaber ich hab mir darüber noch nicht allzu viele gedanken gemacht
- Svenskadu musst eine möglichkeit haben, zu deinem eigenen kernel zurueckzukommen
- Svenskaein master-syscall reicht, aber den musst du dann auch umdefinieren können...
- Godwinenaja der task kann seinem kindprozess eben verbieten die kernelsyscalls aufzurufen und stattdessen ein eigenes interface definieren über virtuelle speichermagie
- Godwinewow mir fällt gerade auf wie sehr das nach einem exokernel klingt eigentlich
- Svenskaoder so
- Svenskaentweder das, oder wie ein software-hypervisor
- Godwineja das kommt der idee glaub ich ganz nahe
- Godwineprinzipiell ist das ja virtualisierung
- Svenskajup
- Svenskadu musst nur die kernelsyscalls implementieren und bekommst einen vollwertigen userspace
- Svenska...also genau das, was windows mit ubuntu macht.
- Godwinenur in kaputt :D
- Godwineich denke das schwerste wird sein bei mehrstufigen schedulern rauszufinden wer noch wie lange laufen darf und and welcher stufe wann unterbrochen werden muss
- Svenskadazu brauchst du einen toplevel-scheduler
- Svenskaden kannst du ja vom timer aus triggern
- Godwineeigentlich muss ich eher ständig die kette durchlaufen init->task1(noch 100ms)->task2(timed out)->task3(noch 50ms) muss also task3 unterbrechen aber wieder task3 ausführen wenn task2 zeit bekommt
- Svenskaja, aber dein toplevel-scheduler ist billig
- Svenskaweil jede drunterliegende einheit sich ja selbst wieder scheduled
- Godwineentweder das oder eben die rechte einen thread zu schedulen seinem eigenen parent(scheduler) gibt
- Svenska...was aufs gleiche rausläuft
- Svenskadu musst nur aufpassen, dass du passend sortierst
- Godwineim grunde könnte ein kindprozess von init 20 threads haben ohne einenen einzigen davon selbst zu verwalten weil diese threads alle im scheduler vom init task sind
- Svenskanaja, wenn du 2 tasks hast und jeweils 50% cpu-zeit verteilst
- Svenskaund der eine jetzt 4 threads erzeugt und von oben schedulen lässt
- Svenskadann musst du aufpassen, dass du nicht 6 einheiten mit je 16,6% cpu-zeit schedulst
- Godwinedas wäre doch das gleiche bei round robin im kernel
- Svenskadu musst ja nicht round robin machen
- Svenskabzw, solltest es nicht
- Godwineja is ja wurscht was implementiert wird letztendlich
- Svenskaerstens hast du interrupthandler, die sollten priorität kriegen (d.h. vor allem sollten treiber direkt unterhalb von init laufen)
- Svenskazweitens kannst du so ein ressourcenmanagement auf allen ebenen laufen lassen, weil init ja im endeffekt alle syscalls abkriegt
- Svenskadu kannst also ram, netzwerktraffic, blockdevices, whatever verteilen
- Svenskadas läuft dann auf so eine virtualisierung raus, die großrechner haben
- Godwineich werd halt jedem task die möglichkeit geben die ipc mechanismen des kernels zu nutzen ausser der parenttask verbietet das explizit und definiert eigene
- Godwinedenkbar sind bis jetzt userevents, pipes, message queues und synchrones message passing über den schedule oder yield syscall ähnlich wie bei l4
- Godwinenaja wie gesagt das ganze wird wahrscheinlich nicht schnell aber hoffentlich flexibel
- Svenska:)
- mgottschlagbrauchst du Pipes? Reicht nicht shmem + messages? :)
- mgottschlagMinimalitätsprinzip ftw
- Godwinealso z.B eine page die beim empfänger nur als readonly gemappt ist damit er lesen kann aber der sender kann schreiben?