実は既に結構挫折気味。
やっぱりPythonではちょっと厳しいかもしれない。
とりあえず一番ややこしいPPU周りの情報を調べて、ちょろちょろ書き始めたあたりでいったんCPU部分のパフォーマンスを調べてみました。
かなり厳しいものがあります。CPU部分のコードはPython的な書き方で書いてたんですが、これじゃ話にならない。まず、アクセサなんてものはつかっちゃいけないのだ。
以下環境はOS:WinXP,CPU:Athlon64 3000+,Memory:1G,Python2.4です。
CPUのレジスタ関連の実装
NESのCPUである6502のレジスタはPCは16bit、それ以外は8bit。8bitの値なんてものはCならunsigned charで一発なんだけど、Pythonにはそんなものない。足し算したらどんどん大きくなるし、引き算したらどんどん小さくなる。ので
1class Py6502(object):
2 def __init__(self):
3 self.A = 0
4 self.X = 0
5 self.Y = 0
6 self.PC = 0
7 # .
8 # .
9 # .
見たいなクラスにするとして、足し算するときなどは必ず self.A = (self.A + x) & 0xff みたいにして8bitに収めないといけない。ここで
1def _create_n_bit_property(name, mask):
2 rname = "_"+name
3 result = {
4 name:property(lambda self: getattr(self, rname),
5 lambda self,v : setattr(self, rname, v & mask),
6 )
7 }
8 return result
9
10class ForceNbitType(type):
11 def __new__(cls, class_name, class_bases, classdict):
12 names = classdict.get("__16bit__")
13 for name in names:
14 classdict.update(_create_n_bit_property(name, 0xffff))
15 names = classdict.get("__8bit__")
16 for name in names:
17 classdict.update(_create_n_bit_property(name, 0xff))
18 cls = type.__new__(cls, class_name, class_bases, classdict)
19 return cls
のようなmetaclassをつくって
1class Py6502(object):
2 __metaclass__ = ForceNbitType
3 __8bit__ : "A", "X", "Y"
4 __16bit__ : "PC",
5 def __init__(self):
6 self._A = 0
7 self._X = 0
8 self._Y = 0
9 self._PC = 0
10 # .
11 # .
12 # .
とすれば self.A += 10 とかしてもちゃんと8bitに収まる。
非常に上手くかけるんですが、こんなのやってらんない。遅すぎる。1Frame分(28000サイクル程度)の実行に0.5秒（笑
getattr
getattr は遅い。 getattrの真価は第3引数でdefault値が指定できること（だと思う）。今回のように確実に属性が存在することが分かっているならself.__getattribute__(name)を使うと結構違ってくる。ちなみにPythonのソースではこんな感じ。
1static PyObject *
2slot_tp_getattro(PyObject *self, PyObject *name)
3{
4 static PyObject *getattribute_str = NULL;
5 return call_method(self, "__getattribute__", &getattribute_str,
6 "(O)", name);
7}
8
9static PyObject *
10slot_tp_getattr_hook(PyObject *self, PyObject *name)
11{
12 PyTypeObject *tp = self->ob_type;
13 PyObject *getattr, *getattribute, *res;
14 static PyObject *getattribute_str = NULL;
15 static PyObject *getattr_str = NULL;
16
17 if (getattr_str == NULL) {
18 getattr_str = PyString_InternFromString("__getattr__");
19 if (getattr_str == NULL)
20 return NULL;
21 }
22 if (getattribute_str == NULL) {
23 getattribute_str =
24 PyString_InternFromString("__getattribute__");
25 if (getattribute_str == NULL)
26 return NULL;
27 }
28 getattr = _PyType_Lookup(tp, getattr_str);
29 if (getattr == NULL) {
30 /* No __getattr__ hook: use a simpler dispatcher */
31 tp->tp_getattro = slot_tp_getattro;
32 return slot_tp_getattro(self, name);
33 }
34 getattribute = _PyType_Lookup(tp, getattribute_str);
35 if (getattribute == NULL ||
36 (getattribute->ob_type == &PyWrapperDescr_Type &&
37 ((PyWrapperDescrObject *)getattribute)->d_wrapped ==
38 (void *)PyObject_GenericGetAttr))
39 res = PyObject_GenericGetAttr(self, name);
40 else
41 res = PyObject_CallFunction(getattribute, "OO", self, name);
42 if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
43 PyErr_Clear();
44 res = PyObject_CallFunction(getattr, "OO", self, name);
45 }
46 return res;
47}
上が __getattribute__ 、下が getattr 。ま、こんなことやったって関数呼び出しのオーバーヘッドが一番ツライのでgetterは使わず、setterは必要があるときだけ使うように。これで結構はやくなる。
実行ループ
CPUのエミュレータなんてのはだいたい同じようなパターンで割り込みを除いて簡単に書くと
1def step_execute(self, clocks):
2 while (self.passed_clocks < clocks):
3 opecode = read()# opecodeを取得
4 # 実行
5 count = CLOCK[opecode] # 実行に必要なクロック数を取得
6 self.passed_clocks += count
7 self.passed_clocks -= clocks
なんてのになるわけで、ここが激しくループするわけで。ここはガリガリにちょっとでも節約できるものは節約。
1def step_execute(self, clocks):
2 read = self.memory.read
3 get_method_by_opecode = self.get_method_by_opecode
4 while (self.passed_clocks < clocks):
5 old = self._PC; self._PC += 1; self._PC &= 0xffff
6 opecode = read(old)
7 method = get_method_by_opecode(opecode)
8 count = method()
9 count = count != None and count or CYCLES[opecode]
10 self.passed_clocks += count
11 self.passed_clocks -= clocks
javascriptで . (ドット)演算が遅いとかいうのは最近（？）よく言われていることで、それはPythonにも当然当てはまる。なのでループ前にだせるものはローカルに出しておく。（これが簡単にできるのがRubyよりもPythonがいい部分だよなあ）
あと、実行の部分。ここはCなら関数テーブルかswitch(コンパイラによるけど大差ないと思う）になるんだけど、あいにくPythonにはswitchがないので関数テーブル的なものか if opecode == 0x01: ... elif opecode == 0x02:... elif... かになる。
関数テーブル的なものは
1def ope_0x01(self):
2 #code
3def ope_0x02(self):
4 #code
5
6self.__getattribute__("ope_"+hex(opecode))()
となる。両方やってみたところ、大差はなかったので、関数テーブル的なほうに。
結局
そんな感じでいじってみてかつpsycoを入れて1Frame:0.15程度（PPUやAPUは中身がないので、最後までつくったらもっと遅くなる）。ほかにもいじれそうなところはあって、そこをいじれば0.1は切れそうな感じがしてます。
けど、そこまでやるとPythonである意味がないのも確か。ぶっちゃけ、エミュレータは確実にCが向いている。Javaで書かれているエミュレータもレジスタの値をセットするたびに A & 0xff みたいなことをやっていて、どーもめんどくさい。
じゃぁLLでエミュレーターを書く意味ってなんだ、というと・・・うーん（笑 自己満足以外なにもないでしょうねえ。というわけで自己満足のために、今後もヒマができれば、ちょっとづつ書き進めてみようかなあ。
