Automatic Reference Counting

Huiqi and Toby talk about Automatic Reference Counting - a system of automatic memory management used by some popular programming languages including Python, Object-C, Swift, Rust, and more.

Transcript

The following transcript was automatically generated by an algorithm.

00:00 : wanna wanna talk a little bit about
00:03 : the the memory management oh sure
00:06 : a couple of corrections for the first
00:08 : video that we did
00:09 : uh number one is i said a stack was
00:14 : first and first out well but that's
00:17 : actually wrong it's first first and last
00:20 : out
00:21 : uh yeah if you think through that
00:25 : that makes sense like as a stack
00:28 : you put it you put in the one
00:31 : you put in the two you put in the three
00:34 : if you pop then you get rid of the three
00:39 : if you pop you pop again you get rid of
00:42 : the two so the one which was the first
00:44 : and it actually comes out last um
00:48 : so that's a correction another
00:49 : correction uh i i was reading
00:52 : some more about garbage collection last
00:55 : week
00:56 : and uh originally i said python
01:01 : was uh was a normal gc but
01:04 : it turns out python also uses reference
01:06 : counting
01:07 : so it's not true that python uses
01:11 : the normal gc it uses
01:14 : reference counting as well which i did
01:16 : not know that
01:17 : and and then and then also in terms of
01:20 : terminology i got that wrong
01:22 : also so so turns out
01:25 : if you if you look at the wikipedia page
01:29 : for
01:29 : reference for garbage collection turns
01:32 : out that
01:33 : the automatic reference counting is also
01:36 : considered a type of garbage collection
01:39 : so
01:40 : i i was i was separating them but
01:43 : maybe arc should be under the umbrella
01:47 : of gc um oh we're gonna like
01:50 : we're gonna dive into the concept of the
01:54 : arc
01:54 : and the gc yeah so i i was saying
01:59 : i was saying arc is distinct from gc
02:02 : but in fact arc is uh one type of gc
02:07 : and the other type of gc is they call it
02:10 : in this article they call it tracing
02:13 : so yeah we definitely want to cover what
02:15 : these concepts
02:16 : mean um let's let's first talk about
02:20 : arc which again stands for automatic
02:24 : reference counting
02:25 : and let's start with an example
02:29 : if you have a function and inside of it
02:33 : you make an array um
02:37 : and then maybe you call another function
02:40 : within it
02:41 : passing to the array um
02:45 : so this array the the the numbers the a
02:48 : and b which we assume are like numbers
02:52 : they're not they're not going to be
02:53 : stored in the
02:55 : heap because the numbers numbers
02:58 : just get stored in the frame always
03:01 : when you make an array we're going to
03:04 : allocate
03:05 : heap memory to store the value of of the
03:08 : array
03:09 : the question is how do we know like if
03:12 : we have a heap
03:14 : if we have a heap and it's storing the
03:18 : values of our array so if
03:20 : i'm gonna call f with one and two
03:23 : at some point so the frame is gonna be
03:26 : like that
03:28 : so at the bottom of the stack we're
03:31 : gonna put
03:36 : a is one and b is two
03:40 : and the array is a pointer to this guy
03:45 : which is gonna have one and two
03:48 : and then now we're gonna call g
03:51 : uh and g g's
03:54 : array is gonna be
03:58 : pointing to the same array in the heap
04:01 : um so the so
04:04 : when g is done
04:08 : when g finishes
04:11 : this pointer will go away
04:14 : um when f uh is done
04:17 : then this pointer will go away um
04:20 : the question is we would like a system
04:23 : that
04:24 : knows when no more pointers
04:27 : are referencing this array then we know
04:30 : this can go away we don't we don't need
04:33 : to tell us
04:35 : how does this is just to know how many
04:38 : pointer
04:39 : are there are like where are the points
04:42 : or
04:42 : are they stored in the bank or where are
04:45 : they
04:46 : the registry of point that's a good
04:49 : question
04:49 : um so in the reference counting
04:53 : system what you do is this you you you
04:56 : keep a
04:56 : reference count for each object that's
05:00 : in the heap
05:01 : um and the way i'll do it is i'll just
05:04 : put a little number here
05:06 : in parenthesis so at this point we have
05:09 : a reference count of two because
05:13 : there are two pointers pointing to it
05:15 : there are two references
05:18 : to this array therefore the reference
05:20 : count is
05:21 : two at the moment and if g
05:25 : finishes then this pointer goes away
05:29 : therefore this reference count should go
05:31 : down to one
05:33 : and then okay if f finishes
05:37 : then this array pointer goes away
05:40 : and then this the reference count should
05:42 : go to zero
05:43 : and when your reference count is at zero
05:46 : you know that
05:47 : you can destroy the array itself because
05:50 : nobody else
05:51 : is referencing it anymore so
05:55 : so the way it basically works is
05:58 : every time you assign a heap object
06:02 : to a variable you increase its reference
06:04 : count
06:06 : so for example you have another
06:09 : variable y array
06:14 : equals array if you do that you just
06:17 : increase its reference count again
06:19 : because now there's
06:21 : two references to the same array
06:24 : and when you pass the array to
06:28 : another function call that increases the
06:31 : reference count because
06:32 : inside of the function g
06:36 : inside of the function g well this this
06:41 : this pointer just got copied to this
06:43 : parameter here so so this parameter is
06:46 : pointing to so that increase the
06:48 : reference count again
06:50 : um yeah so that's more or less how that
06:53 : works
06:54 : uh we talked about automatic reference
06:56 : counting right
06:58 : is that is what we just talked about um
07:01 : like automatic reference counting oh
07:03 : yeah is is this automatic
07:05 : um well if your language
07:09 : does this for you automatically then it
07:12 : is automatic reference counting
07:15 : but if your language does not do it for
07:17 : you automatically
07:19 : and requires you to uh
07:24 : notify it yourself by calling some
07:28 : function
07:29 : then it's not automatic reference gotcha
07:32 : so in in
07:33 : in the older version of objective c
07:37 : uh they would actually require you to do
07:39 : this
07:40 : manually if you had an object
07:44 : if you want to increase its reference
07:46 : count you have to call
07:47 : the retain method so you would call
07:51 : retain
07:53 : and that increase it increases its
07:55 : reference count
07:56 : and then later on if you want to
07:58 : decrease the reference count you call
08:00 : release
08:02 : interest this is very interesting uh to
08:05 : so i'll just read this paragraph so
08:08 : while
08:08 : objective c traditionally had no garbage
08:12 : collection
08:14 : and when they said it had no garbage
08:16 : collection
08:17 : at that point basically it had this
08:19 : manual
08:20 : reference counting mechanism where you
08:22 : have to call the methods yourself
08:24 : if you say retain basically they're
08:26 : saying well within the scope of
08:29 : what i'm using it for i need it around
08:32 : so i'm gonna
08:33 : retain it which increases its reference
08:36 : count
08:37 : and then when i don't when i don't need
08:39 : it anymore
08:40 : what whatever the definition of my scope
08:43 : that i choose it to be
08:45 : and when i don't need it anymore i'll
08:47 : release it right
08:49 : um so i'll call that manual reference
08:51 : counting
08:53 : but then in in 2007
08:56 : apple introduced garbage collection
09:00 : for objective c 2.0
09:04 : using an in-house developed runtime
09:07 : collector
09:09 : however with the 2012 release
09:13 : of os 10 10.9
09:16 : garbage collection was deprecated
09:19 : like that one that they made in 2007 was
09:23 : was deprecated in favor of llvm's
09:27 : automatic reference counter arc
09:30 : that was introduced with os 10
09:34 : 10.7 since
09:37 : apple even forbids using that first
09:40 : garbage collector that they made
09:43 : garbage collection has never been
09:45 : introduced
09:46 : for ios oh what we talked about is only
09:49 : for
09:49 : the os 10 but for ios garbage collection
09:53 : has never been introduced
09:55 : due to problems in application
09:57 : responsivity and performance
10:00 : instead ios uses arc only
10:04 : so what is what's the difference between
10:07 : garbage collection
10:08 : and arc here because i thought arc
10:11 : is a meaning of doing garbage collection
10:15 : i guess they are distinguishing kind of
10:18 : between garbage collector
10:19 : and arc we'll talk about what a tracing
10:23 : garbage collector does later
10:27 : but essentially a garbage collector
10:30 : that they introduced in 2007
10:34 : that one had a more severe
10:37 : performance impact than arc
10:41 : arc is more lightweight and and the
10:43 : full-fledged garbage collector
10:46 : just took up more resources
10:49 : so apple has always been very
10:53 : like conscious about performance in
10:55 : everything that they do
10:58 : which i i think that's the reason why
11:02 : they prefer to not have a
11:05 : full-fledged garbage collector apple
11:08 : might be a special case in that
11:10 : because most of the developers in the
11:13 : world
11:14 : use a language that uses a full-fledged
11:17 : garbage collector
11:18 : including javascript and and java
11:23 : those things those languages use a
11:25 : full-fledged garbage collector
11:28 : which does have a performance
11:32 : penalty which we'll talk about
11:36 : arc has a
11:39 : lower performance penalty
11:43 : in general at least that's how it is
11:46 : perceived
11:47 : although other technology is always
11:50 : advancing and people are trying to do
11:51 : better with either approach all the time
11:55 : if we try to keep track of the different
11:58 : places
11:59 : where we would need to increase
12:02 : or decrease the reference count number
12:05 : um
12:06 : those those places would be um
12:09 : so you would need to increment a
12:10 : reference account if you assign
12:13 : and a heap object i'm just going to say
12:16 : object but i mean a heap object to a
12:19 : variable
12:22 : if you if you uh pass it
12:27 : to a function as as a
12:31 : as an argument if you assign it
12:34 : to a
12:37 : field of another object um yeah if you
12:40 : have
12:41 : one object in the heap that has a field
12:43 : that's pointing to another object in the
12:45 : heap
12:46 : then uh the assignment to this field
12:49 : should also increment this number here
12:53 : because that's also a reference to this
12:55 : object
12:56 : where to decrement the reference count
13:00 : so if if you assign an object to a
13:02 : variable
13:03 : you could potentially need to decrement
13:06 : the reference count
13:07 : of the object that the variable used to
13:10 : point to
13:12 : so so if you have like an array variable
13:15 : and it's pointing to this
13:18 : this array in the heap and then using
13:22 : another assign another array to the
13:25 : this array variable so you're gonna
13:28 : remove this link
13:29 : you're gonna add a link to here well
13:31 : this one is gonna
13:33 : plus one but this one you want a minus
13:35 : one right
13:36 : if you assign to a field of an object
13:39 : it's the same thing
13:41 : you need to decrement it
13:44 : what about uh after you pass it to a
13:46 : function and that function returns
13:48 : do you uh decree yeah
13:52 : yeah exactly that that's a case where if
13:55 : you have a function that's receiving an
13:57 : array
13:58 : or there's an another array this
14:01 : is pointing to an array and this this
14:04 : guy
14:04 : is gonna point to another array uh
14:06 : basically when you reach the end of this
14:08 : function then
14:09 : both of these should minus one basically
14:12 : you are
14:13 : removing all the resources that are
14:15 : claimed by this function
14:17 : this function is done so it doesn't need
14:18 : those resources anymore so you wanna
14:21 : you wanna minus one on on everything
14:24 : that's a reference of some variable or
14:27 : some parameter in this function
14:33 : yes exactly when you have closures it
14:35 : makes things more complicated
14:37 : uh we we probably should talk about
14:39 : closure but
14:41 : before talking about closure i'll leave
14:44 : this
14:44 : list as this because these are the big
14:48 : cases now i'm going to talk about
14:52 : special cases so if you return
14:55 : a heap object so for example you have a
14:58 : function
14:59 : so your your f is going to make a heap
15:01 : object
15:03 : put 1 and 2 inside it and then it's
15:05 : going to
15:06 : increment the reference count because it
15:09 : assigned it to
15:10 : a variable a and then it's gonna return
15:13 : it
15:14 : but since we're done with this function
15:17 : it's gonna minus one
15:19 : right so well
15:23 : okay that's a problem because maybe in
15:26 : the h
15:26 : function we call it function just to
15:30 : instantiate this array if
15:33 : if you decrement it to zero you're gonna
15:36 : x out of this and then this has nothing
15:39 : well but
15:40 : when you are oh so this case i guess
15:43 : normal case when you assign
15:44 : to an array to my variable in the h
15:48 : it's it's gonna uh add one like
15:51 : increase by one but in this case because
15:54 : it's not like
15:55 : literally assigned to an array so it's
15:58 : kind of
15:59 : special because the array
16:02 : returns because the array returns you
16:05 : don't want to
16:06 : destroy it before the caller has
16:09 : a handle on it if if this is not
16:12 : destroyed though
16:13 : here you would do a minus one if you
16:16 : deferred it
16:17 : then that might work because the outside
16:20 : would do a plus one on it
16:22 : right right after it receives it and
16:24 : then if you
16:25 : defer this minus one that minus one
16:28 : would
16:29 : happen after this plus one so it will
16:31 : not end up going to zero
16:33 : so that's one potential way you could
16:35 : deal with it
16:36 : there may be other ways to do it i don't
16:39 : actually know how objective c
16:40 : deals with this case but that's a case
16:43 : you have to
16:44 : worry about if you are like implementing
16:47 : a programming language that does this
16:49 : but if you
16:50 : are just going to tell the programmer
16:52 : hey you do it yourself
16:54 : then it's kind of up to them to come up
16:57 : with their convention of
16:58 : when to when to do that let's let's see
17:01 : how it would work with closure does this
17:05 : illustrate the point enough let's say
17:06 : the array initially has
17:08 : reference count of one let's just say
17:11 : one and two are in the array
17:13 : so it goes here we're gonna increase
17:16 : the count to 2 because of this
17:19 : function parameter here that references
17:22 : it also
17:23 : oh wait this is not a good illustration
17:27 : because i'm going to
17:28 : cross this out i'm going to return the
17:30 : function g
17:32 : right so that
17:35 : f will terminate before g terminate
17:39 : i have a special g g star
17:43 : is equal to f
17:46 : of one two
17:51 : and then we're gonna call it g star with
17:55 : the index number of one
17:58 : and then it's gonna return the number
18:01 : two
18:01 : to us so what should happen here this
18:05 : actually doesn't have a reference count
18:07 : because i didn't assign it to a new
18:09 : variable
18:10 : when it goes in here it has a reference
18:12 : count of one the
18:14 : instantiation of this g function here
18:17 : we have to look at this inner function
18:20 : as
18:21 : an object that's retaining this array
18:24 : so because this g is referencing this
18:28 : array from it from the closure scope
18:31 : we're gonna have to uh increase the
18:34 : count here
18:35 : this doesn't matter cause g needs to be
18:39 : reference counted as well i think
18:41 : so g is gonna have a count of
18:44 : one and and g is pointing to this
18:48 : array that's represented by uh
18:51 : increasing the count here when we
18:53 : initialize g
18:55 : g has reference count 1 because we
18:58 : at this step we've assigned this
19:01 : function to g
19:02 : and this array gets incremented because
19:06 : this function references the array
19:10 : and then when we when we return g we get
19:13 : into this problem of
19:14 : we're trying to return the thing so
19:17 : maybe we
19:18 : we defer the minus one here
19:21 : just a little bit so the outside has a
19:23 : chance to catch it
19:26 : so in any case this is like a minus one
19:30 : plus one
19:31 : situation so that when we're here
19:34 : the reference count is still one
19:38 : and then but the reference count oh but
19:40 : the reference count here
19:41 : decreases for array
19:44 : because f finished the reference count
19:48 : for the array decreases to one but it's
19:50 : still not zero so it keeps
19:52 : alive and now if you call g
19:56 : uh g can access this array
19:59 : so basically the key is you just see the
20:02 : function
20:02 : that gets returned as an object that has
20:06 : a field
20:07 : of an array yeah you don't have to think
20:10 : about it as the function itself but
20:12 : it's the closure of the function so
20:15 : maybe we call this
20:17 : the g closure and and the g closure
20:21 : is basically the set of variables
20:24 : the g has to keep remembering
20:29 : the closed variables the the closed
20:32 : variables if you read the wikipedia
20:36 : article about closures
20:37 : it'll say the closed variable is
20:41 : a variable from the elder scope that the
20:43 : inner scope is referencing
20:45 : right so our closed variable is
20:48 : array one but there could be more so for
20:51 : each one of
20:52 : those closed variables i'm going to
20:54 : stick it
20:55 : into this little container here uh and
20:58 : we're gonna
20:59 : and and that's allocated on the heap as
21:01 : well
21:02 : so yeah so i believe um llvm's automatic
21:06 : reference calendar thing i believe
21:10 : that's more or less what that system
21:13 : does
21:14 : is automatically generate these
21:16 : instructions to
21:17 : increment and decrement the calendar etc
21:21 : like performance wise this is not great
21:24 : actually
21:24 : because if you just think about what a
21:27 : program does
21:28 : um that it could potentially generate
21:31 : a lot of these instructions just to add
21:35 : one
21:35 : and minus one there could be just many
21:38 : many of those
21:39 : inserted into your program you know that
21:42 : can impact performance
21:44 : and so did there's some optimizations
21:47 : that people have worked on
21:50 : there are cases where the the adding one
21:54 : or subtracting one are not really
21:57 : necessary
21:58 : if you analyze the source code and
22:01 : their optimization is to sort of remove
22:04 : the ones
22:04 : that aren't totally necessary and i
22:07 : haven't
22:08 : looked deeply into how that stuff worked
22:11 : but
22:11 : there are like computer science papers
22:14 : on that kind of stuff
22:16 : a while ago i created a programming
22:18 : language
22:19 : called uh chameleon i actually allowed
22:23 : you to switch the memory manager between
22:26 : normal gc or arc like this is a struct
22:29 : that has two fields
22:31 : two integer fields and when you make a
22:34 : new struct
22:35 : you you actually instead of saying new
22:37 : in this language you say
22:39 : alak because i wanted to make it very
22:41 : explicit
22:42 : that you're allocating so when you alloc
22:46 : you're allocating this struct onto the
22:49 : heap
22:49 : like this there's a new object on the
22:52 : heap
22:53 : with a and b in it and uh
22:57 : you you have an option of not using a
23:00 : memory manager and if that's what you
23:03 : did
23:04 : then there's no freeing of anything
23:08 : if you want to free anything you
23:09 : actually have to call it the free
23:11 : operator you would have to say
23:13 : free it manually but if you use a memory
23:16 : manager
23:17 : then it'll be scope based um
23:21 : it'll say at the end of the scope it'll
23:24 : actually try to free this guy
23:25 : at this stage of my implementation i
23:29 : asked the programmer to write a
23:32 : release function for every structure and
23:35 : then it'll it'll automatically based on
23:37 : the name
23:38 : you'll automatically call this function
23:40 : oh okay
23:42 : so the point is this is only for
23:45 : in this case you don't need it but this
23:47 : is only for if one of the fields
23:50 : points to yet another structure that's
23:52 : allocated on the heap
23:54 : then you would you would want to like
23:55 : release that one like if
23:58 : if if this guy has like a
24:01 : a person and and then you would like
24:04 : you wanna release person so the point of
24:08 : release
24:09 : number pair is is if there's another
24:13 : pointer to another heap object uh this
24:17 : tells the compiler how to release that
24:20 : guy
24:20 : as well really for the okay yeah
24:24 : but but i guess yeah but this is a small
24:27 : like maybe i don't want to dwell on that
24:30 : it's just like
24:31 : maybe i i could have done it
24:33 : automatically too
24:34 : but at the moment i haven't so i guess
24:37 : the point of
24:37 : manual uh manual uh
24:41 : mem like garbage collection system
24:44 : so maybe in the real case that uh the
24:47 : programmer will not
24:49 : uh increase or decrease in each step and
24:52 : but they want to say hey when the
24:53 : program ends
24:55 : when this particular module finished i'm
24:57 : gonna release
24:58 : all of them together so that they don't
25:00 : have to
25:01 : use their memory on the my minus one
25:04 : plus plus one
25:05 : or use it you use the instructions yeah
25:08 : yeah
25:09 : what you're saying is a important point
25:11 : but uh
25:12 : which is you're saying that a programmer
25:16 : can potentially
25:19 : implement this more efficiently because
25:22 : they have more knowledge
25:24 : about how the program work and and
25:26 : therefore
25:27 : if you try to do everything
25:29 : automatically produce some
25:31 : inefficiencies
25:32 : probably and and that's very true that's
25:35 : very true
25:37 : uh one example of that
25:40 : is in one of jonathan blows videos
25:43 : jonathan blow the indie game producer
25:47 : who also made a programming language for
25:49 : making games
25:50 : one of the innovations that he made in
25:52 : his programming language
25:54 : is something called the temporary
25:58 : storage buffer he actually utilizes
26:01 : how a video game works as a trick
26:04 : to make his memory management faster
26:07 : a video game has this wild true
26:10 : almost all video games are like this
26:12 : like handle
26:14 : events and then update
26:18 : game state and then render a game right
26:22 : like basically he made up a section of
26:25 : the
26:25 : temporary heap let's call it within the
26:28 : code of any of these
26:30 : stages you can allocate
26:33 : memory from the temp heap if you do that
26:36 : it'll just like
26:37 : first come first serve like the first
26:39 : one will get this chunk
26:41 : the second one will get this trunk third
26:43 : one get this chunk and so forth right
26:46 : the code within all these all three of
26:49 : these
26:49 : functions are just making use of
26:52 : this temporary storage there's a
26:56 : basically agreement that everything
27:00 : that's allocated from this temporary
27:02 : storage
27:03 : will be cleaned up at the end of this
27:06 : while loop
27:08 : so so at the end of this while basically
27:11 : all of these
27:12 : go away all of them are freed at the
27:14 : same time essentially
27:16 : to to be made available for the next
27:20 : iteration of the while loop so the next
27:22 : iteration of the while loop
27:23 : is starting all over at the beginning of
27:26 : this section of memory it's like
27:28 : nothing ever happened uh so so
27:31 : this code is like oh this is free now
27:34 : use it
27:35 : this is free now use it so what that
27:38 : means
27:38 : is there's actually no need
27:41 : at all to keep track of who
27:45 : owns what because this is just a
27:48 : contiguous address space you just need a
27:51 : pointer to say at the beginning
27:53 : this is where the next bit of free space
27:56 : is and if i allocated it
27:58 : i move the pointer up here if i allocate
28:01 : this much
28:02 : i move the next pointer up here and so
28:04 : forth so you only have to remember this
28:06 : one pointer
28:08 : and then at when you reach this point
28:11 : all you do is
28:12 : put this pointer back here reset it back
28:14 : to the beginning and then
28:16 : you're done there's no keeping track of
28:19 : all the
28:20 : individual pointers you don't need to
28:21 : remember all these individual pointers
28:23 : and whether they're available
28:25 : and you need to skip over them to
28:28 : allocate
28:28 : new space or anything like that none of
28:31 : that matters
28:32 : so so you skip and you don't have to do
28:34 : reference counting
28:36 : that is you skip over a lot of that
28:38 : complexity
28:39 : and for for like like resetting
28:41 : everything is a big o of one and
28:44 : you know allocating a bit of space is
28:46 : big o of one it's much much cheaper
28:50 : now is because he knows this while loop
28:54 : is
28:54 : how everything works in this game
28:57 : programming language or game framework
28:59 : because
29:00 : like the module is decided by the while
29:04 : loop but if you want to make it generic
29:07 : then you're gonna have to do more stuff
29:09 : to keep up with
29:12 : yeah if you can't assume anything about
29:15 : how the program is structured
29:18 : then but you still want the memory
29:21 : management to work perfectly
29:23 : then you have to use an automatic
29:25 : management system which
29:27 : can't use this kind of hacks to optimize
29:30 : it
29:31 : do you have any other overall like broad
29:34 : questions about this
29:36 : uh yeah i guess i i guess if we could uh
29:40 : because we talked about like uh the uh
29:43 : like the full garbage collection system
29:45 : and the arc system i guess we
29:47 : talked about arc more but we
29:50 : have we covered like how is the the uh
29:53 : the full garbage collection system yeah
29:57 : it works i'm saving that for next time
30:01 : because um i know that that's gonna take
30:04 : more time
30:05 : to cover so uh yeah
30:08 : let's save that for next time if you're
30:11 : curious
30:12 : in the meantime if you build javascript
30:14 : apps
30:15 : and you use chrome then you're using the
30:19 : oronoco garbage collector which is the
30:22 : one that's
30:23 : shipped with the v8 javascript engine
30:26 : and i actually saw pretty good
30:29 : talk about it is it this one this
30:32 : category of garbage collectors
30:35 : have one major drawback
30:38 : to it which is that from time to time
30:42 : it needs to come in and do its job
30:45 : because this job is so intensive
30:48 : that it can pause your program while
30:51 : it's doing that
30:52 : okay and then the rest of your program
30:54 : has to be on hold now
30:56 : because the garbage collector is doing
30:59 : its job right now
31:00 : there's a big reason why some people do
31:02 : not like
31:03 : this full garbage collector and
31:06 : uh and and prefer to use
31:09 : something like arc or prefer to just do
31:12 : it themselves
31:13 : right however uh like the people who
31:17 : are like doing innovation in this space
31:20 : they're actually trying really hard to
31:22 : you know minimize
31:24 : this pause and the the va team is one of
31:27 : the one of the teams that are working on
31:29 : that