Bestand wählen
Merken

Atomic Mode-Setting

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
on this but this is like the 1st time I've presented from not speaking loudly enough you have know every hearing all of that but this is my name's carry it with that in the I am a kernel developer idea I maintain the tiger of platform along with that kind Alex and Stewart talk later on you should stay found you're in for a treat yeah I also tried to do most graphics because that's what I'm interested in is what we what we do well the so I'm going to talk about comic mode setting a have they have a short summary this there's a lot to cover so as I find the truth when you cover everything in all that much detail so let's let's get started so we have a for a bit of history we have we've had a number of of ways to do mode setting and and graphics and then and very early on user space was essentially doing everything and there was like bias was involve an extra 6 we could actually needed by a support to get the modes right and all that the downside is that you had you had to have a next Ribot was talking directly to the hardware registers and in the notes you can do that if you're not a super user so X needs to be run with superuser privileges on which is a bad thing because it's a huge piece of code and it and you of wrong so in the Middle Ages the the durum was introduced as a means to share I want 1 and 1 of the downsides of having the extra talk to the hardware directly is that was the only 1 that could talk to the graphics hardware because it you reprint synchronizing that no single point of synchronization and you're theorem allowed us to do was to have 1 kernel divides that would actually multiplex between the various clients on there were you cut some of the some of the things that were were being tried was to have a unified API in the kernel to to do buffer management and command submissions which abuse and that just doesn't work because graphics hardware is completely different on on on different vendors so but and then the downside of that was 1 of the things it didn't address for that user space was still performing modes having and that does have its own set of problems this is also a pretty dark time in the graphics history and there's like which transcend and other people being burned at the stake and the kind of thing so I'm I'm kind of glad that it's the only got into this around this time so I'm glad that I didn't have to put up with it Our Cs when they become a thing was introduced as a way to to abstract away outputs management what proper device management for user space that uses this could talk to put a torque using 1 API to our tool of devices essentially and so it's not in the kernel driver selection do the mode setting for you have an API that you use to talk to the intensive mode the flights of the display panels the projectors that also manages buffer objects like every driver has to means of allocating buffers there's a there's a common API even offers like linear property useful stand out so you can actually have a completely generic driver using that API that that will our work on every every GPU essentially that that can do 10 minutes there's also hope attending so if you put plug out your teacher might you be divided by unit just works and so what is there's so many details of kernel-mode having is that it has these objects and they're mostly some of them are visible to user space like this year seize year see is basically a representation of the display controller so if it takes the buffer you takes parameters to set the mode of the video timing just scans about to some encoder encoder pass it on to connect and then it goes into an HQ my the monitor or into the panel on a lot of on and so we can set modes we can now set the frame buffer that are supposed to be displayed and we can also page that buffers which is important if you want to do caring free graphics of in graphics there's this concept of the blank where you have like a short period of time between 2 frames where it just as an update the screen and and page flipping is essentially you can't synchronize to the blank so that whenever you depart from this you get like an update of your frame buffer that doesn't show any tearing tearing is the effect that happens if you update not within the blind but while extending out and we can get half of the of 1 picture to have another picture and it just looks ugly and now we also plane planes are that that's a term that we use for overlay path where where you can just have 1 special window on top of your root window the ruling of being I the what you usually see that like the frame of a consul your X desktop so rude window and and planes are probabilistic can put on top of that you can do often do color space conversion I can use over the outputs and use it for persons the kind of stuff I want 1 of the 8 1 of the concepts there was also introduced was that of object properties they can set properties on planes on surety season they can influence the way that they behave is and so unfortunately not not everything is perfect I still the the current API that we have this kind of limited in ways for instance if you tell the hardware to set the mode at some point it fails there's no real way to fall back to want to roll back what whatever you did Lu and unless you do yeah very complicated drivers that you have to know that you're in a pretty bad position because it just it can tell you I fails and there's no display some cases can even see messages that it that it with there would tell you that it failed so on fortunately many drivers are pretty good at that setting mode so you you don't often see that happen but if it happens you have no way of across recovering the 1 or the other there are things that came doesn't do currently is that you can't updates in screen configuration and at at once or in totality so if you have like multiple the overlays if you want to show on screen there's a way to ensure that the action displayed at the same frame circuit what usually happens is to display 1 and the other and you see it yet you see the difference is see 1 popping up and the other the and de 1 1 of the things with planes is that they're sort of tacked on and you can you can do thus synchronized page flipping the events in sequence thing for the root window you can do it for overlays because the API just in doesn't have that and that causes problems for composite those because they want to do things like perfect prince and I show you a minute what that means this but if it's it's so 1 of the things that way and so is all about really because it allows you to have like you built up a frame you render it and then you just pass it to a screen you you page that that and it's it's there in totality on so this is
what what the perfect frame is supposed to look like the bottom and what what we want to have what what happens to the current API is that you have a black screen you want to show to this is the red 1 of the blue rectangles are suppose to be overlaid with you display to overlays what you get is to get 1 1st and then the other and what what you really want if you want to have both at the same time if the application television both and something we just can't do it need so atomic
noting with out what what atomic motoring allows you to do is that there's still 2 things that are really at 1 1 is that it allows you to consequently in output configuration to the kernel it will it will actually validate at each level will validate whether it can actually drive this configuration if you can do it at your reports never before action touching hardware it that so this so you yet you don't have a need to roll back because you can check this configuration it doesn't work because use you you don't even try to set it because the the driver knows is can work and did the the the the 2nd the 2nd thing that it does is industry based on the same mechanism is that you and I hope that I can make that clearer later on the 2nd thing that it does is you can actually queue up for for should provide a complete set of settings to apply and it and it will actually to applied at at the same the blank interval so you can actually get no page things think the events occur especially for for everything the that it doesn't it sounds it sounds very complicated them mean atomic something that that everybody familiar with but it sounds more complicated than it is it turns out that the connection from the whole of Cold and that the core theorem core is actually able to do a lot of the things that you would have to do manual it in in your drivers this so the year
and we don't have this in this slide but some some of the background and this is that that is the Android has been that has needed this kind of functionality for quite a while and and they've always come up with a with their own solutions as I think it's called ADF for atomic display framework or something and and and they can do some of these things and and on the other hand it's that you can really go and have 1 of those writers and portion of because upstream here and kms is the framework that is supposed to you so what 1 of the girls was to also satisfy the needs of Android using this API so that eventually could just have 1 display driver to rule them all avenues on Linux on Android on so that I'm going to talk a bit about what the basic building blocks are forced to to make commitment setting work and it said the nice thing about the commitment thing is that you can actually to this in steps and you can if you start with this basic building blocks in section 3 simple convert the driver to comply with the new atomic setting the some Sin traditional chemists the that that the root window is kind of special you don't really see it as a as a window it's basically just in the frame buffer that this year see scans out and that 1 of the building blocks is universal planes which means that you actually get to deal with all the play and and modern hardware is actually that way of that's often designed that way that you have that that the root window is just like a regular overlay it's just treated specially in software and so so the the 1 a thing such universal planes does is that it just considers everything to be but even the window and also process it just exposes them as regular planes which had has various advantages 1 is that you can't use the same code because of mistrust the very same register sets that you talk to and it also means that user space has a much much easier time dealing with them so the um like I said the root window becomes a regular plane and the cursor becomes a regular planet cursor it's important because the cursor API that old kms has is pretty limited in that you can also only a passive a specific format so you can't you're supposed to pass in the RGB 32 bit format it and some we're just can't do that so I'm somewhat part where you can use proper workers as because the API doesn't allow with the with with claims that the thing is that you can issue query planes for the this this performance that it supports connection just know take occurs and user space uh render it into a buffer of past a buffer to that plane and just display that person and no matter what format the Harvard supports the idea there's a a good set of helpers and mostly and tell that work 2 2 3 support the old userspace interfaces in terms of universal planes we can actually just have a driver that it isn't only universal planes but also so be compatible with older users that is in the same with the even the other way around that you can actually have a heart where it doesn't have a separate plane for for for the the root window you connection emulated as the primary plane if the bot buy some of those so helpers they would just are you implement the new universal played callbacks in terms of the old functionality that we had that we just talked to Syracuse he's on the so when it 1 of the other things that atomic Mossing does it's essentially it moves all the things that were being passed to to the API as parameters it moves that into properties so every object like this year to see your connected or planes have a bunch of new properties now that you can set independently but this is important because these the user there the whole state of your heart rate is actually coded in atomic state objects now so that you have a would you do if you want to change your display configuration you take an state object and modify it so you set properties into distinct objects and and and then you can apply you can check to state object but it's such a valid configuration and then you can also ask to the heart where to apply this configuration on for 1 of the drawbacks of that is that we haven't had a they needs to actually use blob properties that you would need for something like a like a video the video mode structure to set mode has various fields where he says we tell it how how wide is how high is it what the frequency is a the kind of thing you need to have some kind of love property otherwise you would have to have like a ton of properties just described the mode 1 of the things that we haven't done yet and for having never had a need to actually pass from userspace passing evolved into trouble so what we can do is we can take take out the 4 readouts the units for instance using blocks but we can write them into the Carmel that's 1 of the things that's being worked on this this just really busy busywork nothing that so if possible to so the the they're just me to the 2nd part of the presentation and I'm a trick on any chemist private developers here your hands all right that's more than I had expected on so this is where you guys and everyone else so I'm hoping that this would show that graphically sexual pretty trivial you may be very interested in destroying us the on so universal claims are really like I said before modern hardware has usually exposes these things as planes in some way so it's pretty trivial to actually right the code to get that to work and that many drivers have been converted to like all the big ones that are using it and many of the SSC drivers do that as well so there's a lot of references that you that you have the year by about mention that this part of going to be about converting drivers so this is part of the next few slides are going to be about the work that you need to do to prepare a driver to be converted Tom depressing is if you do the same it's really
trivial fact you make it work with atomic motor some of this is not going to be as easy though so and I'll try to I I I I I spent about a month or so before the conference to try to to convert our Tegra driver to and it was kind of a lot of work to make it fit into this model if you if you if you do this all a right already then it should be really easy so I so when it at 1 of the things that atomic mode saying doesn't it takes a lot of work from years we have like like if you if you the if you want to pass buffers to a display control you need to make sure that the memory that it accesses is still valid that it's allocated because otherwise you would all of it all of a sudden situation where you it would access memory that's just not meant for it to be used and and the atomic mode setting has pretty strict requirements that she goes and it and it holds onto the buffers as long as as the hardware is accessing it that uses the blanks to to to determine how long a buffer a right to be so tha some the good thing is that in the past drivers of pretty much done that all by themselves so there's a lot of code and various drivers to make sure that buffers are only only unmapped or or on thin for memory memory but what when they're no longer in use with atomic nodes setting you just have to do any of that you just that he essentially just pass in a buffer from users for users present in a buffer and a court takes care of everything and the driver doesn't have to worry about so was but what 1 of the important things and I think I'll Orangemen into that's the other thing is that that it's the prime minister is such that you actually have to tell the durum core when your display the control is not scanning out anymore because otherwise what the helpers would do is that they would wait for the blank to happen but if you're research then it's never going to happen and it will time out and you have a warning in your kernel or so what you want to do is there is a function that you need to call and I think the latest info is that you need to do is to call that in your driver at the very beginning just to make sure that your that internally theorem and came as no that it's off and then whenever you you turn it on like it's going out in you buffer you turn this year to see on then you just called adherence here to see the blank on function just to tell it the blanks from now on this story to be the blank unless I find myself off again a few if you do that rights and then it's just that gonna work automatically for you 1 is saying so of lead us not not something that everybody has to do we had to do this on Tegra because we were or I should say I myself was lazy forward and in the the expectations of atomic modes setting are that you do things in a certain way if you don't do minute in in a certain way it's just not gonna work and this is important for DPMs and I will go into some more detail later on so I'll skip that work for now so there's various callbacks for seasoned and encoded the various objects where and there they have somewhat weird names like the prepare called back is used when it's here to see on encoder is actually being disabled in that's forest Oracle reason on that the modes having the most call biggest is is called whenever you have a state change with every action change the mode so not when you switch it off for you enable it but when when you the changes like you change your resolution the change of frame right a kind of that I took commit is someone that that's that has the code where you enable the hardware work so you can actually and that's where the what's going to be important for Durkheim as is that you can choose which all us without changing which on without changing the the settings at the end the back at a time when I wrote the Tegra driver the problem was that word that I thought I'd be covering just moving everything into DPMs callbacks so that you can just have it you do it in 1 place he just enable everything except the mode and the good thing is that we actually a pretty good power-saving that way because you just turn everything off when that's the screen is turned off and turn everything back on when it come comes back on and it's pretty fast so you can actually do that for you know the it the the the sad part of that was that it's not how modes having uh expect things to work so I had to most of month 11 working and this is just rewriting drivers and reshuffling code of 1 this is this so the at the actual conversion to atomic his after this work is the trivial ah there's distri phases you can go through you can often you connections give those you can do it all at once it's not it's not very much that that's done in 2 phases uh 1 of the good things and I went through some pain especially specifically to ensure that we don't have regressions and it means that we can actually at each point in the in the convergence we could actually I have a a set up that would still building which was screen and in fact and the thing is we found a few things in in the current implementation that that weren't where memory was being the can and all that kind of stuff so the yeah the the the for the 1st phase is going to be to have transitional have words in the next slides are going to give more details about this the the then there's a it's phase where you establish this what I referred to earlier we have everything in in states and then you need to what you need to assume that you you extended driver to actually of managed at states in in in your driver and in the last step isn't just rollout atomic support which means that you actually have you want everything up for that use the the atomic follow the callback set that you've implemented on the uh what 1 1 very good thing is that these helpers are are very modular and I guess I should so thanks to benefit that you will use not here today but but he did most of the work so should be all thankful to him so it's really really and we use it to the that the conversion and and you can also it tailors very well to the various hardware out there so it should be easy to get every everybody to make everybody happy and so the the transitional helpers
are our I like the the 1st step in in getting getting things going and this is to make what you do is you you you you extend your your various subjects that you have like the CART season planes primarily extend them with callback that are specifically of the targeted and atomic mode setting the the differences yeah for planes and 4 for for c at its use yes you have atomic check atomic well 1st atomic check functions which perform the checking step if you want to validate that the the the the configuration is actually going to work but you do all the checking in atomic track and if any of those atomic functions failed then is the motel is just not going to happen and it's a special important to note that atomic check functions must not touch hardware they must just perform checks the can also cash information that they they compute but they must not touch hardware and that's important because as soon as you touch heart rate might just have it turns off and was going to say see error messages anymore room for it for C. R. T. C. is you can also have the the atomic begin atomic flush call that's there there really basically the bracket the whole mode setting 1 1 0 to C so that atomic beginners called at the very beginning of mode said then there's a bunch of stuff for you check other the what you update your of planes and Syracuse and then there's the comic flush which is called at the very end to to apply these updates I talk a bit more about atomic clocks later on on there's a new call back for sureties called mode said no if the that's like the new 1 that use for everything and then there's a mode said 10 mode said Bayes currently but you don't use anymore after converting common that the goal of motor no years the just modify the search the timings so that you have the only thing that you do various you set a mode and it doesn't add to scan out anything i which is opposed to what we had before where you would set the mode and you would also passed to the frame buffer it would ultimately automatically scan out that for a lot room so this is this means that it's not possible to to have a static matches had a modes and get a display to light up would have no content on screen so usually it would just be black I I guess various hardware has means to change the color but black and the people it the so for planes there's a bit more to do there's are prepare the and clean up the those are the things that are used as I mentioned earlier when you attach a frame buffer to a service to a plane you need to on some of that we need to append it to memory for intermittent need to make sure it's that it's in video RAM for instance if you have discrete memory you need to make sure that it's the map for in Ireland you that kind of thing you can it and prepare the uh prepare is is allowed to fail it's 1 of the few ones that the secular failed and it's actually run before setting the mode so that you can you can actually see whether setting this claim that that's important for instance if a frame buffers to be fought for the overlay officers in incompatible frame the format that cannot be is kind of the reverse you and the memories thinking you it's called after the 4 in the frame buffer is not stand out anymore but you know you can remove it from the around if you need more space and that kind of the atomic check is the same as for the RTC is you just validate that you can actually do this on the atomic update essentially just is there is to to program the plane so that they become position that you can set the format and that kind of a you update the hardware at that point is not allowed to fail if you want to avail you flame atomic checked and it's not even going to cold atomic updates atomic disable is kind of a special case for atomic updated just there is there's a few detail in this long commit locks if you want to know the details of it the that then the the conditions under which a plane is is is so is determined to be disabled are kind of difficult especially if you have if you go through the transition and so I won't go into many details about that are what 1 the 1 of the caveats with phase 1 is is that you need to actually wire up the atomic destroy state which is actually supposed to be only wired up in a later stage which you want to have a it no memory leaks at all then you need to wired up at this stage because internally atomic will already allocated the state and if you don't have the destroys they call that a 2nd free more so you'd have memory it's enough for most people a prominent going to care about this because once you done with the with the complete conversion you have that anyway so it's just a transitory state where where where it would lead memory
the did uh are to the atomic state scaffolding is pretty trivial because you can usually just use the default helper is that that atomic mostly provides there there's a few things go where I should say what they do on that the reset are called back is essentially it's called at the very beginning when a driver loads was supposed to do is to just take read out the hardware states upgrade the atomic state that came as has worked to create the 1st atomic state and and and the idea is that eventually you can use that to do seamless transitions from from word to kernel for the just read out the states and if the state matches whatever uses Bayes wants to set later on it just as I have to do anything it's all automatic if you do right of the duplicates state is really just the men copy it just can't take state Senate copies it to another object with that's used in in in in in updating states if you change a configuration you take the state that you have you copy it and then you you modify and that's the reason why it's a call is because some of the some of the convex you to do more than just copy values in to take references on a frame buffer for instance so that they have the correct a reference count and on and free to all your on the destroy state similar in that it's usually just a free real tested take care to to drop references again if you've taken a reference frame buffer that stored in that state need to drop the reference to make sure that it doesn't mean but for for most cases default help will be good enough and I'll go into more detail on how to override and later on be rolling out atomic supporters is that is pretty much it is it's kind of easy there's 2 steps to there's 1 is to to switch to a comic culprit internal that way you get whatever you do internally in tunnel you know good news which proponents the callbacks internally after that you can get rid of the whole of code that you had before these are just the names of the functions they have kernel block documentation with pretty good descriptions of what they do so this is really just use them for for a call back so you would not otherwise have had implemented with driver specific code so you just really modify it's like a few lines of code changes for this whole transition it's like a couple of 1 so the the driver needs implement the atomic puppet check which will just make sure that to call the check functions on your object to make sure that the whole sets of nodes that is correct the the comment is just the set where you apply the settings the this the 2nd step is to wire up things like the use of space well for we have this set C RTC which would just the mode and set the frame buffer and there's a help but it will just use the atomic called you've implemented for the claimants at the I of uses those standard interfaces and implements still the legacy articles the the same goes for 4 page flipping that the problem is with page flipping you you're supposed to be asynchronously so you're not supposed to wait until it's actually done so you're supposed to pass it directly back to you pass control to users based directly and then uses Bayes can hold your file descriptor for the year and divide of and wait for completion that's why you need to provide a custom atomic commit book which will the sale of all of of waiting for a under the blanket in in the background so at that point your drivers completely atomic it has a semantics user space expects that the comic effect so it's much complete there's more busy work later on to make it work really well and I get to that in a 2nd where you can do now is that you could probably do that and the various stages already but it's 45 just do it at the end of europe out a lot of like the most sediments at base that I was talking about earlier there are no longer used when users and it get rid of them DPMs you can get rid of the DPMs because it's a mess because nobody needs it really a was invented at a time when we could actually put your monitor into various power-saving modes like switch of the was h Planken search of the blank at or switch of completely you don't need any of that anymore and on so we have a new new callbacks that are much more intuitive you can enable isn't can disable things and the court will take care of everything else so you have you the full on a full and that's really what modern hardware can do there's there's not much left that connection with various other modes the so the interesting thing is that I realize at the end is that that's and she what we had done integra right I mean we did everything the pianist added the the good thing about rewriting everything is that we now have less code and the court does more of it for us at school the on point and so after after you're gone through all the conversion you have the much everything in place and you could just go and be happy and a more work than men detection make kids and that's actually it's interesting because that's why you get to do perfect rings up until now you can read
to perfect you you can make sure that frames are perfect because they don't have the code yet and where it's interesting what what you do usually with atomic status you have your own a specific a structure where you and that the atomic states to the standard atomic state and then you add fields to it that story stated specifically of life um principle what what we do on on tag right is that we store things what we have this atomic check function which which just checks that the format is valid that resolution is supported and all that and we have like tiling modes where the memories in the the kind of thing that we need to check for and why we're checking for every can also store it in that state object and sort of pre-computed and at the at at at the commits stage you can just use that value not recomputed again because at the commits they we can fail anymore so we can only use values that we know are safe to use so we have no checking anymore in in the update function with at the commit state stage on this the idea of the what 1 of the other things it can do at that point is actually do something in atomic flush you can have that as a just a placeholder essentially because you don't have to do it really have the right semantics but you need to do it if you want to do proper atomic mode setting and that's important but it's 1 of things it's typically called Grove it's it's the concept where you have a you can do updates to hardware to registers about these updates so the play immediately yes you have to have a set specific bits in the driver that you make the setting is applied at wanted good things is most heart rate can she do this synchronize with the the blank so they you write the values regicide you update those go it's and then the the updates will automatically be applied at the next the blank so you get all that good stuff for free that's 1 1 a good thing is that you can do with atomic flashes you can keep states and you can you can keep track of the state what needs to be updated atomic flush you just set the scope bits and it will all be automatically applied for you there had to be blank that's how it works and tag references that we have this register where it says that you have a go essentially for the the mode said like the timing we have a go but for each plane that we support for the cursor so as we track internally we tracked which planes are actually change and then we set those go Brits in atomic flush which should allow us to just have this 1 point where you the right to register ones that make sure that everything is applied at this very same frame boundary so the user space IOC so this is 1 thing that's very new is 1 of the things that the 1st being the most debated I Octel's always difficult because you have to make sure that once you have a reduced kernel with that that contains and you have to to be around forever so people are often reluctant to to and use space it's now brand new in Version 3 . 20 that's uh going to say what do the merge whenever that is going to open in about a week presumably Our if there's a mechanism so that we use behind it we hide it behind that they become a parameter which is which means that we can developers conceptus kernel parameter but it also means that if you set it you need to specific you take action to it which means it doesn't automatically become maybe so you week we were still allowed to change radically so it's sort of uh safety mechanism the way how it works and that's where the other building blocks come places that you have essentially just say an array of object ideas and I don't think I mentioned before but every object like Sierra to see planes uh encoders connectives all all have their object ladies uh which are unique in in your system so you can just have how it works is you have a set of of an array of object ideas and then you have there a number of object type in a number of properties per object and then again an array of properties so that and they kind index each other it's a pretty simple code but if we just that huge set of properties that that the kernel can apply some and then there's flags and can do page flipping uh that essential this means it's supposed to asynchronously apply it so your eye helpful doesn't block essentially don't I guess that's what in non block us to right because there's there's a special code to handle page looking it's it's related to events like yeah that way you schedule event you put an event in a Q and whenever you you told call your of the 5 descriptor you have all that event once it's completed it just makes it the Paul returns and then you can read out the event so it's so used to implement like our main groups and applications in the kind there's also you allow mode sets a flag I think it means you can most people that I a confused you sometimes it's going pretty well documented can we do that there's a the act and
I I alluded to that earlier cool things they can do that is you can you have if you implement covaried out at the reset state it means that you get you you create the initial atomic states and that means that you get I think Intel has written a lot of code to make sure that they can be a seamless transitions and if we do it right OK she do this use this to do this song in in general for every driver and so dealership drivers and to do is to make sure that the state that they created at load time corresponds to what the actual hardware is and then is uses these once a set this mode again and the core will just realize well this is no change at all so it just and then the the the 1 when the other thing is it's been known to being thought about is to use more common helpers to do things for you like the incomes commits it's very likely that that we'll have common patterns and we can probably come up with a common code protection do it now than it is also 1 of the things that I guess benchmarking people like is is asynchronous page that's which means that usually do page flip so and in a way that you can synchronize into the blank because it gives you know tearing but it also means that you're limited to your refresh rate of the of the monitor and it's economist page let's give you so we give you a way to just page flip but as soon as you can so you get you get frame rates that there how fast your GP you can go and and those some ideas are to just have a way to to implementing slightly jails for print of all which is just a way of of specifying whether you want to do asynchronous pictures you can also use it to to have have that's not synchronized to every frame but every other frame and the kinds up the you know the stairs more at more work that can be done to have like standard properties where space can just rely on various properties being present in having the same semantics kind of
so in summary but is they there it we have a need for atomic mode setting because it addresses issues in the current API about where we just can't do certain things but the good thing about it is that is also it gets gets rid of a whole of coding drivers moves a other stuff into the core but it's also not very complicated it's very act you once you once you understood the basic building blocks of actually pretty trivial I it makes a lot of things very easy that 1 of the 1 of the things that you need to take care if you want to convert your driver is that you make sure you have you you know your your driver is according to him expectations because otherwise you have a ton of work to do that before that she works for you and um and like I said the the actual conversion motive pretty to reveal once you have everything in place so I guess is what that's working on the driver below converted now because otherwise you're going to miss all the good stuff that's that's going to come so that's that's my last slide if you have any questions you have what the I love you the question was uh brought how difficult is it to validate that the mode is actually valid I guess the answer is it depends on how hardware locked up in in many cases on un-tag reference and that's pretty easy because you have various constraints that you know from beta sheets uh for from from your programming manual uh there's things like frequency pixel clocks so important if you know that your PLR can drive can provide this frequency you can reject it because it's just not gonna work other than that I I guess other drivers have other your requirements but it's a at it's usually pretty simple we the question was mean what I was testing everything of converge so the question is how do I test every stage of the convergence as with a lot of time but it's really painful and I actually had I went to the trouble and did that on for generation of Tigris to make sure that and on on for 2 different types of outputs to make sure that it doesn't break I I did skip some steps because I was sure that they wouldn't break a mature amateur that's actually true but I'm hoping and I'm I'm I'm thinking that nobody's going to use the interim stages anyway so and it you know the the end result works so nobody's gonna try and you know find we the the now we know that the question is do we have automated tools and Intel is pretty big on automated tools we don't have any of that fortunately we the 5 right yeah there's there's the idea is that we can have a lot of a lot of the stuff that Intel has no automated tools is generic so it's Polly just take somebody you know to spend some time on making those tests available for everybody cost that amount of the GP the Intel GPU tools uh repository or even just keep them in a repository and make him in a bit of the code that's until specific and just make a more useful I guess that where you can actually make up halfway alternate what you what you need to this the and all the right that the question is is it possible to use this to to apply a configuration across multiple outputs I guess the answer and the answer is yes so I guess if you want to what 1 to consider so if you want to consider multiple like like bandwidth risk the restriction of frequency restrictions then you must you probably need to do some thing in your driver to do that that just generally it works on on any kind of output the the userspace IOC this just in among dimension of properties you can and it's so immediately atomic status se to seize the program 1 pipeline uh and you can just add many of those into 1 atomic state so you can apply it to as many as you want if you want to coordinate between different so now it's parts of your driver then that's trimer-specific but it certainly doable good what thank you and on the end of and the the question is are there any plans to deprecate the the the legacy user-space interfaces and the question to that is the kernel interfaces yeah I guess you know we can do pretty much anything inside the common as long as it's not userspace ABI yeah I I guess at some point 1 once every driver is converted we can we can we can do that yes the I and that will you you the last by you and I know my question is whether we have also considered virtual deployed uh diffuse and the answer is that a yes to some degree but they have they have all kinds special handling already and I'm I'm gonna someone very familiar with how that actually works and so on so is something that we want to support of the DOI 1st we don't have much experience so I can't really say how how how how you make it work I guess if you don't have the restrictions of the of having a display controller that lecture scans out your you're the blank handing can just be a not essentially because as soon as you just disable all your your search is yours once you remove the buffer you can make sure in your virtual driver that you just don't access to the and that you just work fine Ch hopefully for more questions of a great and was made a few and in the
Umsetzung <Informatik>
Bit
Punkt
Freeware
Datensichtgerät
Selbstrepräsentation
Adressraum
Synchronisierung
Raum-Zeit
Videokonferenz
Kernel <Informatik>
Homepage
Client
Einheit <Mathematik>
Datenmanagement
Perfekte Gruppe
Trennschärfe <Statistik>
Theorem
Bildschirmfenster
Wurzel <Mathematik>
Beamer
Parametersystem
ATM
Hardware
Kategorie <Mathematik>
Frequenz
Ereignishorizont
Linearisierung
Arithmetisches Mittel
Menge
ATM
Decodierung
Message-Passing
Instantiierung
Ebene
Folge <Mathematik>
Subtraktion
Total <Mathematik>
Rahmenproblem
Ortsoperator
Gruppenoperation
Zahlenbereich
Overlay-Netz
Systemplattform
Term
Code
Puffer <Netzplantechnik>
Softwareentwickler
Konfigurationsraum
Touchscreen
Soundverarbeitung
Einfache Genauigkeit
Schlussregel
Quick-Sort
Objekt <Kategorie>
Ordinalzahl
Druckertreiber
Digitaltechnik
Gamecontroller
Farbenraum
Eigentliche Abbildung
PRINCE2
Rahmenproblem
Gruppenoperation
Mengensystem
Rechteck
Ordinalzahl
Kartesische Koordinaten
Kernel <Informatik>
Übergang
Homepage
Theorem
Minimum
Konfigurationsraum
Funktion <Mathematik>
Touchscreen
Einfach zusammenhängender Raum
Kraftfahrzeugmechatroniker
Vervollständigung <Mathematik>
Hardware
Programm/Quellcode
Ereignishorizont
Arithmetisches Mittel
Druckertreiber
Hydrostatischer Antrieb
ATM
Speicherabzug
Verkehrsinformation
Umsetzung <Informatik>
Bit
Punkt
Datensichtgerät
Hinterlegungsverfahren <Kryptologie>
Raum-Zeit
Kernel <Informatik>
Eins
Videokonferenz
Chatbot
Einheit <Mathematik>
Regulärer Graph
Lineare Regression
Theorem
Bildschirmfenster
Wurzel <Mathematik>
Phasenumwandlung
Bildauflösung
Schnittstelle
Sinusfunktion
ATM
Lineares Funktional
Parametersystem
Hardware
Kategorie <Mathematik>
Güte der Anpassung
Gebäude <Mathematik>
Abfrage
p-Block
Humanoider Roboter
Bitrate
Frequenz
Rechenschieber
Datenfeld
Menge
Rechter Winkel
Festspeicher
ATM
Dateiformat
Garbentheorie
Decodierung
Information
Faserbündel
Cursor
Instantiierung
Aggregatzustand
Ebene
Rahmenproblem
Gruppenoperation
Mathematisierung
Implementierung
Ordinalzahl
Kombinatorische Gruppentheorie
Overlay-Netz
Term
Code
Framework <Informatik>
Puffer <Netzplantechnik>
Informationsmodellierung
Erwartungswert
Knotenmenge
Software
Softwareentwickler
Datenstruktur
Grundraum
Konfigurationsraum
Touchscreen
Einfach zusammenhängender Raum
Wald <Graphentheorie>
Objekt <Kategorie>
Ordinalzahl
Druckertreiber
Mereologie
Gamecontroller
Speicherabzug
Wort <Informatik>
Bit
Umsetzung <Informatik>
Punkt
Datensichtgerät
Konvexer Körper
Zählen
Raum-Zeit
Formale Semantik
Homepage
Videokonferenz
Eins
Kernel <Informatik>
Deskriptive Statistik
Poisson-Klammer
Reverse Engineering
Default
Phasenumwandlung
Gerade
Schnittstelle
Umwandlungsenthalpie
ATM
Lineares Funktional
Vervollständigung <Mathematik>
Hardware
Programm/Quellcode
Systemaufruf
Ähnlichkeitsgeometrie
p-Block
Bitrate
Teilbarkeit
Dienst <Informatik>
Parametrische Übertragungsfunktion
Menge
Rechter Winkel
Festspeicher
Konditionszahl
ATM
Dateiformat
Information
Instantiierung
Aggregatzustand
Fehlermeldung
Ebene
Maschinenschreiben
Subtraktion
Rahmenproblem
Ortsoperator
Gruppenoperation
Mathematisierung
Entscheidungsmodell
Ordinalzahl
Overlay-Netz
Code
Leck
Knotenmenge
Weg <Topologie>
Inhalt <Mathematik>
Konfigurationsraum
Hilfesystem
Touchscreen
Soundverarbeitung
Einfach zusammenhängender Raum
Matching <Graphentheorie>
Elektronische Publikation
Office-Paket
Objekt <Kategorie>
Mapping <Computergraphik>
Ordinalzahl
Druckertreiber
Last
Gamecontroller
Wort <Informatik>
Bit
Punkt
Freeware
Versionsverwaltung
Kartesische Koordinaten
Synchronisierung
Raum-Zeit
Kernel <Informatik>
Eins
Formale Semantik
Homepage
Fahne <Mathematik>
Bildauflösung
Umwandlungsenthalpie
Parametersystem
ATM
Lineares Funktional
Kraftfahrzeugmechatroniker
Hardware
Freier Parameter
Kategorie <Mathematik>
Güte der Anpassung
Gebäude <Mathematik>
p-Block
Bitrate
Ereignishorizont
Randwert
Datenfeld
Menge
Automatische Indexierung
Rechter Winkel
Festspeicher
ATM
Dateiformat
Decodierung
Aggregatzustand
Cursor
Ebene
Rahmenproblem
Mathematisierung
Gruppenoperation
Zahlenbereich
Ordinalzahl
Code
Flash-Speicher
Weg <Topologie>
Datentyp
Softwareentwickler
Datenstruktur
Hilfesystem
Einfach zusammenhängender Raum
Videospiel
Physikalisches System
Quick-Sort
Objekt <Kategorie>
Druckertreiber
Eigentliche Abbildung
Resultante
Bit
Umsetzung <Informatik>
Punkt
Datensichtgerät
Hochdruck
Raum-Zeit
Formale Semantik
Homepage
Kernel <Informatik>
Mustersprache
Kontrollstruktur
Funktion <Mathematik>
Schnittstelle
Softwaretest
ATM
Multifunktion
Hardware
Dokumentenserver
Kategorie <Mathematik>
Gebäude <Mathematik>
p-Block
Bitrate
Frequenz
Rechenschieber
Generator <Informatik>
Menge
Rechter Winkel
ATM
Portscanner
Aggregatzustand
Nebenbedingung
Subtraktion
Rahmenproblem
Hausdorff-Dimension
Mathematisierung
Automatische Handlungsplanung
Ordinalzahl
Code
Puffer <Netzplantechnik>
Multiplikation
Erwartungswert
Datentyp
Diffusor
Optimierung
Konfigurationsraum
Pixel
Ordinalzahl
Druckertreiber
Minimalgrad
Last
Digital Object Identifier
Mereologie
Gamecontroller
Speicherabzug
Bandmatrix

Metadaten

Formale Metadaten

Titel Atomic Mode-Setting
Alternativer Titel Graphics - Kms Atomic
Serientitel FOSDEM 2015
Autor Reding, Thierry
Lizenz CC-Namensnennung 2.0 Belgien:
Sie dürfen das Werk bzw. den Inhalt zu jedem legalen Zweck nutzen, verändern und in unveränderter oder veränderter Form vervielfältigen, verbreiten und öffentlich zugänglich machen, sofern Sie den Namen des Autors/Rechteinhabers in der von ihm festgelegten Weise nennen.
DOI 10.5446/34414
Herausgeber FOSDEM VZW
Erscheinungsjahr 2016
Sprache Englisch
Produktionsjahr 2015

Inhaltliche Metadaten

Fachgebiet Informatik

Ähnliche Filme

Loading...
Feedback