Object management on Ruby 2.1
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Number of Parts | 50 | |
| Author | ||
| License | CC Attribution - ShareAlike 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/37482 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language | ||
| Producer | ||
| Production Place | Miami Beach, Florida |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
|
Ruby Conference 201313 / 50
2
3
7
13
15
17
18
19
28
29
35
39
44
48
49
50
00:00
Memory managementObject (grammar)Insertion lossMechanism designParameter (computer programming)RepetitionAssociative propertySoftware developerVirtual realityVirtual machineInterpreter (computing)Software maintenanceEvent horizonText editorPoint (geometry)Memory managementObject (grammar)Goodness of fitInheritance (object-oriented programming)2 (number)Event horizonMultiplication signCore dumpRoutingVideoconferencingSoftware maintenanceLine (geometry)MereologySpeicherbereinigungOnline helpLogic gateChainSoftware developerLoginModule (mathematics)FamilyBridging (networking)Rule of inferenceInterpreter (computing)XMLComputer animation
04:11
Interpreter (computing)Core dumpLocal GroupSoftware developerMereologyCore dumpSoftware developerGroup actionFormal languageCapability Maturity ModelMultiplication signComputer animation
04:52
Software developerMonster groupPatch (Unix)HierarchyTelecommunicationBoss CorporationDemosceneKey (cryptography)HierarchyComputer animation
05:33
Associative propertyInternet forumASCIIMonster groupPatch (Unix)Type theoryMereologyPatch (Unix)NumberPie chartMonster groupComputer animation
06:28
Software developerPeer-to-peerEvent horizonNumberComputer clusterEvent horizonBit rateSoftware developerComputer animation
07:26
Revision controlElectric currentPlanningCore dumpTask (computing)Point (geometry)Software bugBinary codeLatent heatRevision controlComputer animation
08:00
Broadcast programmingSoftware developerEvent horizonComputer animation
08:35
Floating pointSymbol tableObject (grammar)String (computer science)SequenceFormal verificationState of matterPoint (geometry)ExpressionGenetic programmingSet (mathematics)Web syndicationFamilyComputer animation
09:27
Memory managementSpeicherbereinigungIntegerParameter (computer programming)Cache (computing)Object (grammar)Memory managementProjective planeForcing (mathematics)Machine visionComputer animation
10:02
Mathematical analysisMemory managementInformationWebsiteObject (grammar)MeasurementBacktrackingOverhead (computing)Event horizonTracing (software)Sample (statistics)SpacetimeBlock (periodic table)Row (database)Sweep line algorithmMemory managementInterface (computing)Object (grammar)Event horizonSpeicherbereinigungWebsiteMechanism designMathematical analysisHookingUniform resource locatorInformationControl flowOptical disc driveRevision controlComputer animation
12:08
Ferry CorstenObject (grammar)Presentation of a groupRevision controlRight angleWebsiteLine (geometry)Computer animation
13:29
Sample (statistics)Object (grammar)Memory managementTracing (software)Row (database)WebsiteBlock (periodic table)SpacetimeControl flowDigital photographyPresentation of a groupComputer animation
14:15
Digital photographyPresentation of a groupPoint (geometry)PhysicalismComputer animation
15:16
Task (computing)Office suiteGroup actionPoint (geometry)GodSpeicherbereinigungWindowTask (computing)Power (physics)Computer animation
16:08
CodeMemory managementObject (grammar)Parameter (computer programming)AlgorithmMereologyInsertion lossSpeicherbereinigungThresholding (image processing)Read-only memoryDefault (computer science)String (computer science)BefehlsprozessorVirtual machineAerodynamicsLimit (category theory)Integrated development environmentDivisorVariable (mathematics)Maxima and minimaMathematicsParameter (computer programming)Type theorySystem callTunisObject (grammar)Line (geometry)Figurate numberMultiplication signSemiconductor memorySpeicherbereinigungLimit (category theory)Thresholding (image processing)Memory managementNumberDefault (computer science)2 (number)AlgorithmVirtual machineRevision controlWave packetLogic gateSound effectRight angleCASE <Informatik>Computer animation
19:31
Limit (category theory)AerodynamicsParameter (computer programming)SpeicherbereinigungLimit (category theory)Parameter (computer programming)NumberComputer animation
20:07
AlgorithmObject (grammar)Vapor barrierInsertion lossHash functionFloating pointString (computer science)Codierung <Programmierung>QuicksortGroup actionGodSpeicherbereinigungExtension (kinesiology)Point (geometry)Computer animation
21:10
AlgorithmSlide ruleImplementationStrategy gameObject (grammar)Normal (geometry)Military operationMereologySpeicherbereinigungMachine visionMathematicsComputer animation
22:06
Sweep line algorithmStrategy gameMacro (computer science)Codierung <Programmierung>Source codeAlgorithmFinitary relationObject (grammar)Data structureRead-only memoryLibrary (computing)Memory managementPhysical lawSemiconductor memoryInsertion lossTheory of relativitySpeicherbereinigungAlgorithmStrategy gameObject (grammar)Source codeMeasurementMathematicsMacro (computer science)Extension (kinesiology)Limit (category theory)Data structureMultiplication signComputer animation
23:50
Memory managementGame theoryObject (grammar)RootTraverse (surveying)Reverse engineeringSweep line algorithmObject (grammar)Revision controlTraverse (surveying)Analytic continuationAlgorithmSweep line algorithmComputer animation
24:49
Object (grammar)HypothesisHash functionSocial classFlow separationRead-only memoryAlgorithmType theoryRight angleObject (grammar)Semiconductor memoryCovering spaceData miningDifferent (Kate Ryan album)Rule of inferenceElectric generatorMultiplication signEndliche ModelltheorieGodSpacetimeResultantSpeicherbereinigungFigurate numberHypothesisAlgorithmCombinational logicSocial classVulnerability (computing)ConcentricComputer animation
28:03
Sweep line algorithmObject (grammar)Overhead (computing)RootNormal (geometry)Traverse (surveying)Traverse (surveying)Slide ruleAlgorithmObject (grammar)Overhead (computing)Speicherbereinigung2 (number)Strategy gameGroup actionComputer animation
29:12
Object (grammar)LeakRootSweep line algorithmSoftware bugTraverse (surveying)Object (grammar)Strategy gameTheory of relativityMedical imagingoutputCountingType theoryComputer animation
30:26
Vapor barrierMilitary operationWritingInterpreter (computing)Theory of relativityType theoryVapor barrierObject (grammar)CASE <Informatik>Computer animation
31:00
Vapor barrierWritingMilitary operationInterpreter (computing)Image registrationObject (grammar)Extension (kinesiology)Level (video gaming)Computer programSource codeComputer configurationAxiom of choiceCASE <Informatik>Observational studyCausalityVideoconferencingVapor barrierVariable (mathematics)Instance (computer science)SpeicherbereinigungExtension (kinesiology)Axiom of choiceTable (information)Electric generatorComputer programmingPoint (geometry)AreaGodPhase transitionComputer animation
33:05
Insertion lossInterpreter (computing)CompilerAlgorithmSpeicherbereinigungComputer configurationAxiom of choiceCodierung <Programmierung>PlastikkarteMathematicsSpeicherbereinigungMusical ensembleElectric generatorQuicksortComputer configurationExtension (kinesiology)Goodness of fitComputer animation
33:45
Normal (geometry)Object (grammar)Point (geometry)Type theoryFlow separationKey (cryptography)MathematicsNumberObject (grammar)Vapor barrierPoint (geometry)Rule of inferenceInterpreter (computing)Normal (geometry)Projective planeRight angleComputer animation
34:31
Operator (mathematics)Object (grammar)Normal (geometry)Military operationRule of inferenceInterpreter (computing)Operator (mathematics)Object (grammar)Computer animation
35:07
RootObject (grammar)Traverse (surveying)Military operationNormal (geometry)MathematicsSweep line algorithmForcing (mathematics)Multiplication signMathematical analysisStopping timeSweep line algorithmPoint (geometry)Computer animation
35:58
Object (grammar)Extension (kinesiology)AlgorithmInterpreter (computing)Core dumpSocial classInsertion lossSweep line algorithmKolmogorov complexityParameter (computer programming)NumberSpacetimeImplementationAreaTraverse (surveying)StrutMilitary operationWritingVapor barrierBlock (periodic table)Codierung <Programmierung>Variable (mathematics)Pointer (computer programming)Software bugSlide ruleObject (grammar)ChainCountingPoint (geometry)Extension (kinesiology)Macro (computer science)Vapor barrierComputer animation
36:46
Performance appraisalIdeal (ethics)BenchmarkObject (grammar)Task (computing)Sweep line algorithmPerformance appraisalBenchmarkGodMultiplication signObject (grammar)ResultantProduct (business)Figurate numberComputer animation
37:53
Sweep line algorithmPerformance appraisalBenchmarkFigurate numberTotal S.A.Run time (program lifecycle phase)Multiplication signMathematicsResultantMereologyComputer animation
39:07
Performance appraisalSweep line algorithmMaxima and minimaDenial-of-service attackBounded variationResultantPerformance appraisalDemo (music)Group actionComputer clusterPoint (geometry)Computer programmingMotion captureComputer animation
40:41
Instance (computer science)Computer programmingComputer animation
41:33
Insertion lossObject (grammar)Object (grammar)SpeicherbereinigungVapor barrierExtension (kinesiology)AlgorithmAnalytic continuationException handlingProjective planeVideoconferencingVideo gameComputer animation
42:27
Task (computing)Object (grammar)Physical systemRead-only memoryComputer programBenchmarkLoop (music)Reduction of orderOverhead (computing)EstimationSpacetimeThresholding (image processing)Parameter (computer programming)Multiplication signComputer programmingOperator (mathematics)System callQuicksortProjective planePoint (geometry)AdditionSpeicherbereinigungObject (grammar)Semiconductor memoryTask (computing)Performance appraisalComputer animation
44:28
Memory managementInsertion lossMechanism designParameter (computer programming)Point (geometry)Group actionMemory managementObject (grammar)Lecture/Conference
Transcript: English(auto-generated)
00:17
Well, thank you so much for coming to this room.
00:21
So I want to talk about this title, Object Management on Ruby 2.1. We at Heroku are working on improving the quality of Ruby 2.1. So today I want to introduce the effort for the object management, especially for the garbage collection.
00:46
So we rewrite the core module in C language, gc.c. So we changed so many lines and adding several features.
01:05
So this is a summary. And if you read this page, you can understand my presentation. So every year, I recommend the other presentation,
01:24
not this year. Usually I recommend the other presentation, but maybe you need to go bridge. Is it OK to continue this presentation?
01:46
So let me introduce myself. So my name is Koichi Sasada. Family name is Sasada, and a given name is Koichi. So this is Ichi. Ichi means one. So this is a very traditional naming rule in Japan.
02:08
So this naming rule represents that I'm the first son of my parents. So this is my login name.
02:22
So Ichi came from this name. So if I'm a second person, a second son of my parents, then my name was Koichi.
02:42
So it means second. And I'm working on Heroku. I'm a full-time CRuby developer and working in Japan as a CRuby committer and one director of Ruby Association.
03:04
So let me add a phrase to Ruby Association. So Ruby Association is foundation to encourage Ruby developers, development, and Ruby communities. China is Mars and located at Mars City in Japan. So we do many activities, maintenance of Ruby,
03:25
CRuby interpreter. So we spend some money to maintenance. So one, nine, three, maybe you use this version. And maybe 2.0 will be maintenance by us. And as activity, so we have events.
03:45
We will do a Ruby World Conference in this month. And the award and grant. So there are many activities to continue such a good activity for Ruby community,
04:04
then please read this line. Your contribution is needed. And Heroku, maybe you, of course you know Heroku. You know about Heroku, then me.
04:21
So and I want to also introduce this part. So Heroku supports Ruby development. So there are many talents in Heroku and any other languages. So especially, so Heroku employs three Ruby core developers,
04:44
Matt and Nobu and me. So we name our group Matt's team, Matt's team. So Matt's team in Heroku, we are living in Tokyo and Tochigi and Shimane.
05:00
So it's very far. So usually, we communicate with Skype. So we don't gather in Japan. And in this conference, we can gather three Matt's team. So this is a hierarchy of Matt's team.
05:34
Maybe you know Matt's Motsu-san. So Matt's Motsu-san is known as the title collector. So he has many, many titles.
05:40
I can't write every his title. Maybe Matt's Motsu-san doesn't remember his title, all titles. And Nobu is great patch creator. Nobu, Nobu, ooh.
06:04
Right, OK. So this is a pie chart of commit number in five years. So 22% of commits modified are done by Nobu.
06:23
So this is why we call him Patch Monster. And also, I'm also known as EDD developer. So this is my commit number day by day. So this date is RubyConf 2000.
06:42
So that's RubyConf. And this is a release of Ruby 2.0. And this is a RubyCAD event. And this is a Yuriko. And here is RubyConf. So this is an event development. So if you want to improve the Ruby quality,
07:04
then please invite me. Thank you very much. Thank you very much.
07:21
I like hot place, warm place. The mission of Matt's team is, of course, improve the quality of Ruby next version of C Ruby. So Matt decides the specification of finally. So there are many, many proposals.
07:44
So Matt decides finally. And Nobu fixes the bugs. And my task is to improve the performance. So current target is Ruby 2.1. So Ruby 2.1 will be released at the next Christmas.
08:05
So we are here. So we, we release preview one of Ruby 2.1. And we, as soon as possible, we release the next preview, preview two, in a few days.
08:21
And begin, we release the release candidates at the beginning of December. So there are only a few weeks. Ruby 2.1 has several new features, like that.
08:45
But it is not so much, not so much smaller than the Ruby 2.0. Ruby 2.0 has many, many features, but Ruby 2.1 has such a small feature, it's changing. So 2.1 introduced, for example, the numeric syntax.
09:04
If you write this syntax, it's recognized as such a syntax, such an expression. And this syntax, definition of methods returns a symbol of the method name.
09:24
And blah, blah, blah, several features. And of course, I also do some improvements. So profiling supports, more sophisticated garbage collection, or some other optimization.
09:43
So it's not, of course it is there, not only my efforts, but also many, many Ruby committers' efforts. So today's title is Object Management. So I introduced these improvements today.
10:06
At first, so we introduced new profiling support. Maybe two topics.
10:21
And today, I want to introduce this interface for object management. So, Ruby 2.0 or earlier, we don't have any event mechanism to hook the object creation and the allocation.
10:43
So Ruby 2.1 has such a event. So this feature, we can collect some more detailed analysis about object management. For example, the correct object allocation site information, correct, blah, blah, blah.
11:03
And for details, we introduced these four events. So this is object creation, and this is after the allocation of objects. And two garbage collection events,
11:21
the ggstart and ggend. We have lazy-sweep, so we start the marking and do sweep partially, do sweep partially, do sweep partially, and at the end of sweep, then ggend are called.
11:44
So with this feature, it is very, so it is easy to make some useful feature like that. So I, for example, I implemented the trace object allocation.
12:00
So let me do a demonstration.
12:23
So I, one, now I'll go, I modify the ILB command, like that, at the several lines. This modified version, ILB has a new feature,
12:46
where are you from? So for example, a goal, object, new. Then you can ask the creation site of this object,
13:01
then return to this line. And so, for example, maybe you use PPModule, usually. So it introduce a new constant, new class, PP. So we can ask the, where are you from?
13:23
Then this is created at this line, this line. Maybe it is useful to debugging or something. And maybe, so this presentation show detail of this feature.
13:47
I have 25 minutes. So let me continue introduce myself.
14:03
And I married recently, this is Member, with Yuki. Yay! This is her photo.
14:23
So you can tweet the celebration to him, see her. So maybe in Japan, it is early morning, so after she wake up, then she will surprise so many tweets.
14:44
So I have three important, I want to say three important points. So my wife is not here, unfortunately. And my wife is excellent, so very nice, very cute.
15:05
I need to repeat this line. And the third point is that my luggage has spare space.
15:21
So my wife is mostly perfect, mostly perfect, so I need to repeat this line. But she has one weak point. So that house cleaning is my task in my house,
15:44
mainly pushing the power of the window. So this means that I'm a garbage collector
16:03
at the office and home. So my task is to improve the garbage collection. So let's talk about the garbage collection. So to make better object management, we made refactoring object management course.
16:23
So as I said, so many lines I really write. And we, mainly we, so today, so there are many, many changes around garbage collection, but I only talk about the two topics,
16:43
GC parameter tuning and new GC algorithm calls. R-Gen GC, it's a special version of generation garbage collection for Ruby.
17:02
So about the GC parameter tuning, so do you know when GC occurs? So there are two, many two types of timing. So if there are no, there are no throat to allocate the object,
17:22
then corrects the unused object. It is very easy to understand. So the second need, the second is if exceeds the threshold of the memory allocation, then invoke the garbage collection. So maybe this number two is not easy,
17:44
so I explain about that. So if we allocate the memory, then invoke the garbage collection.
18:02
So every time we allocate the inside memory, then increase the parameter memory, increase with N. And if this parameter Merock increase bigger than the limit, then cause the invoked GC.
18:21
So the fourth parameter of Merock limit is only eight megabytes. This means that if you allocate the eight megabytes, then invoke the garbage collection. So I think it is too small in recent machine. So I ask, but why such smaller value you choose?
18:44
Then his reply is, I use 10 megabyte machine as 20 years ago. So we change this value. So as default, eight megabyte to,
19:06
we change default value eight megabyte to the 16 megabytes. And more aggressive, more adaptive tuning we changed. So this is a detail of this algorithm,
19:21
but if you have interest about that, please read these slides after my talk. So this is a figure of the Merock increase and Merock limit parameters.
19:41
So we grow the Merock limit aggressively. So there are more small number of garbage collection out there. So on 2.0, the Merock limit is too small,
20:02
so there are many, many garbage collection here. So next, let me introduce generation garbage collection into CLB.
20:21
So generation garbage collection is not new technology. It's very old technology. Maybe it's 30 years ago, the generation garbage collection is implemented. 30 years or more old.
20:40
So we introduce generation garbage collection to improve the G-Ship HOMAS with some technique. So this is two technical things.
21:01
So important things is no compatibility issue with the extension. It is important points. And I talked about this topic at Rubikahi and Iruko this year,
21:21
so if you want to see more details, so please google my presentation. So there are many, many topics to introduce a garbage collection, but I only have 25 minutes,
21:40
so I will skip some part of this thing, this topic. So to understand the new GC technique, you need to know about garbage collection,
22:02
basic about garbage collection. So I need to make a lecture with garbage collection. So basically, we, CLB, are using Markov slip algorithm
22:26
with some techniques. And so basically, it's implemented on three friendly strategy. So three friendly strategy means
22:41
you don't need to insert magical macro in C source code. And many, many C extension under this strategy, so we need to keep this strategy. So because of such a strategy, we have several restriction,
23:02
so we can't know object relation change timing, and we can't use moving garbage collection such as copying algorithm and compacting algorithm. And because of object data structure, it means how to make, how to manage the objects,
23:24
then we can't measure exact memory consumption, and so this limitation, this limitation is, so we need to introduce generation garbage collection
23:45
on such a restriction. So this is very basic. Markov slip algorithm is at first
24:03
marking the reachable objects. So traverse this object and mark it, and traverse this one, and traverse this one, continue. And then traverse all object, it's possible to traverse from loose objects.
24:22
Then we can understand the marked objects can need to, can't correct. It is their use. And we can correct, we can understand these untraversal objects are garbage,
24:42
so sweep unmarked objects. So this is the basic of mark-and-slip algorithm. So and generation garbage collection, there is a weak generation hypothesis.
25:01
Most objects are young. Then we can concentrate big grammation effort only on the young objects. So this is a figure to show the lifetime of objects.
25:21
So this figure shows 95% of objects that at the first garbage collection. So most of objects cannot survive the first garbage collection. So we can, so we can see,
25:47
we can concentrate on the youngest objects. And this is a type four type. So some objects are corrected
26:02
at the first time garbage collection, and some type of objects like class has long lifetime. So you can see that most of objects are very short,
26:22
most of the type of objects has very, very short lifetime and some of objects has long lifetime. So there are no here, no objects here.
26:44
So generation garbage collection using this assumption. So separate the younger generation and older generation and mark-and-slip, sorry, garbage collection for only younger generation.
27:10
Usually, garbage collection on young space and GC space, so, and if there are no memory, then GC both spaces.
27:22
If no memory. Generally, minor garbage collection and major garbage collection can use different garbage collection algorithm. Popular combination is minor GC for copying GC
27:42
and, sorry, copying GC for minor garbage collection and mark-and-slip for major garbage collection. But we cannot use the copy garbage collection because of the restriction. So we use both mark-and-slip.
28:05
So if we, so this slide shows how to use, how to do minor garbage collection with mark-and-slip. So traverse the objects
28:23
and change the young objects to the old objects. And second minor garbage collection,
28:40
we can, we traverse this old object and we understand they are old. So we can understand, we can skip the marking of these objects. So we can reduce the marking overhead.
29:01
And at the major garbage collection, so it is the same as the simple mark-and-slip algorithm. So, but this strategy has a, this strategy has a problem.
29:23
So it's possible to miss the marking, and so there are possibility to marking leak. So for example, the old object has a relation
29:42
to the new object, then it can leak this marking. So it's cause a critical value if we cannot traverse, mark the new objects.
30:05
So usually we use the remember set. So if it detects the creation of the relation, so this one to this one, then remember this object and mark this object and this object.
30:28
So this, to detect the old to new type reference, we need to insert the light barrier everywhere. So if there is a old object and a new object
30:42
and refer to new object, then light barrier detects such a relation, creation relation. So the algorithm, so this is not Ruby's case,
31:04
but it's a general case. So in Ruby, so if we, so old array refer to the new objects, then it needs a light barrier. And also, the instance value of,
31:22
so insert the new object to the instance variable who then it needs a light barrier. So we, so repeating that, so missing the light barrier, it's cause a bug.
31:40
It's cause a table bug, we cannot debug this one. So we need to insert the light barrier to introduce a generational garbage collection, but it is very difficult, especially for the, for C extension.
32:02
C extension, now they don't have, they don't have light barrier just now. So there are many, many case we need to insert the light barrier. So this is a problem.
32:27
So this is a two choice. So give up the generational garbage collection is one choice, and introduce the generational garbage collection is second choice. With rewriting all of the C extension.
32:42
So performance is bad, so Ruby 2.0 garbage collection is slow, but compatibility is good. So we choose this choice before 2.0 and earlier. So this is a trade-off of speed and compatibility.
33:08
So challenge is to break such a trade-off. So to overcome such a restriction, we introduced a new garbage collection algorithm,
33:22
restricted generational garbage collection. So using this algorithm, performance is good because we can use generational garbage collection. And most of C extension works without any modification. So compatibility is good.
33:41
So we choose this option. So key idea, key idea is to introduce shady object. Key is very doubtful. So separate the normal object and shady object,
34:02
and we insert the normal object, sorry, we insert the light barrier into the normal object. And if we don't want to insert the light barrier correctly, then it's rather shady.
34:24
So we are not sure that shady object point new object or not. So, and introduce such a very simple rule into interpreter.
34:44
At marking, don't promote shady object to the object, and remember shady object pointed from the old object. As the shady operation for all normal objects, then demote the object and remember shady,
35:00
shady to shady object. So maybe it is complicated, but it works now. So I skipped this slide. So if you want to know the details, please ask me after that.
35:22
So skip the detail. So after introducing the RGGC, we can show the stop time of marking. We can show the marking time. And unfortunately, sweep time is same as 2.0.
35:44
And we need to insert light barrier, some parts, so we can, so it is some overhead. So it is analysis of the detail.
36:01
So I prepared these slides for academic people, but I skipped these slides. It is too detailed. This is one important point for extension writer. So please do not use this macro,
36:23
but use this macro to get to two sets. It includes light barrier correctly. If you use this macro, then the object
36:40
tend to shady object. So performance will be down. Maybe everyone likes the performance evaluation, so I showed the performance evaluation with RGGC.
37:05
So this is a very simple, very simple micro benchmark. So create many old objects at first and many new objects, so many time minor garbage production. So this is a result of time.
37:27
So this figure shows that marking time is, so before RGGC, the marking time is very high, but after introducing the RGGC, it's very short time.
37:48
It will become very short time. But sweeping time is the same. This figure shows not the micro benchmark, but a big benchmark for creating the Ruby's document
38:02
using the R doc. So this shows marking time without RGGC is so slow. But using the RGGC, it's very fast marking time.
38:28
So this is a compare of the accumulated execution time. So marking time is very fast. Sleeping time is same at now.
38:42
And so this is total time of RGGC. R doc. So it is 12% of improvement of total execution time because of the reducing the garbage execution time.
39:02
I think it is very good result. And I want to introduce Nari-san. So he make a very fantastic result of evaluation of RGGC.
39:30
Could you explain the demo about this demo?
39:50
Hi.
40:03
This program is Dancing Perfume. Perfume is a famous popular group in Japan. This uses perfumes, motion capture data, and Ruby SDL draws this dancing.
40:26
This program is on Ruby 2.0.
40:47
And this program is on Ruby 2.1 using RGGC.
41:03
Thank you so much, Nari-san. Maybe you want to know about the detail of this program. So he talk at the lightning talk
41:21
about this program and perfume. So don't miss it. So continue to, let's continue.
41:46
So I skipped the detail, the technical detail of RGGC, but this algorithm introduce a generation garbage collection
42:01
with allowing mixing light barrier protected object and light barrier unprotected object. And there are no, mostly no compatibility issue with C extension. So, and we can insert the light barrier gradually. So I believe this is a good approach to Ruby
42:24
to introduce generation garbage collection. So there are several remaining tasks. For example, we need to reduce the old object. It has impact to the performance.
42:43
And the minor GC and major GC timing. So when it should be a minor GC and when it should be a major GC, it's a very difficult program. So if we make a major GC many times,
43:04
then slow down program. But if only a few major GC are out, then memory consumption, it has memory consumption issue. So we have several approach to overcome this feature.
43:23
So we introduce, so we are, so we are implementing and evaluating the three generation garbage collection. Introduce infant objects.
43:41
And also, we have, we implemented and evaluating the estimating how, so estimating how many, how much memory all the objects consumes. So there, so we are implementing this feature, but it's under evaluation.
44:01
So if we can understand it is good for Ruby, so then Ruby 2.1 has these features. We will have these features. So in other words, we, just now, we are working on garbage collection.
44:25
So there are many, many future works. So let's finish this presentation. So summary is Ruby 2.1 will be released at the next Christmas.
44:41
And we rewrite the, we rewriting, rewriting now. Writing the object management to improve performance. So thank you very much.