#lost · 2017-02-17

1,087 Nachrichten · Seite 6 von 6 · Original-CSV herunterladen

  1. Godwinealso ich habe einen treiber und der erstellt einen thread der bei handler() anfangen soll
  2. Svenskanaja, du baust eine kette aus threads, die nacheinander ausgefuehrt werden
  3. Svenskaund wo jeweils ein thread auf den nächsten verweist
  4. Svenskaund in diese kette musst du jetzt einen beliebigen, wichtigen thread reinfummeln
  5. Godwineöhm
  6. Svenskadu könntest einen thread *unterbrechen* ;)
  7. 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);}
  8. Godwinewobei jeder dieser tasks wieder das gleiche mit seinen threads oder denen seiner eigenen kindprozesse tun könnte
  9. Svenskadas sind timeouts, richtig?
  10. Svenskadh du unterbrichst einen thread nach X zeiteinheiten
  11. Godwinejoa also jeder thread bekommt eine 100ms zeitscheibe
  12. Svenskaaber wer *startet* den handler?
  13. Godwinealso der treiber erstellt jetzt einen thread z.B mit sys_new_thread(handler_function(), blabla thread status);
  14. Godwinebekommt die tid seines neuen threads
  15. Godwineund gibt die seinem parentthread der ihn scheduled
  16. Svenskaund die wird dann regelmäßig vom parent aufgerufen und guckt, ob sie was zu tun hat?
  17. Svenska...aka du willst interrupts *pollen* ?? ;)
  18. Godwinenein xD
  19. Godwinedieser thread ist ja inaktiv bis der irq kommt
  20. Godwineder wird nicht scheduled
  21. Godwineder init task macht das gleiche btw für den ist der "parent" praktisch der kernel selbst
  22. Godwinewenn jetzt irq1 kommt dann unterbricht der kernel und führt den irq1 thread vom init task aus
  23. Svenskaund geht dann wieder zurueck in den unterbrochenen thread?
  24. Godwineder kann dann den handlerthread im treiber entweder in die schedulingliste aufnehmen oder gleich selbst aufrufen
  25. 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
  26. Godwinedas ganze ist komplizierter als nötig das sehe ich ein xD
  27. Svenskaok^^
  28. Svenskaund alles geht in die irq-latenz
  29. 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
  30. Svenskawelcher scheduler? :D
  31. Godwineheißt dann ist es wieder irq->kernel_handler->treiber_handler->kernel->...
  32. Godwinealso der init task sagt ja seinem parent also dem kernel dass bei einem irq1 der thread x von prozess y ausgeführt wird
  33. Godwinealso auch direkt den treiber
  34. Godwinewürde dir der sourcecode helfen? xD
  35. Svenskanee xD
  36. 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
  37. Svenskaklingt nach systemd's cgroups
  38. Svenskawo die gesamte ressourcenverteilung hierarchisch aufgeteilt wird
  39. Svenskaallerdings in deinem inklusive der interrupts
  40. 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
  41. Godwinewas das ganze am ende bringen soll weiß ich selbst noch nicht so ganz xD
  42. Svenskasyscalls verändern?
  43. Godwinenaja ein userspace host könnte z.B einen handler für int 0x80 bereitstellen und ein paar linux syscalls abbilden ^^
  44. Svenskanaja, und wie kommst du an deinen eigenen kernel ran, wenn du jeden syscall ueberschreiben kannst? :D
  45. Godwinenaja welcher task den handler bereitstellt ist ja kontextabhängig
  46. Godwinewenn ein kindprozess diesen int 0x80 ausführt ist das ein impliziter yield zum syscall handler des parent tasks
  47. Godwineaber ich hab mir darüber noch nicht allzu viele gedanken gemacht
  48. Svenskadu musst eine möglichkeit haben, zu deinem eigenen kernel zurueckzukommen
  49. Svenskaein master-syscall reicht, aber den musst du dann auch umdefinieren können...
  50. Godwinenaja der task kann seinem kindprozess eben verbieten die kernelsyscalls aufzurufen und stattdessen ein eigenes interface definieren über virtuelle speichermagie
  51. Godwinewow mir fällt gerade auf wie sehr das nach einem exokernel klingt eigentlich
  52. Svenskaoder so
  53. Svenskaentweder das, oder wie ein software-hypervisor
  54. Godwineja das kommt der idee glaub ich ganz nahe
  55. Godwineprinzipiell ist das ja virtualisierung
  56. Svenskajup
  57. Svenskadu musst nur die kernelsyscalls implementieren und bekommst einen vollwertigen userspace
  58. Svenska...also genau das, was windows mit ubuntu macht.
  59. Godwinenur in kaputt :D
  60. Godwineich denke das schwerste wird sein bei mehrstufigen schedulern rauszufinden wer noch wie lange laufen darf und and welcher stufe wann unterbrochen werden muss
  61. Svenskadazu brauchst du einen toplevel-scheduler
  62. Svenskaden kannst du ja vom timer aus triggern
  63. 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
  64. Svenskaja, aber dein toplevel-scheduler ist billig
  65. Svenskaweil jede drunterliegende einheit sich ja selbst wieder scheduled
  66. Godwineentweder das oder eben die rechte einen thread zu schedulen seinem eigenen parent(scheduler) gibt
  67. Svenska...was aufs gleiche rausläuft
  68. Svenskadu musst nur aufpassen, dass du passend sortierst
  69. 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
  70. Svenskanaja, wenn du 2 tasks hast und jeweils 50% cpu-zeit verteilst
  71. Svenskaund der eine jetzt 4 threads erzeugt und von oben schedulen lässt
  72. Svenskadann musst du aufpassen, dass du nicht 6 einheiten mit je 16,6% cpu-zeit schedulst
  73. Godwinedas wäre doch das gleiche bei round robin im kernel
  74. Svenskadu musst ja nicht round robin machen
  75. Svenskabzw, solltest es nicht
  76. Godwineja is ja wurscht was implementiert wird letztendlich
  77. Svenskaerstens hast du interrupthandler, die sollten priorität kriegen (d.h. vor allem sollten treiber direkt unterhalb von init laufen)
  78. Svenskazweitens kannst du so ein ressourcenmanagement auf allen ebenen laufen lassen, weil init ja im endeffekt alle syscalls abkriegt
  79. Svenskadu kannst also ram, netzwerktraffic, blockdevices, whatever verteilen
  80. Svenskadas läuft dann auf so eine virtualisierung raus, die großrechner haben
  81. 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
  82. Godwinedenkbar sind bis jetzt userevents, pipes, message queues und synchrones message passing über den schedule oder yield syscall ähnlich wie bei l4
  83. Godwinenaja wie gesagt das ganze wird wahrscheinlich nicht schnell aber hoffentlich flexibel
  84. Svenska:)
  85. mgottschlagbrauchst du Pipes? Reicht nicht shmem + messages? :)
  86. mgottschlagMinimalitätsprinzip ftw
  87. Godwinealso z.B eine page die beim empfänger nur als readonly gemappt ist damit er lesen kann aber der sender kann schreiben?