PEP 659: Specializing Adaptive Interpreter #1957

markshannon · 2021-05-11T12:33:38Z

No description provided.

JelleZijlstra

Added some wording suggestions.

JelleZijlstra · 2021-05-11T12:50:16Z

pep-0659.rst

+==========
+
+Python is widely acknowledged as slow.
+Whilst Python will never attain the performance of low-level langauges like C, Fortran, or even Java,


Suggested change

Whilst Python will never attain the performance of low-level langauges like C, Fortran, or even Java,

Whilst Python will never attain the performance of low-level languages like C, Fortran, or even Java,

JelleZijlstra · 2021-05-11T12:51:54Z

pep-0659.rst

+There have been several ways of doing this proposed in the academic literature,
+but most attempt to optimize regions larger than a single bytecode [1]_ [2]_.
+Using larger regions than a single instruction, requires code to handle deoptimization in the middle of a region.
+Specialization at the level on individual bytecodes makes deoptimization trivial, as it cannot occur in the middle of a region.


Suggested change

Specialization at the level on individual bytecodes makes deoptimization trivial, as it cannot occur in the middle of a region.

Specialization at the level of individual bytecodes makes deoptimization trivial, as it cannot occur in the middle of a region.

JelleZijlstra · 2021-05-11T12:52:33Z

pep-0659.rst

+Specialization at the level on individual bytecodes makes deoptimization trivial, as it cannot occur in the middle of a region.
+
+By speculatively specializing individual bytecodes, we can gain significant performance improvements without anything but the most local,
+and trivial to implement, de-optimizations.


Suggested change

and trivial to implement, de-optimizations.

and trivial to implement, deoptimizations.

JelleZijlstra · 2021-05-11T12:53:46Z

pep-0659.rst

+
+Quickening is the process of replacing slow instructions with faster variants.
+
+Quickened code has number of advantages over the normal bytecode:


Suggested change

Quickened code has number of advantages over the normal bytecode:

Quickened code has a number of advantages over the normal bytecode:

JelleZijlstra · 2021-05-11T12:54:05Z

pep-0659.rst

+* It can use super-instructions that span lines and take multiple operands.
+* It does not need to handle tracing as it can fallback to the normal bytecode for that.
+
+In order that tracing can supported, and quickening performed quickly, the quickened instruction format should match the normal


Suggested change

In order that tracing can supported, and quickening performed quickly, the quickened instruction format should match the normal

In order that tracing can be supported, and quickening performed quickly, the quickened instruction format should match the normal

JelleZijlstra · 2021-05-11T12:55:18Z

pep-0659.rst

+To do this, an array of specialization data entries will be maintained alongside the new instruction array.
+For instructions that need specialization data, the operand in the quickened array will serve as a partial index, 
+along with the offset of the instruction, to find the first specialization data entry for that instruction.
+Each entry will be 8 bytes (for a 64 bit machine). The data in a entry, and the number of entries needed, will vary from instruction to instruction.


Suggested change

Each entry will be 8 bytes (for a 64 bit machine). The data in a entry, and the number of entries needed, will vary from instruction to instruction.

Each entry will be 8 bytes (for a 64 bit machine). The data in an entry, and the number of entries needed, will vary from instruction to instruction.

JelleZijlstra · 2021-05-11T12:55:54Z

pep-0659.rst

+Quickened instructions will be stored in an array (it is neither necessary not desirable to store them in a Python object) with the same
+format as the original bytecode. Ancillary data will be stored in a separate array.
+
+Each instruction will use 0 or more data entries. Each instruction within family must have the same amount of data allocated, although some


Suggested change

Each instruction will use 0 or more data entries. Each instruction within family must have the same amount of data allocated, although some

Each instruction will use 0 or more data entries. Each instruction within a family must have the same amount of data allocated, although some

JelleZijlstra · 2021-05-11T12:56:14Z

pep-0659.rst

+Each instruction will use 0 or more data entries. Each instruction within family must have the same amount of data allocated, although some
+instructions may not use all of it. Instructions that connot be specialized, e.g. ``POP_TOP``, do not need any entries.
+Experiments show that 25% to 30% of instructions can be usefully specialized.
+Different families will need different amount of data, but most need 2 entries (16 bytes on a 64 bit machine).


Suggested change

Different families will need different amount of data, but most need 2 entries (16 bytes on a 64 bit machine).

Different families will need different amounts of data, but most need 2 entries (16 bytes on a 64 bit machine).

JelleZijlstra · 2021-05-11T12:57:16Z

pep-0659.rst

+This is an obvious candidate for specialization. For example, the call in ``len(x)`` is repesented as the bytecode ``CALL_FUNCTION 1``.
+In this case we would always expect the object ``len`` to be the function. We probably don't want to specialize for ``len``
+(although we might for ``type`` and ``isinstance``), but it would be beneficial to specialize for builtin functions taking a single argument.
+A fast check that the underlying function is a builtin function taking a single argument (``METHOD_O``) would allow use to avoid a


Suggested change

A fast check that the underlying function is a builtin function taking a single argument (``METHOD_O``) would allow use to avoid a

A fast check that the underlying function is a builtin function taking a single argument (``METHOD_O``) would allow us to avoid a

WM7586

pep-0659.rst

CAM-Gerlach · 2023-01-10T04:47:39Z

@python/organization-owners Spam x2 👆

markshannon added 6 commits May 3, 2021 12:54

PEP 657: Specializing Adaptive Interpreter

1f389bb

Edit PEP 657

63ae731

Renumber PEP

e4ca6bb

Edits to aaptive specializing PEP.

4e072b0

Renumber

f628dc1

Fix backticks

603de6a

markshannon requested a review from a team as a code owner May 11, 2021 12:33

the-knights-who-say-ni added the CLA signed label May 11, 2021

JelleZijlstra requested changes May 11, 2021

View reviewed changes

Fix typos and grammatical errors.

2e69111

markshannon merged commit ab2d326 into python:master May 11, 2021

markshannon deleted the specializing-adaptive-interpreter branch May 11, 2021 14:29

erlend-aasland mentioned this pull request May 13, 2022

pep8/greppable exception messages erlend-aasland/peps#1

Closed

erlend-aasland mentioned this pull request Jun 27, 2022

pep 687/mark as accepted erlend-aasland/peps#2

Closed

WM7586 approved these changes Jan 10, 2023

View reviewed changes

WM7586 suggested changes Jan 10, 2023

View reviewed changes

python locked as spam and limited conversation to collaborators Jan 10, 2023

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

PEP 659: Specializing Adaptive Interpreter #1957

PEP 659: Specializing Adaptive Interpreter #1957

markshannon commented May 11, 2021

JelleZijlstra left a comment

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

JelleZijlstra May 11, 2021

WM7586 left a comment

CAM-Gerlach commented Jan 10, 2023

	Whilst Python will never attain the performance of low-level langauges like C, Fortran, or even Java,
	Whilst Python will never attain the performance of low-level languages like C, Fortran, or even Java,

	Specialization at the level on individual bytecodes makes deoptimization trivial, as it cannot occur in the middle of a region.
	Specialization at the level of individual bytecodes makes deoptimization trivial, as it cannot occur in the middle of a region.

	and trivial to implement, de-optimizations.
	and trivial to implement, deoptimizations.


		Quickening is the process of replacing slow instructions with faster variants.

		Quickened code has number of advantages over the normal bytecode:

	Quickened code has number of advantages over the normal bytecode:
	Quickened code has a number of advantages over the normal bytecode:

	In order that tracing can supported, and quickening performed quickly, the quickened instruction format should match the normal
	In order that tracing can be supported, and quickening performed quickly, the quickened instruction format should match the normal

	Each entry will be 8 bytes (for a 64 bit machine). The data in a entry, and the number of entries needed, will vary from instruction to instruction.
	Each entry will be 8 bytes (for a 64 bit machine). The data in an entry, and the number of entries needed, will vary from instruction to instruction.

	Each instruction will use 0 or more data entries. Each instruction within family must have the same amount of data allocated, although some
	Each instruction will use 0 or more data entries. Each instruction within a family must have the same amount of data allocated, although some

	Different families will need different amount of data, but most need 2 entries (16 bytes on a 64 bit machine).
	Different families will need different amounts of data, but most need 2 entries (16 bytes on a 64 bit machine).

	A fast check that the underlying function is a builtin function taking a single argument (``METHOD_O``) would allow use to avoid a
	A fast check that the underlying function is a builtin function taking a single argument (``METHOD_O``) would allow us to avoid a

PEP 659: Specializing Adaptive Interpreter #1957

PEP 659: Specializing Adaptive Interpreter #1957

Conversation

markshannon commented May 11, 2021

JelleZijlstra left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

WM7586 left a comment

Choose a reason for hiding this comment

CAM-Gerlach commented Jan 10, 2023