Merge branch 'master' of github.com:JuliaLang/julia

CONTRIBUTING.md

@@ -95,14 +95,17 @@ Build as usual, and do `make clean testall` to test your contribution. If your c
 
 ##### General Formatting Guidelines For Julia code contributions
 
- - 4 space indent
+ - 4 spaces per indentation level, no tabs
  - use whitespace to make the code more readable
- - no whitespace at the end of a line
+ - no whitespace at the end of a line (trailing whitespace)
  - comments are good, especially when they explain the algorithm
+ - try to adhere to a 92 character line length limit
+ - use upper camel case convention for modules, type names
+ - use lower case with underscores for method names
 
 ##### General Formatting Guidelines For C code contributions
 
- - 4 space indent
+ - 4 spaces per indentation level, no tabs
  - space between if and ( (if (x) ...)
  - newline before opening { in function definitions
  - f(void) for 0-argument function declarations

Makefile

@@ -37,6 +37,7 @@ $(build_docdir):
 	@mkdir -p $@/examples
 	@cp -R doc/devdocs doc/manual doc/stdlib $@
 	@cp -R examples/*.jl $@/examples/
+	@cp -R examples/clustermanager $@/examples/
 
 git-submodules:
 ifneq ($(NO_GIT), 1)
@@ -152,12 +153,12 @@ $(build_private_libdir)/sys0.o:
 
 BASE_SRCS := $(wildcard base/*.jl base/*/*.jl base/*/*/*.jl)
 
-,:=,
+COMMA:=,
 $(build_private_libdir)/sys.o: VERSION $(BASE_SRCS) $(build_docdir)/helpdb.jl $(build_private_libdir)/sys0.$(SHLIB_EXT)
 	@$(call PRINT_JULIA, cd base && \
 	$(call spawn,$(JULIA_EXECUTABLE)) -C $(JULIA_CPU_TARGET) --build $(call cygpath_w,$(build_private_libdir)/sys) \
 		-J$(call cygpath_w,$(build_private_libdir))/$$([ -e $(build_private_libdir)/sys.ji ] && echo sys.ji || echo sys0.ji) -f sysimg.jl \
-		|| { echo '*** This error is usually fixed by running `make clean`. If the error persists$(,) try `make cleanall`. ***' && false; } )
+		|| { echo '*** This error is usually fixed by running `make clean`. If the error persists$(COMMA) try `make cleanall`. ***' && false; } )
 
 $(build_bindir)/stringreplace: contrib/stringreplace.c | $(build_bindir)
 	@$(call PRINT_CC, $(CC) -o $(build_bindir)/stringreplace contrib/stringreplace.c)
@@ -448,17 +449,17 @@ distcleanall: cleanall
 	run-julia run-julia-debug run-julia-release run \
 	install dist source-dist git-submodules
 
-test: release
+test: check-whitespace release
 	@$(MAKE) $(QUIET_MAKE) -C test default
 
-testall: release
+testall: check-whitespace release
 	cp $(build_prefix)/lib/julia/sys.ji local.ji && $(JULIA_EXECUTABLE) -J local.ji -e 'true' && rm local.ji
 	@$(MAKE) $(QUIET_MAKE) -C test all
 
-testall1: release
+testall1: check-whitespace release
 	@env JULIA_CPU_CORES=1 $(MAKE) $(QUIET_MAKE) -C test all
 
-test-%: release
+test-%: check-whitespace release
 	@$(MAKE) $(QUIET_MAKE) -C test $*
 
 perf: release

NEWS.md

@@ -156,6 +156,8 @@ Library improvements
 
   * Split `Triangular` type into `UpperTriangular`, `LowerTriangular`, `UnitUpperTriagular` and `UnitLowerTriangular` ([#9779])
 
+  * ClusterManager - Performance improvements([#9309]) and support for changing transports([#9434])
+
 Deprecated or removed
 ---------------------
 

base/abstractarray.jl

@@ -24,7 +24,7 @@ ndims{T<:AbstractArray}(::Type{T}) = ndims(super(T))
 length(t::AbstractArray) = prod(size(t))::Int
 endof(a::AbstractArray) = length(a)
 first(a::AbstractArray) = a[1]
-first(a) = (s = start(a); done(a, s) ? error("collection is empty") : next(a, s)[1])
+first(a) = (s = start(a); done(a, s) ? throw(ArgumentError("collection must be non-empty")) : next(a, s)[1])
 last(a) = a[end]
 ctranspose(a::AbstractArray) = error("ctranspose not implemented for $(typeof(a)). Consider adding parentheses, e.g. A*(B*C') instead of A*B*C' to avoid explicit calculation of the transposed matrix.")
 transpose(a::AbstractArray) = error("transpose not implemented for $(typeof(a)). Consider adding parentheses, e.g. A*(B*C.') instead of A*B*C' to avoid explicit calculation of the transposed matrix.")

base/array.jl

@@ -1046,7 +1046,9 @@ end
 function hcat{T}(V::Vector{T}...)
     height = length(V[1])
     for j = 2:length(V)
-        if length(V[j]) != height; throw(ArgumentError("vector must have same lengths")); end
+        if length(V[j]) != height
+            throw(DimensionMismatch("vectors must have same lengths"))
+        end
     end
     [ V[j][i]::T for i=1:length(V[1]), j=1:length(V) ]
 end

base/ascii.jl

@@ -98,7 +98,11 @@ write(io::IO, s::ASCIIString) = write(io, s.data)
 ascii(x) = convert(ASCIIString, x)
 convert(::Type{ASCIIString}, s::ASCIIString) = s
 convert(::Type{ASCIIString}, s::UTF8String) = ascii(s.data)
-convert(::Type{ASCIIString}, a::Array{UInt8,1}) = is_valid_ascii(a) ? ASCIIString(a) : error("invalid ASCII sequence")
+convert(::Type{ASCIIString}, a::Vector{UInt8}) = begin
+    is_valid_ascii(a) || throw(ArgumentError("invalid ASCII sequence"))
+    return ASCIIString(a)
+end
+
 function convert(::Type{ASCIIString}, a::Array{UInt8,1}, invalids_as::ASCIIString)
     l = length(a)
     idx = 1

base/base64.jl

@@ -63,7 +63,7 @@ end
 #Returns the first decoded byte and stores up to two more in cache
 function b64decode!(encvec::Vector{UInt8}, cache::Vector{UInt8})
     if length(encvec) < 2
-        error("Incorrect base64 format")
+        throw(ArgumentError("incorrect base64 format, block must be at least 2 and at most 4 bytes"))
     end
     @inbounds u = revb64chars[encvec[1]]
     @inbounds v = revb64chars[encvec[2]]

base/bitarray.jl

@@ -7,11 +7,13 @@ type BitArray{N} <: DenseArray{Bool, N}
     len::Int
     dims::NTuple{N,Int}
     function BitArray(dims::Int...)
-        length(dims) == N || error("number of dimensions must be $N (got $(length(dims)))")
+        length(dims) == N || throw(ArgumentError("number of dimensions must be $N, got $(length(dims))"))
         n = 1
+        i = 1
         for d in dims
-            d >= 0 || error("dimension size must be nonnegative (got $d)")
+            d >= 0 || throw(ArgumentError("dimension size must be ≥ 0, got $d for dimension $i"))
             n *= d
+            i += 1
         end
         nc = num_bit_chunks(n)
         chunks = Array(UInt64, nc)
@@ -34,7 +36,14 @@ length(B::BitArray) = B.len
 size(B::BitVector) = (B.len,)
 size(B::BitArray) = B.dims
 
-size(B::BitVector, d) = (d==1 ? B.len : d>1 ? 1 : error("dimensions should be positive (got $d)"))
+size(B::BitVector, d) = begin
+    if d == 1
+        return B.len
+    elseif d > 1
+        return 1
+    end
+    throw(ArgumentError("dimension must be ≥ 1, got $d"))
+end
 size{N}(B::BitArray{N}, d) = (d>N ? 1 : B.dims[d])
 
 isassigned{N}(B::BitArray{N}, i::Int) = 1 <= i <= length(B)
@@ -592,7 +601,7 @@ function resize!(B::BitVector, n::Integer)
 end
 
 function pop!(B::BitVector)
-    isempty(B) && error("argument must not be empty")
+    isempty(B) && throw(ArgumentError("argument must not be empty"))
     item = B[end]
     B[end] = false
 
@@ -626,7 +635,7 @@ function unshift!(B::BitVector, item)
 end
 
 function shift!(B::BitVector)
-    isempty(B) && error("argument must not be empty")
+    isempty(B) && throw(ArgumentError("argument must not be empty"))
     @inbounds begin
         item = B[1]
 
@@ -753,7 +762,7 @@ function deleteat!(B::BitVector, inds)
     while !done(inds, s)
         (i,s) = next(inds, s)
         if !(q <= i <= n)
-            i < q && error("indices must be unique and sorted")
+            i < q && throw(ArgumentError("indices must be unique and sorted"))
             throw(BoundsError(B, i))
         end
         new_l -= 1
@@ -1540,8 +1549,8 @@ function any(B::BitArray)
     return false
 end
 
-minimum(B::BitArray) = isempty(B) ? error("argument must be non-empty") : all(B)
-maximum(B::BitArray) = isempty(B) ? error("argument must be non-empty") : any(B)
+minimum(B::BitArray) = isempty(B) ? throw(ArgumentError("argument must be non-empty")) : all(B)
+maximum(B::BitArray) = isempty(B) ? throw(ArgumentError("argument must be non-empty")) : any(B)
 
 ## map over bitarrays ##
 
@@ -1682,7 +1691,7 @@ ctranspose(B::BitArray) = transpose(B)
 function permutedims(B::Union(BitArray,StridedArray), perm)
     dimsB = size(B)
     ndimsB = length(dimsB)
-    (ndimsB == length(perm) && isperm(perm)) || error("no valid permutation of dimensions")
+    (ndimsB == length(perm) && isperm(perm)) || throw(ArgumentError("no valid permutation of dimensions"))
     dimsP = ntuple(ndimsB, i->dimsB[perm[i]])::typeof(dimsB)
     P = similar(B, dimsP)
     permutedims!(P, B, perm)
@@ -1694,7 +1703,9 @@ end
 function hcat(B::BitVector...)
     height = length(B[1])
     for j = 2:length(B)
-        length(B[j]) == height || error("dimensions must match")
+        if length(B[j]) != height
+            throw(DimensionMismatch("dimensions must match"))
+        end
     end
     M = BitArray(height, length(B))
     for j = 1:length(B)
@@ -1726,7 +1737,9 @@ function hcat(A::Union(BitMatrix,BitVector)...)
         Aj = A[j]
         nd = ndims(Aj)
         ncols += (nd==2 ? size(Aj,2) : 1)
-        if size(Aj, 1) != nrows; error("rows must match"); end
+        if size(Aj, 1) != nrows
+            throw(DimensionMismatch("row lengths must match"))
+        end
     end
 
     B = BitArray(nrows, ncols)
@@ -1746,7 +1759,9 @@ function vcat(A::BitMatrix...)
     nrows = sum(a->size(a, 1), A)::Int
     ncols = size(A[1], 2)
     for j = 2:nargs
-        size(A[j], 2) == ncols || error("columns must match")
+        if size(A[j], 2) != ncols
+            throw(DimensionMismatch("column lengths must match"))
+        end
     end
     B = BitArray(nrows, ncols)
     Bc = B.chunks
@@ -1784,14 +1799,16 @@ function cat(catdim::Integer, X::Union(BitArray, Integer)...)
 
     if catdim > d_max + 1
         for i = 1:nargs
-            dimsX[1] == dimsX[i] || error("all inputs must have same dimensions when concatenating along a higher dimension");
+            if dimsX[1] != dimsX[i]
+                throw(DimensionMismatch("all inputs must have same dimensions when concatenating along a higher dimension"))
+            end
         end
     elseif nargs >= 2
         for d = 1:d_max
             d == catdim && continue
             len = d <= ndimsX[1] ? dimsX[1][d] : 1
             for i = 2:nargs
-                len == (d <= ndimsX[i] ? dimsX[i][d] : 1) || error("mismatch in dimension ", d)
+                len == (d <= ndimsX[i] ? dimsX[i][d] : 1) || throw(DimensionMismatch("mismatch in dimension $d"))
             end
         end
     end

base/broadcast.jl

@@ -37,7 +37,7 @@ function broadcast_shape(As::Union(AbstractArray,Number)...)
                 if bshape[d] == 1
                     bshape[d] = n
                 elseif bshape[d] != n
-                    error("arrays could not be broadcast to a common size")
+                    throw(DimensionMismatch("arrays could not be broadcast to a common size"))
                 end
             end
         end
@@ -49,12 +49,12 @@ end
 function check_broadcast_shape(shape::Dims, As::Union(AbstractArray,Number)...)
     for A in As
         if ndims(A) > length(shape)
-            error("cannot broadcast array to have fewer dimensions")
+            throw(DimensionMismatch("cannot broadcast array to have fewer dimensions"))
         end
         for k in 1:ndims(A)
             n, nA = shape[k], size(A, k)
             if n != nA != 1
-                error("array could not be broadcast to match destination")
+                throw(DimensionMismatch("array could not be broadcast to match destination"))
             end
         end
     end