Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
    Simon
    @SimonDanisch
    yes! let me see how it works best currently!
    Simon
    @SimonDanisch
    is the calculation super slow?
    Christopher Rackauckas
    @ChrisRackauckas
    it's using an implicit Euler method
    there's a reason why there's so much research in timestepping routines and making ODE solvers faster for stiff equations :smile:
    Sheehan Olver
    @dlfivefifty
    No the calculation is really fast as soon as QR cache is built up
    The solve takes about 0.004s though evaluating on the grid is slower, 0.2s, but still 5fps or so
    Christopher Rackauckas
    @ChrisRackauckas
    oh I see, you just cache the QR
    how many basis elements does it take (what's the size of the matrix?)
    Sheehan Olver
    @dlfivefifty
    I want to move the evaluation step to the GPU
    Christopher Rackauckas
    @ChrisRackauckas
    I really need to get on-board and take some time learning ApproxFun
    Sheehan Olver
    @dlfivefifty
    It grows adaptively, so Inf x Inf
    Christopher Rackauckas
    @ChrisRackauckas
    but how could you do that on the GPU?
    They're awful at dynamic allocation
    Sheehan Olver
    @dlfivefifty
    Just the evaluation step
    Christopher Rackauckas
    @ChrisRackauckas
    (Xeon Phi on the otherhand sounds interesting for this)
    Sheehan Olver
    @dlfivefifty
    This is a 2D Clenshaw
    The plotting grid is not adaptive
    Christopher Rackauckas
    @ChrisRackauckas
    what exactly is the evaluation step doing?
    assembling a matrix?
    Sheehan Olver
    @dlfivefifty
    No
    Evaluating the solution on the grid
    Christopher Rackauckas
    @ChrisRackauckas
    oh I see
    Sheehan Olver
    @dlfivefifty
    Nope
    Clenshaws algorithm
    Simon
    @SimonDanisch
    could you turn it into a broadcast, as in f.(matrix), where f is a non allocating pure function?
    Christopher Rackauckas
    @ChrisRackauckas
    oh, so it's the evaluation of the basis, not the projection to the basis?
    Sheehan Olver
    @dlfivefifty
    Simon
    @SimonDanisch
    @time u=\(QR,C*u;tolerance=1E-5)
      5.121884s
    that's what I mean with slow, btw ;)
    Sheehan Olver
    @dlfivefifty
    The first step builds up the cache
    Simon
    @SimonDanisch
    but that was the third
    am I on some old version, maybe?
    Sheehan Olver
    @dlfivefifty
    @ChrisRackauckas evaluating an expansion in a basis, you don't construct the basis itself (though maybe that's better...) it's a generalisation of Horner algorithm
    It grows the cache adaptively
    Christopher Rackauckas
    @ChrisRackauckas
    I see
    so the Clenshaw algorithm is the name for the recursive algorithm for generating the Chebyshev polynomials? And you are not constructing the basis, just evaluating the expansion in the Chebyschev basis until some tolerance is reached?
    Sheehan Olver
    @dlfivefifty
    @SimonDanisch it grows the cache adaptively. The third step the solution is growing so the cache needs to grow. Eventually it saturates and the cache is sufficient
    Christopher Rackauckas
    @ChrisRackauckas
    I'll take my ApproxFun questions over to your channel.
    Sheehan Olver
    @dlfivefifty
    @ChrisRackauckas no you don't generate the basis. It evaluates the expansion directly, in reverse order. So a backward recurrence instead of forward
    The expansion is already finite once it's calculated, so not adaptive
    Simon
    @SimonDanisch
    hm... it seems like it even gets slower...
    I'm on frame 10 and started it a couple of minutes ago
    still on 11 ... it definitely gets a lot slower over time...
    Simon
    @SimonDanisch
    okay, I added video streaming, which should be lots faster than previous options to capture a glvisualize video
    also, i adapted your example to incorperate the video streaming, plus computing in a different process ;)
    I've change the example to use rand instead of your calculation... it was simply too slow to play around with it productively
    addprocs(1)
    workid = workers()[end]
    @everywhere using ApproxFun, MultivariateOrthogonalPolynomials, FixedSizeArrays
    @everywhere import MultivariateOrthogonalPolynomials: plan_evaluate
    using Plots, GLVisualize
    window = glscreen()
    @async GLWindow.waiting_renderloop(window)
    
    N = 600
    x = linspace(0f0, 2f0, N)
    X = x * fill(1, (1, N))
    Y = fill(1, (N, 1)) * x'
    Z = rand(Float32, N, N)
    vis = visualize((X,Y,Z), :surface)
    _view(vis)
    
    test = homedir()*"/test.mkv"
    # framerate should rather be dynamic... not sure how to set that up
    # you'll need ffmpeg installed and in the path!
    io, buffer = GLVisualize.create_video_stream(test, window)
    
    while isopen(window)
        # lets run this in another process, to not freeze GLVisualize
        Z = remotecall_fetch(workid, X) do X
            Z = map(x-> rand(Float32), X)
            sleep(1.0) # simulate compute
            Z
        end
        GLAbstraction.set_arg!(vis, :position_z, Z)
        yield()
        GLVisualize.add_frame!(io, window, buffer)
    end
    close(io) # flush video stream and write it out
    Sheehan Olver
    @dlfivefifty
    still on 11 ... it definitely gets a lot slower over time...
    Are you calling chop!(u,1E-7)? Otherwise, the length will continue to grow