Commits

shomah4a  committed 7b0a002

trasnalte to japanese

  • Participants
  • Parent commits c1a46bb

Comments (0)

Files changed (1)

File tutorial.rst

  PyPy を使ってでインタプリタを書く
 ===================================
 
+.. contents::
+
 .. Written by Andrew Brown <brownan@gmail.com>, with help from the PyPy developers
 .. on the pypy-dev mailing list.
 
 .. data types at your disposal.  Oh, but an interpreted language interpreting
 .. another language would be slow, right? That's twice as much interpreting going on.
 
-もしあなたが既存の高級言語に似た言語で、例えば Python であなたの言語を記述できたとすれば素敵だと思いませんか?
+もしあなたが既存の高級言語に似た言語で、例えば Python であなたの言語を記述できたとすれば素敵だと思いませんか?
 あなたが自動メモリ管理やリッチなデータ型などの高級言語の全ての利点を利用したいと思うならば、それはたしかに理想的になるでしょう。
 ああ、しかしインタプリタが他の言語を他の言語で解釈することで遅くなると思っていませんか? 実行のために二倍の解釈をしなければいけませんから。
 
 
     テープのポインタを1セル左に動かす
     
-+
+\+
     .. Increments the value of the cell underneath the pointer
 
     ポインタが指すセルの値をインクリメントする
     
--
+\-
     .. Decrements the value of the cell underneath the pointer
 
     ポインタが指すセルの値をデクリメントする
 これはかなり実装を簡潔にしています。
 
 
-First Steps
-===========
-Let's start out by writing a BF interpreter in plain old Python. The first step
-is sketching out an eval loop::
+.. First Steps
+
+最初の一歩
+==========
+
+.. Let's start out by writing a BF interpreter in plain old Python. The first step
+.. is sketching out an eval loop
+
+昔ながらの Python で BF を書くことから始めてみましょう。
+最初の一歩は評価ループの大枠を書くことです。
+
+::
 
     def mainloop(program):
         tape = Tape()
 
             pc += 1
         
-As you can see, a program counter (pc) holds the current instruction index. The
-first statement in the loop gets the instruction to execute, and then a
-compound if statement decides how to execute that instruction.
+.. As you can see, a program counter (pc) holds the current instruction index. The
+.. first statement in the loop gets the instruction to execute, and then a
+.. compound if statement decides how to execute that instruction.
 
-The implementation of [ and ] are left out here, but they should change the
-program counter to the value of the matching bracket. (The pc then gets
-incremented, so the condition is evaluated once when entering a loop, and once
-at the end of each iteration)
-        
-Here's the implementation of the Tape class, which holds the tape's values as
-well as the tape pointer::
+おわかりのように、プログラムカウンタ(pc)は現在の命令のインデックスを保持します。
+ループの一文目は実行する命令を取得していて、その後の文が命令をどうやって実行するか決定できた場合、合成します。
+
+
+.. The implementation of [ and ] are left out here, but they should change the
+.. program counter to the value of the matching bracket. (The pc then gets
+.. incremented, so the condition is evaluated once when entering a loop, and once
+.. at the end of each iteration)
+
+[ および ] の実装はここでは置いておきます。しかし、それらはプログラムカウンタを対応する括弧の値に変更する必要があります。
+(ループに入るときの条件が一度だけ評価されるように pc はインクリメントされ、そして各反復の終了時に一度行われます。)
+
+.. Here's the implementation of the Tape class, which holds the tape's values as
+.. well as the tape pointer
+
+ここで Tape クラスの実装です。 Tape クラスはテープの値だけでなく、テープのポインタも保持します。
+
+::
 
     class Tape(object):
         def __init__(self):
         def devance(self):
             self.position -= 1
             
-As you can see, the tape expands as needed to the right, indefinitely. We
-should really add some error checking to make sure the pointer doesn't go
-negative, but I'm not worrying about that now.
+.. As you can see, the tape expands as needed to the right, indefinitely. We
+.. should really add some error checking to make sure the pointer doesn't go
+.. negative, but I'm not worrying about that now.
+
+おわかりのように、テープは必要に応じて右側に無限に拡張されます。
+私たちは本当であればポインタの値が負にならないようにいくつかのエラーチェックをする必要があります。しかし、ここではそのような心配はしないでおきます。
             
-Except for the omission of the "[" and "]" implementation, this code will work
-fine.  However, if the program has a lot of comments, it will have to skip over
-them one byte at a time at runtime. So let's parse those out once and for all.
+.. Except for the omission of the "[" and "]" implementation, this code will work
+.. fine.  However, if the program has a lot of comments, it will have to skip over
+.. them one byte at a time at runtime. So let's parse those out once and for all.
 
-At the same time, we'll build a dictionary mapping between brackets, so that
-finding a matching bracket is just a single dictionary lookup. Here's how::
+省略された "[" と "]" の実装をのぞいて、このコードはうまく動きます。
+しかし、プログラムに沢山のコメントがあった場合、実行時に一度に1バイト以上スキップする必要があります。
+では、一度にこれらの出力を解析してみましょう。
+
+.. At the same time, we'll build a dictionary mapping between brackets, so that
+.. finding a matching bracket is just a single dictionary lookup. Here's how
+
+同時に、対応する括弧を一度の辞書探索で見つけられるように括弧同士のマッピングをするための辞書を作ります。
+以下はその方法です::
 
     def parse(program):
         parsed = []
         
         return "".join(parsed), bracket_map
 
-This returns a string with all invalid instructions removed, and a dictionary
-mapping bracket indexes to their matching bracket index.
+.. This returns a string with all invalid instructions removed, and a dictionary
+.. mapping bracket indexes to their matching bracket index.
 
-All we need is some glue code and we have a working BF interpreter::
+これは、すべての不正な命令を取り除いた文字列と、対応する括弧と括弧のインデックスをマッピングをするための辞書を返します。
+
+.. All we need is some glue code and we have a working BF interpreter
+
+必要なのはいくつかのグルーコードであり、動作する BF のインタプリタを持っています::
 
     def run(input):
         program, map = parse(input.read())
         import sys
         run(open(sys.argv[1], 'r'))
         
-If you're following along at home, you'll also need to change the signature of
-mainloop() and implement the bracket branches of the if statement. Here's the
-complete example: `<example1.py>`_
+.. If you're following along at home, you'll also need to change the signature of
+.. mainloop() and implement the bracket branches of the if statement. Here's the
+.. complete example: `<example1.py>`_
 
-At this point you can try it out to see that it works by running the
-interpreter under python, but be warned, it will be *very* slow on the more
-complex examples::
+あなたが自宅で一緒にフォローしている場合、 mainloop 関数の識別子の変更と、括弧での if 文での分岐を実装する必要があります。
+
+ここに完全な例があります: `<example1.py>`_
+
+
+.. At this point you can try it out to see that it works by running the
+.. interpreter under python, but be warned, it will be *very* slow on the more
+.. complex examples
+
+ここでは Python インタプリタを実行することで動作することをあなたが見るために試すことができます。
+しかし警告気をつけてください、それはもっと複雑な例では *非常に* 遅くなります::
 
     $ python example1.py 99bottles.b
     
-You can find mandel.b and several other example programs (not written by me) in
-my repository.
-        
-PyPy Translation
+.. You can find mandel.b and several other example programs (not written by me) in
+.. my repository.
+
+私のリポジトリには mandel.b といくつかのサンプルプログラムがあります。
+
+.. PyPy Translation
+
+PyPy による変換
 ================
-But this is not about writing a BF interpreter, this is about PyPy. So what
-does it take to get PyPy to translate this into a super-fast executable?
 
-As a side note, there are some simple examples in the pypy/translator/goal
-directory of the PyPy source tree that are helpful here. My starting point for
-learning this was the example "targetnopstandalone.py", a simple hello world
-for PyPy.
+.. But this is not about writing a BF interpreter, this is about PyPy. So what
+.. does it take to get PyPy to translate this into a super-fast executable?
 
-For our example, the module must define a name called "target" which returns the
-entry point. The translation process imports your module and looks for that
-name, calls it, and the function object returned is where it starts the
-translation.
+これは BF のインタプリタを書くことについてではなく、これは PyPy について書いている。
+PyPy を超高速な実行ファイルに変換するためにはどうすればよいのでしょう?
+
+.. As a side note, there are some simple examples in the pypy/translator/goal
+.. directory of the PyPy source tree that are helpful here. My starting point for
+.. learning this was the example "targetnopstandalone.py", a simple hello world
+.. for PyPy.
+
+サイドノートとして、PyPy ソースツリーの pypy/translator/goal ディレクトリに存在する有用ないくつかの簡単な例を示します。
+学習のための例として、PyPy での単純な Hello, World の例である「targetnopstandalone.py」を出発点としました。
+
+.. For our example, the module must define a name called "target" which returns the
+.. entry point. The translation process imports your module and looks for that
+.. name, calls it, and the function object returned is where it starts the
+.. translation.
+
+この例では、モジュールはエントリポイントを返す「target」と呼ばれるオブジェクトを定義する必要があります。
+変換プロセスはこのモジュールをインポートし、「target」オブジェクトを探索し、呼び出し、そして返ってきた関数オブジェクトから変換を開始します。
 
 ::
 
     if __name__ == "__main__":
         entry_point(sys.argv)
         
-The entry_point function is passed the command line arguments when you run the
-resulting executable.
+.. The entry_point function is passed the command line arguments when you run the
+.. resulting executable.
 
-A few other things have changed here too. See the next section...
+生成された実行ファイルを実行すると、entry_point 関数にはコマンドライン引数が渡されます。
 
-About RPython
-=============
-Let's talk a bit about RPython at this point. PyPy can't translate arbitrary
-Python code because Python is a bit too dynamic. There are restrictions on what
-standard library functions and what syntax constructs one can use. I won't be
-going over all the restrictions, but for more information see
+.. A few other things have changed here too. See the next section...
+
+他のいくつかのものもここで変更されています。次のセクションを参照してください…
+
+RPython について
+================
+
+.. Let's talk a bit about RPython at this point. PyPy can't translate arbitrary
+.. Python code because Python is a bit too dynamic. There are restrictions on what
+.. standard library functions and what syntax constructs one can use. I won't be
+.. going over all the restrictions, but for more information see
+
+ここでは、 RPython について少し説明します。 PyPy は任意の Python コードを変換することはできません。
+なぜなら、 Python は少々ダイナミックであるためです。
+そこで、プログラムが使用できる標準ライブラリ関数と構文構造を制限しています。
+私は全ての制限について把握しているわけではありません。詳しい情報は下記 URL を参照してください。
 http://readthedocs.org/docs/pypy/en/latest/coding-guide.html#restricted-python
 
-In the example above, you'll see a few things have changed.  I'm now using low
-level file descriptors with os.open and os.read instead of file objects.
-The implementation of "." and "," are similarly tweaked (not shown above).
-Those are the only changes to make to this code, the rest is simple enough for
-PyPy to digest.
+.. In the example above, you'll see a few things have changed.  I'm now using low
+.. level file descriptors with os.open and os.read instead of file objects.
+.. The implementation of "." and "," are similarly tweaked (not shown above).
+.. Those are the only changes to make to this code, the rest is simple enough for
+.. PyPy to digest.
 
-That wasn't so hard, was it? I still get to use dictionaries, expandable lists,
-and even classes and objects! And if low level file descriptors are too low for
-you, there are some helpful abstractions in the rlib.streamio module included
-with PyPy's "RPython standard library."
+上記の例では、いくつかの変更が見て取れます。
+ここでは os.open と os.read を用いて低レベルファイル記述子をファイルオブジェクトの代わりに使用しています。
+(上記例では示されませんが)「.」と「,」の実装も同様に調整されています。
 
-For the example thus far, see `<example2.py>`_
+.. That wasn't so hard, was it? I still get to use dictionaries, expandable lists,
+.. and even classes and objects! And if low level file descriptors are too low for
+.. you, there are some helpful abstractions in the rlib.streamio module included
+.. with PyPy's "RPython standard library."
 
-Translating
-===========
-If you haven't already, check yourself out the latest version of PyPy from
-their bitbucket.org repository::
+これらはそれほど難しくはありませんよね? 私は辞書も拡張可能なリストもさらにクラスとオブジェクトも利用できるのです!
+低レベルファイル記述子あなたにとってが低すぎる場合は、 PyPy の「RPython 標準ライブラリ」にある rlib.streamio モジュールに便利な抽象構造が存在します。
+
+.. For the example thus far, see `<example2.py>`_
+
+ここまでの例は `<example2.py>`_ にあります。
+
+.. Translating
+
+変換
+====
+
+.. If you haven't already, check yourself out the latest version of PyPy from
+.. their bitbucket.org repository
+
+あなたがまだ最新版の PyPy を bitbucket.org のリポジトリからチェックアウトしていないならば::
 
     $ hg clone https://bitbucket.org/pypy/pypy
     
-(A recent revision is necessary because of a bugfix that makes my example
-possible)
+.. (A recent revision is necessary because a of bugfix that makes my example
+.. possible)
 
-The script to run is in "pypy/translator/goal/translate.py". Run this script,
-passing in our example module as an argument.
+(私の例を実行するために最新版でのバグフィックスが必要です)
+
+.. The script to run is in "pypy/translator/goal/translate.py". Run this script,
+.. passing in our example module as an argument.
+
+スクリプトの実行には 「pypy/translator/goal/translate.py」を使用します。
+このスクリプトにサンプルモジュールを引数として渡して実行してください。
 
 ::
 
     $ python ./pypy/pypy/translator/goal/translate.py example2.py
     
-(You can use PyPy's python interpreter for extra speed, but it's not necessary)
+.. (You can use PyPy's python interpreter for extra speed, but it's not necessary)
 
-PyPy will churn for a bit, drawing some nice looking fractals to your console
-while it works. It takes around 20 seconds on my machine.
+(必須ではありませんが、 PyPy の Python インタプリタを使用することで高速化できます)
 
-The result from this is an executable binary that interprets BF programs.
-Included in my repository are some example BF programs, including a mandelbrot
-fractal generator, which takes about 45 seconds to run on my computer. Try it
-out::
+.. PyPy will churn for a bit, drawing some nice looking fractals to your console
+.. while it works. It takes around 20 seconds on my machine.
+
+PyPy の実行にはしばし時間がかかり、実行中は素敵な見た目のフラクタルをコンソールに描きます。
+私のマシンではおおよそ 20 秒程度掛かっています。
+
+.. The result from this is an executable binary that interprets BF programs.
+.. Included in my repository are some example BF programs, including a mandelbrot
+.. fractal generator, which takes about 45 seconds to run on my computer. Try it
+.. out
+
+この結果は BF プログラムの実行可能なバイナリのインタプリタです。
+私のリポジトリにはいくつかのサンプル BF プログラムが含まれています。
+そこに含まれるマンデルブロフラクタル生成器は、私の計算機で実行すると大体 45 秒ほどかかります。
+試してみてください。
+
+::
 
     $ ./example2-c mandel.b
 
-Compare this to running the interpreter un-translated on top of python::
+.. Compare this to running the interpreter un-translated on top of python
+
+Python 上で動く未変換のインタプリタと比較してみます::
+
 
     $ python example2.py mandel.b
     
-Takes forever, doesn't it?
+.. Takes forever, doesn't it?
 
-So there you have it. We've successfully written our own interpreter in RPython
-and translated it with the PyPy toolchain.
+永遠に実行していませんか?
 
-Adding JIT
+.. So there you have it. We've successfully written our own interpreter in RPython
+.. and translated it with the PyPy toolchain.
+
+これでおわかりでしょう。
+RPython でインタプリタを書き、 PyPy ツールチェインで変換することに成功したのです。
+
+
+.. Adding JIT
+
+JIT の追加
 ==========
-Translating RPython to C is pretty cool, but one of the best features of PyPy
-is its ability to *generate just-in-time compilers for your interpreter*.
-That's right, from just a couple hints on how your interpreter is structured,
-PyPy will generate and include a JIT compiler that will, at runtime, translate
-the interpreted code of our BF language to machine code!
 
-So what do we need to tell PyPy to make this happen? First it needs to know
-where the start of your bytecode evaluation loop is. This lets it keep track of
-instructions being executed in the target language (BF).
+.. Translating RPython to C is pretty cool, but one of the best features of PyPy
+.. is its ability to *generate just-in-time compilers for your interpreter*.
+.. That's right, from just a couple hints on how your interpreter is structured,
+.. PyPy will generate and include a JIT compiler that will, at runtime, translate
+.. the interpreted code of our BF language to machine code!
 
-We also need to let it know what defines a particular execution frame. Since
-our language doesn't really have stack frames, this boils down to what's
-constant for the execution of a particular instruction, and what's not. These
-are called "green" and "red" variables, respectively.
 
-Refer back to `<example2.py>`_ for the following.
+RPython から C に変換することはとてもクールです。しかし、 PyPy の最高の機能のひとつは、 *あなたのインタプリタのために Just-in-time コンパイラを生成* できることです。
+そうです、あなたのインタプリタがどのように構成されているのか、といういくつかのヒントのみで PyPy はラインタイムにインタプリタの対象の BF 言語からマシン語に変換する JIT コンパイラを生成し、含めることが可能なのです!
 
-In our main loop, there are four variables used: pc, program, bracket_map, and
-tape. Of those, pc, program, and bracket_map are all green variables. They
-*define* the execution of a particular instruction. If the JIT routines see the
-same combination of green variables as before, it knows it's skipped back and
-must be executing a loop.  The variable "tape" is our red variable, it's what's
-being manipulated by the execution.
 
-So let's tell PyPy this info. Start by importing the JitDriver class and making
-an instance::
+.. So what do we need to tell PyPy to make this happen? First it needs to know
+.. where the start of your bytecode evaluation loop is. This lets it keep track of
+.. instructions being executed in the target language (BF).
+
+では、これを実現するために PyPy にヒントを与えるためには何をする必要があるのでしょう?
+まず、あなたのバイトコード評価ループがどこから開始するのかを知る必要があります。
+これにより対象となる言語(BF)で実行される命令を追跡できます。
+
+.. We also need to let it know what defines a particular execution frame. Since
+.. our language doesn't really have stack frames, this boils down to what's
+.. constant for the execution of a particular instruction, and what's not. These
+.. are called "green" and "red" variables, respectively.
+
+何が特定の実行フレームを定義しているかを知らせることも必要です。
+実際にはスタックフレームを持っていない私たちの言語から、結局のところどの定数が実行する特定の命令で、どれがそうではないのかをです。
+
+.. Refer back to `<example2.py>`_ for the following.
+
+以下の文章のために `<example2.py>`_ に戻って参照してください。
+
+.. In our main loop, there are four variables used: pc, program, bracket_map, and
+.. tape. Of those, pc, program, and bracket_map are all green variables. They
+.. *define* the execution of a particular instruction. If the JIT routines see the
+.. same combination of green variables as before, it knows it's skipped back and
+.. must be executing a loop.  The variable "tape" is our red variable, it's what's
+.. being manipulated by the execution.
+
+メインループでは 4 個の変数が使われています: pc, program, bracket_map, tape.
+これらのうち、 pc, program, bracket_map は全てグリーン変数です。
+それらは特定の命令を *定義* しています。
+JIT のルーチンが以前と同じグリーン変数の組み合わせを発見すると、手前に戻ってループを実行する必要があると知っています。
+「tape」変数はレッド変数で、実行によって内容が変更されます。
+
+.. So let's tell PyPy this info. Start by importing the JitDriver class and making
+.. an instance
+
+さあ、 PyPy にこの情報を伝えてみましょう。 JitDriver クラスをインポートしてインスタンスを作ることから開始します::
 
     from pypy.rlib.jit import JitDriver
     jitdriver = JitDriver(greens=['pc', 'program', 'bracket_map'],
             reds=['tape'])
     
 And we add this line to the very top of the while loop in the mainloop
-function::
+function
+
+そしてこの行 mainloop 関数のを while ループの一番上に追加します::
 
         jitdriver.jit_merge_point(pc=pc, tape=tape, program=program,
                 bracket_map=bracket_map)
                 
-We also need to define a JitPolicy. We're not doing anything fancy, so this is
-all we need somewhere in the file::
+.. We also need to define a JitPolicy. We're not doing anything fancy, so this is
+.. all we need somewhere in the file
+
+JitPolicy についてもまた定義する必要があります。
+私たちは手の込んだことをやっていません。これがファイルのどこかに書く必要のあることの全てです::
 
     def jitpolicy(driver):
         from pypy.jit.codewriter.policy import JitPolicy
         return JitPolicy()
         
-See this example at `<example3.py>`_
+.. See this example at `<example3.py>`_
+
+ここでの例は `<example3.py>`_ を参照してください
         
-Now try translating again, but with the flag ``--opt=jit``::
+.. Now try translating again, but with the flag ``--opt=jit``
+
+``--opt=jit`` オプションをつけて最変換してみます::
 
     $ python ./pypy/pypy/translator/goal/translate.py --opt=jit example3.py
 
-It will take significantly longer to translate with JIT enabled, almost 8
-minutes on my machine, and the resulting binary will be much larger. When it's
-done, try having it run the mandelbrot program again. A world of difference,
-from 12 seconds compared to 45 seconds before!
+.. It will take significantly longer to translate with JIT enabled, almost 8
+.. minutes on my machine, and the resulting binary will be much larger. When it's
+.. done, try having it run the mandelbrot program again. A world of difference,
+.. from 12 seconds compared to 45 seconds before!
 
-Interestingly enough, you can see when the JIT compiler switches from
-interpreted to machine code with the mandelbrot example. The first few lines of
-output come out pretty fast, and then the program gets a boost of speed and
-gets even faster.
+JIT を有効にすると変換に大幅に長くかかるでしょう。私のマシンでは大体 8 分かかります。
+そして出来上がるバイナリファイルはとても大きくなります。
+それが終わったらマンデルブロプログラムを再度実行してみてください。
+以前の 45 秒と 12 秒とを比べると違う世界です!
 
-A bit about Tracing JIT Compilers
-=================================
-It's worth it at this point to read up on how tracing JIT compilers work.
-Here's a brief explanation: The interpreter is usually running your interpreter
-code as written. When it detects a loop of code in the target language (BF) is
-executed often, that loop is considered "hot" and marked to be traced. The next
-time that loop is entered, the interpreter gets put in tracing mode where every
-executed instruction is logged.
+.. Interestingly enough, you can see when the JIT compiler switches from
+.. interpreted to machine code with the mandelbrot example. The first few lines of
+.. output come out pretty fast, and then the program gets a boost of speed and
+.. gets even faster.
 
-When the loop is finished, tracing stops. The trace of the loop is sent to an
-optimizer, and then to an assembler which outputs machine code. That machine
-code is then used for subsequent loop iterations.
+興味深いことに、マンデルブロの例で JIT コンパイラがインタプリタからマシンコードに切り替えるところを見られるのです。
+最初の数行はかなりはやく出力され、その後のプログラムは速度が加速され、より速くなります。
 
-This machine code is often optimized for the most common case, and depends on
-several assumptions about the code. Therefore, the machine code will contain
-guards, to validate those assumptions. If a guard check fails, the runtime
-falls back to regular interpreted mode.
+.. A bit about Tracing JIT Compilers
 
-A good place to start for more information is
+JIT コンパイラの追跡について
+============================
+
+.. It's worth it at this point to read up on how tracing JIT compilers work.
+.. Here's a brief explanation: The interpreter is usually running your interpreter
+.. code as written. When it detects a loop of code in the target language (BF) is
+.. executed often, that loop is considered "hot" and marked to be traced. The next
+.. time that loop is entered, the interpreter gets put in tracing mode where every
+.. executed instruction is logged.
+
+JIT コンパイラの動きをトレースする方法を今の時点で読むことに価値があります。
+ここで簡単な説明をします: 通常インタプリタはあなたが書いたインタプリタのコードを実行しています。
+対象言語(BF)のループを検出したとき、多くの場合は実行され、ループが「ホット」だと考えられるとトレースするようにマークされます。
+次回ループに入ると、インタプリタはトレースモードに移行し、全ての実行された命令は記録されます。
+
+.. When the loop is finished, tracing stops. The trace of the loop is sent to an
+.. optimizer, and then to an assembler which outputs machine code. That machine
+.. code is then used for subsequent loop iterations.
+
+ループが終了したときにトレースは停止します。ループをトレースした結果はオプティマイザに送られ、出力するマシンコードになります。
+マシンコードは後続のループのイテレーションに使用されます。
+
+.. This machine code is often optimized for the most common case, and depends on
+.. several assumptions about the code. Therefore, the machine code will contain
+.. guards, to validate those assumptions. If a guard check fails, the runtime
+.. falls back to regular interpreted mode.
+
+マシンコードは多く場合、最も一般的なケースで最適化され、コードはいくつかの仮定に紐付けられます。
+したがって、マシンコードにはそれらの仮定を検証するためのガードが含まれます。
+ガードのチェックに失敗した場合、ランタイムは通常のインタプリタモードにフォールバックします。
+
+.. A good place to start for more information is
+
+詳細を参照するのに以下の場所から開始するとよいでしょう
 http://en.wikipedia.org/wiki/Just-in-time_compilation
 
-Debugging and Trace Logs
-========================
-Can we do any better? How can we see what the JIT is doing? Let's do two
-things.
+.. Debugging and Trace Logs
 
-First, let's add a get_printable_location function, which is used during debug
-trace logging::
+デバッグとトレースログ
+======================
+
+.. Can we do any better? How can we see what the JIT is doing? Let's do two
+.. things.
+
+より良くすることはできますか? どうすれば JIT が行っていることを見られるのでしょう?
+二つのことをやってみましょう。
+
+.. First, let's add a get_printable_location function, which is used during debug
+.. trace logging
+
+まず、 デバッグとレースの記録をする際に使われる get_printable_location 関数を追加しましょう。
+
+::
 
     def get_location(pc, program, bracket_map):
         return "%s_%s_%s" % (
     jitdriver = JitDriver(greens=['pc', 'program', 'bracket_map'], reds=['tape'],
             get_printable_location=get_location)
             
-This function is passed in the green variables, and should return a string.
-Here, we're printing out the BF code, surrounding the currently executing
-instruction with underscores so we can see where it is.
+.. This function is passed in the green variables, and should return a string.
+.. Here, we're printing out the BF code, surrounding the currently executing
+.. instruction with underscores so we can see where it is.
 
-Download this as `<example4.py>`_ and translate it the same as example3.py.
+この関数はグリーン変数を受け取り、文字列を返します。
+ここでは、 BF のソースコードを出力します。
+現在実行中の命令の周囲にはアンダースコアをつけ、どこを実行しているかわかるようにしています。
 
-Now let's run a test program (test.b, which just prints the letter "A" 15 or so
-times in a loop) with trace logging::
+.. Download this as `<example4.py>`_ and translate it the same as example3.py.
+
+`<example4.py>`_ をダウンロードして、 example3.py と同様に変換してみてください。
+
+.. Now let's run a test program (test.b, which just prints the letter "A" 15 or so
+.. times in a loop) with trace logging
+
+さあ、ログを取りながらテストプログラムを実行してみましょう (test.b は "A" を 15 回程度ループして出力するだけのプログラムです)
+
+::
 
     $ PYPYLOG=jit-log-opt:logfile ./example4-c test.b
     
-Now take a look at the file "logfile". This file is quite hard to read, so
-here's my best shot at explaining it.
+.. Now take a look at the file "logfile". This file is quite hard to read, so
+.. here's my best shot at explaining it.
 
-The file contains a log of every trace that was performed, and is essentially a
-glimpse at what instructions it's compiling to machine code for you. It's
-useful to see if there are unnecessary instructions or room for optimization.
+今すぐ「logfile」の中を見てみましょう。このファイルはかなり読みづらいので、ここが私の説明の腕の見せどころです。
 
-Each trace starts with a line that looks like this::
+.. The file contains a log of every trace that was performed, and is essentially a
+.. glimpse at what instructions it's compiling to machine code for you. It's
+.. useful to see if there are unnecessary instructions or room for optimization.
+
+このファイルは実施したトレースごとのログを含んでいます。そして本質的にはマシンコードにコンパイルしている命令を垣間見るためのものです。
+これは最適化のための不要な命令や空間を見つけるのに有用です。
+
+Each trace starts with a line that looks like this
+
+それぞれのトレースは以下のような行から始まります::
 
     [3c091099e7a4a7] {jit-log-opt-loop
     
-and ends with a line like this::
+.. and ends with a line like this
+
+そして以下のような行で終了します::
 
     [3c091099eae17d jit-log-opt-loop}
     
-The next line tells you which loop number it is, and how many ops are in it.
-In my case, the first trace looks like this::
+.. The next line tells you which loop number it is, and how many ops are in it.
+.. In my case, the first trace looks like this
 
+次の行はループ番号がどれであるかを示し、オペレーションがいくつその中にあるかを表示しています。
+このケースでは、最初のトレースはこのようになっています::
 
     1  [3c167c92b9118f] {jit-log-opt-loop
     2  # Loop 0 : loop with 26 ops
     29 jump(p0, p1, i2, i3, descr=<Loop0>)
     30 [3c167c92bc6a15] jit-log-opt-loop}
 
-I've trimmed the debug_merge_point lines a bit, they were really long.
+.. I've trimmed the debug_merge_point lines a bit, they were really long.
 
-So let's see what this does. This trace takes 4 parameters: 2 object pointers
-(p0 and p1) and 2 integers (i2 and i3). Looking at the debug lines, it seems to
-be tracing one iteration of this loop: "[>+<-]"
+とても長かったので debug_merge_point と表示されている行を少し取り除きました。
 
-It starts executing the first operation on line 4, a ">", but immediately
-starts executing the next operation. The ">" had no instructions, and looks
-like it was optimized out completely.  This loop must always act on the same
-part of the tape, the tape pointer is constant for this trace. An explicit
-advance operation is unnecessary.
+.. So let's see what this does. This trace takes 4 parameters: 2 object pointers
+.. (p0 and p1) and 2 integers (i2 and i3). Looking at the debug lines, it seems to
+.. be tracing one iteration of this loop: "[>+<-]"
 
-Lines 5 to 8 are the instructions for the "+" operation. First it gets the
-array item from the array in pointer p1 at index i2 (line 6), adds 1 to it and
-stores it in i6 (line 7), and stores it back in the array (line 8).
+では、これが何をしているかを見てみましょう。
+このトレースは四つのパラメータを受け取ります: 二つのオブジェクトのポインタ (p0 と p1) と二つの整数 (i2 と i3) です。
+デバッグ行を見ると、これはこのループのとある反復をトレースしているようです: "[>+<-]"
 
-Line 9 starts the "<" instruction, but it is another no-op. It seems that i2
-and i3 passed into this routine are the two tape pointers used in this loop
-already calculated. Also deduced is that p1 is the tape array. It's not clear
-what p0 is.
+.. It starts executing the first operation on line 4, a ">", but immediately
+.. starts executing the next operation. The ">" had no instructions, and looks
+.. like it was optimized out completely.  This loop must always act on the same
+.. part of the tape, the tape pointer is constant for this trace. An explicit
+.. advance operation is unnecessary.
 
-Lines 10 through 13 perform the "-" operation: get the array value (line 11),
-subtract (line 12) and set the array value (line 13).
+四行目の最初のオペレーション ">" の実行を開始していますが、直後に次のオペレーションを実行開始しています。
+">" は何も実行せず、完全に最適化されているように見えます。
+このループは常にテープの同じ部分に作用する必要があり、テープポインタはこのトレースでは変化しません。
+明示的な事前の操作は不要です。
 
-Next, on line 14, we come to the "]" operation. Lines 15 and 16 check whether
-i9 is true (non-zero). Looking up, i9 is the array value that we just
-decremented and stored, now being checked as the loop condition, as expected
-(remember the definition of "]").  Line 16 is a guard, if the condition is not
-met, execution jumps somewhere else, in this case to the routine called
-<Guard2> and is passed one parameter: p0.
+.. Lines 5 to 8 are the instructions for the "+" operation. First it gets the
+.. array item from the array in pointer p1 at index i2 (line 6), adds 1 to it and
+.. stores it in i6 (line 7), and stores it back in the array (line 8).
 
-Assuming we pass the guard, lines 17 through 23 are doing the dictionary lookup
-to bracket_map to find where the program counter should jump to.  I'm not too
-familiar with what the instructions are actually doing, but it looks like there
-are two external calls and 3 guards. This seems quite expensive, especially
-since we know bracket_map will never change (PyPy doesn't know that).  We'll
-see below how to optimize this.
+五行目から八行目は "+" オペレーションの命令です。
+まず、ポインタ p1 にある配列の i2 番目の要素を取得します。
+その値に 1 を加算して i6 にストアし (七行目)、それを配列に戻します(八行目)。
 
-Line 24 increments the newly acquired instruction pointer. Lines 25 and 26 make
-sure it's less than the program's length.
+.. Line 9 starts the "<" instruction, but it is another no-op. It seems that i2
+.. and i3 passed into this routine are the two tape pointers used in this loop
+.. already calculated. Also deduced is that p1 is the tape array. It's not clear
+.. what p0 is.
 
-Additionally, line 27 guards that i21, the incremented instruction pointer, is
-exactly 86. This is because it's about to jump to the beginning (line 29) and
-the instruction pointer being 86 is a precondition to this block.
+九行目は "<" 命令を開始しますが、これもなにもしません。
+このルーチンに渡された i2 と i3 は、事前に計算されたこのループで使われる二つのテープポインタであるようです。
+おそらく p1 はテープの配列でしょう。 p0 が何であるかははっきりしていません。
 
-Finally, the loop closes up at line 28 so the JIT can jump to loop body <Loop0>
-to handle that case (line 29), which is the beginning of the loop again. It
-passes in parameters (p0, p1, i2, i3).
+.. Lines 10 through 13 perform the "-" operation: get the array value (line 11),
+.. subtract (line 12) and set the array value (line 13).
 
-Optimizing
-==========
-As mentioned, every loop iteration does a dictionary lookup to find the
-corresponding matching bracket for the final jump. This is terribly
-inefficient, the jump target is not going to change from one loop to the next.
-This information is constant and should be compiled in as such.
+10行目から13行目は "-" オペレーションの実行です: 配列の値を取得(11行目), 減算(12行目)そして配列への値の設定です(13行目)。
 
-The problem is that the lookups are coming from a dictionary, and PyPy is
-treating it as opaque. It doesn't know the dictionary isn't being modified or
-isn't going to return something different on each query.
+.. Next, on line 14, we come to the "]" operation. Lines 15 and 16 check whether
+.. i9 is true (non-zero). Looking up, i9 is the array value that we just
+.. decremented and stored, now being checked as the loop condition, as expected
+.. (remember the definition of "]").  Line 16 is a guard, if the condition is not
+.. met, execution jumps somewhere else, in this case to the routine called
+.. <Guard2> and is passed one parameter: p0.
+
+次の14行目では、 "]" オペレーションに到達します。
+15行目と16行目では i9 が true (非ゼロ) かどうかをチェックしています。
+上の行を見てみると、i9 はデクリメントしてストアされた配列の値で、期待通りループの継続条件としてチェックされています ("]" の定義を思い出してください)。
+
+.. Assuming we pass the guard, lines 17 through 23 are doing the dictionary lookup
+.. to bracket_map to find where the program counter should jump to.  I'm not too
+.. familiar with what the instructions are actually doing, but it looks like there
+.. are two external calls and 3 guards. This seems quite expensive, especially
+.. since we know bracket_map will never change (PyPy doesn't know that).  We'll
+.. see below how to optimize this.
+
+ガードをパスしたと仮定すると、17行目から23行目は bracket_map の辞書検索を行い、プログラムカウンタのジャンプ先を探しています。
+私はどの命令が実際に実行されるかを読み解くのにあまり慣れていませんが、二つの外部呼び出しと3つのガードがあるように見えます。
+これらは特に、bracket_map が変更されないと分かっている場合はとても重い処理に見えます (PyPy はそれを知りません)。
+これを最適化する方法を以下に示します。
+
+.. Line 24 increments the newly acquired instruction pointer. Lines 25 and 26 make
+.. sure it's less than the program's length.
+
+24行目は次に獲得する命令のポインタをインクリメントしています。
+25行目と26行目はプログラムの長さよりも短いかどうかを確認しています。
+
+.. Additionally, line 27 guards that i21, the incremented instruction pointer, is
+.. exactly 86. This is because it's about to jump to the beginning (line 29) and
+.. the instruction pointer being 86 is a precondition to this block.
+
+さらに 27行目は命令ポインタをインクリメントした値である i21 が実際に 86 であるかのガードを実行しています。
+これは、最初にジャンプする(29行目)ための前提条件が、命令ポインタの値が 86 であることである為です。
+
+.. Finally, the loop closes up at line 28 so the JIT can jump to loop body <Loop0>
+.. to handle that case (line 29), which is the beginning of the loop again. It
+.. passes in parameters (p0, p1, i2, i3).
+
+最後に、ループが閉じる 28行目で再度ループを開始するようなケースを処理するために JIT はループ本体 <Loop0> にジャンプできます(29行目)。
+
+.. Optimizing
+
+最適化
+======
+
+.. As mentioned, every loop iteration does a dictionary lookup to find the
+.. corresponding matching bracket for the final jump. This is terribly
+.. inefficient, the jump target is not going to change from one loop to the next.
+.. This information is constant and should be compiled in as such.
+
+述べたように、ループの反復ごとに最後のジャンプで対応する括弧を見つけるために辞書検索を行っています。
+ジャンプのターゲットは次のひとつのループの中で変更されることはないため、これはとても非効率的です。
+情報は定数であり、そのようにコンパイルする必要があります。
+
+.. The problem is that the lookups are coming from a dictionary, and PyPy is
+.. treating it as opaque. It doesn't know the dictionary isn't being modified or
+.. isn't going to return something different on each query.
+
+問題となっているのは辞書からのルックアップで、 PyPy はそれそのままを扱っています。
+辞書が変更されないことかクエリごとに別の値を返さないことを知らないためです。
 
 What we need to do is provide another hint to the translation to say that the
 dictionary query is a pure function, that is, its output depends *only* on its
 inputs and the same inputs should always return the same output.
 
-To do this, we use a provided function decorator pypy.rlib.jit.purefunction,
-and wrap the dictionary call in a decorated function::
+私たちがしなければならないのは、変換のために辞書へのクエリが純粋関数であるということを、別のヒントとして提供することです。
+それは、出力が入力の値に *のみ* 依存し、同じ入力からは同じ出力が得られるということです。
+
+.. To do this, we use a provided function decorator pypy.rlib.jit.purefunction,
+.. and wrap the dictionary call in a decorated function
+
+pypy.rlib.jit.purefunction で提供されているデコレータ関数を使用し、辞書呼び出しの関数をラップしてください::
 
     @purefunction
     def get_matching_bracket(bracket_map, pc):
         return bracket_map[pc]
         
-This version can be found at `<example5.py>`_
+.. This version can be found at `<example5.py>`_
+
+このバージョンは `<example5.py>`_ です。
 
 Translate again with the JIT option and observe the speedup. Mandelbrot now
 only takes 6 seconds!  (from 12 seconds before this optimization)
 
-Let's take a look at the trace from the same function::
+JIT オプションとともに再度変換し、高速化されていることを確認してください。
+マンデルブロの実行は今では 6秒しかかかりません! (最適化前は 12 秒でした)
+
+Let's take a look at the trace from the same function
+さあ、同じ関数のトレースを見てみましょう::
 
     [3c29fad7b792b0] {jit-log-opt-loop
     # Loop 0 : loop with 15 ops
     jump(p0, p1, i2, i3, descr=<Loop0>)
     [3c29fad7ba32ec] jit-log-opt-loop}
     
-Much better! Each loop iteration is an add, a subtract, two array loads, two
-array stores, and a guard on the exit condition. That's it! This code doesn't
-require *any* program counter manipulation.
+.. Much better! Each loop iteration is an add, a subtract, two array loads, two
+.. array stores, and a guard on the exit condition. That's it! This code doesn't
+.. require *any* program counter manipulation.
 
-I'm no expert on optimizations, this tip was suggested by Armin Rigo on the
-pypy-dev list. Carl Friedrich has a series of posts on how to optimize your
-interpreter that are also very useful: http://bit.ly/bundles/cfbolz/1
+とても良いです! ループの反復ごとに減算、二つの配列の読み込み、二つの配列のストア、そして終了条件のガードが追加されています。
+これです! このコードは *どんな* プログラムカウンタの操作も必要ありません。
 
-Final Words
-===========
-I hope this has shown some of you what PyPy is all about other than a faster
-implementation of Python.
+.. I'm no expert on optimizations, this tip was suggested by Armin Rigo on the
+.. pypy-dev list. Carl Friedrich has a series of posts on how to optimize your
+.. interpreter that are also very useful: http://bit.ly/bundles/cfbolz/1
+
+私は最適化のエキスパートではありません。このヒントは pypy-dev mailing list でArmin Ring に提案されたものです。
+Carl Friedrich はあなたのインタプリタを最適化する際に役立つ一連の記事を書いています: http://bit.ly/bundles/cfbolz/1
+
+.. Final Words
+
+最後に
+======
+
+.. I hope this has shown some of you what PyPy is all about other than a faster
+.. implementation of Python.
+
+PyPy が他の全てより速い Python の実装であることを示せたと思っています。
 
 For those that would like to know more about how the process works, there are
 several academic papers explaining the process in detail that I recommend. In
 particular: Tracing the Meta-Level: PyPy's Tracing JIT Compiler.
 
-See http://readthedocs.org/docs/pypy/en/latest/extradoc.html
+処理の仕組みについてもっと知りたい人のために、私が推奨する詳細なプロセスを説明するいくつかの学術論文があります。
+特に: Tracing the Meta-Level: PyPy's Tracing JIT Compiler.
+
+これを見てください http://readthedocs.org/docs/pypy/en/latest/extradoc.html