@bridgman (and other devs etc.)
In the slight hope that you are still reading this thread: don't forget that for every vocal hmm "crazy" here in the forum, there are several silent readers who appreciate such insightful information of yours (well, there is at least one for sure...), so keep posting if you are in the mood, it IS appreciated
Announcement
Collapse
No announcement yet.
Radeon Gallium3D OpenCL Is Coming Close
Collapse
X
-
Originally posted by Qaridariumbecause you admit that I am rhetorically gifted and that makes me competent to judge him.
Leave a comment:
-
Originally posted by Qaridariumread this book then you understand how bridgman works:"The Art of Being Right: 38 Ways to Win an Argument" http://en.wikipedia.org/wiki/The_Art_of_Being_Right
Leave a comment:
-
Originally posted by Qaridariumin your rhetoric we only get 45-50% in "LOL-OEM-LOL" products and we get it because the "LOL-OEM-LOL" take care about opensource drivers.
and we get 10-20% performance with the Llano because amd sell these GPUs with there CPUs directly to the customer and no "LOL-OEM-LOL" is there to protect us from AMD's make fun on open-source customers LOL!
amd should really stop to sell APUs to customers directly then maybe the performance increase from 10-20% to 45-50%
i'll take you seriously again if the products AMD sell directly to consumers are on the same performance level than the products from the LOL-OEM-LOL companies.
i can only recommend to buy INTEL if someone don't wanna spend expensive money on a LOL-OEM-LOL graphic card product.
Leave a comment:
-
Originally posted by crazycheese View PostExcuse me for short intervention, but what about complexity of Linux? Was it fatal? Has number of hackers reduced from version 0.01 till recent or increased?
Graphics driver development community seems to be growing at roughly the same pace as the general Linux developer community, with roughly the same mix of commercial and volunteer developers.
Take a read through http://go.linuxfoundation.org/who-writes-linux-2012 - starting to see a number of graphics developers showing up in the "top contributors" list.
Originally posted by crazycheese View PostWe don't get 80% performance, we get 20%.
Originally posted by crazycheese View PostWe are missing raw programming resource, everyone knows this.
Originally posted by crazycheese View PostAlso, everyone knows we don't achieve this resource by talking it over and over, or by endlessly changing points of view and finding array of arguments.
Originally posted by crazycheese View PostIf we are to change something, we are to pick direction and follow it. This will never happen, it is fact.
Linux started out with fairly basic implementations of all the major functions, then over the years different subsystems were gradually replaced with more complex but more featureful and higher performing implementations. That's the same pattern we are seeing with graphics -- UMS gets replaced with KMS, shader translators get replaced with shader compilers, classic Mesa HW layer gets replaced with Gallium3D layer, layers get blended together for performance (eg Intel plans to use GLSL IR in the graphics HW layer) etc...
That seems like the right approach to me, but it is not consistent with "open source drivers running faster than proprietary drivers in the first couple of years" which is what everyone except the developers seemed to expect. Now I guess the popular sentiment is "things aren't moving as fast as I hoped so open source drivers are always going to suck", which is just as wrong.Last edited by bridgman; 14 May 2012, 10:13 PM.
Leave a comment:
-
Originally posted by bridgman View PostThis is one of the interesting tradeoffs. Do you want the driver to be simple and accessible so more people can potentially contribute, or do you want it to be sufficiently sophisticated that it could potentially match the performance of proprietary drivers at the cost of reducing the pool of potential contributors ?
Leave a comment:
-
Originally posted by benjamin545 View Postso in the linux ecosystem, we have some paid hardcore developers and we have a lot of hobbyists. hobbyists will never ever individualy on their own design a modern graphics driver thats competitive with todays standards, and thats ok. now as we have seen in the linux graphics stack over the past few years, paid hardcore developers have come a long way in creating a very competative graphics stack, but we really want hobbyists to be a part of that too, and while some have, i think a lot of people while willing a possibly able to conribute, still feel overwhelmed with the complexity of it all.
The current open source driver standards seem to be aimed at the knee of the curve, where they're sufficiently complex to allow writing "fairly performant" without becoming "twice as complex for a small increase in performance". Seems like a good compromise, but it's important to understand that it *is* a compromise.
As an example, the open source drivers have a relatively large amount of common code and a relatively small amount of HW-specific code but if you want to get that last 20% of potential performance you generally need to move the line up and have substantially more of the driver stack being hardware-specific. That makes the driver code larger and more complex, which in turn makes it a lot harder for potential developers to contribute.
Originally posted by benjamin545 View Postgetting more the the point i guess, is that if tgsi is a simpler ir to transport between various componants, if i was a newcomer wanting to develop a componant, it would be easier to deal with tgsi. if it is then nessicary to convert it to something more specific to what i am doing, (whitch is what ive been hearing all along is that its too hard to create one all encompasing ir that is perfect for all state trackers and all hardware drivers), then that is what would hae to be done. at least then you could try to make your internal ir something specific to your hardware, for instance, i sure the nvfx/nv30 driver, with its ununified shader cores, is much diferent than the nv50 or nv0c or whatever.
Originally posted by benjamin545 View Postit would be best if other parts of gallium had that same kind of mentality, for instance, memory management is one where initialy gallium was sold as being able to abstract memory management compleatly into the sinsys portion of the driver, but whate ive read before is that a lot of the memory management has been implemented in the hardware drivers usualy due to some feature missing from gallium or it just being easier for whoever is doing it to do it in the driver (im guessing proboobly a lot of that comes from the initial testing and learning stages).Last edited by bridgman; 13 May 2012, 11:15 PM.
Leave a comment:
-
well, then it seems like the obvious answer is if we cant have both a structured ir thats as easily transportable between componants (best of both worlds) then we have to use the right ir at the right time for the right solution.
i guess you have to take a step back and try to realize what the big picture is, what is it we want. regarding gallium3d, and i know thats excluding intel and anchient stuff, but what can you realy do about that, is we want a strong central structure that interconects various piecies that do specific functionalities (heres a opencl state tracker, heres a nvidia generation X driver, heres a windows xp winsys connector). this is what gallium3d was billed as. but it was intended for use initialy and primarily for the linux ecosystem, even if it wasn't locked into that specific role.
so in the linux ecosystem, we have some paid hardcore developers and we have a lot of hobbyists. hobbyists will never ever individualy on their own design a modern graphics driver thats competitive with todays standards, and thats ok. now as we have seen in the linux graphics stack over the past few years, paid hardcore developers have come a long way in creating a very competative graphics stack, but we really want hobbyists to be a part of that too, and while some have, i think a lot of people while willing a possibly able to conribute, still feel overwhelmed with the complexity of it all.
getting more the the point i guess, is that if tgsi is a simpler ir to transport between various componants, if i was a newcomer wanting to develop a componant, it would be easier to deal with tgsi. if it is then nessicary to convert it to something more specific to what i am doing, (whitch is what ive been hearing all along is that its too hard to create one all encompasing ir that is perfect for all state trackers and all hardware drivers), then that is what would hae to be done. at least then you could try to make your internal ir something specific to your hardware, for instance, i sure the nvfx/nv30 driver, with its ununified shader cores, is much diferent than the nv50 or nv0c or whatever.
it would be best if other parts of gallium had that same kind of mentality, for instance, memory management is one where initialy gallium was sold as being able to abstract memory management compleatly into the sinsys portion of the driver, but whate ive read before is that a lot of the memory management has been implemented in the hardware drivers usualy due to some feature missing from gallium or it just being easier for whoever is doing it to do it in the driver (im guessing proboobly a lot of that comes from the initial testing and learning stages).
Leave a comment:
-
Originally posted by benjamin545 View PostAh, so, basicaly, we( we as in you, dont you just love when people say we but really they themselves aren't part of the "we") have no clue how demanding compute will be on the ir and in what way the ir will need to bend to effectivly operate.
Originally posted by benjamin545 View Postcan you tell me this then. i know we often hear about the ir languages probobly more so than any other componant of the graphics stack below the actual end user api's, but how inconviniant is it really to switch from one to the other? in a game engine it would be a real job to change out from ogl to dx, even from ogl to ogl es if ddone certain ways, but how much of a bother would it be for you to change amd compute back end frrom the llvm over to tgsi if that was the more unified aproch?
This wasn't a matter of intertia though -- some of the IRs are structured as trees or linked lists which a compiler can work on directly (eg optimization steps) while others like TGSI are "flat" and intended for exchange between components rather than as an internal representation worked on directly by the compiler.
That breaks the problem down into two parts :
1. Should the IR be something suitable for direct use by compiler internals, or should it be something designed primarily for transmittal between driver components ?
The advantage of something "flat" like TGSI or AMDIL is that it is relatively independent of compiler internals. The disadvantage is that all but the simplest compilers will require a more structured IR internally and so translation to and from TGSI will be required at each component boundary. Complicating the matter is that while the extra translations seem like they would slow things down they only slow down the compilation step not the runtime execution. Compilation does not usually happen every time the shader is run - minimum is once at program startup, with recompilation sometimes needed when state info that affects shader code changes or if the driver's cache of compiled shaders fills up.
If the choice is something "flat" then TGSI is probably the most likely choice for the open source stacks. If a flat IR is *not* chosen, then we get to question 2...
2. Assuming a structured IR is used, which one should be used ?
This is where GLSL IR and LLVM IR enter the picture, and where the choice of shader compiler internals becomes a factor.
For graphics, the Intel devs were talking about feeding GLSL IR directly into the HW shader compiler for graphics.
Before you say "that's wierd", remember that the high level compiler in Mesa (the "OpenGL state tracker") generates GLSL IR directly which is then converted into TGSI or Mesa IR for use by HW layer drivers so using GLSL IR bypasses some translation steps. For graphics, "Classic" HW drivers use Mesa IR today while "Gallium3D" HW drivers use TGSI. Bottom line is that when you run a GL program on any option source driver the shader starts as GLSL IR then gets optionally translated to something else.
Clover, on the other hand, starts with Clang which generates LLVM IR directly, so the kernel starts as LLVM IR then gets optionally translated to something else.
Once you get down to the HW driver, the shader compiler is likely to need a structured IR such as GLSL IR or LLVM IR. You can see where this is going...
Originally posted by benjamin545 View Postalso, whats the chances someone will start slinging gcc ir in there as an option what with their plans to try and make a competing ir more like what llvm has?Last edited by bridgman; 13 May 2012, 08:13 PM.
Leave a comment:
Leave a comment: