[Haskell-cafe] Compiled program using OpenGL fails to trigger GPU switch on Mac, but works in GHCi

[Carter Schonwald]

Hey Jesper:
hrm... have you tried other compilation / ffi choices that can influence
the function call?

eg: using the "safe" rather than "unsafe" modifier?
http://www.haskell.org/haskellwiki/GHC/Using_the_FFI#Introduction
(the safe modifier doesn't seem like it matters here, but its a simple
experiment to check)

likewise, another experiment would be write your own c code wrapper around
that opengl call, and  call that wrapper from haskell.

OH, and your code snippet isn't specifying *where* the glfw code is linked
from! might it be linking to the *wrong* variant of the library since
you're not specifying where the code is? You might want to set up a little
cabal configured project that specifies all of that stuff.

additionally, have you tried your code on ghc 7.6.2 ?  (do this last i
suppose)


I don't know if any of these ideas are actually helpful, but if they are,
please share what you've learned.

cheers
-Carter



On Sat, Mar 16, 2013 at 9:53 PM, Jesper Särnesjö <sarnesjo at gmail.com> wrote:

> On Thu, Mar 14, 2013 at 12:51 AM, Jesper Särnesjö <sarnesjo at gmail.com>
> wrote:
> > In short, I have two programs, one written in Haskell [1] and one
> > written in C [2], that consist of calls to the same functions, in the
> > same order, to the same C library, but which do not exhibit the same
> > behavior. Further, the Haskell program behaves differently when
> > compiled using GHC, and when run in GHCi. I would like to know why
> > this is, and how to fix it.
>
> To be clear, I think this isn't really an OpenGL problem, but rather
> one related to FFI or event handling. If anyone could explain to me,
> in general, how and why a call to a foreign function returning IO ()
> might cause different behavior in Haskell than in C, that might help
> me track down the problem.
>
> I've updated my test programs to use glGetString [3] to check which
> renderer is active. On my machine, it should return "NVIDIA GeForce GT
> 330M OpenGL Engine" if rendering happens on the discrete GPU, and
> "Intel HD Graphics OpenGL Engine" or "Apple Software Renderer"
> otherwise. These are the results of running the C and Haskell programs
> in various ways:
>
>     $ gcc -lglfw -framework OpenGL glfw_test.c && ./a.out
>     NVIDIA GeForce GT 330M OpenGL Engine
>
>     $ ghc -lglfw -framework OpenGL -fforce-recomp glfw_test.hs &&
> ./glfw_test
>     [...]
>     Apple Software Renderer
>
>     $ runhaskell -lglfw glfw_test.hs
>     NVIDIA GeForce GT 330M OpenGL Engine
>
>     $ ghci -lglfw glfw_test.hs
>     [...]
>     Prelude Main> main
>     NVIDIA GeForce GT 330M OpenGL Engine
>
> The C program behaves as expected, as does the Haskell one when run
> using runhaskell or GHCi. Only the Haskell program compiled using GHC
> behaves incorrectly. Again, the OS event that signifies that a GPU
> switch has occurred fires either way, but for the compiled Haskell
> program, it fires with roughly a second's delay. Why would that be?
>
> --
> Jesper Särnesjö
> http://jesper.sarnesjo.org/
>
> [1] https://gist.github.com/sarnesjo/5151894#file-glfw_test-hs
> [2] https://gist.github.com/sarnesjo/5151894#file-glfw_test-c
> [3] http://www.opengl.org/sdk/docs/man3/xhtml/glGetString.xml
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe at haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.haskell.org/pipermail/haskell-cafe/attachments/20130317/e553df53/attachment.htm>