#lost · 2016-11-30

381 Nachrichten · Seite 2 von 2 · Original-CSV herunterladen

  1. kevinMasterQ32: Die klassische Ada-Erfahrung halt. Und bei "streng typisiert" denke ich immer an Ada.
  2. JonathanAuweia ;)
  3. MasterQ32ich bin am überlegen, ob ich überhaupt klassen haben will :D
  4. JonathanOweh
  5. MasterQ32hm?
  6. JonathanFunktional? *g*
  7. Jonathan*grusel*
  8. MasterQ32^^
  9. kevinDu könntest es prototypenbasiert machen wie JS *g*
  10. MasterQ32naja, ich packs mal
  11. MasterQ32hab gleich ne übungsgruppe
  12. JonathanBis dann ;)
  13. kevinDann mal viel Spaß
  14. Jonathankevin: JS? Noch schlimmer :P
  15. MasterQ32ich dachte eigentlich an sowas wie generics und implizite "klassenfunktionen"
  16. kevinJonathan: Streng typisiertes JS, wohlgemerkt!
  17. MasterQ32also sowas wie
  18. MasterQ32fn method(this : record, i : int) -> int;
  19. MasterQ32var x : record;
  20. MasterQ32x.method(10);
  21. Jonathankevin: Also Java mit beschissener Syntax? *g*
  22. XanClicHat Rust eigentlich inzwischen Vererbung?
  23. MasterQ32so, bis später
  24. kevinAb wann ist Vererbung Vererbung?
  25. XanClicComposition vs. Inheritance sagt Google
  26. XanClicDas geb ich mal so weiter
  27. kevinWürdest du sagen, QAPI hat Vererbung?
  28. XanClicAuf hoher Ebene ja, auf Sprachebene nein
  29. XanClicOder wobei, QAPI als Sprache hat Vererbung
  30. XanClicAber C halt nicht
  31. XanClicUnd bei Rust kann man natürlich andere Klassen mittels Attributen einbinden, aber offenbar gibt es keinen eingebauten Syntactic Sugar für Vererbung
  32. XanClicOder ich schließe das mal aus “isn't really supported”
  33. moritz31_@kevin hattest recht :'D wieder kaputt
  34. kevinAch? ;-)
  35. moritz31_irgendwas mach ich noch falsch :'D aber das bekomm ich schon noch raus
  36. kevinAlso schon die fünf Zeilen vorhin haben falsch ausgesehen, falls es die noch gibt
  37. moritz31_ne die gibt es schon lange nicht mehr ist nur noch page_table[PT_index] = (uint32_t) phys | flags
  38. moritz31_fffff004 ist doch die addresse der nächsten PT oder ?
  39. kevinDie Adresse der zweiten PT mit ein paar Flags dazugeodert
  40. kevinAlso, die _physische_ Adresse der zweiten PT mit Flags
  41. moritz31die virtuelle Addrese oder ?
  42. moritz31die physische ist bei mir 0x401000 + die Flags
  43. moritz31die virtuellen Adressen sind doch fffff000 fffff004 fffff008 usw oder ?
  44. kevinfffff004 ist die virtuelle Adresse des PDE und enthält die physische Adresse einer PT (plus Flags)
  45. moritz31an fffff000 liegt doch quasi pd[0] und fffff004 ist pd[1] oder ?
  46. moritz31ups denkfehler
  47. moritz31:'D
  48. moritz314kb und so
  49. moritz31jetzt wird wieder nicht 0x0 gemappt :'D hab das gefühl ich sollte nochmal alles von vorne anfangen
  50. moritz31TAAAAADDAAAAAA 3 PT allokiert :'D mein problem lag nicht beim erstellen einer PT selbst sondern mehr beim holen :'D da hab ich immer die physische mir geholt :D'
  51. kevinScheint langsam vorwärts zu gehen :-)
  52. moritz31warum wird die allokation immer langsamer? bin gerade am viele pagetables allokieren hab jetzt schon 0x50 :'D
  53. moritz31aber des fängt schnell an und wird dann immer langsamer
  54. moritz31so 0x61 * 4MB allokiert :'D
  55. moritz31so ich bin happy für heute :'D
  56. kevinWenn es spürbar langsamer wird, würde ich mir Gedanken machen... Morgen. ;-)
  57. moritz31ja es wird mega langsam ......
  58. moritz31von am Anfang 10*4MB die Sekunden auf dann 1*4MB alle 10 Sekunden
  59. MasterQ32kevin: hast du ahnung von coroutinen? :D
  60. kevinDefiniere Ahnung
  61. MasterQ32kennst du die grundlegende funktionsweise ? :D
  62. kevinHm, und definiere Coroutinen wohl auch *g*
  63. MasterQ32"kooperative userspace-threads" :D
  64. kevinIch kenne mich mit der Coroutinenart, die qemu benutzt, aus
  65. MasterQ32manuell steuerbar
  66. MasterQ32okay
  67. MasterQ32ich würde gerne sowas ähnliches machen
  68. kevinWeil ich die selber geschrieben habe ;-)
  69. MasterQ32aber ich habe das gefühl, dass C++ mit RAII und diese Art Coroutine sich beißt, oder?
  70. kevinAber es gibt da viele relativ unterschiedliche APIs, die unterschiedlich benutzt werden
  71. MasterQ32jedenfalls wenn ich die coroutinen abbreche, bevor sie terminiert
  72. kevinWieso willst du sie denn abbrechen bevor sie terminiert?
  73. MasterQ32kurz gesagt: reasons
  74. kevinSowas gibt es in qemu nicht, obwohl es kein C++ ist
  75. kevinIch glaube dir die Reasons nicht
  76. kevinRausspringen geht immer
  77. MasterQ32ich habe objekte, welche endlosschleifen ausführen
  78. MasterQ32bei level unload werden die objekte + coroutinen gelöscht
  79. MasterQ32no matter what state
  80. MasterQ32und ich will den user nicht damit beschäftigen, auf level unloads zu reagieren
  81. MasterQ32brb
  82. MasterQ32re
  83. MasterQ32re
  84. MasterQ32jetzt aber richtig :P
  85. MasterQ32hast du mir zwischendurch ne antwort?
  86. kevinHm, kannst du da nicht irgendwie eine Exception injecten oder so, dass du auf den obersten Level zurückkommst bevor du die Coroutine wegwirfst?
  87. MasterQ32ich hab zu wenig ahnung von exceptions in C++ in sowohl GCC als auch MSVC
  88. kevinJo, das ist aber die Ebene, auf der man sich rumschlägt, wenn man Coroutinen baut
  89. MasterQ32joar, ich würde aber eben was fertiges verwenden
  90. MasterQ32was halt für C ist
  91. MasterQ32https://github.com/cloudwu/coroutine
  92. kevinC bringt dir in dem Fall aber auch nichts
  93. kevinWenn die Coroutine was malloct, muss sie das auch wieder freigeben bevor sie beendet wird
  94. MasterQ32ja, soviel ist klar
  95. MasterQ32aber dafür kann ich special cases bauen
  96. MasterQ32da kann man drumrum arbeiten :P
  97. kevinIch würde einfach sagen, dass die Coroutinen sich selber ausdrücklich beenden müssen, wenn das Level zu Ende ist
  98. MasterQ32das ist aber nervig :D
  99. MasterQ32und fehleranfällig
  100. MasterQ32weil es coroutinen gibt, die in verschiedenen, gleichzeitig geladenen leveln sind
  101. MasterQ32genauso kann es objekte geben, die nicht an ein level gebunden sind
  102. MasterQ32usw usf :D
  103. kevinNaja, vermutlich haben die Coroutinen, wenn sie so langlaufend sind, alle eine Art Eventloop, oder?
  104. MasterQ32nah, nicht wirklich
  105. MasterQ32event behandeln == neue coroutine spawnen
  106. kevinWarum laufen sie dann so lang?
  107. MasterQ32weil sie game logic implementieren
  108. kevinSollten sie dann nicht ziemlich zügig fertig sein?
  109. MasterQ32sowas wie "türe öffnet/schließt sich"
  110. MasterQ32oder "Gegner-KI"
  111. MasterQ32die läuft halt das ganze spiel dauerhaft durch
  112. kevinTüre öffnet/schließt sich klingt für mich nach einem Funktionsaufruf und wenn die Türe dann offen ist, ist die Coroutine fertig
  113. MasterQ32du hast halt teilweise solchen code:
  114. MasterQ32while(true) {
  115. MasterQ32my.pan += time_step; // rotate
  116. MasterQ32yield();
  117. MasterQ32}
  118. kevinAh, da ist die Schleife doch
  119. MasterQ32genau
  120. MasterQ32das ist halt nen etwas ungewohntes, aber durchaus sehr angenehmes paradigma, mit sowas zu arbeiten+
  121. kevinUnd wo wäre da jetzt das Problem, statt while(true) dann eben while(!should_exit) zu schreiben?
  122. MasterQ32schreibaufwand und komplexität:
  123. MasterQ32for(var i = 0; i < 100; i += time_step) {
  124. MasterQ32animate(me, "death");
  125. MasterQ32yield();
  126. MasterQ32}
  127. MasterQ32damit wäre die abbruchbedinung wieder komplexer
  128. MasterQ32und ich muss in jede schleife diese abbruchbedingung aufnehmen
  129. MasterQ32das bläht den code massiv auf
  130. kevinJo, aber Sprachfeatures verbieten und Magie um alle dynamischen Speicherallokationen wird auch nicht besonders schön
  131. MasterQ32naja, nicht um alle
  132. MasterQ32ich hab eben speicher, der an das objekt gebunden ist
  133. kevinHm, aber vielleicht geht das mit den Exceptions auch ohne dass du den Mechanismus kennst
  134. kevinUnd zwar könnte yield() die Exception werfen
  135. MasterQ32ich kommentiere das mal mit: aua, das könnte tatsächlich funktionieren :D
  136. kevinDirekt nach dem Reenter in die Coroutine würde es prüfen, ob sie beendet werden soll
  137. MasterQ32void yield() { realYield(); if(should_exit) throw "up"; }
  138. MasterQ32quasi so?
  139. kevinthrow up? *lol*
  140. MasterQ32und in mein trampolin pack ich nen generisches try { coroutine(); } catch(...) { }
  141. kevinAber ja, irgendwie so
  142. MasterQ32das problem ist halt: what do when exception? :D
  143. kevinHm? Im Trampolin meinst du?
  144. MasterQ32ich müsste auf nen eigenen exceptiontyp für termination und einen generischen exceptiontyp für generic failure prüfen, oder?
  145. MasterQ32ja
  146. kevinCoroutine beenden und gut
  147. MasterQ32und halt mitloggen, dass was schief gegangen ist
  148. MasterQ32in klassischer Gamestudio-Manier: Spiel anhalten, MessageBox aufploppen, Chaos anrichten! :D
  149. kevinDu meinst, wenn irgendwelche anderen Exceptions bis ins Trampolin durchkommen? Kann man machen, ja.
  150. MasterQ32okay, cool
  151. MasterQ32dann teste ich das mal, wenn motivation da :D
  152. MasterQ32das würde mir dinge vereinfachen
  153. moritz31So daheim :'D Also zugriffe werden immer langsamer aber einen Pagefault gibts nicht kein Plan was da los ist
  154. kevinWenn ich raten soll, geht in deinem Allokator was ziemlich schief, dass er immer länger nach was freiem suchen muss
  155. moritz31der sucht ja aber nach nix freiem
  156. moritz31ich hab ja noch keine Funktion alà findFreePage oder sowas
  157. kevinWas macht dein pmm_alloc() oder wie es hieß denn sonst?
  158. MasterQ32so, endlich daheme
  159. MasterQ32hm, literals oder coroutinen? :D
  160. MasterQ32hey darklink
  161. MasterQ32bei meinem lieblingspizzaservice arbeiten götter
  162. moritz31so mein Bug im Memorymanagment gefunden :'D
  163. moritz31war eigentlich kein Bug sondern Dummheit ^
  164. PaddySind das nicht die meisten Bugs?
  165. Paddy<MasterQ32> hm, literals oder coroutinen? :D
  166. moritz31@Paddy joa hast Recht :'D aber diesmal war es mehr eine Optimierung
  167. PaddyIch bin ja für Coroutinen-Literale
  168. MasterQ32mist. :P
  169. MasterQ32ne, das hat leider nix miteinander zu tun :D
  170. XanClicDa lässt sich bestimmt was machen
  171. MasterQ32kommt ja nicht auf plöde ideen :D
  172. PaddyDu bist in #lost
  173. PaddyHier gibt es nur blöde Ideen
  174. MasterQ32stimmt
  175. XanClicManchmal gibts auch gute Ideen, die dann nur in der Praxis doof sind
  176. MasterQ32stackmaschinen? :D
  177. XanClicSind die in der Praxis denn doof?
  178. XanClicUnd ich mag mich irren, ich bin ja auch noch nicht so lange hier, aber ich glaube, Stackmaschinen wurden nicht von #lost erfunden
  179. MasterQ32scheinbar ja, sonst würden wir doch sicher ein paar CPU-Architekturen haben, die nichtregistermaschinen sind :D
  180. XanClicEs gibt ja einen Unterschied zwischen Maschinen, die man in Hardware bauen will, und solchen, die durch einen JIT laufen sollen
  181. MasterQ32jau