Write Assigned Name with airSlate SignNow

Write assigned name

um our next talk is from pia ikinger who is a master student at the university burg with a research interest in using quant quantitative software engineering methodology on the linux kernel she will be presenting on so you're a linux kernel developer name all the subsystems please welcome pierre yes thank you so much for the introduction so again my name is pia eichner i am a student at the university of applied sciences in ringsbook in germany and there really isn't that much to say about me yet since i'm really still a student and i'm still at the very start of my career but my research interests include the organizational and maintenance structure of the linux kernel which is ultimately the topic of this talk so just a quick introduction to the people who made this all possible um our collaborators so we have ramsar stephanie scherzinger and wolfgang maurer ralph ramsar the phd student he developed and maintains most of the tools that provide the very foundation of all these findings that i will now present and just a quick introduction to what really drives us to our motivation and goals so what we want to do is to formalize and assess the linux kernel development process and by doing that we sort of hope to gain some sort of deeper understanding about how it all works and at the end of the day if we have that understanding we want to sort of support and enhance it and we're providing and developing tools to support the open source community like we're using linux the linux kernel is a prime example for that but anybody who uses a open source development process or just git for that matter could use our tools and the things that we develop are especially interesting to assist and support safety critical developments so i'll get to that later our collaboration partners include eliza from the linux foundation you may or may not have heard that name before this is a project to enable linux in safety critical environments and the university of paso and i am going to be talking a lot about safety critical environments and safety critical certification so just a quick introduction to what the entire idea is behind that so it's needless to say that safety critical environments are highly sensitive environments and in very very extreme case scenarios you like having software that works and having software that works the way it's intended to work could ensure the difference between survival and death and what safety critical certification aims to achieve is to try to ensure software quality by all means necessary and one idea to sort of achieve that is to look at the development process and correlate that to the quality of the software so the underlying assumption here is that the development process can impact the quality of the software if you have a really really good development process well-defined and everything and like every single patch needs to be discussed every single feature reviewed stuff like that and the developers strictly comply by this process the idea is how bad can the end product be at the end of the day so that's obviously uh subject to to discussion but still um this is the assumption that the certification is based upon and if you can prove that your developers strictly comply by this process and if you can prove to what degree because there will always be irregularities right you achieve a you can you can get a certification for safety critical environments and you're one step further to enabling your software there and now if we try to introduce linux to safety critical environments we run into some major certification challenges because of its open development process so the thing about linux open source development process is that the broad opinion is that it's very well defined and it's really good and it produces some really good and quality code but nobody really cares to properly document perfectly everything that's happened and everything and how it was reviewed and stuff like that with the goal in mind to then later use that to prove that certain criteria for this certification were actually met so the idea behind that is all this data is public and with a little bit of data mining we could have an exposed fact analysis after it already happened and characterize the entire process um with with hindsight and just a second um characterize the entire process with hindsight and use statistical methods to research and understand the development process and the thing that we are really interested in is is patch integration specifically so um the things that i'm asking myself is who integrates a patch and and how exactly does a patch end up in mainline like this is the sort of stuff that we're discussing and i am sure that you're probably very familiar with the concept of the maintainers hierarchy right so there are developers who develop patches and they send them to file maintainers and then to subsystem maintainers like pull requests and at the end of the day it somehow ends up in mainline all the way up there so this is like a common concept um that's that people refer to and stuff like that and we really wanted to get to know this thing so originally we wanted to know about two things in particular so first of all the conforming integration of patches this will not be the topic of this talk this is something we we worked on but it will not be the prime topic of this talk but do keep it in mind for later because i'll get back to that so conforming integration of patches just basically means if you have a patch just look at the affected files and um look at get maintenance.pl or the maintainers file just who is the relevant maintainer for this particular patch who are the relevant maintainers and if one of these maintainers integrates that patch like a relevant maintainer we will call that patch conformingly integrated so that's just one classification and we wanted to sort of analyze that and also we wanted to analyze the patch traversal through the maintenance hierarchy so there's this thing called the maintenance hierarchy and it's supposedly well defined and we have a patch that goes all the way up here and we really wanted to know how it ends up in in mainline at the end of the day so uh what we wanted to know is the like any any cross-cutting patches and and pull requests going on like for example this patch uh going straight up here and then maybe down to the file maintainer down there and then straight into main line or is it all like compliant with the defined maintenance hierarchy and we were all good to go and this these were the projects that we defined really wanted to work on and i remember it so well i walked up to my supervisor and i asked them okay i'm so ready to start this i'm so enthusiastic where can i find this maintenance hierarchy and and where can i start analyzing it and comparing um the the patch data to the actual maintenance hierarchy and that's where it all begins so the problem is there is no clear-cut definition of the maintenance hierarchy and this is where all these questions and and stuff started so we did a little bit brainstorming and we thought okay so there's supposedly this thing like subsystem maintainers but actually where can i find a documentation on all subsystems and one question led to another and you find yourself thinking what exactly is a subsystem even and that's the name of this talk this may seem like a really really trivial question but i do invite you to pause and ponder for a second on this because um if i were to ask you right now what exactly is a subsystem what would you tell me and i am just making assumptions here but i'm probably thinking you'd say something like well that's easy so there's the thing called the maintainer's value i just look it up there and you would not be the only one with that opinion so in documentation for early stage planning it stated that again the maintainers file is the place to start but not all subsystems are represented there so it's not directly stated but it's mentioned as if like the singular entries and maintainers are standalone subsystems like all of these entries are real standalone subsystems which in again means that there are over 2 thousands of them but right who am i to judge problem solved we know what subsystems are well only thing is if you look a little bit deeper and search for the term um subsystem and official documentation you may stumble across something like this so basically contains you should usage information about media subsystem and stuff about media subsystem so obviously there's this thing called the media subsystem and apparently maintainers is the place to start so if you go up to maintainers and look it up you will not find a signal media or media subsystem entry in maintainers rather there are over 100 subsystems subsystems containing the word media which then raises the question which one is it and if i were to ask you which one of these standalone subsystems is the media subsystem that is mentioned here pick any one of them and tell me which one is the one that's like like is that is being talked about sorry um and i'm again just making assumptions but i think you tell me something like no it's not any singular one of them it's like probably the summary of them and i might be nitpicky here but these are sort of contradicting usages of the term subsystem and there is no clear-cut definition like is it in maintainers it's not in maintainers what exactly is it and we can't really work with that we need a clear and well defined definition of um of term subsystem so we just went ahead and did that for ourselves and just thought about what would be the most intuitive way to think about subsystem and we defined the term so spoiler alert the entries and maintainers are not subsystems we will call them sections from now on and sections can intersect so there can be files that belong in two sections at once which we will measure in lines of code and if they do we will call them thematically related and their grouping or theoretically strong related sections will be then called a subsystem so like the grouping of magically strong related media sections will be the media subsystem and i hope you do agree with us on that like this is probably a very intuitive way to think about the term subsystem like it has something to do with maintainers but still it's more like a grouping based on thematic relations so this sort of work can be so exciting but so unpredictable at the same time so we stumbled into a problem that we just did not think would be a problem prior to starting there is no clear listing of subsystems but why not find out ourselves we have our definition now and we still wanted to look at conforming integration of patches so do keep that in mind like was a patch integrated by a relevant maintainer yes and no conforming yes or no and now let's just apply our term for subsystem detection and really see what we can find and really try to apply that and just a very very quick notch to just very quick interjection to a a very recent article so there's very very recently there's been this article by jonathan corvette freaking section it's called maintenance truth and fiction and it's like analyzing the maintainers file and the basic gist of it is to analyze the maintenance file and look for any sort of inconsistencies and and stuff like that so the maintenance file is still a file that um needs to be maintained but there are still like weird stuff in there like um maintainers no like sections that don't have any maintainers and stuff like that and that was just a basic gist of this article like analyzing maintainers and looking for inconsistencies and what we are doing exactly is also analyzing maintainers but like looking at a completely different topic we're analyzing maintainers and trying to sort of um compare it to reality like how exactly are patches integrated when looking at maintainers and when comparing it to relevant maintenance and if you analyze it and compare it to the linux kernel repository and base it on on like shared files and stuff like that what sort of structure could you find like what sort of subsystems could you find so we're both sort of analyzing maintainers but two different aspects of it i'm just if you've read it or not it's a really good read so maybe do go back after this talk and read it but i just wanted to um quickly not show that article because it was just so recent and so unexpected that this this project was also going on but not to get off track here our goal is still to like find and analyze subsystems and what how we wanted to achieve that was to like try to visualize the maintainer sections based on thematical relations and sort of see what we can find there and the thing about visualizing stuff and visualizing relations between things is that it's probably a good idea to start with graphs and disorder because graphs are like a good way to visualize that sort of stuff so let's define the section graph the section graph is an undirected graph and the idea is to have the sections of maintainers become the vertices and they can share edges if they share any lines of code so if there are any files that belong in two sections at once these two sections will share an edge in the section graph and then we can just apply common clustering detection algorithms such as walktrap to detect any clusters or communities um which we will then define as subsystems and that's just the underlying idea and just to get a quick idea for that imagine you have like three sections a b and c and they intersect in some way so a b and c affect files in some way and a is very large and it strongly intersects with b and c and p and c are disjoint you'd have a section graph like this okay so a shares edges with c and b a very very simple idea of like trying to visualize sections and maintainers so that's the section graph and this is it this is the top 20 section graph so it turns out that after all maybe visualizing over 2 000 sections in maintenance was a bit ambitious and out of scope for the project that i did so we had to like cut it down on the largest 20 on the 20 largest sections within the maintainers file and just see what we could find there and that's the result so just let that sink in for a moment this is a visual representation of the maintenance file and its thematic relations based on on the subsystem definition that we provided so this is what it looks like and this is all very pretty and nice to look at but what we really wanted to do was actually detect sub-systems and this is not really of any use if we don't actually know what's inside of these clusters that we defined as subsystems so what we're going to do now is have a little cluster discussion and the basic idea is to just take some of the major clusters and isolate them as an own graph and then re-cluster them again from within to detect any sort of substructures within subsystems and we will later see why that's a good idea sometimes a good idea so just imagine you're taking any one of these major clusters we're gonna take the one down here first and just cut off all the edges to the outside delete all the other vertices and then just look at it as a complete isolated graph not only do that but also re-cluster it again from within to see what sort of like structure you could find from within so that's what we're gonna do now and that's what you're gonna see here in a second so i am just opening a pdf file here and this is it just gonna zoom out for a second to get a basic idea of it so this is the cluster that i just showed you isolated as an own graph and clustered from like again from within and just to get a little look at um the stuff that's going on here so i hope you can read it um there's this very backbone like section going on here that's called networking general and if you look at some of these names in here i'm just going to zoom out a little bit you're going to see a lot of networking stuff going on here so it's networking ip security networking tcp um lots of networking stuff going on here and i'm just i'm just saying this is a clear ongoing theme in here of like networking related sections so um it's not that far-fetched to say this is the networking cluster and uh it spans up this like it has this backbone section it spans up this big subcluster of networking stuff but also you have another subcluster all the way up to the right there and i'm just gonna go over there and just zoom in a little so you can read it so you have kernel nfsd's on our pc locked server down here and send our pc locked clients nfs up here so these are very very similar keywords so it does make sense that they're put in the same subcluster up there and you will just have to believe me when i tell you that these are the only two sections within the entire section graph that have any of these keywords so not only are they put into the same subsystem but in the same sub cluster too so this sort of makes sense i guess so this is the networking cluster and i might be just showing you some perfect examples here where our clustering algorithm wields really sensible results but let's take a look at some other clusters um remember when i bothered you so much about the media subsystem earlier like what's the media subsystem show it to me uh that's your answer this is it this is to be precise this is the media and staging subsystem because sub clustering shows that there's a clear media subcluster on here and a staging subcluster up there and a third sub cluster down here just android drivers we'll get to that in a second and i wanted to know so much about the media subsystem and there it is this is our media subsystem so again we have a very clear backbone section right here media input infrastructure which like spans up the entire um subcluster and there's so much imagery name like going on webcam video virtual video driver stuff like that so this is very clearly the media subsystem which contains a lot of media sections and up here we have apparently within the same subsystem another subcluster that is entirely for staging so there's this staging subsystem as the backbone and there's so much staging going on here and down here we also have annual drivers as an own sub-cluster so it apparently has something to do with staging with the staging subsystem enough to be put into the same subsystem but not in the same sub-cluster like it has something to do with staging but not enough so it is down here and that's the media subsystem for now and you will just have to believe me when i say we could spend hours hours discussing these uh these sections in this graph but you will have to believe me when i say that most of these major clusters and the minor clusters too have very very clear themes going on so i just assigned labels this is the same section graph from before but i just assigned labels to the clusters and of like which their ongoing themes within the subsystems are so we had a look at networking and the media and staging subsystem down here and we have so much more we have scsi arm infiniband usb networking drivers which please note networking drivers is an own cluster and shares a lot of edges with networking down here so this does make sense if you think about it and up here we have drm drivers and sound and usb and stuff like that we don't really have time to discuss all of them in details because we could spend hours discussing them we already have by the way but like not here but um in our work in our project but um sub clustering is not always a good idea like i shout two very clear examples where sub clustering is a good idea some of these are already standalone subsystems one example would be the drm drivers cluster the drm driver subsystem that we can see here and again we have a clear backbone section drm drivers and lots of lots of drm drivers section here so again we have a very very clear ongoing theme and actually i'm showing you this for a reason because i want to talk about this cluster a little bit more just a quick review of what we saw just now media subsystem and drm drivers and do remember when i told you to keep in mind that i was analyzing and and working on confirming patch integrations so just a quick reminder was a patch integrated by a relevant maintainer according to maintainers or the getmancontainer.pl script if yes this is a conforming integration and i'm not going to go into much detail here because that's not the topic of this talk but the basic idea is to analyze recent patch integrations and determine if they were done conformingly or not and also not just that but we want to really have like have a look at any reasons for why patches might have been integrated unconformingly and very very very important disclaimer at this point in time so what we really want to do is to characterize and improve the development process and and characterize patch integration and to achieve that we have to extract the current status analyze it discuss it characterize it and if we as soon as we really understand this we can try to support and enhance it but the first step is to still extract the current status and analyze it what we do not mean to do under any circumstances is we do not mean to point fingers we are not trying to call out any maintainers saying they did a bad job of unconfirming patch integrations trying to tell them how to do that job like blaming them or anything like that this is not at all what we want to do we just need to classify these patches in order to to to prove like prove the criteria and just get a basic idea of what's going on and classification like this in conforming non-conforming is necessary but we're not trying to offend anyone here this is not our goal so with that in mind we found something very interesting about this cluster so um there were some examples of unconforming patch integrations and two of which were for sections within this subsystem so we found one conforming into unconforming integration for intel drm drivers up here and the other one for intel gbt minus g drivers all the way up down there so we have some unconfirming patch integrations but we really want to know who actually are these maintainers that's unconformingly integrated for these sections so the maintainer who integrated for this section right here is a maintainer for this section right here drm drivers and missed gpu patches and the maintainer who integrated unconformingly for this section is a maintainer for this section drm drivers so note that not only do these sections share edges so they are clearly thematically related they are in the same subsystem and the question now is is it okay for a um dear for drm drivers maintainers to integrate within the drm driver subsystem if we define that as a dm driver subsystem and at least for me the obvious answer to that is yes of course obviously like those are drm drivers and moreover these are backbone backbone sections um dram drivers maintainers so this is like a very clear backbone section of the entire drm glyce cluster and this is as close as we currently get at least in our work to like really defining um a clear-cut defining the maintenance hierarchy so you could argue that this is higher up in the maintenance hierarchy than this because this is a backbone section but i'm just saying these are drm driver subsystems and drm drivers maintain us integrating for the um drivers maintainers and that's probably okay which provides a very strong augmentation basis for safety critical certification criteria so this is where it all goes full circle and this is just so cool to notice and moving on let's just take a step back and and just take a look at what we what we achieved so far so we have this definition for subsystems that we now applied and we have a visual representation of maintainers and we achieved a fully automated and mostly very sensible subsystem detection so obviously there are misclassifications such as the nature of clustering algorithms and i can show you some of them too like i didn't just pull out perfect examples i can show some of them too there will be time for questions later and i can still show you some sub clusters subsystems and stuff like that and we also found a very very strong argumentation basis for safety critical certifications so that's really really cool um but believe me when i say we are barely scratching the surface here because there is so much more cool work to be done with this sort of project so the obvious one that i just discussed now is further combinations of subsystems and conforming patch integration that's just what i just showed but also why cuts down the um the cluster graph edit of the section graph at all so why have why not have cluster discussion on the full section graph so why focus on the most influential ones when you could have the full section graph and see the full um like subsystems and stuff like that and wouldn't that be so cool but also why visualize the newest versions of the linux kernel like why not visualize earlier versions and have a sort of history of how subsystems develop and stuff like that and furthermore we had some first um like uh attempts of having an interactive graph so the pdf files that i showed they are very very static and stuff like that but if you can have a really integrate like interactive graph that also if you put in some more work and some more explanations and some more documentation and stuff like that you could have a um interactive graph that like links to the actual linux kind of repository and again if you put in some more work you could have some have an easier overview especially for newcomers who are trying to get familiar with the linux kernel repository and also the work that we do is not exclusive to the linux kernel there are other open source projects that use a sort of like maintainer's file like approach to their development process i'm just naming three here and we already have the logic why not just try to apply it to them and by far the idea that i am most hyped about is why visualize sections wouldn't it be so cool so cool to have a maintainer's graph where you could like um still analyze the maintainers file but instead of analyzing and visualizing sections you could visualize maintainers and thematic relations between maintainers and have sort of a detection for subsystems of maintainers or communities of maintainers and it's going to be a completely different graph it's going to like correlate maybe a little to it but that would be so cool and if you're interested at all in the work that we do with how we did it um all work is integrated at github.com lfd which stands for laboratory for digitalization slash pasta which is the patch deck analysis tool um developed by hal from zawa and just basically this is it if you have any questions there is a 30 seconds delay so maybe start typing them now so much for listening and being interested in the work that we do i am ready for anything that we would like to discuss now so yes that's it thank you very much pierre um yes we will be taking questions uh just by the text chat so if you could prefix your questions with question and we'll ask them as we see them so i can maybe say something in the meantime if you want to look at any of these clusters that i showed in the section graph we could still have any cluster discussion or if you maybe later have any any sort of questions you could still contact me or any of my collaborators two of which are present today who could also write in chat and we could still have cluster discussion after this talk or even like show you how to replicate all this data and all these graphs that i showed you today yourself it's not that hard and yeah just just for your information um we have a question uh from nick it looks like arm was the note with the most edges any insights there yes so okay uh arm is by far the note with the most edges that is indeed correct and it's a very very very highly interconnected cluster as it is inside it's also outside and the reason behind that is i hope you can read that i did my best of having labels that do not intersect but these these are like very very long labels so the reason behind that is this cluster contains so many vertices so many sections that share so like within the entire section graph they have very very high degrees and by far the one with the most degrees is open firmware and flattened device tree bindings um this is in here and there is so much arm stuff going in here within this this very very big subcluster which has like i don't know it just has a very very high overall degree in the um the section graph um that's all i can say that i did not show i i am well aware that this is a very interesting cluster but i did not show it because it's it's very hard to read and it's very hard to look at but i'm very glad that you're interested in it so just this is a sub-cluster down here um with a lot of arm stuff going on which is apparently highly interconnected and you also have one subclass up here which has a lot of pin control stuff going on and um another cluster down here i can show them again in a second that has like some sort of an accident stuff going on and when i researched the degrees of the the vertices inside of these clusters i noticed that within this very very big subcluster up here there are a lot of arm sections which just have a very very high degree i don't know these sections i haven't worked with any of them professionally but that's just the nature of this very subsystem right here so if that answers your question um yes it's it's just very highly connected and it contains the highest degree vertex within the entire section graph open firmware and flattened device stream binding so just on a quick side note and why i didn't really show this one specifically but there is still this very very clear theme going on in here um of arm pin controller and samsung exynos so just a bit a little bit of information on this subsystem and these clusters if that answers your question is it okay um we've got another question from uber who is asking have you considered pruning some sections or clusters from your analysis in many kernels you don't configure a lot of the code so for security critical stuff it might be useful to exclude staging for example not yet we did not have any sorts of cutting down other than the cutting down on the most influential sections so we did not pick any specific sections and just um manually remove them other than the rest okay the rest is the most trivial and boring section because it's shares every single file with every single section so this was the only one that was specifically removed but other than that we did not and we don't necessarily plan on doing that yet either so if we push this work further to really verify like certain criteria for the certifications this might be the case because we are aware that not all subsystems are necessarily really really interesting for safety critical environments but we're not doing that yet so this is still just very very very surface of the work that we're doing here there's so much more to to be gained or so much potential more i don't know it's just the very start of it all so um yeah we we are thinking about it though that answers the question yeah uh question it seems like one of the easiest things to do useful with the data would be to look for likely out of date information in maintainers is that something you've considered um slightly out of date so what you're saying is out of date um sections and like misclassification and stuff like okay this should not belong in this subsystem something like that did i understand that question correctly uh yes looking looking for likely out-of-date information in maintainers information that might need updating in the list no okay so this sort of work really thrives from discussing it with um with the community so okay quick disclaimer at this point i know my section graph right i know my vertices i know this thing like the back of my hand i've had my sheer fear of working with this but what i do not know are the singular sections the singular vertex is vertices because i haven't worked with any of these sections before so what i really can't do at this specific point in time is really look at sections and already know them and know that this should not be long in there or this is outdated and this must be updated and stuff like that that's not what we're currently doing but what we do want to do is show this data to the relevant maintainers and developers who actually work with these sections every day and um this sort of work really fries from that because if you do that then you always have an up-to-date overview of how these subsystems actually looked like that's still something we want to do so have like cluster discussion with the actual maintainers and the actual developers to sort of get this so this is still something we want to do because like i said this sort of work really thrives from showing it to the people that work with these sections every single day and yes that will be a consequence of of doing that after all so we do want to show that to them and there will be some surprising structures of people thinking like okay this should not be long in there or this does actually surprise me that these things have medical relations so that's probably something to come but we don't have anything yet in mind to automate that just having these subsystems and showing it to the developers and maintainers so that's something to come and yeah so we'll probably have that if i want to build a safety critical system could i use your work to identify sections i could consider excluding okay let me realize that if i to consider sections to exclude do we have anything from um wolfgang maher and chet um because i i believe that yes like if you look at the data and how these regular relations are connected but i have to admit i'm not entirely sure so you want to exclude sections for certain surgical inclusion well what you really could find is okay i have these sections that are really important to me and you could find they automatically related to other sections so that's something you could notify and are like find out that they do not share any medical relations with certain sections so these could be like immediately excluded or you could find surprising medical relations for other sections that you do then have to consider so that's something you could use it for sorry i had to think about that for a second but yes i do believe that this sort of work could be beneficial for that because like you could just see okay no edge is shared this is just you can just disregard all of these sections so i i think yes i think any more questions okay it looks like we've uh um finished with the questions so thank you very much pia and if you've got any further questions ask them in the boss channel or send them by email to peer yes please do it's now launched