I am also writing a program that allows you to interactively type in and modify an SDF, which is then interpreted (and differentiated for shading) by a Futhark program.
But it's a bit slow. Raymarching is super compute intensive.
(and a language that can utilise them)
None of them have truly beefy GPUs, though. The dream lives on.
I also need to experiment with the fastest way of writing a bytecode interpreter in Futhark: https://github.com/athas/futhark-cool-sdf/blob/main/lys.fut#L4-L59
Interesting problem, I hadn't even considered that way of creating flexibility in a Futhark program. I could only see splitting the program into smaller parts that can be called from another language, so this is pretty inspiring.
In most cases it is not worth it, I think.
But it's fun to play with.
the use cases will probably be limited, but the idea of applying some user defined function in a futhark kernel is something I have considered, actually for a pretty similar appllication to this.
There is this haskell library called ImplicitCAD, that basically outputs geometry(stl-files) based on equations, but it runs on CPU and is quite sluggish for some things that I tried.
I suppose in most cases the visualisation is the end goal anyway, so then raymarching is more straight to the point, but for, say 3D-printing, it's pretty nice.
And you might have so many contracts, and they may change so often, that it makes no sense to compile specialised code.
That certainly seems like a valid application. For some reason I just find the idea of interpretation on GPU to be a bit fascinating.
I guess the fact that we can also differentiate interpreted programs on GPU made it even more so.
I am still enthralled by the notion of differentiating something like an interpreter.
and I invoke it as e.g.
g (f)
However, say I want to decorate/annotate the
f function to e.g. multiply by two
let mul2 (x) =
x * 2To invoke it as
g (f |> mul2)
sorry if this is an obvious question, but I cannot find an example. I am writing a generic function that takes in an integer and I want to convert a bool to that type of integer in the function. I.e. if it was ant int32 I would use int32.bool. Is there a way of annotating that the type must be an integer or rational. I pressume it is straight forward seeing https://futhark-lang.org/pkgs/github.com/athas/matte/0.1.2/doc/prelude/math.html#1753 but I am not sure
But if you want something more lightweight, you can ask the user to pass in a bool-to-number function. E.g.
def foo 't (x: t) (to_t: bool -> t) = ...
I had my computer crash when I ran a futhark program on my AMD gpu (works, but is slow on my old nvidia gpu). I don't think this is a futhark problem, but I wonder what the issue could be. The power draw should be well within what the PSU can handle, especially since I wasn't running anything heavy on other components. Do you know any 'known good' compute loads to test maximum power draw, just to rule that out as a cause? I have previously run other futhark programs on it without issue.
I have had many random crashes with GPU drivers. Did you get a kernel panic or did the machine just reboot?
the PSU is rated for 1300w, so it really shouldn't be the issue, but I am not sure of exactly how the power is delivered. It's a Dell workstation where it's pretty hard to access the cables except for those intended for expansion.
This doesn't tell you what is going wrong, but it means that AMDs driver (or hardware) has bugs where userspace behaviour can cause reboots.
I guess I have to try running some other programs on the current system in case something has changed
it does sound like a drivevr bug
or hardware, I suppose