docker: we are now using cython 0.24 + update readme for 0.5.1 release

Bump version numbers

it support non str separators
fixes pyston#1297

str: use cpythons [r]partition

…slots_issue1197

Add sq_slots & mp_slots to instance (issue pyston#1197)

Internally we store it as either-dict-or-module, but when we expose
it to Python it needs to be given back as a mapping.  I looked briefly
into switching the internal representation, but that seemed like a much
more invasive change.

Also, add a pytest test that exposed this issue.

Have function.func_globals always be dict-like

implement tp_str and tp_repr for more of our builtin types

+ fix a leak in PyList_Insert

add _bisect, always_use_version support CAPI, set some frequent accessed slots

When try to support tk. The Py_None is a wrapper of pyston `None`. It
will conflict with other library's None. So rename the pure pyston
`None` to pyston_None. And use Py_None instead pyston_None when
possible. Just like dropbox#1231 for Py_True and Py_False

Pyston already has Py_IgnoreEnvironmentFlag, just add it to sys.flags.

Replace None with Py_None and some other fixing.

long: dealloc gmp memory

…1190

Fix extra nonzero call for chained comparisons pyston#1190

Adds a few C API paths plus sets tp_iternext and tpp_hasnext

generator optimizations

use cpython's abstract.c instead of src/capi/abstract.cpp

They end up generating "pass" statements with a lineno of 0, which
trips an assert later on.  This commit just sets them to have a lineno
of 1.

I'm not sure how to test this, since piping into stdin is supposed to
be treated as a file (not as the repl).  Though, we get that wrong right now.

Support empty lines on the repl

using cpython's `sys.flags` inplementation

enable `PyObject_Format` in `from_cpython/Objects/abstract.c`

Fix evaluation order for dict operations

+ use pyston::DenseMap to save a little more memory

this saves about 5%-10% of peak memory on django

hidden classes: split into subclasses to reduce memory consumption

Update to fewer-pyston-changes virtualenv

and change it to use a unordered_map because it uses less memory in this case and is faster
(I assume because it does not have align the key value tuples)
saves about 10% of peak memory on django

ScopeNameUsage merge dicts into a single big one

Comment out some part of listobject.c, use the CPython list sort and
apply some changes to existed Pyston code.

CPython listsort need "allocated" to check and throw exception:
https://github.com/Daetalus/pyston/blob/d84105ffc8a4855bb6e00d9c22ba2baa8bddf969/from_cpython/Objects/listobject.c#L2091
https://github.com/Daetalus/pyston/blob/d84105ffc8a4855bb6e00d9c22ba2baa8bddf969/from_cpython/Objects/listobject.c#L2180

If BoxedList::allocated is -1, it means the items inside were changed.
Some CPython list functions need this to check exceptions.

Switch to CPython list sort(Not its list implementation)

this saves a lot of memory

delete the llvm module after code generation

ICSlotInfo: remove old invalidator entries

we should not execute memory which got allocated using malloc
(crashes a lot of memory inspection tools and also the windows subsystem for linux)
I replaced it with a trivial mmap allocator which never unmaps the memory
(but reuses the memory if a runtime ICs gets deleted)
I think this is fine for now:
- there are <100 runtime ICs used per test
- because all runtime ICs have the same size there is no problem with fragmentation

This stuff got mostly already manually freed but I think this change makes it a little easier to see who owns what.

use more often std::unique_ptr

I'm suprised we did not run into this earlier...

make inner links to dir format

don't handle functions containing lambdas with yields as generators

runtime ICs: use mmap instead of malloc for executable code

it is slighlty faster for small allocations and has the advantage that it is easier to track how much memory our python objects are using

llvm::SmallPtrSet<ICSlotInfo*, 2> and std::unordered_set<ICSlotInfo*> have the same size
but the SmallPtrSet has the advantage that it can already store 2 elements in there and does not allocate 10 elements in the constructor

use PyObject_Malloc in pyston::DenseMap, smaller ICInvalidator, reduce malloc calls

had to change AST_Expression to store a stmt instead of a expr but this has the advantage that memory managment is easier

SourceInfo: remove the AST stmt copy, remove special handling of lambdas

we used to destroy the ICInfo before all references to it got deleted.

I run into this when using the glibc alloc instead of jemalloc

bjit: fix memory corruption

VRegInfo: reduce memory usage

and add the test that exposed it.

addGuard(obj) is dangerous because obj could be deallocated+reallocated
in the same spot, which is what ended up happening here.

Hopefully this doesn't end up keeping things alive for too much
extra time.

Since we are putting more things in the IC gc references,
call GC again after clearing them.

Fix uses of addGuard(python_object)

- previously we never deregistered the EH frame from libunwind (which exposed a bug)
- I removed the calls to register the EH info with gcc since we have our own unwinder which does not need this
- cleaned up the code and fixed some small memory leaks

EH: correctly deregister EH frames and cleanup the code

we free now the code blocks after a recompile in the LLVM tier (except for OSR frames) because
it is likely that we will not use the code anymore.
- we have to make sure we are not currently executing any code we will delete that's why I added bjit_num_inside
- there were some cases where we forgot to deregister stuff
- when profiling we don't actually unmap the code in order to not brake profiling

free bjit code after LLVM codegen

We used to store the string content twice.
This implementation makes use of DenseSet::find_as functionality where one can search using a different type.
I was not sure if the special DenseMapInfo I had to create causes any problems so I choose to create a new source file
for it so that it does not get picked up somewhere else.

this fixes the huge (~350MB) leak in:
for i in xrange(1000000):
    class C(object):
        pass

…asses

hidden classes: free classes of singleton type

string interning: make it slightly more space efficient