If b is an array of Integers, doesn't work. about krylov.jl HOT 18 CLOSED

In that case, the third option works well. I'll implement and make a PR.

from krylov.jl.

Shame on me. It failed because I used a rhs with integer values of integer type. Will investigate further, though.

from krylov.jl.

What doesn't work exactly?

from krylov.jl.

It looks like BLAS.dot only accept floats. I see three solutions:

• Change BLAS.dot to dot;
• Change the type of b from Array{T,1} to Array{Float64,1}, so that it really won't work for Array{Int,1}, but it will be clearer where;
• Change r = copy(b) to r = 1.0*b.

from krylov.jl.

Yes, BLAS is only float32, float64, complex64 and complex128. In my tests, BLAS.dot can be much faster than dot, but things might have changed. I think b should be declared Vector{T} with T <: Real. If the user's b is integer, we should convert it to float64.

from krylov.jl.

Note (for the future) that there are disadvantages to using BLAS.dot:

1. vectors must be contiguous; you can't use non-contiguous slices
2. the implementation doesn't generalize to multiple right-hand sides.

Maybe it's time to benchmark dot again.

from krylov.jl.

Code: https://gist.github.com/abelsiqueira/23148a392462c2d7a07fbdb1f943119f

Minimum, mean and maximum times

BLAS.dot time/dot time. Greater than 1 means that BLAS.dot is that much faster.

Looks like BLAS.dot is much better for small problems.

from krylov.jl.

Many thanks for that! So BLAS.dot remains very much relevant.

from krylov.jl.

What BLAS are you using?

from krylov.jl.

The default. I think that's OpenBLAS.

from krylov.jl.

It must be better tuned than mine because if I try to reproduce your experiment, BLAS.dot and dot are pretty much the same at size 100 or even less.

from krylov.jl.

Fixed in #18.

from krylov.jl.

In the same vein, I'm noticing (with my BLAS) that

• BLAS.dot(x, y) (as opposed to BLAS.dot(n, x, 1, y, 1)) has the same performance as dot(x,y)
• BLAS.nrm2(x,y) is similar to BLAS.nrm2(n, x, 1) and both are faster than norm(x).

I modified your script: https://gist.github.com/272c500b0e0a8557682378b6924aeb48

from krylov.jl.

My results (changed to 15)

from krylov.jl.

I observe the same with nrm2. My statement above was incorrect. I fixed it.

from krylov.jl.

Looking at
https://github.com/JuliaLang/julia/blob/v0.5.0/base/linalg/blas.jl
and
https://github.com/JuliaLang/julia/blob/v0.5.0/base/linalg/generic.jl
I found that

• dot is sufficiently more complicated than BLAS.dot
• BLAS.dot simple should be slightly more complicated that BLAS.dot
• norm is sufficiently more complicated than BLAS.nrm2
• BLAS.nrm2 simple should be slightly more complicated that BLAS.nrm2
• BLAS.nrm2 is simpler that BLAS.dot simple
• BLAS.dot simple uses parametric types, while BLAS.nrm2 simple doesn't.

from krylov.jl.

A straightforward comparison of BLAS.scal! with a simple loop equivalent shows that BLAS.scal! always looses! I wonder if there's room for a package that will benchmark those things and export only the best versions (i.e., it will export, say, BLAS1.dot, which will correspond to either BLAS.dot or to Julia dot, depending on which is faster on a given machine with the BLAS used to build Julia). We should keep in mind that the BLAS functions will only be efficient with contiguous arrays of type <: BlasReal.

from krylov.jl.

I think nobody has gone to the trouble of doing this (or other upgrades on BLAS) because of the relative small performance gain versus the trouble of doing it. But it's at least worth investigating or mentioning on the discourse or the issues.

from krylov.jl.