Merken

System-Level Transactions with picotm

Zitierlink des Filmsegments
Embed Code

Automatisierte Medienanalyse

Beta
Erkannte Entitäten
Sprachtranskript
yet and my name is Thomas in the I
do systems programming what kinds of I spent a few years with was a and I also work on the cookie and which is to this topic again as a see framework for running transactions in C programs and running system leather
coat with transaction semantics but before we get to the transaction according to start looking at some traditional who will this is kind of the children form
for any application as the 2 5 descriptors of the spirit of 1 and we have an input buffer the output buffer this this and the slope and in this new i i waits for input all interesting according to the input buffer computes an output buffer from the input and writes the output to 2 files which are described by 0 and if you want and so this could be In part 2 from 1 is running only when the monitoring station and for when the station but we in poor could wake up the system once per minute the fill input buffer rates the on sensor data out for the weather monitoring
station like temperature humidity and a viewing direction wind speeds then compute some additional up some additional output from that input like relative humidity or maybe changes to previous versions then the weather monitoring station writes the measure of computer data into the final into it back up that and maybe once per day it switches on the antenna and to when that happens the transfers all the new and latest data from trent last 24 hours to send the server for end-users and maybe for predicting the weather the so usually this works quite well but 1 they the following happens that where the monitoring stations in breaks up and from which 14 . integrates the sensor data to the input buffer the complexity of a buffer there is still a probe offered the 1st 5 no choice right the the output buffer to the 2nd Viterbi now the problem appears to discuss now we are in now kind of a prominent problematic situation here because if you wanna to a consistent state you there we go forward in our program but going from work we use we have to write out back up to make it into the data to back up their match again then we just try to write that back up 5 and failed because this was for but we cannot go back and into the previous consistent state this program because going back obtained and we have to discard the um to date we just wrote to that file with that right has already been performed in can is and so look programming or our and from where for that by the monitoring stations that was kind of inconsistent intermediate state and probably a report concluded they'll crash at some point the future then there was the 1st example good example the concurrency they're still we're not running transaction quotas just for some introducing the problem so this time we
have 1 5 descriptor and the thing we have to express the number 1 computes an output buffer writes it have the the the threat of a tool to read something from that day processes the input buffer R and does something that whatever read from the file from so in terms of our weather monitoring station the 1st threat could be part of the code recent data updates
defines the 2nd threat could be part of the code that takes the measured data and transfers it to the centrosome then if you look at this I guess a bonus on the problem here so there's a right and isn't it runs concurrently yeah 0 protection long is not these threats so when but the 1 who writes the could come in inches read something whether it's of for to or anything in between it was stated in a state who knows only the of all of the way the variance right but
the this is the right to file and this leads from the same file the the and the OK now this is same size but if you have see I hope to leave the problem the problem this is not this is
the was the precision independently and this is the position then the basically you read this 1 right in this 1 reads and they are at the same position and they're up this overlapping with a convex set out look at 2nd example still no transactions you and if you look at this code you see the years here and a previous slide in this 0 arrow checking 0 test thinking if an forest is broken would never noticed that just happy continued to run until it doesn't come so from these 2 examples let's
step back for a a moment and see what we actually wanted for that code and which which properties should have who 1st of all there were some kind of between these 2 disciplines for example the 1st from the 1st case um either rewrite the 1st flight entered a 2nd file were a little but it should not be
anything in between the 2nd case if the right we want to all the rights without delete coming in between and reading inconsistence they I want the right is still going on do you want some form of consistency consistency actually means was depends on the application but usually you have consistent statement and you have some of the states and you have a consensus data again and 1st examined was when we were busy waiting for an input that was consistent and we get a number of intermediate steps were reading computing writing once by and twice the moral inconsistent at the end we had updated both fires and were is it's this presentation submit some but that was the right there was a great then the you know what I have that read and write interfere you want do rights and then at the tongue and then you want this right to be visible in the reader who and finally once we have reached a consistent state like once we have been measured and committed output who the new system state should ring system we don't wanna go back except excellently the into an old state even if is a consistent with and In the area from where left because the issue of recognize that this is usually um voted for properties which are associated with transactions so what we actually wanted in our code word transactions the so very quickly just to reiterate is very weird to reduce so we want to
everything or nothing In our cold and will you from consistent state to consists of state and told left incomes estates in between it is thought outside all transactions remove the effects that happened in 1 transaction be isolated from the all the other stuff that an assistant that used until that comment that a transaction commits and once it converts everything becomes visible and to if we're going to the transaction we don't want this you state to disappear from this but so there are many many many databases and the
database is always always kind of the world on their own on so you get suffering and you have tons of ways for configuring and turning out since and there but in the end 18 comes down to so block which cannot be
read you can have the program the and of course you can do you when probably could not implemented operating system with the traditional database um and our examples in the 1st place the whole city and were all Morris generic problems and there is is much but 1 of the solutions that is there is a good in some the remaining slides would have lots of students to receive them will be based on and but remember that this is the design patterns track of the conference so the thing symbols and here the the kind of activity and you could do this
in other languages and with other frameworks there's nothing against specific to see me on the frame using so 1 is again as a transaction
manager for a scene applications and
from where it said so shared library were studied and review want that white um you can run it all known in Oaks from where brothers fairly modular in the transaction manager itself does not have any actual functionality it you can write modules on top of and extended for whatever home system you have we
think the speaking I will get back the initial examples just explained how a typical a transaction looks like so so this this sequel which could be part of AC program it's own there is a big L. statement for each transaction there is a commit that 1 for each transaction news and statement for each transaction and those
3 are provided by the framework itself the implemented as some micro magic but it's kind of the good macro they just tight complexity data have the possible side effects and so in transaction starts with begin at beginning the framework states destruction pointers states stack pointer and then initializes the framework internally just a few variables at the beginning the execution phase starts and that is where the application programmer lists the act and the transactional cold so what the transaction is supposed to do on when the execution the the start of the Committee follows the committee is provided by the framework and at commit time as you expect the transaction gets applied to the system and when there is successful and it becomes the new system state not to commit the framework the goes to and and after event the next instruction C program was executed we will have an example later would
this was much clear the and if there are other costs during the execution or commit the frame of the to the who to recovery and during recovery and application programmer can and specify and
Carol correction of but achieves what can implement certain narrow handling whatever fits the program it is OK
1st example again this time systems and can you see you have to file descriptors
51 Sara gives input buffer there's an output buffer this is why you again that while you wait for input like it is by the star what level monitoring stations breaking up once per minute but this time after we cut it starts the transaction and let's go 1st through this and when everything works well so the introduction against but save or stick on a our instruction pointer and we do some intro set up and then we have fairly input buffer clinics that involve buffer to x is the transaction implementation of the previous input buffer function why this is important I will get to that when we come to our so we fill our input buffer within the transaction and we compute the output buffer within the transaction we do in transactional right and transaction rights are not yet applied there just safe somewhere in the past transactions did we do another that transactional right to other finds captain and again we're not really doing that we're just saying it for then the course comes during a commit the framework gets importunity to we test and see this transaction is lacking to commit if there are any arrows which could there and other problems which could occur if the comment is successful the rights to those fires out applied and to the system what it different from the goes to and then the next after and in specific to go back and restart the the once more so far there isn't actually anything you hear anything exciting this goes what the old program also did and is getting more interesting when we have in our system so we got and we start our transactions a instruction by the stack pointer was an intern initialization we refer to our input buffer in the input
buffer to X and for other monitoring station this could mean readings from sensors from partners stanzas things like temperature or you need to and maybe some those stanzas there's still a not really well calibrated then that functional now detects there's something wrong with the if descendants trying to read from and what it does now is the following does not return into the
execution phase that it does not really report any any arrow here instead of instruction in his constructs the framework that at its recovery good to the framework now rolls back the transaction then goes to recovery and racist at and this is where the programmer can specify called for dealing with arrows that
can occur during program persecution and there are things that are really not a parable that all those cases just send an e-mail to the admin shut down divisive it under the at home scan of the Texas stretching so when everything we severely go wrong he's saying about chapter on divisive but usually we can try to repair and and the case of the the this and the problem we had hindered the we try to function here redemption and a strategy for me the pouring of the same or if it's still part down or maybe you are measured need some sort of calibration I could try to can criticisms of good so headed arrow you tried does something to fix the and then it calls Mr. restart this starts the in framework to restart the transaction not transactions respect to begin because again the input buffer TX and this time it works because they just a character a room that had when we tried to read the and so this term negated and we have no weakening of thought computing the output buffer could for example involves a locating memory from the system here Fremont and using it for some temporary storage the and but maybe there's another there's another hour on and the system of memory so the Continental which is in this fashion will fail to to turn on and since the annual variable to in end again when it happens this function to the return to the execution times it instructs the framework to roll back the transaction and stuff recovery going back just means to go back to the to go to recovery recovery would call function and what we try and this time we see you carry around with women because there some caches or on and a lot a garbage collector somehow it frees memory so again we start our transactions that the it's trial the in the the sensors and input buffer a computer output buffer this time it works they just freak memory the end of we cannot get the output buffer with the memory just free during recovery and we the transaction by 2 and 0 no problem which I to try to do with the the transaction right to after a 1 but again we have this problem
that discuss follow then guarantees of being a way to handle that so the want extracted 1 detects that probably dead right would not be committed because we're just this the binding loans please decide return it does not important parallel to the execution cycle instructs the agenda framework to roll back the transaction going back this time means that we have throwing away that alignment is here or at least we we say here for a comment where I'm doing anything we're doing did in the output buffer to its function of the
input buffer Dexter Avenue side effects and or packet begins and follow begin again we go to recover it and apparently trying for the disk for that I could try to some problem along the free up memory on the disk on it's temporary something so now we free up memory we do we start again go back to the in and FIL the input buffer could don't output of the the 1st transaction right to the 2nd transaction right this time
framework things OK there's enough this space amenable to use projection of this right is likely to become infinite and then were done at the execution we go to commit and during commit we can read data and the test again is that transaction is likely to commit or to generate an arrow and that everything is going because it and we're back and they go to the end and start of and in principle any of any transaction don't but detector our cost recovery and restarts and successfully completes is just as good as long as that directly goes to the committee included successfully so
but it 1 slide about implementation um kind of the backbone for all transaction systems are lots of some sort this like here so there's so a transaction log that the framework keeps running transactions who and whom on this
is ue log for the whole pick some major source of the start and then we did fill input buffer which did not do anything that we had the
computer output buffer and internally
the the located memory and frequently then we didn't to rights that didn't really commit an functions that do not have any side effects they don't need to be mentioned the but are things like those once and we don't wanna right until we actually commit so whenever we call logistics it will put an entry into the transaction log for later processing to include if we have a function like my locked in our transactions than OA transaction cannot simply go back and restart because before restarts and hence to free the memory just located with metal so whenever mellow grants when kids the and it puts that entry into lock and to when all transaction has to be so as to aboard then the framework goes through or is it a bag words and on does any operation that needs to be so um the functions that are delayed until commit short or and share and grew from which it is unknown if the transaction has to be a report on 2nd example this time concurrency this before the non-transactional called we have 1 5 descriptor we have to threats this time implemented with transactions or 1st threat bonds a transaction started again so you can see it's computes the output buffer does the transaction right the final does occur it there's some code there there is and and what was it reaches the end statement it's basically done and done the 1st which the 2nd threat
only the it just from the same fired at this written by the 1st threat and then after the end of transaction input is processed and the decays of our our and the and by the monitoring stations that is called would be part of the uh part of the part of and measures and classified this is part of descending code which transfers the
funds modify content to the central servers along with that now let's say we start with the 1 then we start our transactions begins begins as the insect point of states Sequoia assist instruction pointer from it computes the output buffer and has the right now offered right but before the commit he gets the schedule and get scheduled by the bring system and it also starts this transaction interest to read and this time it will not read inconsistent data occurrence the when the transaction right across then in the quote I takes the locks for the as for the part of the file where the right takes place so the occurs it also tries to take this looks at the lots for that region defined are held by the 1st transaction and because the 2nd transaction cannot acquire locks for that region the file that can detect the conflict and act accordingly and acting accordingly means telling the framework that we just but disposition just discovered the term the problem of the currency and in the framework this now supposed to somehow handle that arrow and to solve the problem the resolving the problem in the simplest case means just the pull back the transaction and start a new we were doing that I so great just a friend OK it cannot continue yeah I can acquire these notes these do something about to frame the rules back the transaction starts from the then we in between gets discount shows the 1st threatening constituent and can continue with the comment no it's not stop and through right so it allowed us to commit and 2 and addenda to commit those locks are released and so the the transaction is bound and of the 1 that number 1 goes with but number 2 it will not restart it does the rate this time it works because the read can acquire locks does a commitment offer and likewise so you could dressing something around so 1st to read runs and it requires a lot successfully and then went through the woman comes and tries to write it cannot acquire locks so and we the the the it can um
all of the functionality which I've been talking about the whole time now is implemented as modules when a framework is close to me begin commit and statements so intimate cold the restart but all these functions that are labeled and and with T X they are provided by modules and most modules are running on top of the framework in when you and the new system or when you have a long with
different problems or maybe a new library and you 1 or on the transaction can write a module for that we basically we just want you will come but the framework and an interactive the framework in framework interacts what you can extent and the have been applied to destroy the use case where religious 3 functions here and we just the modular something says it just as the molecule with the framework in our life the all this function pointers here they're called when the frame were once the module to do something on walking unlocked they lot data structures that are maintained by what you whom you have a function for validating consistency so see that transaction still running on consistent data out of that data has been updated by Concurrent Transaction stone consistent with what the the transaction expects to your client under functions for applying undoing events that are is in the transactions Transaction Log move up the concurrency control and clear something that people could not use a Finnish function which once again of consumption used on it which is a device that the end of the track I there is another function opinion and if from module has a has something to report to the framework and to be applied or undone later the pendulum can use and then if there is an arrow concurrency problem only cover from the us then it is terrorist busy of generic our structure which describes iterative framework going the who in the case of let's say a transactional not the transactional when it 1st lines on a threat in its suggested in what you will miss to build on new ones but would tend the function pointer for undoing any effects that the mental can on physical freeing to when worried it was OK and next for in not objects would be to actually alocate where from the systems but if that succeeds in invented a transaction log them and deterrent the allocated memory if there is no memory in the system may come from Carol that would report that a framework and to the rule structure would then containing the angle code with some of the constant saying basically were out of memory do something about it you can query that information during the recovery to read the book and so on the is any modularity component as 1st of what you do whatever it does then if it works but anyway if it fails to recover from a and as was that this having a reliance UniForum framework in my samples and in and on on C code
but in principle this could be done in any language with framework the to which modules are there which support 1st of all transactions memory and transaction memory is something like the fireworks summers we just had just this time we're working on memory locations where there is a new clinics store to next when that is executed in a transaction you can know what 1 transaction log of variables into the transaction contigs were stored transactional variables somewhere to the outside of the selection a the and both of these functions having they acquire locks for these regions so and when you have like 2 number of transactions and a number of 2 of the variables and all these transactions they read online ruined store the variables then the transaction the component would do the concurrency control there is a certain function functional privatize and the privatize and you don't get a copy you get actual
location in your transactions
yield copies of that location you privatize that global memory location your your transaction can excellent directly and privatize it could do things like 1 copy of constrain copy and compare such things on and here a man copy for example mean privatize the source buffer privatize the destination buffer into regular and could and do all the concurrency control of will be done but the underlying transaction American and the others were coherence things stuff now tons of these functions and always the same privatized to then I can memory location in this in the examples so you know and OK it's a little helicase during a transaction and if you have to roll back the transaction you could memory is freed all American and free is low the as the operation but it's still a until the committee actually takes place so if you this an transaction after all that and after we started in memory will still be there because we do not get commit to and we have seen final and the examples the who is also going lose so you can open a file and you can close the file open is similar to analog so when the the opening a transaction and then the transaction aborts moved back to find you just open problematic closed minded to read write or have been sometimes nearest more on there's some kernel so when you have a function in your transaction that somehow quantifies the incoming move variable and you can see no need a transaction alspac and was restarted every restored so a transaction
always the we starts with the same and you have there is some support for the math library and all the maths functions on the and the support for changing viewing point environments of your transactions somehow changes running order or something like that during a rollback it would running wild for food is restored and there are exceptions supported so just like I know if you have 1 of his math functions fails and new here's where the floating-point exception that will be detected by the function and the covering distorted and during a rollback on the exception state of transactions will be restored to the and there's some support for the 5 system
but finds terms while our shared by a lot of programs so you can fully guarantee anything there on for example when you create they find undefined system when you transactional spec and it's defined there's no guarantee that there isn't any other program which just comes in and
creates the same fight again but but you can do that but the only so to summarize
that presentation only of designing or writing called transaction here there will be have lead to save coat and this terrible cold because all the complicated stuff the concurrency control the error
detection and error handling only written wants and can be shared How long transactions for things like this in library and unique stuff which strongly supported even among all of these applications different systems so on the heart problems also holds all is left to implement is directional execution and some are handling the framework itself is available it it could get it at all it's so lightly license so fairly can do anything with come the topic is interesting to you you could check out what have here right tutorials about this on how to implement transaction memory hard to do transactional developing free and things like that the and I also want where are you in a minute if you will the so John remember anything from this presentation instruments they this but
of the in depends on the system so 1st of all at the beginning of the commit you lock your instructor modules to lock all the resources that the
transaction users you have to smell it it's that where you can kind of see if there are any of problems in a system which could lead to an award where if you have optimistic
concurrency control you could have you have to validate that the who the to the transaction still runs on it consists of data and then the next step is kind of depends on the system so if you have no if you have a a system or if you have modules that implement two-phase commit you can do that you do things and you have that magic that which enables everything adjusted during the Committee for the you will have a system transaction like the fire rights here you cannot really come fully guarantee transaction semantics to complete the only intermittent use no problem and but I you cannot do things like our handling which can still fail on has yet to Frisco and it depends on whatever you want the sum of the squares of the this you can also in that depends on what your you can have pessimistic or optimistic and pessimistic addresses the simple things and I had this had optimistic in all its version of this cold and I removed it because it was entirely useless this too slow and did not provide the velocity of the universe of what was the form of the sentence things we know of no not the well I don't know what the level of the of the of the right was the and the this this come of the framework itself they could in the frame of itself does not provide any functionality like file O or I it just provides the basics of the raw framework and that is what use here right we hope he's my and yes and no because the frame of its and it only comes with these functions in you can use that that's the idea to use but if you have your given your problem you will have to write and presenting an implementation off the transaction a cocktail of course so this book on the new where I have to write and module which implements this so this is all the all the way up here have been known to many of you would get what the heart of and it doesn't really world Bank try all of you who was the the analysis you does not 1 as I said it's a design pattern so if you have a C + + construct and you to a try catch it will kind of carrying out and things but there is no additional Algeria's commit you know who you and there is no we start in a yes of course it would have been the use of questions but already filled in with the use of lower after that the rest of the year they have the then you cannot will look at this image of the 1st day of the Lord what are you going to do that in this area and what is the of of the parties of you might want to go over the whole year is critical of them and the to the reason is that in your life of the the of the yes I guess that was movement was trying to tell the last the last article the that are yet and if you look you might be easier in C + + to do with this or hard depending on what kind of super sparse you right on during in senior will usually you will end up with things like go to our all have you can have so that you see function and at the end of 2 C function as this arrow handling block which rituals back the effects of the function and whenever your function occur season Harold Innis attention jumps into the handling and and and 1 of us anyway but we do we all some of the people you looks at you cannot cannot occur Chris 1st of all you have to face looking and whenever you see here the you can whenever you see whenever you try to acquire lock in it fails um the module which sees the arrow constructs the framework a framework will recover and recovering means when back the transaction as part of that all the locks or released and we the please the sum of the of the of the of the of the of the come and that depends on and also depends on the you of the way yes but may it yeah OK it would kind kind you can wait if you know exactly which transaction weights
for which other transaction so you can you can avoid cycles and that's how it transactional transaction and in the transaction managers usually solve this so when you tell and framework the dead you cannot acquire a lot and the framework knows
which which transaction has this slope acquired you can write for that transaction if there is a cycle of building up and closes then 1 of course has to has to restart and so we started this kind of the native implementation but can be optimized there it is there's a and what is the love of of and I don't have any meaningful performance this long ago I had this and then I would be road a lot of scope and there's no performance of the so the things that we know have you I know and it's only use is only useful for things like peloponnesian as soon as it was system called for any more complicated stuff just forget about how transaction and the more you know of for all of the to give you you some of that for whom I think I've been thinking about that and in principle it can be done I think that she sees accounts of transaction analysis where's port I think I'm not sure but I think they have a hybrid system where they run hardware transactional memory and if that fails they switch to suffer transactional memory where they they require all the locks there and sulfur which is what the framework used so on I I think the this could be implemented here as well hybrid transaction resistance states more questions was 1st of 3 and as yet have the love we hear the practice set the whole of the although the problem of of right that time of the of the of the my 1st of all I would be necessary only for writing so reading reading basically means you go to the file read whatever's there and 1st of all them you acquire the locks and then with read so there's no addition of and for writing an and you have the right set of course and right side as committed when a transaction could simply and you know all virtually of the you know all the things all you get is worth it you know I don't know what this is so sorry in the world and of course the that the in the future where of you work you know always the sum of the thing so this was the union you heard of it as a a but only reusable longitudinal all of these yeah it is that this is the way it was 1 of them as we did the using of and and are or you every probability the word come to think of as well as in the goal for for the pure memory in the 2 strategies that you do some kind of my ex-king I which probably is what you mean I'm still not quite sure what does John the things we talking about and or you have some right through schemas safety all values but you can think about this priorities that never had a lot of of it was the sum of all word of the shape the changes memory always you no that's not what this does so you know how is that no How is what did not use the euro area on the right of all of the issues so that we could were all the all so the loan is really not not I know it's just and it's just a regular series which is dynamic dedicated and the new invented any any event consists of a module number which is handed out by the framework to the module but it registers and there's an opcode which use local to you so the framework the core framework doesn't have to know that and as a user pointer with just data points 32 and what the the I guess into that and try to we tried to stay as close as what are not I try to stay as close as possible and to the Paul 6 semantics when implemented this you know who are not like problem no this doesn't yet dual acquires system looks for that or if you have a new snapshots and systems could work but these commands would be if you could do this automatic of course by guess gets better strategy would be to just provide support within a transaction for the statements which to things like locating politics logs on the fire regions but it 4 in world you mean is the question is how how far and how fast the woman and there are certain limitations on Linux and Unix is 1st have for concurrency control and file system physostigmine stuff and then if you really wanted to all the locking and really be um be on the safe side and maybe even run transaction cold and non-transactional called work on the same data structures you going crazy and it's not feasible I think but if you have just an application of threats and done the no transactions and their work shared data structures look too good part and for additional we overtime already OK so for yeah for additional let's say guarantees like system-wide locking also but it's not done by default but commands could be integrated in the framework yeah of which yes struggle to to but would you and because of all both
of the name of the more you which are already in use of the word this OK
and can fix 2nd what's which operation does what depends on the strategy and your module and so isn't just somebody before it should work on memory you could have your transaction store everything in
a local right sent and and that update the memory but you could also safety memories all value somewhere do with
the rights immediately and and if you have to roll back just applied the old stuff again I could also do so to do all the of he this guy and I have about the world the on the left of the because of what if you do a
lot of the the lock manager of ck and all ck is part of the framework and what you should not have to manage to locks what it does is to acquire a lot data structures which is just the structure in C. and whatever happens to locks is done internally in different it was here at the time right of what the the book you want I 1 and in very abstract level and its but in very abstract and it is not only had very abstract level so it's a situ log of the stuff you did which has side effects and if that involves any locks with CKD then it's the problem of them what she was which requires lots but what does that mean in the lock this see that any more questions graph is a and so on and the thing that yes this would be that it would be such online launch question is if it gives a set of my long john and DOS and so it's not actually really complicated and so as to the statement we have a good year beginning there's this set and stores the IP and stack pointer and then it goes to an internal begin function and that's it and the the is that and the same the if you have to the i'm because it's the easiest implementation the of but then it's not really a transaction is and it's an aberrated lock in that and have because that is kind of the whole what the transaction is supposed so the transaction costs before each of the transaction goes to 0 1 from 1 consistent state to another consistency that involves handling and concurrency control and then if you fail in between you and the transaction inconsistent state and even if you do error recovery at that point is still have to restart your transaction and then why not have this run as part of the transaction fails to support for all they of the changes in the south of that back this is the the that who could be worried yeah the a of and a and B and the answer is you this and this just to let you all of and and yeah but only differ only the transaction the threat of distance that do transaction is that local and only on that that you under and I was just told that the time is up for decision if you wanna have question answers to these come here we can talk thank you for attending
Kartesische Koordinaten
Aggregatzustand
Framework <Informatik>
Computeranimation
Formale Semantik
Puffer <Netzplantechnik>
Open Source
Bildschirmmaske
Freeware
Pufferspeicher
Arbeitsplatzcomputer
Optimierung
Transaktionsverwaltung
Funktion <Mathematik>
Schreiben <Datenverarbeitung>
Fehlermeldung
Physikalisches System
Ein-Ausgabe
Elektronische Publikation
Bitrate
Transaktionsverwaltung
Funktion <Mathematik>
Mereologie
Ein-Ausgabe
Cookie <Internet>
Punkt
Datenparallelität
Mathematisierung
Versionsverwaltung
Zahlenbereich
Systemzusammenbruch
Wärmeübergang
Aggregatzustand
Computer
Term
Komplex <Algebra>
Code
Computeranimation
Richtung
Puffer <Netzplantechnik>
Pufferspeicher
Arbeitsplatzcomputer
Kontrollstruktur
Optimierung
Widerspruchsfreiheit
Einflussgröße
Auswahlaxiom
Funktion <Mathematik>
Schreiben <Datenverarbeitung>
Fehlermeldung
Matching <Graphentheorie>
Güte der Anpassung
Relativitätstheorie
Ein-Ausgabe
Elektronische Publikation
Transaktionsverwaltung
Thread
Funktion <Mathematik>
Rechter Winkel
Datenparallelität
Ein-Ausgabe
Mereologie
Server
Verkehrsinformation
Aggregatzustand
Wärmeübergang
Elektronische Publikation
Code
Computeranimation
Pufferspeicher
Thread
Funktion <Mathematik>
Rechter Winkel
Mereologie
Ein-Ausgabe
Datenparallelität
Varianz
Aggregatzustand
Softwaretest
Wald <Graphentheorie>
Ortsoperator
Kategorie <Mathematik>
Konvexer Körper
Nebenbedingung
Partielle Differentiation
Elektronische Publikation
Code
Computeranimation
Zeichenkette
Rechenschieber
Ordinalzahl
Transaktionsverwaltung
Rechter Winkel
Zeitrichtung
Nebenbedingung
Zahlenbereich
Schreiben <Datenverarbeitung>
Partielle Differentiation
Kartesische Koordinaten
Computerunterstütztes Verfahren
Kombinatorische Gruppentheorie
Code
Computeranimation
Bildschirmmaske
Notepad-Computer
Transaktionsverwaltung
Widerspruchsfreiheit
Funktion <Mathematik>
Soundverarbeitung
Befehl <Informatik>
Elektronische Publikation
Kategorie <Mathematik>
Datenhaltung
Physikalisches System
Ein-Ausgabe
Widerspruchsfreiheit
Zeichenkette
Transaktionsverwaltung
Ordinalzahl
Thread
Funktion <Mathematik>
Flächeninhalt
Rechter Winkel
Wort <Informatik>
Aggregatzustand
Formale Semantik
Datenhaltung
Soundverarbeitung
t-Test
Entwurfsmuster
Symboltabelle
Widerspruchsfreiheit
Computeranimation
Rechenschieber
Generizität
Weg <Topologie>
Software
Netzbetriebssystem
Optimierung
Transaktionsverwaltung
Lineares Funktional
Formale Semantik
Rahmenproblem
Formale Sprache
Besprechung/Interview
Soundverarbeitung
Familie <Mathematik>
Schreiben <Datenverarbeitung>
Firmware
Kartesische Koordinaten
Physikalisches System
Modul
Widerspruchsfreiheit
Framework <Informatik>
Computeranimation
Demoszene <Programmierung>
Software
Transaktionsverwaltung
Datenmanagement
Programmbibliothek
Transaktionsverwaltung
Schnittstelle
Programmiergerät
Kartesische Koordinaten
Sprachsynthese
Fortsetzung <Mathematik>
Komplex <Algebra>
Framework <Informatik>
Computeranimation
Wiederherstellung <Informatik>
Variable
Code
Optimierung
Zeiger <Informatik>
Transaktionsverwaltung
Phasenumwandlung
Soundverarbeitung
Befehl <Informatik>
Fehlermeldung
Firmware
Physikalisches System
Ereignishorizont
Transaktionsverwaltung
Mereologie
Phasenumwandlung
Makrobefehl
Aggregatzustand
Schnittstelle
Programmiergerät
Rahmenproblem
Besprechung/Interview
Implementierung
Kartesische Koordinaten
Framework <Informatik>
Computeranimation
Übergang
Wiederherstellung <Informatik>
Puffer <Netzplantechnik>
Pufferspeicher
Code
Arbeitsplatzcomputer
Zeitrichtung
Zeiger <Informatik>
Optimierung
Transaktionsverwaltung
Funktion <Mathematik>
Lineares Funktional
Fehlermeldung
Firmware
Physikalisches System
Ein-Ausgabe
Transaktionsverwaltung
Funktion <Mathematik>
Rechter Winkel
Ein-Ausgabe
Phasenumwandlung
Wiederherstellung <Informatik>
Konstruktor <Informatik>
Programmiergerät
Framework <Informatik>
Computeranimation
Arithmetisches Mittel
Puffer <Netzplantechnik>
Pufferspeicher
Transaktionsverwaltung
Funktion <Mathematik>
Ein-Ausgabe
Arbeitsplatzcomputer
Zeitrichtung
Wiederherstellung <Informatik>
Transaktionsverwaltung
Phasenumwandlung
Lesen <Datenverarbeitung>
Computer
Term
Framework <Informatik>
Division
Computeranimation
Puffer <Netzplantechnik>
Pufferspeicher
Zeitrichtung
Optimierung
Speicher <Informatik>
Parallele Schnittstelle
E-Mail
Transaktionsverwaltung
Funktion <Mathematik>
Lineares Funktional
Systemverwaltung
Rechenzeit
Physikalisches System
Ein-Ausgabe
Quick-Sort
Entscheidungstheorie
Transaktionsverwaltung
Funktion <Mathematik>
Rechter Winkel
Festspeicher
Ein-Ausgabe
Dreiecksfreier Graph
Strategisches Spiel
Wiederherstellung <Informatik>
Speicherbereinigung
Softwaretest
Soundverarbeitung
Konvexe Hülle
Inverter <Schaltung>
Tablet PC
Ein-Ausgabe
Widerspruchsfreiheit
Framework <Informatik>
Raum-Zeit
Computeranimation
Puffer <Netzplantechnik>
Pufferspeicher
Transaktionsverwaltung
Funktion <Mathematik>
Rechter Winkel
Mini-Disc
Festspeicher
Ein-Ausgabe
Zeitrichtung
Projektive Ebene
Wiederherstellung <Informatik>
Bildschirmsymbol
Transaktionsverwaltung
Funktion <Mathematik>
Datenparallelität
Gemeinsamer Speicher
Implementierung
Computer
Login
Framework <Informatik>
Code
Computeranimation
Puffer <Netzplantechnik>
Pufferspeicher
Logistische Verteilung
Operations Research
Transaktionsverwaltung
Funktion <Mathematik>
Soundverarbeitung
Lineares Funktional
Nichtlinearer Operator
Befehl <Informatik>
Quellcode
Physikalisches System
Ein-Ausgabe
Quick-Sort
Rechenschieber
Transaktionsverwaltung
Thread
Funktion <Mathematik>
Rechter Winkel
Zurücksetzung <Transaktion>
Festspeicher
Datenparallelität
Ein-Ausgabe
Wort <Informatik>
Verkehrsinformation
Abstimmung <Frequenz>
Punkt
Kondition <Mathematik>
Versionsverwaltung
Zahlenbereich
Term
Code
Hinterlegungsverfahren <Kryptologie>
Framework <Informatik>
Computeranimation
Puffer <Netzplantechnik>
Pufferspeicher
Arbeitsplatzcomputer
Notepad-Computer
Zeitrichtung
Inhalt <Mathematik>
Zeiger <Informatik>
Transaktionsverwaltung
Widerspruchsfreiheit
Einflussgröße
Funktion <Mathematik>
Schlussregel
Physikalisches System
Elektronische Publikation
Ein-Ausgabe
Bitrate
Transaktionsverwaltung
Thread
Funktion <Mathematik>
Rechter Winkel
Ein-Ausgabe
Datenparallelität
Mereologie
Lesen <Datenverarbeitung>
Aggregatzustand
Schnittstelle
Rahmenproblem
Datenparallelität
Interaktives Fernsehen
Oval
ROM <Informatik>
Login
Code
Framework <Informatik>
Computeranimation
Eins
Methodenbank
Client
Weg <Topologie>
Modul <Datentyp>
Stichprobenumfang
Programmbibliothek
Zeitrichtung
Zusammenhängender Graph
Datenstruktur
Maßerweiterung
Zeiger <Informatik>
Ereignishorizont
Transaktionsverwaltung
Widerspruchsfreiheit
Gerade
Modul
SISP
Soundverarbeitung
Lineares Funktional
Videospiel
Fehlermeldung
Befehl <Informatik>
Winkel
Cookie <Internet>
Schlussregel
Physikalisches System
Modul
Ereignishorizont
Objekt <Kategorie>
Transaktionsverwaltung
Funktion <Mathematik>
Festspeicher
Gamecontroller
Wiederherstellung <Informatik>
Information
Lineares Funktional
Datenparallelität
Formale Sprache
Zahlenbereich
ROM <Informatik>
Modul
Dialekt
Framework <Informatik>
Computeranimation
Transaktionsverwaltung
Variable
Festspeicher
Trennschärfe <Statistik>
Gamecontroller
Zusammenhängender Graph
URL
Speicheradresse
Speicher <Informatik>
Transaktionsverwaltung
Nebenbedingung
Punkt
Ausnahmebehandlung
Datenparallelität
Zurücksetzung <Transaktion>
Mathematisierung
ROM <Informatik>
Computeranimation
Kernel <Informatik>
Puffer <Netzplantechnik>
Variable
Regulärer Graph
Standardabweichung
Programmbibliothek
Punkt
Speicheradresse
Betriebsmittelverwaltung
Transaktionsverwaltung
Analogieschluss
Metropolitan area network
Lineares Funktional
Nichtlinearer Operator
Elektronische Publikation
Mathematisierung
Ausnahmebehandlung
Programmierumgebung
Physikalisches System
Paarvergleich
Quellcode
Elektronische Publikation
Zeichenkette
Transaktionsverwaltung
Funktion <Mathematik>
Festspeicher
Gamecontroller
URL
Programmbibliothek
Ordnung <Mathematik>
Programmierumgebung
Aggregatzustand
Ausnahmebehandlung
Datenparallelität
Besprechung/Interview
Kombinatorische Gruppentheorie
Twitter <Softwareplattform>
Information
Term
Computeranimation
Open Source
Standardabweichung
Code
Punkt
Optimierung
Transaktionsverwaltung
Fehlermeldung
Mathematisierung
Physikalisches System
Programmierumgebung
Nebenläufigkeitskontrolle
Web log
Transaktionsverwaltung
Funktion <Mathematik>
Gamecontroller
Programmbibliothek
Fehlermeldung
Fehlermeldung
Subtraktion
Kontrollstruktur
Eindeutigkeit
Implementierung
Kartesische Koordinaten
Physikalisches System
Information
Twitter <Softwareplattform>
Kombinatorische Gruppentheorie
Framework <Informatik>
Computeranimation
Web log
Open Source
Transaktionsverwaltung
Code
Festspeicher
Programmbibliothek
Transaktionsverwaltung
Fehlermeldung
Geschwindigkeit
Gewichtete Summe
Gewicht <Mathematik>
Rahmenproblem
Datenparallelität
Adressraum
Versionsverwaltung
Implementierung
Framework <Informatik>
Computeranimation
Übergang
Formale Semantik
Bildschirmmaske
Vererbungshierarchie
Zeitrichtung
Grundraum
Bildgebendes Verfahren
Analysis
Soundverarbeitung
Videospiel
Lineares Funktional
Konstruktor <Informatik>
Entwurfsmuster
p-Block
Schwach besetzte Matrix
Physikalisches System
Elektronische Publikation
Modul
Arithmetisches Mittel
Transaktionsverwaltung
Quadratzahl
Flächeninhalt
Rechter Winkel
Mereologie
Gamecontroller
Punkt
Gewichtete Summe
Datenparallelität
Mathematisierung
Besprechung/Interview
Implementierung
Zahlenbereich
Kartesische Koordinaten
Login
Framework <Informatik>
Computeranimation
Formale Semantik
Datenmanagement
Inverser Limes
Dateiverwaltung
Datenstruktur
Hybridrechner
Zeiger <Informatik>
Default
Analysis
Addition
Befehl <Informatik>
Shape <Informatik>
Hardware
Befehlscode
Reihe
Physikalisches System
Elektronische Publikation
Modul
Dialekt
Ereignishorizont
Transaktionsverwaltung
Flächeninhalt
Menge
Rechter Winkel
Festspeicher
Dreiecksfreier Graph
Gamecontroller
Strategisches Spiel
Speicherabzug
Wort <Informatik>
Nichtlinearer Operator
Transaktionsverwaltung
Rechter Winkel
Zurücksetzung <Transaktion>
Festspeicher
Strategisches Spiel
Wort <Informatik>
Operations Research
Speicher <Informatik>
Modul
Transaktionsverwaltung
Computeranimation
Punkt
Datenparallelität
Mathematisierung
Besprechung/Interview
Implementierung
Keller <Informatik>
Login
Framework <Informatik>
Computeranimation
Übergang
Datenmanagement
Abstand
Speicher <Informatik>
Zeiger <Informatik>
Datenstruktur
Widerspruchsfreiheit
Soundverarbeitung
Lineares Funktional
Fehlererkennungscode
Befehl <Informatik>
Graph
Entscheidungstheorie
Arithmetisches Mittel
Transaktionsverwaltung
Menge
Rechter Winkel
Mereologie
Gamecontroller
Aggregatzustand

Metadaten

Formale Metadaten

Titel System-Level Transactions with picotm
Untertitel The Days of Plenty Are Yet to Come
Serientitel FrOSCon 2017
Autor Zimmermann, Thomas
Lizenz CC-Namensnennung 4.0 International:
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/32267
Herausgeber Free and Open Source software Conference (FrOSCon) e.V.
Erscheinungsjahr 2017
Sprache Englisch

Inhaltliche Metadaten

Fachgebiet Informatik
Abstract How to implement reliable system software with transactions. Theory and practice.
Schlagwörter The days of plenty are over

Zugehöriges Material

Folgende Ressource ist Begleitmaterial zum Video
Video wird in der folgenden Ressource zitiert

Ähnliche Filme

Loading...