bca2b53 | Tim Besard | 07 May 2018, 09:28:22 UTC | Fixes for LLVM 6.0 | 07 May 2018, 09:28:22 UTC |
233b78e | Tim Besard | 07 May 2018, 08:43:26 UTC | Some missing includes. | 07 May 2018, 08:46:33 UTC |
2bbbad3 | Tim Besard | 13 February 2018, 14:37:11 UTC | Add CodegenParams to jl_create_native | 07 May 2018, 08:46:33 UTC |
9a57d92 | Tim Besard | 13 February 2018, 13:14:31 UTC | Add exports and functionality for accessing generated native code. | 07 May 2018, 08:46:33 UTC |
5969810 | Tim Besard | 13 February 2018, 13:14:05 UTC | Re-export the LLVM context. | 07 May 2018, 08:46:33 UTC |
43a44f2 | Jameson Nash | 06 April 2018, 19:00:51 UTC | more accurate specsig tracking | 07 May 2018, 08:46:33 UTC |
bd5add5 | Jameson Nash | 06 April 2018, 15:38:58 UTC | codegen: restructure, remove recursion also provides support for using a different code_native format, as a fallback, later we'll want to make this more configurable there are now several primary interfaces to native code: - codegen: mostly internal, support for translating IR to LLVM - jitlayers: manages compilation passes, especially at runtime - aotcompile: support for managing external code - disasm: pretty-printer for code objects - debuginfo: tracking for unwind info also removes the global type caches and move all codegen pass handling to aotcompile.cpp | 07 May 2018, 08:46:33 UTC |
74af878 | Jarrett Revels | 06 May 2018, 22:14:08 UTC | [NewOptimizer] Port #26826 to new optimizer (#26981) * fix InferenceResult cache lookup for new optimizer * utilize cached vararg type info in new inlining pass * fix test to work with new optimizer * fix predicate for exploiting cached varargs type info * atypes no longer needs to be modified to match cached types * don't require varargs to be in last position to exploit cached type info * restore missing isva boolean | 06 May 2018, 22:14:08 UTC |
bf29b40 | Valentin Churavy | 06 May 2018, 19:25:45 UTC | Merge pull request #26594 from JuliaLang/kc/SLP_llvm06 enable the SLP Vectorizer optimization pass by default | 06 May 2018, 19:25:45 UTC |
dde401e | Andreas Noack | 06 May 2018, 18:37:18 UTC | Search the julia subfolder first in RPATH (#26972) Fixes #26830 | 06 May 2018, 18:37:18 UTC |
32bcf5d | Kristoffer Carlsson | 23 March 2018, 12:40:41 UTC | enable the SLP Vectorizer optimization pass by default | 06 May 2018, 07:48:44 UTC |
bfb1c1b | Valentin Churavy | 06 May 2018, 00:40:29 UTC | Merge pull request #26925 from JuliaLang/vc/llvmbb Upgrade to LLVM 6 and use BinaryBuilder for LLVM on CI | 06 May 2018, 00:40:29 UTC |
10749b9 | Keno Fischer | 06 May 2018, 00:09:52 UTC | Merge pull request #26989 from JuliaLang/kf/gcunionphi [GCLowering] Fix phis of unions | 06 May 2018, 00:09:52 UTC |
4339f74 | Keno Fischer | 05 May 2018, 21:39:51 UTC | Merge pull request #26986 from JuliaLang/jb/fix26979 fix #26979, incorrect typeassert in deserialize | 05 May 2018, 21:39:51 UTC |
d45c700 | Valentin Churavy | 05 May 2018, 21:26:20 UTC | Merge pull request #26998 from JuliaLang/sf/fix_docs_typo Fix typo in docs, `ayncmap` -> `asyncmap` | 05 May 2018, 21:26:20 UTC |
03ed69b | Elliot Saba | 05 May 2018, 21:25:11 UTC | Fix typo in docs, `ayncmap` -> `asyncmap` [ci skip] | 05 May 2018, 21:25:11 UTC |
b72a570 | Keno Fischer | 04 May 2018, 23:53:45 UTC | [GCLowering] Fix phis of unions This fixes gc lowering for phis of the form: ``` %phi = phi {%jl_value_t addrspace(10)*, i8} [%aunion, %a], [%bunion, %b] ``` This kind of struct (used by the tagged union representation) has special support in GC lowering. After optimization, these structs often survive quite far as a struct (i.e. the destructuring of them is often elided). We simply need to extend this support to the cases that handle phi and select nodes. Fixes crashes with the new optimizer enabled noted in #26925 | 05 May 2018, 20:21:33 UTC |
4c5e1ae | Keno Fischer | 05 May 2018, 20:20:36 UTC | [GCLowering] Don't consider the ptls getter a safepoint The fact that this was absent was masking a bug (fixed in a previous commit). Now, we don't currently allow any safepoints or allocations before the call to the ptls getter, but in the future we may want to do things like callee-rooted arguments, which would have to be rooted across the ptls getter if it were a safepoint. With the bug fixed, we can proactively add this to the list of known non-safepoints. | 05 May 2018, 20:20:36 UTC |
16757f8 | Keno Fischer | 05 May 2018, 20:14:02 UTC | [GCLowering] Remove Unrooted* Dataflow variables We stopped using these a while ago when we switched to using LiveSet diffs for computing where to root values. | 05 May 2018, 20:17:02 UTC |
4b13cec | Keno Fischer | 05 May 2018, 20:02:09 UTC | [GCLowering] Make sure to consider values dead at function entry | 05 May 2018, 20:17:00 UTC |
ff07076 | Keno Fischer | 05 May 2018, 20:00:47 UTC | [GCLowering] Some cleanup | 05 May 2018, 20:15:38 UTC |
2cab814 | Matt Bauman | 05 May 2018, 14:43:09 UTC | Fix computation of sparse BroadcastStyle dimensionality (#26978) when falling back to a DefaultArrayStyle for array types that are not included in the support for PromoteToSparse. Fixes #26977 | 05 May 2018, 14:43:09 UTC |
901b240 | Jeff Bezanson | 04 May 2018, 22:02:36 UTC | fix #26979, incorrect typeassert in deserialize | 04 May 2018, 22:02:36 UTC |
ee2211c | Jeff Bezanson | 04 May 2018, 21:10:15 UTC | fix #26916, anon fn syntax with 1 kw and 1 optional arg (#26970) | 04 May 2018, 21:10:15 UTC |
6f50774 | Jeff Bezanson | 04 May 2018, 21:09:08 UTC | Merge pull request #26876 from JuliaLang/jb/iterfixes several iterator trait fixes | 04 May 2018, 21:09:08 UTC |
55a47e8 | Keno Fischer | 04 May 2018, 21:08:42 UTC | Merge pull request #26980 from JuliaLang/mb/deprecate-set-map Deprecate map(f, ::AbstractSet) | 04 May 2018, 21:08:42 UTC |
a6c4691 | Matt Bauman | 04 May 2018, 17:41:47 UTC | Deprecate map(f, ::AbstractSet) `map` on sets previously returned a `Set`, possibly changing the order or number of elements. This behavior is deprecated and in the future `map` will preserve order and number of elements. Fixes #26359. | 04 May 2018, 17:41:47 UTC |
702d0d5 | Valentin Churavy | 27 April 2018, 15:39:46 UTC | switches Julia to LLVM 6.0.0 and uses BinaryBuilder for CI - changes the support LLVM version to 6.0.0 - adds support for using a pre-built LLVM binary from `staticfloat/LLVMBuilder` taking advantage of the BinaryBuilder infrastructure. - adds two Makefile flags: - `BINARYBUILDER_TRIPLET` the BinaryBuilder triplet you are building for. An example would be `x86_64-linux-gnu`. - `USE_BINARYBUILDER_LLVM = 0` set this to 1 if you want to use the pre-built binaries for LLVM. - uses the pre-built binaries on OSX Travis instead of the bottle. - uses the pre-built binaries on Appveyor instead of a custom cache. | 04 May 2018, 15:48:59 UTC |
7f47f42 | Valentin Churavy | 28 April 2018, 19:43:35 UTC | fix LLVM >5 on Win32 | 04 May 2018, 15:48:59 UTC |
429a885 | Jarrett Revels | 04 May 2018, 14:50:08 UTC | enable/improve constant propagation through varargs methods (#26826) - Store varargs type information in the InferenceResult object, such that the info can be used during inference/optimization - Hack in a more precise return type for getfield of a vararg tuple. Ideally, we would handle this by teaching inference to track the types of the individual fields of a Tuple, which would make this unnecessary, but until then, this hack is helpful. - Spoof parents as well as children during recursion limiting, so that higher degree cycles are appropriately spoofed - A broadcast test marked as broken is now no longer broken, presumably due to the optimizations in this commit - Fix relationship between depth/mindepth in limit_type_size/is_derived_type. The relationship should have been inverse over the domain in which they overlap, but was not maintained consistently. An example of problematic case was: t = Tuple{X,X} where X<:Tuple{Tuple{Int64,Vararg{Int64,N} where N},Tuple{Int64,Vararg{Int64,N} where N}} c = Tuple{X,X} where X<:Tuple{Int64,Vararg{Int64,N} where N} because is_derived_type was computing the depth of usage rather than the depth of definition. This change thus makes the depth/mindepth calculations more consistent, and causes the limiting heuristic to return strictly wider types than it did before. - Move the optimizer's "varargs types to tuple type" rewrite to after cache lookup.Inference is populating the InferenceResult cache using the varargs form, so the optimizer needs to do the lookup before writing the atypes in order to avoid cache misses. Co-authored-by: Jameson Nash <vtjnash@users.noreply.github.com> Co-authored-by: Keno Fischer <keno@alumni.harvard.edu> | 04 May 2018, 14:50:08 UTC |
598ebff | Kristoffer Carlsson | 04 May 2018, 14:34:01 UTC | run LibGit2/libgit2 tests again (#26971) | 04 May 2018, 14:34:01 UTC |
64bceb5 | Fredrik Ekre | 04 May 2018, 13:09:38 UTC | Fix documentation warnings (#26974) * fix various doc-linking problems * spaces > tabs the tabs in NEWS.md tripped up the markdown parser and interpreted those lines as an inline code snippet | 04 May 2018, 13:09:38 UTC |
fa0704b | Rafael Fourquet | 03 May 2018, 21:58:03 UTC | specify eltype for Random.UniformBits (internal type) (#26940) | 03 May 2018, 21:58:03 UTC |
fdf1682 | Andreas Noack | 03 May 2018, 21:56:12 UTC | Fix Vector'Diagonal (ans Transpose as well) to avoid infinite recursion. (#26924) Also add optimized methods for x'D*y to avoid allocating temporary vector | 03 May 2018, 21:56:12 UTC |
fcbfc5d | Eric Davies | 03 May 2018, 21:50:43 UTC | Implement isopen for RemoteChannel (#26890) | 03 May 2018, 21:50:43 UTC |
dc3aa5a | Keno Fischer | 03 May 2018, 21:26:47 UTC | Merge pull request #26968 from JuliaLang/mb/restorenonscalarsetindextobootstrap Restore nonscalar `setindex!(::Array,...)` for bootstrap | 03 May 2018, 21:26:47 UTC |
fe99c4a | Keno Fischer | 03 May 2018, 19:51:12 UTC | Merge pull request #26961 from JuliaLang/mb/randomerrandom Make random test less likely to fail | 03 May 2018, 19:51:12 UTC |
fa9b575 | Keno Fischer | 03 May 2018, 19:50:31 UTC | Merge pull request #26960 from Liozou/outlining Update stacktraces docs | 03 May 2018, 19:50:31 UTC |
b9f412b | Andreas Noack | 03 May 2018, 18:23:50 UTC | Set seed in SparseArrays test for dropzeros to avoid occasional test (#26965) failure Fixes #26909 | 03 May 2018, 18:23:50 UTC |
bda1d1d | Matt Bauman | 03 May 2018, 15:16:44 UTC | Restore nonscalar `setindex!(::Array,...)` for bootstrap This reverts a very tiny tiny portion of commit 7e2ce0e5433af4fcaee9f7893f90d80c21316044. | 03 May 2018, 15:16:44 UTC |
b4798b9 | Matt Bauman | 03 May 2018, 15:03:08 UTC | More exact computation of allocations in Sparse broadcast (#26950) * More exact computation of allocations in Sparse broadcast This uses `@allocated` to actually compute how expensive it is to convert a transposed sparse matrix to a CSC structure instead of just guessing. | 03 May 2018, 15:03:08 UTC |
61350d6 | Keno Fischer | 03 May 2018, 14:04:38 UTC | Merge pull request #26964 from JuliaLang/kf/misc [NewOptimizer] Fix complaints by legacy validator on new IR | 03 May 2018, 14:04:38 UTC |
f851ff7 | Keno Fischer | 03 May 2018, 14:04:24 UTC | Merge pull request #26963 from JuliaLang/kf/phinoderefactor [NewOptimizer] Refactor phinode codegen | 03 May 2018, 14:04:24 UTC |
8e8ddd4 | Keno Fischer | 03 May 2018, 01:53:18 UTC | [NewOptimizer] Fix complaints by legacy validator on new IR Once things settle we should integrate the validator with the new IR verifier, but for now just make sure it doesn't complain on new style IR. | 03 May 2018, 02:40:03 UTC |
a5c119f | Keno Fischer | 03 May 2018, 00:52:53 UTC | [NewOptimizer] Refactor phinode codegen Turns out the old approach we used didn't work, because it was possible for the processing of one phi node to clobber the operands of another (e.g. in a loop where one phi node depends on another). Fix this by using two buffers. This isn't great, but hopefully LLVM should do ok at it. If not, we can fix LLVM or try to be smarter. | 03 May 2018, 02:38:23 UTC |
7e2ce0e | Matt Bauman | 02 May 2018, 20:11:34 UTC | RFC: Deprecate implicit scalar broadcasting in setindex! (#26347) The current `setindex!` function (the `A[i] = b` syntax) does three very different operations: * Given an index `i` that refers to only one location (scalar indexing), `A[i] = b` modifies `A` in that location to hold `b`. * Given an index `I` that refers to more than one location (non-scalar indexing), `A[I] = b` can mean one of two things: * If `b` is an AbstractArray (multi-value), assign the values it contains to those locations `I` in `A`. That is, essentially, `[A[i] = bᵢ for (i, bᵢ) in zip(I, b)]`. * If `b` is not an AbstractArray (scalar-value), then broadcast its value to every location selected by `I` in `A`. These two different behaviors in the non-scalar indexing case basically make using this function in a generic way impossible. If you want to _always_ set the value `b` to many indices of `A`, you _cannot_ use this syntax because `b` might happen to be an array in some cases, radically changing the meaning of the expression. You need to manually iterate over the indices, using scalar setindex methods. But we now also have the new `broadcast!` syntax, `A[I] .= B`, which uses the usual broadcasting semantics to determine how `B` should fill into the values of `A`. This PR deprecates the implicit broadcasting of scalar values in non-scalar indexing in favor of an explicit `.=` broadcast syntax, leaving multi-value non-scalar indexing intact. This is the _exact opposite_ of PR #24368. | 02 May 2018, 20:11:34 UTC |
5a062fa | Keno Fischer | 02 May 2018, 19:12:11 UTC | Merge pull request #26958 from JuliaLang/kf/placateverifier [NewOptimizer] Placate LLVM IR verifier | 02 May 2018, 19:12:11 UTC |
cdb5893 | Matt Bauman | 02 May 2018, 18:30:08 UTC | Make random test less likely to fail Previously, one of Random's tests was checking `rand(s) != rand(s)`, where `s` was a 11001-length range. This is expected to have a one-in-11001 chance of failure, and indeed it has caused at least one CI failure. This changes it to something much less likely to spuriously fail -- if I have my probabilities right here I think it'd be on the order of 10^-20. | 02 May 2018, 18:30:08 UTC |
64040ce | Steven G. Johnson | 02 May 2018, 18:22:32 UTC | bump utf8proc to 2.1.1 (#26917) * bump utf8proc to 2.1.1 This contains a bug fix for a normalization error (JuliaLang/utf8proc#128), so I would recommend backporting. * added test for JuliaLang/utf8proc#128 * update checksums | 02 May 2018, 18:22:32 UTC |
804c246 | Fredrik Ekre | 02 May 2018, 18:01:57 UTC | add examples for at-test macros, fix #26018 (#26955) * add examples for at-test macros, fix #26018 * fix show for Test.Broken | 02 May 2018, 18:01:57 UTC |
093bb0f | Liozou | 02 May 2018, 18:00:05 UTC | Update stacktraces docs | 02 May 2018, 18:00:45 UTC |
76f7d0b | Matt Bauman | 02 May 2018, 17:42:34 UTC | Broadcast.AbstractArrayStyle constructor fixups (#26944) All subtypes of AbstractArrayStyle should implement a constructor that takes a `Val(ndims)` argument. This fixes up a number of the builtin styles and adds some tests. | 02 May 2018, 17:42:34 UTC |
b199a69 | Keno Fischer | 02 May 2018, 16:08:29 UTC | [NewOptimizer] Placate LLVM IR verifier | 02 May 2018, 16:10:07 UTC |
12fea2d | Fredrik Ekre | 02 May 2018, 15:12:38 UTC | better deprecation message for (+|-)(::Array, ::Number) deprecation (#26954) | 02 May 2018, 15:12:38 UTC |
743887c | Matt Bauman | 02 May 2018, 14:41:45 UTC | Broadcast performance: fix type stability (#26942) Remove a needless construction of a covariant typevar within a tuple. Tuples already are covariant. Before: ```julia julia> xset= 10:15 10:15 julia> yset= 12:14 12:14 julia> f(x,y) = sqrt( x^2 + y^2 ) f (generic function with 1 method) julia> function loop3(xset, yset) m = Matrix{Float64}(undef, 3, length(xset)*length(yset)) i = 1 @inbounds for x in xset, y in yset m[:,i] .= (Float64(x), Float64(y), f(x,y)) i += 1 end m end loop3 (generic function with 1 method) julia> using BenchmarkTools julia> @benchmark loop3($xset, $yset) BenchmarkTools.Trial: memory estimate: 5.59 KiB allocs estimate: 109 -------------- minimum time: 9.634 μs (0.00% GC) median time: 10.504 μs (0.00% GC) mean time: 16.472 μs (32.25% GC) maximum time: 43.241 ms (99.95% GC) -------------- samples: 10000 evals/sample: 1 ``` After: ```julia julia> @benchmark loop3($xset, $yset) BenchmarkTools.Trial: memory estimate: 544 bytes allocs estimate: 1 -------------- minimum time: 186.732 ns (0.00% GC) median time: 193.974 ns (0.00% GC) mean time: 217.001 ns (6.63% GC) maximum time: 69.051 μs (99.42% GC) -------------- samples: 10000 evals/sample: 616 ``` | 02 May 2018, 14:41:45 UTC |
60031ad | Keno Fischer | 02 May 2018, 10:34:58 UTC | Merge pull request #26948 from JuliaLang/kf/effectfree [NewOptimizer] Make stmt_effect_free less aggressive | 02 May 2018, 10:34:58 UTC |
7d48ecb | Keno Fischer | 02 May 2018, 00:43:23 UTC | Merge pull request #26900 from JuliaLang/kf/unionsplit [NewOptimizer] Union Split during Inlining | 02 May 2018, 00:43:23 UTC |
575b9e3 | Keno Fischer | 02 May 2018, 00:42:24 UTC | Merge pull request #26951 from JuliaLang/kf/misctests [NewOptimizer] Fix misc compiler tests for new IR | 02 May 2018, 00:42:24 UTC |
9ef2af9 | Keno Fischer | 01 May 2018, 21:43:03 UTC | Merge pull request #26943 from JuliaLang/kf/nestedtrycatch [NewOptimizer] Fix PhiC type lifting for nested try/catch | 01 May 2018, 21:43:03 UTC |
c42b5eb | Keno Fischer | 01 May 2018, 21:39:37 UTC | Merge pull request #26945 from JuliaLang/kf/phicodegencorner [NewOptimizer] Fix phi node codegen corner case | 01 May 2018, 21:39:37 UTC |
fa02d34 | Keno Fischer | 01 May 2018, 19:45:17 UTC | [NewOptimizer] Make stmt_effect_free less aggressive Previously, the new optimizer used the pre-existing `effect_free` function to determine whether it is safe to remove an unreferenced statement. However, this function ignores many builtin's error cases, causing them to be removed when that is not legal to do (because that would potentially remove an exception that would otherwise be thrown). Start fixing this, by introducing a version of the function that is correct for a subset of intresting functions. We will likely need to expand this when we look at the benchmarks, but this should be correct for now. | 01 May 2018, 21:37:26 UTC |
8f4ff91 | Keno Fischer | 01 May 2018, 21:19:31 UTC | Correct comment | 01 May 2018, 21:19:56 UTC |
3305ef2 | Keno Fischer | 01 May 2018, 15:51:01 UTC | Widen element type for processed array | 01 May 2018, 21:19:55 UTC |
ce70402 | Keno Fischer | 24 April 2018, 11:39:43 UTC | [NewOptimizer] Union Split during Inlining This adds union splitting optimizations to the inliner. This works a bit differently from the old optimizer, which did union splitting on the bail out path. Instead, we try to run the full inliner on any union split case that's a dispatch tuple (and record what to do in that case). Doing that allows an effective resolution of #23338, though this PR doesn't quite do that yet, since some further (minor) fixes are needed. | 01 May 2018, 21:19:55 UTC |
9732218 | Keno Fischer | 01 May 2018, 21:05:16 UTC | [NewOptimizer] Fix misc compiler tests for new IR A couple of tests need adjustments for the new IR. With this and all the currently pending PR, I see all tests passing locally with the new optimizer enabled. | 01 May 2018, 21:15:48 UTC |
f528323 | Keno Fischer | 01 May 2018, 17:09:02 UTC | [NewOptimizer] Fix phi node codegen corner case Just a silly corner case where we forgot to check whether val.typ == Union{}, causing a crash in the cmdlineargs test. | 01 May 2018, 17:26:01 UTC |
67018fb | Keno Fischer | 01 May 2018, 15:16:57 UTC | [NewOptimizer] Fix PhiC type lifiting for nested try/catch Fixes two closely related bugs: - PhiC nodes were not participating in type refinement during SSA construction, leading to PhiC nodes that were part of a phi cycle to have too narrow a type. - PhiC nodes part of a Phi cycle did not get an appropriate upsilon node inserted during type lifting. | 01 May 2018, 15:19:59 UTC |
23388ae | Keno Fischer | 01 May 2018, 15:19:08 UTC | Merge pull request #26918 from JuliaLang/kf/reverseaffinity [NewOptimizer] Backport reverse affinity changes from #26778 | 01 May 2018, 15:19:08 UTC |
132a9f4 | Jameson Nash | 01 May 2018, 03:19:27 UTC | inference: first try to tmerge tuples to a single Vararg type (#22120) | 01 May 2018, 03:19:27 UTC |
8770821 | Valentin Churavy | 30 April 2018, 21:25:44 UTC | Remove indirect dependency on system ZLIB (#26888) * Remove indirect dependency on system ZLIB - build LLVM without ZLIB support - use the bundled ZLIB for libgit * backport bundled zlib patch | 30 April 2018, 21:25:44 UTC |
509d6a1 | Matt Bauman | 27 April 2018, 21:12:42 UTC | Travis: download moreutils from the release tarball (#26902) * Update moreutils git repo location in .travis.yml The old `kitenet.net` domain is down. Checking on wayback, its pages had been throwing 302 redirects to this new domain. * Try downloading tarball from http.debian.net [av skip] | 27 April 2018, 21:12:42 UTC |
c9c2b5f | Keno Fischer | 27 April 2018, 18:24:21 UTC | Merge pull request #26901 from JuliaLang/kf/sroafix [NewOptimizer] Fix bug in getfield elim pass | 27 April 2018, 18:24:21 UTC |
99016fd | Keno Fischer | 27 April 2018, 14:52:39 UTC | [NewOptimizer] Backport reverse affinity changes from #26778 In #26778, I changed the way that the reverse affinity flag works in order to support node insertion during compaction. In particular, I had originally (for ease of implementation primarily) had that flag simply change which BB an inserted node belongs to (i.e. if that flag was set and there was a basic block boundary at the insertion site, the new node would belong to the previous BB). In #26778, I changed this to instead be a flag of whether to insert before or after a given instruction. As it turns out, this change is also required for correctness. Because domsorting can change the notion of "previous instruction" by moving basic blocks, we had (in rare circumstances) instructions end up in the wrong BB. Backporting those changes fixes that. | 27 April 2018, 18:06:38 UTC |
f93591d | Keno Fischer | 25 April 2018, 16:25:56 UTC | [NewOptimizer] Fix bug in getfield elim pass We were looking at the pre-compacted IR rather than the compacted one, causing errors. We need to clean all this up once we rip out the old optimizer code, but for now, let's get this correct. | 27 April 2018, 15:02:44 UTC |
1429744 | Kristoffer Carlsson | 26 April 2018, 20:58:09 UTC | fix pkg3 precompile (#26913) | 26 April 2018, 20:58:09 UTC |
ef76d9c | Matt Bauman | 26 April 2018, 14:57:43 UTC | Merge pull request #26891 from JuliaLang/mb-teh-jn-ajk/lazydotfuse Customizable lazy fused broadcasting in pure Julia | 26 April 2018, 14:57:43 UTC |
f4349c1 | Kristoffer Carlsson | 26 April 2018, 12:18:39 UTC | Merge pull request #26908 from JuliaLang/kc/bump_pkg3_7 Bump Pkg3 | 26 April 2018, 12:18:39 UTC |
acb6cae | Kristoffer Carlsson | 25 April 2018, 10:18:51 UTC | fix adding and developing detached repos | 26 April 2018, 10:04:15 UTC |
88c342a | Douglas Bates | 25 April 2018, 14:37:28 UTC | Spelling | 26 April 2018, 10:01:25 UTC |
2620370 | Kristoffer Carlsson | 24 April 2018, 13:07:42 UTC | fix up on package with no manifest (#257) * fix up on package with no manifest * add debug stuff * wut * sigh * fixups | 26 April 2018, 10:01:18 UTC |
026bd86 | Kristoffer Carlsson | 24 April 2018, 13:07:09 UTC | give refspecs to the registry (#258) | 26 April 2018, 10:01:11 UTC |
67fc4fc | Martin Holters | 26 April 2018, 05:10:30 UTC | Fix `comprod!` to use `mul_prod` instead of `add_sum` (#26905) | 26 April 2018, 05:10:30 UTC |
18ad6a8 | Matt Bauman | 25 April 2018, 15:43:26 UTC | Change lowering of `A .= x` to match fused RHS cases Now instead of lowering to `broadcast!(identity,A,x)`, it lowers to `Broadcast.materialize!(A, Broadcast.broadcasted(identity, x))`, with all names resolved in the top module. | 25 April 2018, 15:43:40 UTC |
edd4dcf | Matt Bauman | 25 April 2018, 14:07:15 UTC | Correct NEWS.md | 25 April 2018, 14:07:15 UTC |
75798f9 | Matt Bauman | 25 April 2018, 05:54:42 UTC | Remove the last of the base broadcast methods... by implementing a preprocessing step for chunked bitarray broadcast that converts boolean-only functions to ones that support chunk-wise operation. Also add a number of tests for this codepath | 25 April 2018, 05:54:42 UTC |
8a2d88a | Matt Bauman | 24 April 2018, 19:39:01 UTC | Remove hack that avoided materialize in fallback broadcast For reasons beyond my comprehensions, this previously failed to inline despite the at-inline. For reasons that are also beyond my comprehension, this hack is no longer necessary. | 24 April 2018, 19:39:01 UTC |
4cd10d3 | Matt Bauman | 24 April 2018, 17:34:24 UTC | Test and fix #26127 | 24 April 2018, 17:34:24 UTC |
c9a0a41 | Matt Bauman | 24 April 2018, 16:14:35 UTC | Rename Broadcast.make to Broadcast.broadcasted | 24 April 2018, 16:14:35 UTC |
9f5351c | Valentin Churavy | 24 April 2018, 14:26:44 UTC | Merge pull request #26893 from JuliaLang/sf/documenter Bump documenter version | 24 April 2018, 14:26:44 UTC |
a1450b3 | staticfloat@gmail.com | 24 April 2018, 02:59:17 UTC | Bump documenter version Documenter 0.17.0 contains the fix for https://github.com/JuliaDocs/Documenter.jl/pull/699, which allows doc builds inside of git worktrees to actually finish. | 24 April 2018, 02:59:44 UTC |
ef9168a | Jeff Bezanson | 24 April 2018, 02:56:14 UTC | fix a use of `isbitstype` in new optimizer (#26887) | 24 April 2018, 02:56:14 UTC |
dbe1ae0 | Matt Bauman | 23 April 2018, 23:56:46 UTC | Customizable lazy fused broadcasting in pure Julia This patch represents the combined efforts of four individuals, over 60 commits, and an iterated design over (at least) three pull requests that spanned nearly an entire year (closes #22063, #23692, #25377 by superceding them). This introduces a pure Julia data structure that represents a fused broadcast expression. For example, the expression `2 .* (x .+ 1)` lowers to: ```julia julia> Meta.@lower 2 .* (x .+ 1) :($(Expr(:thunk, CodeInfo(:(begin Core.SSAValue(0) = (Base.getproperty)(Base.Broadcast, :materialize) Core.SSAValue(1) = (Base.getproperty)(Base.Broadcast, :make) Core.SSAValue(2) = (Base.getproperty)(Base.Broadcast, :make) Core.SSAValue(3) = (Core.SSAValue(2))(+, x, 1) Core.SSAValue(4) = (Core.SSAValue(1))(*, 2, Core.SSAValue(3)) Core.SSAValue(5) = (Core.SSAValue(0))(Core.SSAValue(4)) return Core.SSAValue(5) end))))) ``` Or, slightly more readably as: ```julia using .Broadcast: materialize, make materialize(make(*, 2, make(+, x, 1))) ``` The `Broadcast.make` function serves two purposes. Its primary purpose is to construct the `Broadcast.Broadcasted` objects that hold onto the function, the tuple of arguments (potentially including nested `Broadcasted` arguments), and sometimes a set of `axes` to include knowledge of the outer shape. The secondary purpose, however, is to allow an "out" for objects that _don't_ want to participate in fusion. For example, if `x` is a range in the above `2 .* (x .+ 1)` expression, it needn't allocate an array and operate elementwise — it can just compute and return a new range. Thus custom structures are able to specialize `Broadcast.make(f, args...)` just as they'd specialize on `f` normally to return an immediate result. `Broadcast.materialize` is identity for everything _except_ `Broadcasted` objects for which it allocates an appropriate result and computes the broadcast. It does two things: it `initialize`s the outermost `Broadcasted` object to compute its axes and then `copy`s it. Similarly, an in-place fused broadcast like `y .= 2 .* (x .+ 1)` uses the exact same expression tree to compute the right-hand side of the expression as above, and then uses `materialize!(y, make(*, 2, make(+, x, 1)))` to `instantiate` the `Broadcasted` expression tree and then `copyto!` it into the given destination. All-together, this forms a complete API for custom types to extend and customize the behavior of broadcast (fixes #22060). It uses the existing `BroadcastStyle`s throughout to simplify dispatch on many arguments: * Custom types can opt-out of broadcast fusion by specializing `Broadcast.make(f, args...)` or `Broadcast.make(::BroadcastStyle, f, args...)`. * The `Broadcasted` object computes and stores the type of the combined `BroadcastStyle` of its arguments as its first type parameter, allowing for easy dispatch and specialization. * Custom Broadcast storage is still allocated via `broadcast_similar`, however instead of passing just a function as a first argument, the entire `Broadcasted` object is passed as a final argument. This potentially allows for much more runtime specialization dependent upon the exact expression given. * Custom broadcast implmentations for a `CustomStyle` are defined by specializing `copy(bc::Broadcasted{CustomStyle})` or `copyto!(dest::AbstractArray, bc::Broadcasted{CustomStyle})`. * Fallback broadcast specializations for a given output object of type `Dest` (for the `DefaultArrayStyle` or another such style that hasn't implemented assignments into such an object) are defined by specializing `copyto(dest::Dest, bc::Broadcasted{Nothing})`. As it fully supports range broadcasting, this now deprecates `(1:5) + 2` to `.+`, just as had been done for all `AbstractArray`s in general. As a first-mover proof of concept, LinearAlgebra uses this new system to improve broadcasting over structured arrays. Before, broadcasting over a structured matrix would result in a sparse array. Now, broadcasting over a structured matrix will _either_ return an appropriately structured matrix _or_ a dense array. This does incur a type instability (in the form of a discriminated union) in some situations, but thanks to type-based introspection of the `Broadcasted` wrapper commonly used functions can be special cased to be type stable. For example: ```julia julia> f(d) = round.(Int, d) f (generic function with 1 method) julia> @inferred f(Diagonal(rand(3))) 3×3 Diagonal{Int64,Array{Int64,1}}: 0 ⋅ ⋅ ⋅ 0 ⋅ ⋅ ⋅ 1 julia> @inferred Diagonal(rand(3)) .* 3 ERROR: return type Diagonal{Float64,Array{Float64,1}} does not match inferred return type Union{Array{Float64,2}, Diagonal{Float64,Array{Float64,1}}} Stacktrace: [1] error(::String) at ./error.jl:33 [2] top-level scope julia> @inferred Diagonal(1:4) .+ Bidiagonal(rand(4), rand(3), 'U') .* Tridiagonal(1:3, 1:4, 1:3) 4×4 Tridiagonal{Float64,Array{Float64,1}}: 1.30771 0.838589 ⋅ ⋅ 0.0 3.89109 0.0459757 ⋅ ⋅ 0.0 4.48033 2.51508 ⋅ ⋅ 0.0 6.23739 ``` In addition to the issues referenced above, it fixes: * Fixes #19313, #22053, #23445, and #24586: Literals are no longer treated specially in a fused broadcast; they're just arguments in a `Broadcasted` object like everything else. * Fixes #21094: Since broadcasting is now represented by a pure Julia datastructure it can be created within `@generated` functions and serialized. * Fixes #26097: The fallback destination-array specialization method of `copyto!` is specifically implemented as `Broadcasted{Nothing}` and will not be confused by `nothing` arguments. * Fixes the broadcast-specific element of #25499: The default base broadcast implementation no longer depends upon `Base._return_type` to allocate its array (except in the empty or concretely-type cases). Note that the sparse implementation (#19595) is still dependent upon inference and is _not_ fixed. * Fixes #25340: Functions are treated like normal values just like arguments and only evaluated once. * Fixes #22255, and is performant with 12+ fused broadcasts. Okay, that one was fixed on master already, but this fixes it now, too. * Fixes #25521. * The performance of this patch has been thoroughly tested through its iterative development process in #25377. There remain [two classes of performance regressions](#25377) that Nanosoldier flagged. * #25691: Propagation of constant literals sill lose their constant-ness upon going through the broadcast machinery. I believe quite a large number of functions would need to be marked as `@pure` to support this -- including functions that are intended to be specialized. (For bookkeeping, this is the squashed version of the [teh-jn/lazydotfuse](https://github.com/JuliaLang/julia/pull/25377) branch as of a1d4e7ec9756ada74fb48f2c514615b9d981cf5c. Squashed and separated out to make it easier to review and commit) Co-authored-by: Tim Holy <tim.holy@gmail.com> Co-authored-by: Jameson Nash <vtjnash@gmail.com> Co-authored-by: Andrew Keller <ajkeller34@users.noreply.github.com> | 23 April 2018, 23:56:46 UTC |
c0a278c | Jameson Nash | 23 April 2018, 20:33:32 UTC | Merge pull request #26839 from JuliaLang/jn/iddict-delete IdDict: support deletion, and support `nothing` used as a key | 23 April 2018, 20:33:32 UTC |
692408c | Fredrik Ekre | 23 April 2018, 18:23:43 UTC | fix deprecations of \cdot and \times (#26884) | 23 April 2018, 18:23:43 UTC |
43fe63c | Matt Bauman | 23 April 2018, 18:17:30 UTC | Support reshaping custom 0-dimensional arrays (#26870) Fixes #26163. | 23 April 2018, 18:17:30 UTC |
923cb6a | Jeff Bezanson | 23 April 2018, 18:11:12 UTC | fix some cases of dot syntax lowering (#26878) fix #26739, error for `sum.[1]` fix #26873, should have no error for `f."a"` | 23 April 2018, 18:11:12 UTC |
5e57c21 | Jameson Nash | 17 April 2018, 19:49:18 UTC | IdDict: support deletion, and support `nothing` used as a key previously, if we deleted one key or added `nothing` as a key, we might lose some of the other entries too (until rehash) fix #26833 | 23 April 2018, 16:23:06 UTC |
55b3fc2 | Jameson Nash | 17 April 2018, 18:51:50 UTC | clang-format table.c | 23 April 2018, 16:23:06 UTC |
22ded18 | Kristoffer Carlsson | 23 April 2018, 10:12:23 UTC | Pkg3: deterministically close the LibGit2 repo in tests (#26883) | 23 April 2018, 10:12:23 UTC |
de705f3 | Stefan Karpinski | 22 April 2018, 20:14:39 UTC | Merge pull request #26854 from JuliaLang/kc/bump_pkg3_6 Bump Pkg3 | 22 April 2018, 20:14:39 UTC |