- conservative references into the large/huge heaps are especially expensive
- it's nice to know what kind of object we are scanning

So we can compare against their latest instead of whatever was in apt.

Notably, to the rewriter.  Turns out that a decent amount of the time that
used to get allocated to slowpaths is actually time spent in the rewriter,
doing successful rewrites.

Take another pass over the failing cpython tests

Switch BoxedMethodDescriptor to tpp_call

While it's bad that we do so poorly with large heaps,
that's not the point of this benchmark.

- "Override" the stattimer stack while we are throwing an exception.
- Mark some more things as being back in "builtins" code.

Minor, but should cut down on some overhead

reduce api conversions

We got away with sloppy exception clearing in some places, since
raiseExcHelper would end up calling typeCall which would re-throw
the capi exception that hadn't been cleared.

Now that typeCall doesn't do that (which is fine), those bugs got
exposed.

We can't rewrite into the object-creation behavior, but
we can rewrite the decision to just use CPython's c slots.

ie try to avoid api conversion.

something like 40x slower.  also, has some sort of super-linear overhead:
10xing the size of the benchmark takes 33x longer for us, but 10x longer
for cpython.  (Looks like it's coming from the GC)

We should hopefully be able to avoid getting here in the first place
though.

add tpp_call for faster calling of non-functions

This register reuse here didn't go through our locations-tracking
infrastructure, and it just assumed it'd be ok to do.  I think it's
only called from places where the register we reuse won't be used
after this function.

This broke though when I added the ability to allocate orig-arg
registers; now, the argument is still dead in that it won't be used
by the function, but it could be "used" if a guard failed.  But this
wasn't being tracked in the locations map, so we ended up trashing
the orig arg despite the lengths we went to to not do that :/

It used to get away with telling other functions that it had
already guarded its args, since it could rely on the fact that
it could only get called through the path in runtimeCallInternal
that would guard the args.

Now that it can be called through the tpp_call fastpath (which maybe
should just guard the args), it has to guard them itself.

Could be faster with templates but seems roughly even for now.

Similar to ArgPassSpec.  Previously we kept them on the CLFunction,
but there are places where we want to specify a certain parameter
signature without having a clfunction available.

travis-ci compile and test in single step

Temporary fix for freeing-classes-before-instances bug

Was running into it, so just added a quick fix that should hopefully
get us through until rudi gets in his real fix.

This commit just delays freeing the class objects until the end of the
sweep.  It doesn't deal with a number of corner cases such as if
a class and a metaclass get freed at the same time (they both get delayed
to the same point), or if we free a class with weakrefs to it (it just
gets treated like a normal weakreferent).

Don't have cheetah_test look for system cheetah

do 100 queries per insert instead of 1000 after all inserts.

cheetah's tests do a PATH search for the "cheetah" executable,
and since we were appending the test-cheetah's location to PATH,
it would find the system cheetah preferentially to the test cheetah.

This is fine since on most systems there isn't a system cheetah, but
somehow mine has one.  The system cheetah will invoke the system python,
which will end up passing more of the tests.

We could prepend PATH instead of append to it, but it looks like the
the tests don't need anything else, so for now don't pass in anything else
in PATH.

Include total-tests-run in our test-suite-results checking

I'm seeing fewer failures locally than specified in the file, and
I'm guessing it's because I'm somehow skipping some tests, but I'm
not sure.

this increases cpython time on _imperative.py to ~2 seconds (and lowers pyston's % from ~480% to ~380%).
the declarative benchmark takes 10 seconds for cpython with this change, but it doesn't work on pyston at all yet.

Add debug symbols to release mode.

_U_dyn_register: Use binary search to find insert location

change timers back to ticks

This reverts commit 89df764f.