Portable Efficient Assembly Code-generator in Higher-level Python (PeachPy)

Portable Efficient Assembly Code-generator in Higher-level Python (PeachPy)

Definition: 

For writing high-performance assembly kernels PeachPy(a Python framework) is used.

Features of PeachPy are:

• It has a universal assembly syntax for OS like Windows, Unix and Golang.
• It has also an automatic adaption of function to different calling conventions and ABIs. 
• It has also a capability of automatic register allocation and it is flexible also.
• It also generated a function prolog and epilog.
• It also supports x86-64 instructions up to AVX-512 and SHA.
• It can auto-generate the metadata files.
• It is based on Python metaprogramming and code-generation.
• It is compatible on any of these Python 2 and Python 3, CPython and PyPy.

How to install it?

As PeachPy is actively developed so we don't have any stable release of it, just use the master version:

• you can download it from this link(git clone https://github.com/Maratyszcza/PeachPy.git).
• And use the following command to install:
• cd PeachPy
• pip install -r requirements.txt
• python setup.py generate
• pip install.

For Using PeachPy as a command-line tool

# These two lines are not needed for PeachPy, but will help you get autocompletion in good code editors

from peachpy import *

from peachpy.x86_64 import *

# Lets write a function float DotProduct(const float* x, const float* y)

# If you want maximum cross-platform compatibility, arguments must have names

x = Argument(ptr(const_float_), name="x")

# If name is not specified, it is auto-detected

y = Argument(ptr(const_float_))

# Everything inside the `with` statement is function body

with Function("DotProduct", (x, y), float_,

  # Enable instructions up to SSE4.2

  # PeachPy will report error if you accidentially use a newer instruction

  target=uarch.default + isa.sse4_2):

  # Request two 64-bit general-purpose registers. No need to specify exact names.

  reg_x, reg_y = GeneralPurposeRegister64(), GeneralPurposeRegister64()

  # This is a cross-platform way to load arguments. PeachPy will map it to something proper later.

  LOAD.ARGUMENT(reg_x, x)

  LOAD.ARGUMENT(reg_y, y)

  # Also request a virtual 128-bit SIMD register...

  xmm_x = XMMRegister()

  # ...and fill it with data

  MOVAPS(xmm_x, [reg_x])

  # It is fine to mix virtual and physical (xmm0-xmm15) registers in the same code

  MOVAPS(xmm2, [reg_y])

  # Execute dot product instruction, put result into xmm_x

  DPPS(xmm_x, xmm2, 0xF1)

  # This is a cross-platform way to return results. PeachPy will take care of ABI specifics.

  RETURN(xmm_x)

Now compile this code in binary object file which you can link into a program.

# Use MS-COFF format with Microsoft ABI for Windows

python -m peachpy.x86_64 -mabi=ms -mimage-format=ms-coff -o example.obj example.py

# Use Mach-O format with SysV ABI for OS X

python -m peachpy.x86_64 -mabi=sysv -mimage-format=mach-o -o example.o example.py

# Use ELF format with SysV ABI for Linux x86-64

python -m peachpy.x86_64 -mabi=sysv -mimage-format=elf -o example.o example.py

# Use ELF format with x32 ABI for Linux x32 (x86-64 with 32-bit pointer)

python -m peachpy.x86_64 -mabi=x32 -mimage-format=elf -o example.o example.py

# Use ELF format with Native Client x86-64 ABI for Chromium x86-64

python -m peachpy.x86_64 -mabi=nacl -mimage-format=elf -o example.o example.py

What else? You can convert the program to Plan 9 assembly for use with Go programming language:

# Use Go ABI (asm version) with -S flag to generate assembly for Go x86-64 targets

python -m peachpy.x86_64 -mabi=goasm -S -o example_amd64.s example.py

# Use Go-p32 ABI (asm version) with -S flag to generate assembly for Go x86-64 targets with 32-bit pointers

python -m peachpy.x86_64 -mabi=goasm-p32 -S -o example_amd64p32.s example.py

If Plan 9 assembly is too restrictive for your use-case, generate .syso objects which can be linked into Go programs:

# Use Go ABI (syso version) to generate .syso objects for Go x86-64 targets

# Image format can be any (ELF/Mach-O/MS-COFF)

python -m peachpy.x86_64 -mabi=gosyso -mimage-format=elf -o example_amd64.syso example.py

# Use Go-p32 ABI (syso version) to generate .syso objects for Go x86-64 targets with 32-bit pointers

# Image format can be any (ELF/Mach-O/MS-COFF)

python -m peachpy.x86_64 -mabi=gosyso-p32 -mimage-format=elf -o example_amd64p32.syso example.py

Dependencies:

• In PeachPy the instruction classes are generated from Opcodes Database.
• Using auto-generated tests the encodings are validated against binutils.
• A six and enum34 packages is used by PeachPy as a compatibility layer between Python 2 and Python 3. 

Download