#lost · 2016-10-06

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

  1. darklinkabgesehen davon, dass das executable format NCCH heißt
  2. MasterQ32:D
  3. darklinkund exefs und romfs enthält
  4. MasterQ32:P
  5. JonathanMoin
  6. MasterQ32Hey Jonathan
  7. darklinkhi
  8. JonathanHeute mal 1,5mm^2 Kabel geholt, jetzt fixe ich meine Ground-Probleme im neuen Drahthaufen *g*
  9. darklink^^
  10. MasterQ32viel Erfolg!
  11. JonathanDanke :)
  12. MasterQ32ich bastel grade an einem token-compiler für den interpreter
  13. MasterQ32ich brauch wohl irgendwann mal noch ein HexEdit "File"
  14. MasterQ32wie sinnvoll ist code a'la for(int i = 0; i < size; i++) { data = realloc(data, ++len); } ?
  15. MasterQ32Jonathan: XanClic, habt ihr da was sinnvolles zu?
  16. JonathanÄh ja
  17. JonathanAlso für mich klingt das nach "ganz viel wtf"
  18. Jonathandata = realloc(data, len + size); //Tut doch auch?
  19. JonathanOder was soll dein Code tun? Den Heap fragmentieren? Wenn ja, dann bist du da auf dem besten Weg
  20. MasterQ32:D
  21. Jonathan:P
  22. MasterQ32ich schreibe eine datenmenger unbekannter größe
  23. MasterQ32len und size inkrementieren sehr unterschiedlich
  24. Jonathan"Datenmenge unbekannter Größe"... Du schreibst einen Puffer, an den man hinten beliebig viele Daten anhängen kann?
  25. JonathanOder wie genau soll das Ding funktionieren?
  26. MasterQ32ja, ungefähr so
  27. JonathanWie sollen die Daten wieder ausgelesen werden aus dem Puffer?
  28. JonathanSequenziell?
  29. MasterQ32ich übersetze text in tokens und speichere eine tokensequenz ab
  30. MasterQ32das heißt, ich kenne die finale größe nicht, bevor ich sie komplett tokenized habe
  31. JonathanWieso genau willst du das als "flachen" binären Puffer speichern?
  32. JonathanIn welcher Sprache machst du das denn eigentlich?
  33. JonathanC++?
  34. MasterQ32C
  35. MasterQ32"Wieso genau willst du das als "flachen" binären Puffer speichern?" das ist das format, das ich am ende brauche
  36. JonathanWieso das?
  37. MasterQ32weil ich das so in einer "datei" abspeichern werde und diese sind flache puffer
  38. JonathanMh :P
  39. JonathanIch hätte jetzt erst mal eine verkettete Liste von Token-Structs vorgeschlagen, aber das geht in dem Fall ja nicht wirklich
  40. MasterQ32dann hätte ich die gleiche fragmentierung
  41. JonathanMach eine verkettete Liste von Puffern fester Größe
  42. MasterQ32weil die tokens halt zwischen 1 bis n bytes haben
  43. MasterQ32ich hab übrigens während des loops keine weiteren mallocs, also theoretisch dürfte der heap nicht fragmentieren, solange ich nach hinten vergrößern kann
  44. Jonathanstruct partial_buffer {size_t total_bytes, size_t used_bytes, partial_buffer* next, char[1] data};
  45. MasterQ32und dann malloc(sizeof(struct partial_buffer) + datalen - 1)
  46. JonathanDu könntest auch gleich größere Blöcke nehmen :P
  47. JonathanDafür ist used_bytes da
  48. MasterQ32ich werde wohl zu einem realloc mit größerem inkrement wechseln
  49. JonathanWürde ich nicht machen
  50. MasterQ32why not?
  51. JonathanDu weißt ja nicht, wie dein Heap vorher schon aussah
  52. MasterQ32hm, stimmt
  53. JonathanIch würd immer z.B. 4096 Bytes große partielle Puffer nehmen und die verketten
  54. Jonathan(Oder größer, je nach Geschmack)
  55. JonathanUnd dann den hintersten mit Daten auffüllen und bei Bedarf noch einen anhängen
  56. JonathanDu kannst in deiner Schleife ja immer einen Pointer auf den letzten partiellen Puffer mitführen, dann musst du die Liste nicht immer neu durchgehen
  57. MasterQ32apropos 4096, du erinnerst mich da an was :D
  58. JonathanDu könntest die Größe der partiellen Puffer auch so wählen, dass du direkt das OS nach Speicher fragen kannst und keinen Heap mehr brauchst
  59. JonathanDann kann da auch nix fragmentieren
  60. MasterQ32örm :D
  61. JonathanHmmm?
  62. MasterQ32"OS nach speicher fragen" =:= "malloc"
  63. MasterQ32:D
  64. JonathanÄh, dein Kernel stellt Heap-Funktionen bereit? *g*
  65. MasterQ32korrekt
  66. JonathanUnd ein malloc(1) verbraucht wie viel Speicher?
  67. MasterQ32gute frage, kann ich dir so konkret nicht sagen
  68. MasterQ32malloc aligned speicher auf 4 bytes
  69. MasterQ32und braucht dann wohl noch die passende overhead für den eintrag
  70. MasterQ32im heap
  71. MasterQ32https://github.com/mattconte/tlsf
  72. MasterQ32nutze das hier
  73. JonathanGut, also wenigstens keine ganzen Pages ;)
  74. JonathanDas hatte ich nämlich befürchtet *g*
  75. MasterQ32nene
  76. MasterQ32das ganze läuft so:
  77. MasterQ32ich initialisiere einigen kram (mit pages), danach suche ich den RAM von hinten ab nach dem letzten zusammenhängenden block speicher
  78. MasterQ32und initialisiere da drin meinen HEAP
  79. MasterQ32was zur zeit 126MB von 128MB sind
  80. JonathanÖöööh
  81. JonathanDu hast keine getrennten Adressräume?
  82. MasterQ32ich hab nur einen basic-interpreter
  83. MasterQ32keine assemblerprogramme
  84. JonathanOhje *g*
  85. JonathanAber gut
  86. JonathanDann willst du ja noch weniger realloc benutzen, wenn das der einzige Heap im ganzen System ist
  87. MasterQ32okay, scheint nix zu fragmentieren :D
  88. JonathanNa dann... :P
  89. MasterQ32also ich hab grade einfach mal das realloc n paar hunder mal mit nem increment von 2 aufgerufen
  90. MasterQ32kam am ende der selbe pointer raus
  91. Jonathan*g*
  92. JonathanEin gutes Programm verlässt sich nicht auf Implementation Details ;P
  93. JonathanIch würde die verkettete Liste von Teilpuffern nehmen, aber wenn realloc allein auch geht, dann tu das
  94. JonathanFang wenigstens Fehler von realloc passend ab
  95. MasterQ32joar
  96. JonathanUnd generell von malloc etc :P
  97. MasterQ32hehe
  98. MasterQ32ich hab nen wrapper um malloc, ich kann jederzeit ne kernelpanic mit out-of-memory auslösen
  99. Jonathan... *g*
  100. Jonathanmalloc = kernelpanic, auch nett ;)
  101. JonathanAlso, Fehlschlag von malloc
  102. MasterQ32naja, was soll ich sonst machen? :D
  103. MasterQ32ne spaß, ich behandel das schon sinnvoll
  104. JonathanAuweia :P
  105. MasterQ32erwarte in dem projekt keine sinnvollen sachen :D
  106. Jonathan*g*
  107. MasterQ32ich möchte mal was mehr oder weniger fertig bekommen
  108. MasterQ32http://pastebin.com/aVnqkpjS
  109. MasterQ32ich würde das ganze jetzt so lösen
  110. JonathanSieht ja sogar recht vernünftig aus
  111. MasterQ32kann man imho auch nicht viel falsch machen
  112. MasterQ32das if könnte unintelligenter gelöst werden
  113. PaddyMoin
  114. MasterQ32hoy Paddy
  115. MasterQ32kennt jemand ein tool, mit dem ich eine hexadezimale sequenz zu einer binärdatei übersetze
  116. Paddyxxd?
  117. MasterQ32okay, mal gucken
  118. MasterQ32hm
  119. MasterQ32das braucht ja addressen
  120. MasterQ32ah, geht auch ohne
  121. PaddyWill man das näher wissen, was du da machst? ;-)
  122. MasterQ32ich debugge bytecode
  123. MasterQ32ich überarbeite meine basic-ausführung
  124. MasterQ32https://puu.sh/rA71v/132435c052.png
  125. MasterQ32so, genug für heute
  126. MasterQ32code compilieren und ausführen geht
  127. MasterQ32darauf kann ich jetzt bauen
  128. PaddyDas mit genug für heute sehe ich auch so
  129. PaddyFünf Minuten Pause mindestens ;-)
  130. MasterQ32:D
  131. MasterQ32aber hey, jetzt kann ich anfangen, callstacks und rekursion einzufügen
  132. MasterQ32und andere kontrollstrukturen
  133. PaddyJo, bei mir ist noch alles kaputt