Seite 8 von 8
Re: Emulator in Python...
Verfasst: Dienstag 25. August 2015, 13:48
von jerch
@jens:
In der Auflistung sieht man recht gut, wieviel Zeit in den Registern verbracht wird. Ohne Änderung der internen API könntest Du z.B. die komplexen Registermethoden optimieren und immernoch lesbar bleiben - Beispiel:
Code: Alles auswählen
def set_H(self, a, b, r):
if self.H == 0:
r2 = (a ^ b ^ r) & 0x10
self.H = 0 if r2 == 0 else 1
# kannst Du auch schreiben als
def set_H(self, a, b, r):
if not self.H and ((a ^ b ^ r) & 0x10):
self.H = 1
Das allein wird allerdings nicht soviel bringen, auch ist im Sinne der Lokalität das self.H störend. Deutlich effektiver wäre es, die Attribut-/Methoden-Lookups lokal vorzuhalten oder ganz loszuwerden. Das ginge aber nur mit API-Änderung der Register-Objekte und entsprechender Anpassung auf Callerebene. Damit würde aber auch der Code unpythonischer, was Du wahrscheinlich nicht möchtest.
Re: Emulator in Python...
Verfasst: Dienstag 25. August 2015, 15:18
von jens
Ja, "dot-names" zu "kürzen" bringt schon was:
https://gist.github.com/jedie/015d3cb9de25eb7f0188
Hab gerade mal was probiert:
https://github.com/6809/MC6809/commit/b ... 182381cL15
Am Ende kommt allerdings nicht all zu viel dabei rum. Aber in diesem Fall, ist es eh generierter code...
Re: Emulator in Python...
Verfasst: Donnerstag 27. August 2015, 18:39
von jerch
@jens:
Ich hab mal ein wenig mit Deinem CPU-Code rumprobiert - im Ergebnis konnte ich in CPython 2.7 die Cycles von 850.000 auf 1.300.000 bringen. Folgendes hat die Sache beschleunigt:
- Ersetzen der getter/setter durch direkten Attributzugriff am cc-Register für die einzelnen Bits (ohne API-Change, ~50% des Speedups)
- Umstellen der cc-Register-Methoden auf 1-2 Zeiler (kein API-Change, ~20% des Speedups)
- Umstellen aller lesenden Registerzugriffe von `.get()` auf `.value` in der CPU-Klasse (~20% des Speedups)
- Umstellen des Speichers von Bytearray auf eine Liste (~10% des Speedups)
Ich vermute, dass Du durch Entfernen der vielen lokalen Zwischenvariablen in den Instruktionen-Methoden noch etwas einsparen könntest. Mehr als 1.500.000 cycles/s sind aber wahrscheinlich nicht zu schaffen ohne größeren Umbau an den Registern (ist immer noch die "Hauptlast").
Edit:
Und `pypy -m MC6809.cli benchmark` läuft mit 12 Mio. cycles/s.
Re: Emulator in Python...
Verfasst: Donnerstag 27. August 2015, 19:37
von jens
Die ganzen .get() / .set() methoden, wollte ich eh weg machen... Während der Entwicklungsphase waren sie allerdings hilfreich. Allerdings weiß ich auch nicht mehr warum
Kannst du einen Pull-Request machen?!?
Laufen die Unittests noch durch?
btw. die API ist jetzt nicht in Stein gemeißelt. Ich hab eh Änderungen mit den Mixin-Klassenaufteilung, siehe WIP-branch:
https://github.com/6809/MC6809/compare/split_cpu
Re: Emulator in Python...
Verfasst: Samstag 29. August 2015, 17:17
von jerch
@jens:
Die Tests laufen noch durch, musste nur fürs Entfernen von `.get` die Tests anpassen. Natürlich ist die coverage gesunken, da mein hinzugefügter Kram nicht abgedeckt ist. Achso - irgendwo hatte ich einen Bug gefunden, ich glaube es war in EXG (habs leider nicht protokolliert). Fehlt da der Test zu?
Re: Emulator in Python...
Verfasst: Sonntag 30. August 2015, 09:24
von jens
Mag sein. Durch das absplitten vom DragonPy Emulator, sind einige Tests davon nicht mehr abgedeckt ;(
Könnte allerdings DragonPy für die Tests installieren lassen. Zumindest für travis CI
Re: Emulator in Python...
Verfasst: Montag 31. August 2015, 15:14
von jens
Ich hab es nun auch so eingerichtet, das die DragonPy tests, ebenfalls mit laufen. Doch ich hatte nicht damit gerechnet, das die Test-Abdeckung damit nicht besser wird. Naja, heißt ja nur, das alleine die Tests in MC6809 schon gut sind
jerch hat geschrieben:irgendwo hatte ich einen Bug gefunden, ich glaube es war in EXG (habs leider nicht protokolliert). Fehlt da der Test zu?
EXG ist abgedeckt.
EXG bei dein pull request (nur MC6809 tests):
https://coveralls.io/builds/3429967/sou ... 9.py#L1367
EXG mit den DragonPy tests zusammen:
https://coveralls.io/builds/3442782/sou ... 9.py#L1466
Re: Emulator in Python...
Verfasst: Montag 31. August 2015, 15:24
von jerch
Ja sorry es war auch nicht EXG sondern Deine Helfermethode `_convert_differend_width` dazu. Da stimmten Deine Docstring-Beschreibung nicht mit dem Verhalten überein. Für die Konvertierung der Registerinhalte von 16 auf 8 Bit war Deine Korrektur ein `src_value = src_value | 0xff00`. Das macht aber nicht, was der Docstring beschreibt. Es führte zu keinem Fehler in den Tests, da die Register das beim Speichern in der `.set`-Methode auf 8 Bit korrigiert haben.
Re: Emulator in Python...
Verfasst: Montag 31. August 2015, 16:09
von jens
jerch hat geschrieben:Ja sorry es war auch nicht EXG sondern Deine Helfermethode `_convert_differend_width` dazu. Da stimmten Deine Docstring-Beschreibung nicht mit dem Verhalten überein. Für die Konvertierung der Registerinhalte von 16 auf 8 Bit war Deine Korrektur ein `src_value = src_value | 0xff00`. Das macht aber nicht, was der Docstring beschreibt. Es führte zu keinem Fehler in den Tests, da die Register das beim Speichern in der `.set`-Methode auf 8 Bit korrigiert haben.
Ah! Interessante Information...
Die DocStrings kommen ursprünglich aus den Dokumentationen. siehe:
https://github.com/6809/MC6809/blob/mas ... op_docs.py
Es ist nicht auszuschließen, das die Dokumentation falsch ist. Hatte auch schon früher ein paar kleine Fehler gefunden...
Zu EXG hatte ich auch einen extra Thread, hier:
http://archive.worldofdragon.org/phpBB3 ... &hilit=EXG
Genau mit der Frage, was passiert, wenn 16 und 8 Bit hin und her Transferiert wird...
Re: Emulator in Python...
Verfasst: Dienstag 1. September 2015, 09:07
von jerch
Wenn ich den Dump richtig interpretiere, ist das hohe Byte bei 8 -> 16 Bit immer 0xff, und 16 -> 8 lädt das untere Byte. Heisst die Register werden vorher "geeinst" und der Wert bitaddiert. Gibts eigentlich einen speziellen Grund, warum die Registerbits vorher auf eins gesetzt werden? Hätte ja erwartet, dass die genullt werden.
Re: Emulator in Python...
Verfasst: Dienstag 1. September 2015, 09:46
von jens
jerch hat geschrieben:Gibts eigentlich einen speziellen Grund, warum die Registerbits vorher auf eins gesetzt werden? Hätte ja erwartet, dass die genullt werden.
Keine Ahnung. Ich hab es auch immer noch nicht auf dem echten Computer nach geprüft...
Allerdings ist es so, das beim "nullen" die unittests nicht durchlaufen. z.B. der mit der CRC32 Berechnung.
Von daher gehe ich davon aus, das es so richtig ist.
Allerdings ist mit dennoch ein Fehler aufgefallen! Das Konvertieren von 16Bit zu einem 8Bit, führt zu einem falschen Ergebnis!
Zumindest intern in der Methode. Hinterher ist es IMHO egal, weil ein 8Bit Register beim setzten, eh den Wert abschneidet.
Dazu kommt noch, das der DocString falsch war...
Siehe:
https://github.com/6809/MC6809/commit/5 ... a052ec73e9
EDIT: Mir ist noch aufgefallen, das der aktuelle code ein wenig umständlich ist. Deswegen:
https://github.com/6809/MC6809/commit/2 ... 0dfcf40c10
Kannst du deinen Pull aktualisieren?
Re: Emulator in Python...
Verfasst: Mittwoch 2. September 2015, 20:53
von jens
@jerch: ich hab mir jetzt dein
https://github.com/6809/MC6809/pull/1/files näher angesehen...
Was mir nicht gefällt sind die ganzen
& register.BASE
Dann hab ich mich gefragt, was ist eigentlich schneller:
oder:
Hab timeit angeworfen:
Code: Alles auswählen
from timeit import Timer
import sys
# TEST_DATA = [0xff] * 10000
# TEST_DATA += [0x100] * 10000
# test1: 1.441sec
# test2: 1.434sec
TEST_DATA = [0xff] * 20000
TEST_DATA += [0x100] * 2000
# test1: 1.139sec
# test2: 1.593sec
def test1():
for n in TEST_DATA:
if n>0xff:
x = n & 0xff
else:
x = n
def test2():
for n in TEST_DATA:
x = n & 0xff
if __name__ == "__main__":
def timeit(func, number):
name = func.__name__
sys.stdout.write("%20s: " % name)
sys.stdout.flush()
t = Timer("%s()" % name, setup="from __main__ import %s" % name)
print("%.3fsec" % t.timeit(number))
number = 1000
timeit(test1, number)
timeit(test2, number)
Also, wenn ein Überlauf nicht so häufig vorkommt, dann ist die
if-Variante schneller.
Ich gehe einfach mal davon aus, das es in der Praxis nicht so oft vor kommt.
Deswegen hab ich mal einen Testlauf mit dem Benchmark gemacht.
Dazu hab ich den 'master' branch genommen und
https://github.com/6809/MC6809/blob/5da ... py#L63-L91 noch abgeändert.
Also diese beiden Varianten gegeneinander Verglichen:
Code: Alles auswählen
class ValueStorage8Bit(ValueStorage):
def set(self, v):
if v > 0xff:
v = v & 0xff
self.value = v
return v # e.g.: r = operand.set(a + 1)
class ValueStorage16Bit(ValueStorage):
def set(self, v):
if v > 0xffff:
v = v & 0xffff
self.value = v
return v # e.g.: r = operand.set(a + 1)
Code: Alles auswählen
class ValueStorage8Bit(ValueStorage):
def set(self, v):
v = v & 0xff
self.value = v
return v # e.g.: r = operand.set(a + 1)
class ValueStorage16Bit(ValueStorage):
def set(self, v):
v = v & 0xffff
self.value = v
return v # e.g.: r = operand.set(a + 1)
Leider schwanken die Benchmark Werte so stark, das man keine genaue Aussage treffen kann

Re: Emulator in Python...
Verfasst: Mittwoch 2. September 2015, 22:33
von jerch
Ja das ist nicht hübsch und auch der Grund, warum ich mit ctypes Typen rumprobiert hatte.
Bitte nimm die Änderungen nicht zu ernst, das sind größtenteils quick&dirty Ersetzungen, um die Flaschenhälse im profiling zu bessern. In einem zweiten Ansatz habe ich auch die generierten Instruktionen durch eine einfachere Abstraktion ersetzt, was aber nicht mehr viel bringt. Ein Ansatz mit Megaloop bringt auch nichts, dafür fehlt Python ein switch-statement in O(1). Das Funktionsmapping ist da schon das beste und auch viel lesbarer. Wenn ich dazu komm, räum ich die Änderungen nochmal auf und leg es ins Repo. Dann kannst Du schauen, ob Du was davon übernehmen willst.
Re: Emulator in Python...
Verfasst: Donnerstag 3. September 2015, 14:28
von jens
Ich hab nun den "mixin" CPU branch in "master" gemerged.
jerch hat geschrieben:Bitte nimm die Änderungen nicht zu ernst, das sind größtenteils quick&dirty Ersetzungen, um die Flaschenhälse im profiling zu bessern.
Außerdem hab ich ein paar deiner Vorschläge aufgenommen. z.B. ein Teil der CC Register Klasse und den Verzicht auf .get():
https://github.com/6809/MC6809/commit/3 ... d742516562
Re: Emulator in Python...
Verfasst: Donnerstag 3. September 2015, 16:28
von jens
So und die CC Register direkt in die CPU einpflanzen per mixin hab ich nun mit
https://github.com/6809/MC6809/commit/b ... 719df9cbd7 angegangen...
Jetzt muß ich allerdings DragonPy anpassen...
Re: Emulator in Python...
Verfasst: Donnerstag 3. September 2015, 19:18
von darktrym
Gibts denn mittlerweile Audio im Emulator?
Re: Emulator in Python...
Verfasst: Donnerstag 3. September 2015, 20:32
von jens
Nein. Grundsätzlich möglich, halte ich es allerdings schon...
Re: Emulator in Python...
Verfasst: Donnerstag 11. Februar 2016, 18:25
von jens
Wer mich mal sehen will... Vom letzten Python Treffen in Düsseldorf über DragonPy:
https://www.youtube.com/watch?v=GFuxPDo ... xKeV1ZxL22