memory.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 1990-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
msgid ""
msgstr ""
"Project-Id-Version: Python 2.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 01:01+0900\n"
"PO-Revision-Date: 2019-09-01 05:18+0000\n"
"Last-Translator: tomo\n"
"Language-Team: Japanese (http://www.transifex.com/python-doc/python-27/"
"language/ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../c-api/memory.rst:8
msgid "Memory Management"
msgstr "メモリ管理"

#: ../../c-api/memory.rst:17
msgid "Overview"
msgstr "概要"

#: ../../c-api/memory.rst:19
msgid ""
"Memory management in Python involves a private heap containing all Python "
"objects and data structures. The management of this private heap is ensured "
"internally by the *Python memory manager*.  The Python memory manager has "
"different components which deal with various dynamic storage management "
"aspects, like sharing, segmentation, preallocation or caching."
msgstr ""
"Python におけるメモリ管理には、全ての Python オブジェクトとデータ構造が入った"
"プライベートヒープ (private heap) が必須です。プライベートヒープの管理は、内"
"部的には *Python メモリマネージャ (Python memory manager)* が確実に行います。"
"Python メモリマネージャには、共有 (sharing)、セグメント分割 (segmentation)、"
"事前割り当て (preallocation)、キャッシュ化 (caching) といった、様々な動的記憶"
"管理の側面を扱うために、個別のコンポーネントがあります。"

#: ../../c-api/memory.rst:25
msgid ""
"At the lowest level, a raw memory allocator ensures that there is enough "
"room in the private heap for storing all Python-related data by interacting "
"with the memory manager of the operating system. On top of the raw memory "
"allocator, several object-specific allocators operate on the same heap and "
"implement distinct memory management policies adapted to the peculiarities "
"of every object type. For example, integer objects are managed differently "
"within the heap than strings, tuples or dictionaries because integers imply "
"different storage requirements and speed/space tradeoffs. The Python memory "
"manager thus delegates some of the work to the object-specific allocators, "
"but ensures that the latter operate within the bounds of the private heap."
msgstr ""
"最低水準層では、素のメモリ操作関数 (raw memory allocator) がオペレーティング"
"システムのメモリ管理機構とやりとりして、プライベートヒープ内にPython 関連の全"
"てのデータを記憶するのに十分な空きがあるかどうか確認します。素のメモリ操作関"
"数の上には、いくつかのオブジェクト固有のメモリ操作関数があります。これらは同"
"じヒープを操作し、各オブジェクト型固有の事情に合ったメモリ管理ポリシを実装し"
"ています。例えば、整数オブジェクトは文字列やタプル、辞書とは違ったやり方で"
"ヒープ内で管理されます。というのも、整数には値を記憶する上で特別な要件があ"
"り、速度/容量のトレードオフが存在するからです。このように、Python メモリマネ"
"ジャは作業のいくつかをオブジェクト固有のメモリ操作関数に委譲しますが、これら"
"の関数がプライベートヒープからはみ出してメモリ管理を行わないようにしていま"
"す。"

#: ../../c-api/memory.rst:36
msgid ""
"It is important to understand that the management of the Python heap is "
"performed by the interpreter itself and that the user has no control over "
"it, even if they regularly manipulate object pointers to memory blocks "
"inside that heap.  The allocation of heap space for Python objects and other "
"internal buffers is performed on demand by the Python memory manager through "
"the Python/C API functions listed in this document."
msgstr ""
"重要なのは、たとえユーザがいつもヒープ内のメモリブロックを指すようなオブジェ"
"クトポインタを操作しているとしても、Python 用ヒープの管理はインタプリタ自体が"
"行うもので、ユーザがそれを制御する余地はないと理解することです。Python オブ"
"ジェクトや内部使用されるバッファを入れるためのヒープ空間のメモリ確保は、必要"
"に応じて、Python メモリマネージャがこのドキュメント内で列挙しているPython/C "
"API 関数群を介して行います。"

#: ../../c-api/memory.rst:49
msgid ""
"To avoid memory corruption, extension writers should never try to operate on "
"Python objects with the functions exported by the C library: :c:func:"
"`malloc`, :c:func:`calloc`, :c:func:`realloc` and :c:func:`free`.  This will "
"result in  mixed calls between the C allocator and the Python memory manager "
"with fatal consequences, because they implement different algorithms and "
"operate on different heaps.  However, one may safely allocate and release "
"memory blocks with the C library allocator for individual purposes, as shown "
"in the following example::"
msgstr ""
"メモリ管理の崩壊を避けるため、拡張モジュールの作者は決して Python  オブジェク"
"トを C ライブラリが公開している関数: :c:func:`malloc` 、 :c:func:"
"`calloc` 、 :c:func:`realloc` および :c:func:`free` で操作しようとしてはなり"
"ません。こうした関数を使うと、C のメモリ操作関数と Python メモリマネージャと"
"の間で関数呼び出しが交錯します。 C のメモリ操作関数とPython メモリマネージャ"
"は異なるアルゴリズムで実装されていて、異なるヒープを操作するため、呼び出しの"
"交錯は致命的な結果を招きます。とはいえ、個別の目的のためなら、 C ライブラリの"
"メモリ操作関数を使って安全にメモリを確保したり解放したりできます。例えば、以"
"下がそのような例です::"

#: ../../c-api/memory.rst:68
msgid ""
"In this example, the memory request for the I/O buffer is handled by the C "
"library allocator. The Python memory manager is involved only in the "
"allocation of the string object returned as a result."
msgstr ""
"この例では、I/O バッファに対するメモリ要求は C ライブラリのメモリ操作関数を"
"使っています。Python メモリマネジャは戻り値として返される文字列オブジェクトを"
"確保する時にだけ必要です。"

#: ../../c-api/memory.rst:72
msgid ""
"In most situations, however, it is recommended to allocate memory from the "
"Python heap specifically because the latter is under control of the Python "
"memory manager. For example, this is required when the interpreter is "
"extended with new object types written in C. Another reason for using the "
"Python heap is the desire to *inform* the Python memory manager about the "
"memory needs of the extension module. Even when the requested memory is used "
"exclusively for internal, highly-specific purposes, delegating all memory "
"requests to the Python memory manager causes the interpreter to have a more "
"accurate image of its memory footprint as a whole. Consequently, under "
"certain circumstances, the Python memory manager may or may not trigger "
"appropriate actions, like garbage collection, memory compaction or other "
"preventive procedures. Note that by using the C library allocator as shown "
"in the previous example, the allocated memory for the I/O buffer escapes "
"completely the Python memory manager."
msgstr ""
"とはいえ、ほとんどの状況では、メモリの操作は Python ヒープに固定して行うよう"
"勧めます。なぜなら、Python ヒープは Python メモリマネジャの管理下にあるからで"
"す。例えば、インタプリタを C で書かれた新たなオブジェクト型で拡張する際には、"
"ヒープでのメモリ管理が必要です。Python ヒープを使った方がよいもう一つの理由と"
"して、拡張モジュールが必要としているメモリについて Python メモリマネージャに "
"*情報を提供* してほしいということがあります。たとえ必要なメモリが内部的かつ非"
"常に特化した用途に対して排他的に用いられるものだとしても、全てのメモリ操作要"
"求を Python メモリマネージャに委譲すれば、インタプリタはより正確なメモリフッ"
"トプリント (memory footprint) の全体像を把握できます。その結果、特定の状況で"
"は、Python メモリマネージャがガベージコレクションやメモリのコンパクト化、その"
"他何らかの予防措置といった、適切な動作をトリガできることがあります。上の例で"
"示したように C ライブラリのメモリ操作関数を使うと、I/O バッファ用に確保したメ"
"モリは Python メモリマネージャの管理から完全に外れることに注意してください。"

#: ../../c-api/memory.rst:90
msgid "Memory Interface"
msgstr "メモリインタフェース"

#: ../../c-api/memory.rst:92
msgid ""
"The following function sets, modeled after the ANSI C standard, but "
"specifying behavior when requesting zero bytes, are available for allocating "
"and releasing memory from the Python heap:"
msgstr ""
"Python ヒープに対してメモリを確保したり解放したりするために、以下の関数セット"
"が利用できます。これらの関数は ANSI C 標準に従ってモデル化されていますが、0 "
"バイトの領域を要求した際の動作についても定義しています:"

#: ../../c-api/memory.rst:99
msgid ""
"Allocates *n* bytes and returns a pointer of type :c:type:`void\\*` to the "
"allocated memory, or *NULL* if the request fails. Requesting zero bytes "
"returns a distinct non-*NULL* pointer if possible, as if ``PyMem_Malloc(1)`` "
"had been called instead. The memory will not have been initialized in any "
"way."
msgstr ""
"*n* バイトをメモリ確保し、確保されたメモリを指す :c:type:`void\\*`  型のポイ"
"ンタを返します。確保要求に失敗した場合には *NULL* を 返します。 0 バイトをリ"
"クエストすると、可能ならば独立した非 *NULL* のポインタを返します。このポイン"
"タは ``PyMem_Malloc(1)`` を代わりに呼んだときのようなメモリ領域を指していま"
"す。確保されたメモリ領域はいかなる初期化も行われていません。"

#: ../../c-api/memory.rst:107
msgid ""
"Resizes the memory block pointed to by *p* to *n* bytes. The contents will "
"be unchanged to the minimum of the old and the new sizes. If *p* is *NULL*, "
"the call is equivalent to ``PyMem_Malloc(n)``; else if *n* is equal to zero, "
"the memory block is resized but is not freed, and the returned pointer is "
"non-*NULL*.  Unless *p* is *NULL*, it must have been returned by a previous "
"call to :c:func:`PyMem_Malloc` or :c:func:`PyMem_Realloc`. If the request "
"fails, :c:func:`PyMem_Realloc` returns *NULL* and *p* remains a valid "
"pointer to the previous memory area."
msgstr ""
"*p* が指しているメモリブロックを *n* バイトにサイズ変更します。メモリの内容の"
"うち、新旧のサイズのうち小さい方までの領域は変更されません。 *p* が *NULL* な"
"らば、この関数は ``PyMem_Malloc(n)`` と等価になります; *p* が *NULL* ではな"
"く *n* がゼロに等しい場合は、メモリブロックはサイズ変更されますが、解放はされ"
"ず、非 *NULL* のポインタを返します。 *p* の値が *NULL* でないならば、それは以"
"前呼び出した :c:func:`PyMem_Malloc` や :c:func:`PyMem_Realloc` の返した値でな"
"ければなりません。メモリ要求が失敗した場合は、 :c:func:`PyMem_Realloc` は "
"*NULL* を返し、 *p* は以前のメモリ領域への正しいポインタのままとなります。"

#: ../../c-api/memory.rst:119
msgid ""
"Frees the memory block pointed to by *p*, which must have been returned by a "
"previous call to :c:func:`PyMem_Malloc` or :c:func:`PyMem_Realloc`.  "
"Otherwise, or if ``PyMem_Free(p)`` has been called before, undefined "
"behavior occurs. If *p* is *NULL*, no operation is performed."
msgstr ""
"*p* が指すメモリブロックを解放します。 *p* は以前呼び出した :c:func:"
"`PyMem_Malloc` や :c:func:`PyMem_Realloc` の返した値でなければなりません。そ"
"れ以外の場合や、 ``PyMem_Free(p)`` を 呼び出した後だった場合、未定義の動作に"
"なります。 *p* が *NULL* なら、何も行いません。"

#: ../../c-api/memory.rst:124
msgid ""
"The following type-oriented macros are provided for convenience.  Note  that "
"*TYPE* refers to any C type."
msgstr ""
"以下に挙げる型対象のマクロは利便性のために提供されているものです。*TYPE* は任"
"意の C の型を表します。"

#: ../../c-api/memory.rst:130
msgid ""
"Same as :c:func:`PyMem_Malloc`, but allocates ``(n * sizeof(TYPE))`` bytes "
"of memory.  Returns a pointer cast to :c:type:`TYPE\\*`.  The memory will "
"not have been initialized in any way."
msgstr ""
":c:func:`PyMem_Malloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトのメモリを"
"確保します。 :c:type:`TYPE\\*` に型キャストされたポインタを返します。メモリに"
"は何の初期化も行われていません。"

#: ../../c-api/memory.rst:137
msgid ""
"Same as :c:func:`PyMem_Realloc`, but the memory block is resized to ``(n * "
"sizeof(TYPE))`` bytes.  Returns a pointer cast to :c:type:`TYPE\\*`. On "
"return, *p* will be a pointer to the new memory area, or *NULL* in the event "
"of failure.  This is a C preprocessor macro; p is always reassigned.  Save "
"the original value of p to avoid losing memory when handling errors."
msgstr ""
":c:func:`PyMem_Realloc` と同じですが、 ``(n * sizeof(TYPE))`` バイトにサイズ"
"変更されたメモリを確保します。 :c:type:`TYPE\\*` に型キャストされたポインタを"
"返します。関数が終わったとき、 *p* は新しいメモリ領域のポインタか、失敗した場"
"合は *NULL* になります。これは C プリプロセッサのマクロで、 p は常に上書きさ"
"れます。エラーを処理するときにメモリを失う事を避けるには、 p の元の値を保存し"
"ておいてください。"

#: ../../c-api/memory.rst:146
msgid "Same as :c:func:`PyMem_Free`."
msgstr ":c:func:`PyMem_Free` と同じです。"

#: ../../c-api/memory.rst:148
msgid ""
"In addition, the following macro sets are provided for calling the Python "
"memory allocator directly, without involving the C API functions listed "
"above. However, note that their use does not preserve binary compatibility "
"across Python versions and is therefore deprecated in extension modules."
msgstr ""
"上記に加えて、C API 関数を介することなく Python メモリ操作関数を直接呼び出す"
"ための以下のマクロセットが提供されています。ただし、これらのマクロは Python "
"バージョン間でのバイナリ互換性を保てず、それゆえに拡張モジュールでは撤廃され"
"ているので注意してください。"

#: ../../c-api/memory.rst:153
msgid ":c:func:`PyMem_MALLOC`, :c:func:`PyMem_REALLOC`, :c:func:`PyMem_FREE`."
msgstr ""
":c:func:`PyMem_MALLOC` 、 :c:func:`PyMem_REALLOC` 、 :c:func:`PyMem_FREE` 。"

#: ../../c-api/memory.rst:155
msgid ":c:func:`PyMem_NEW`, :c:func:`PyMem_RESIZE`, :c:func:`PyMem_DEL`."
msgstr ""
":c:func:`PyMem_NEW` 、 :c:func:`PyMem_RESIZE` 、 :c:func:`PyMem_DEL` 。"

#: ../../c-api/memory.rst:159
msgid "Object allocators"
msgstr ""

#: ../../c-api/memory.rst:161
msgid ""
"The following function sets, modeled after the ANSI C standard, but "
"specifying behavior when requesting zero bytes, are available for allocating "
"and releasing memory from the Python heap."
msgstr ""
"以下の関数群が利用して Python ヒープに対してメモリを確保したり解放したり出来"
"ます。これらの関数は ANSI C 標準に従ってモデル化されていますが、0 バイトを要"
"求した際の動作についても定義しています:"

#: ../../c-api/memory.rst:165
msgid ""
"By default, these functions use :ref:`pymalloc memory allocator <pymalloc>`."
msgstr ""
"デフォルトではこれらの関数は :ref:`pymalloc メモリアロケータ <pymalloc>` を利"
"用します。"

#: ../../c-api/memory.rst:169
msgid ""
"The :term:`GIL <global interpreter lock>` must be held when using these "
"functions."
msgstr ""
"これらの関数を呼ぶときには、 :term:`GIL <global interpreter lock>` を保持して"
"おく必要があります。"

#: ../../c-api/memory.rst:174
msgid ""
"Allocates *n* bytes and returns a pointer of type :c:type:`void\\*` to the "
"allocated memory, or *NULL* if the request fails."
msgstr ""
"*n* バイトを割り当て、そのメモリを指す :c:type:`void\\*` 型のポインタを返しま"
"す。要求が失敗した場合 *NULL* を返します。"

#: ../../c-api/memory.rst:177
msgid ""
"Requesting zero bytes returns a distinct non-*NULL* pointer if possible, as "
"if ``PyObject_Malloc(1)`` had been called instead. The memory will not have "
"been initialized in any way."
msgstr ""

#: ../../c-api/memory.rst:184
msgid ""
"Resizes the memory block pointed to by *p* to *n* bytes. The contents will "
"be unchanged to the minimum of the old and the new sizes."
msgstr ""
"*p* が指すメモリブロックを *n* バイトにリサイズします。古いサイズと新しいサイ"
"ズの小さい方までの内容は変更されません。"

#: ../../c-api/memory.rst:187
msgid ""
"If *p* is *NULL*, the call is equivalent to ``PyObject_Malloc(n)``; else if "
"*n* is equal to zero, the memory block is resized but is not freed, and the "
"returned pointer is non-*NULL*."
msgstr ""

#: ../../c-api/memory.rst:191
msgid ""
"Unless *p* is *NULL*, it must have been returned by a previous call to :c:"
"func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or :c:func:"
"`PyObject_Calloc`."
msgstr ""

#: ../../c-api/memory.rst:194
msgid ""
"If the request fails, :c:func:`PyObject_Realloc` returns *NULL* and *p* "
"remains a valid pointer to the previous memory area."
msgstr ""

#: ../../c-api/memory.rst:200
msgid ""
"Frees the memory block pointed to by *p*, which must have been returned by a "
"previous call to :c:func:`PyObject_Malloc`, :c:func:`PyObject_Realloc` or :c:"
"func:`PyObject_Calloc`.  Otherwise, or if ``PyObject_Free(p)`` has been "
"called before, undefined behavior occurs."
msgstr ""

#: ../../c-api/memory.rst:205
msgid "If *p* is *NULL*, no operation is performed."
msgstr "*p* が *NULL* の場合何もしません。"

#: ../../c-api/memory.rst:208
msgid "In addition, the following macro sets are provided:"
msgstr ""

#: ../../c-api/memory.rst:210
msgid ":c:func:`PyObject_MALLOC`: alias to :c:func:`PyObject_Malloc`"
msgstr ""

#: ../../c-api/memory.rst:211
msgid ":c:func:`PyObject_REALLOC`: alias to :c:func:`PyObject_Realloc`"
msgstr ""

#: ../../c-api/memory.rst:212
msgid ":c:func:`PyObject_FREE`: alias to :c:func:`PyObject_Free`"
msgstr ""

#: ../../c-api/memory.rst:213
msgid ":c:func:`PyObject_Del`: alias to :c:func:`PyObject_Free`"
msgstr ""

#: ../../c-api/memory.rst:214
msgid ""
":c:func:`PyObject_DEL`: alias to :c:func:`PyObject_FREE` (so finally an "
"alias to :c:func:`PyObject_Free`)"
msgstr ""

#: ../../c-api/memory.rst:221
msgid "The pymalloc allocator"
msgstr "pymalloc アロケータ"

#: ../../c-api/memory.rst:223
msgid ""
"Python has a *pymalloc* allocator optimized for small objects (smaller or "
"equal to 512 bytes) with a short lifetime. It uses memory mappings called "
"\"arenas\" with a fixed size of 256 KiB. It falls back to :c:func:`malloc` "
"and :c:func:`realloc` for allocations larger than 512 bytes."
msgstr ""

#: ../../c-api/memory.rst:228
msgid "*pymalloc* is the default allocator of :c:func:`PyObject_Malloc`."
msgstr ""

#: ../../c-api/memory.rst:230
msgid "The arena allocator uses the following functions:"
msgstr "アリーナアロケータは、次の関数を使います:"

#: ../../c-api/memory.rst:232
msgid ":c:func:`mmap` and :c:func:`munmap` if available,"
msgstr "利用できる場合、:c:func:`mmap` と :c:func:`munmap`、"

#: ../../c-api/memory.rst:233
msgid ":c:func:`malloc` and :c:func:`free` otherwise."
msgstr "それ以外の場合は :c:func:`malloc` と :c:func:`free`。"

#: ../../c-api/memory.rst:235
msgid ""
"The threshold changed from 256 to 512 bytes. The arena allocator now uses :c:"
"func:`mmap` if available."
msgstr ""

#: ../../c-api/memory.rst:243
msgid "Examples"
msgstr "例"

#: ../../c-api/memory.rst:245
msgid ""
"Here is the example from section :ref:`memoryoverview`, rewritten so that "
"the I/O buffer is allocated from the Python heap by using the first function "
"set::"
msgstr ""
"最初に述べた関数セットを使って、 :ref:`memoryoverview` 節の例を Python ヒープ"
"に I/O バッファをメモリ確保するように書き換えたものを以下に示します::"

#: ../../c-api/memory.rst:258
msgid "The same code using the type-oriented function set::"
msgstr "同じコードを型対象の関数セットで書いたものを以下に示します::"

#: ../../c-api/memory.rst:270
msgid ""
"Note that in the two examples above, the buffer is always manipulated via "
"functions belonging to the same set. Indeed, it is required to use the same "
"memory API family for a given memory block, so that the risk of mixing "
"different allocators is reduced to a minimum. The following code sequence "
"contains two errors, one of which is labeled as *fatal* because it mixes two "
"different allocators operating on different heaps. ::"
msgstr ""
"上の二つの例では、バッファを常に同じ関数セットに属する関数で操作していること"
"に注意してください。実際、あるメモリブロックに対する操作は、異なるメモリ操作"
"機構を混用する危険を減らすために、同じメモリ API ファミリを使って行うことが必"
"要です。以下のコードには二つのエラーがあり、そのうちの一つには異なるヒープを"
"操作する別のメモリ操作関数を混用しているので *致命的 (Fatal)* とラベルづけを"
"しています。 ::"

#: ../../c-api/memory.rst:285
msgid ""
"In addition to the functions aimed at handling raw memory blocks from the "
"Python heap, objects in Python are allocated and released with :c:func:"
"`PyObject_New`, :c:func:`PyObject_NewVar` and :c:func:`PyObject_Del`."
msgstr ""
"素のメモリブロックを Python ヒープ上で操作する関数に加え、 :c:func:"
"`PyObject_New` 、 :c:func:`PyObject_NewVar` 、および :c:func:`PyObject_Del` "
"を使うと、 Python におけるオブジェクトをメモリ確保したり解放したりできます。"

#: ../../c-api/memory.rst:289
msgid ""
"These will be explained in the next chapter on defining and implementing new "
"object types in C."
msgstr ""
"これらの関数については、次章の C による新しいオブジェクト型の定義や実装に関す"
"る記述の中で説明します。"