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ö <sarne...@gmail.com> wrote: > On Thu, Mar 14, 2013 at 12:51 AM, Jesper Särnesjö <sarne...@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@haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe