An error occurred fetching the project authors.
  1. 14 Nov, 2015 1 commit
  2. 13 Nov, 2015 2 commits
  3. 06 Nov, 2015 2 commits
  4. 02 Nov, 2015 1 commit
    • Kevin Modzelewski's avatar
      Rename CLFunction->FunctionMetadata · c8360f6d
      Kevin Modzelewski authored
      and a couple of the other related functions:
      - addRTFunction is now an overload of FunctionMetadata::addVersion
      - boxFunctionMetadata is now createFunctionFromMetadata (it doesn't return a box)
      - createRTFunction was just a wrapper around new FunctionMetadata(), so get rid of it
      - boxRTFunction is now FunctionMetadata::create
      
      "CLFunction" never really made sense as a name, and some of the other related functions
      didn't make sense either (especially after a couple refactorings happened).  Hopefully
      this makes it less confusing.
      c8360f6d
  5. 16 Oct, 2015 1 commit
  6. 22 Sep, 2015 1 commit
    • Kevin Modzelewski's avatar
      Try to fix set-dtor segfault · 3b44af6b
      Kevin Modzelewski authored
      The issue is that the set destructor, which is marked as "safe",
      will try to access the type object.  But a safe destructor is not
      allowed to assume that any objects are alive, including its own class.
      
      We do actually force the class to be alive during a safe destructor,
      but the tp_mro field was not so lucky.  We could try to address this by
      saying again that types have ordered finalizers, which will cause them
      to also keep their references alive.  But this doesn't completely work
      since it will cause issues with objects that have actual ordered finalizers.
      
      So for now, just remove type-check from the destructor.
      3b44af6b
  7. 18 Sep, 2015 1 commit
  8. 16 Sep, 2015 2 commits
    • Kevin Modzelewski's avatar
      Improve pickling of builtins · 5a04076c
      Kevin Modzelewski authored
      5a04076c
    • Kevin Modzelewski's avatar
      Match cpython's HEAPTYPE flag · 3b40ed33
      Kevin Modzelewski authored
      It's supposed to mean "whether this type is heap allocated", but
      it gets used as "is this a builtin/extension type".  We heap-allocate
      our builtin types so we were setting HEAPTYPE, but this keeps on
      causing issues.  I don't think anything actually uses HEAPTYPE to mean
      it's on the stack or heap, so let's just set them all to be HEAPTYPE=0.
      
      For better or worse, I ended up implementing this by changing the builtin
      types from BoxedHeapClasses to BoxedClasses, which seems to make sense.
      This had the effect of changing the existence of the tp_as_foo structs,
      which get automatically created for HeapClasses but not for non-heap classes.
      So most of the changes in this commit are trying to make sure that we
      have those when CPython has them.
      3b40ed33
  9. 14 Sep, 2015 1 commit
    • Kevin Modzelewski's avatar
      dict: the gc can resurrect objects after dealloc · 83379f19
      Kevin Modzelewski authored
      so object's can be resurrected even with a non-resurrecting
      tp_dealloc.  The only thing that can happen at that point is
      that the gc_visit function will get called.
      
      This shows up in the new sqlalchemy tests: they use a subclass
      of dict (defaultdict), which defines a custom tp_dealloc.  We call that,
      which ends up calling dict_cls->tp_dealloc, which calls ~DenseMap
      on the internal DenseMap.  The GC will accidentally keep the object
      alive (via a stack reference or something similar), and call its
      visit function on the next GC.  But ~DenseMap does not leave the map
      in a consistent state, so iterating over it will end up producing
      garbage values.  To solve this, add a new function that does
      all the same memory-freeing, but does a tiny bit of extra work to keep
      the DenseMap in a valid state for future gc_visit calls.
      83379f19
  10. 11 Sep, 2015 1 commit
  11. 09 Sep, 2015 2 commits
    • Marius Wachtler's avatar
      Fix set comparisons · b91071cd
      Marius Wachtler authored
      b91071cd
    • Kevin Modzelewski's avatar
      Allow changing the number of default arguments · df2808da
      Kevin Modzelewski authored
      We already supported changing the values, but not the number
      of them.  The main trickiness here is
      - We had been assuming that the number of defaults was immutable,
        so I had to find the places that we used it and add invalidation.
      - We assumed that all functions based on the same source function would
        have the same number of defaults.
      
      For the first one, I found all the places that looked at the defaults array,
      which should hopefully be all the places that need invalidation.
      
      One tricky part is that we will embed the num_defaults data into code produced
      by the LLVM tier, and we currently don't have any mechanism for invalidating
      those functions.  This commit side-steps around that since the only functions that
      we can inline are the builtins, and those you aren't allowed to change the defaults
      anyway.  So I added a "can_change_defaults" flag.
      
      For the second part, I moved "num_defaults" from the CLFunction (our "code" object)
      to the BoxedFunction (our "function" object), and then changed the users to pull
      it from there.
      df2808da
  12. 04 Sep, 2015 3 commits
    • Rudi Chen's avatar
      Pass address of pointer instead of pointer directly. · 3451880d
      Rudi Chen authored
      Moving gcs will need this to update pointers. There should not be any
      extra dereference, it will just happen on the other side of the
      function.
      
      Use templates to avoid direct (void**) casts -- make sure we're always
      passing an pointer of the form T**.
      3451880d
    • Kevin Modzelewski's avatar
      4dad82a0
    • Kevin Modzelewski's avatar
      Set initialization in init instead of new · 35c8b3f9
      Kevin Modzelewski authored
      Sqlalchemy subclasses set, and overrides __init__ and does some
      custom initialization there.  We were doing the initialization in
      __new__, which works most of the time, except if a generator was
      passed since then sqlalchemy's initialization will see what looks
      like an empty generator since we already consumed it.
      
      So move the initialization to init.  Except for frozenset which still
      needs to do it in new.
      35c8b3f9
  13. 02 Sep, 2015 1 commit
  14. 30 Aug, 2015 1 commit
  15. 21 Aug, 2015 1 commit
  16. 16 Aug, 2015 1 commit
  17. 12 Aug, 2015 1 commit
  18. 06 Aug, 2015 2 commits
  19. 03 Aug, 2015 1 commit
  20. 01 Aug, 2015 1 commit
  21. 31 Jul, 2015 1 commit
  22. 30 Jul, 2015 1 commit
  23. 29 Jul, 2015 1 commit
  24. 28 Jul, 2015 2 commits
  25. 27 Jul, 2015 2 commits
  26. 22 Jul, 2015 1 commit
  27. 21 Jul, 2015 1 commit
  28. 18 Jul, 2015 1 commit
    • Kevin Modzelewski's avatar
      Change attributes from strings to BoxedStrings · c5b1d41e
      Kevin Modzelewski authored
      The real benefit is that we intern the strings that
      end up getting used as attribute names, so we can compare
      them using pointer comparisons.  It should also reduce
      the size overhead of hidden classes, since we no longer
      have to copy the string data into the hidden class.
      c5b1d41e
  29. 23 Jun, 2015 1 commit
  30. 17 Jun, 2015 1 commit
  31. 03 Jun, 2015 1 commit