2Planar point location & persistence (cont) Updates should be persistent since we need all search trees at the end.Partial persistence is enoughWell, we already have the path copying method, lets use it.What do we get ?O(nlogn) space and O(nlog n) preprocessing time.We shall improve the space bound to O(n).
3What are we after ?Break each operation into elementary access steps (ptr traversal) and update steps (assignments, allocations).Want a persistent simulation with consumes O(1) time per update or access step, and O(1) space per update step.
4Making data structures persistent (DSST 89) We will show a general technique to make data structures partially and later fully persistent.The time penalty of the transformation would be O(1) per elementary access and update step.The space penalty of the transformation would be O(1) per update step.In particular, this would give us an O(n) space solution to the planar point location problem
5The fat node methodEvery pointer field can store many values, each tagged with a version number.NULL45715
6The fat node method (Cont.) Simulation of an update step when producing version i:NULL45When a new node is created by the ephemeral update we create a new node, each value of a field in the new node is marked with version i.715When we change a value of a field f to v, we add an entry to the list of f with key i and value v
7The fat node method (Cont.) Simulation of an access step when navigating in version i:NULL45The relevant value is the one tagged with the largest version number smaller than i715
8Partialy persistent deques via the fat node method 1x1V1NullNullV2 = inject(y,V1)xNull21yNullV3 = eject(V2)x21y3zV4= inject(z,V3)xNull21y34
9Fat node -- analysis Space is ok -- O(1) per update step That would give O(n) space for planar point location since each insertion/deletion does O(1) changes amortized.We screwed up the update time, it may take O(log m) to traverse a pointer, where m is the # of versionsSo query time goes up to O(log2n) and preprocessing time is O(nlog2n)
10Node copyingThis is a general method to make pointer based data structures partially persistent.Nodes have to have bounded in degree and bounded outdegreeWe will show this method first for balanced search trees which is a slightly simpler case than the general case.Idea: It is similar to the fat node method just that we won’t make nodes too fat.
11Partially persistent balanced search trees via node copying Here it suffices to allow one extra pointer field in each nodeEach extra pointer is tagged with a version number and a field name.When the ephemeral update allocates a new node you allocate a new node as well.When the ephemeral update changes a pointer field if the extra pointer is empty use it, otherwise copy the node. Try to store pointer to the new copy in its parent.If the extra ptr at the parent is occupied copy the parent and continue going up this way.
12Insert into persistent 2-4 trees with node copying . .1312141820212816
13Insert into persistent 2-4 trees with node copying 1. .1312141820212812141618
14Insert into persistent 2-4 trees with node copying 1. .131214182021282912141618
15Insert into persistent 2-4 trees with node copying 1. .131214182021281214161820212829
16Insert into persistent 2-4 trees with node copying 1. .131214182021281214161820212829
17Node copying -- analysis The time slowdown per access step is O(1) since there is only a constant # of extra pointers per node.What about the space blowup ?O(1) (amortized) new nodes per update step due to nodes that would have been created by the ephemeral implementation as well.How about nodes that are created due to node copying when the extra pointer is full ?
18Node copying -- analysis We’ll show that only O(1) of copings occur on the average per update step.Amorized space consumption = real space consumption + = #(used slots in live nodes)A node is live if it is reachable from the root of the most recent version.==> Amortized space cost of node copying is 0.
19Node copying in general Each persistent nodes has d + p + e + 1 pointerse = extra pointersp = predecessor pointers1 = copy pointer.471165live
20Node copying in general (cont) When there is no free extra ptr copy the node.When you copy node x, and x points to y, c(x) should point to y or to c(y) if y has been copied, update the corresponding predecessor ptr in y or c(y). Add x to the set S of copied nodes.(S contains 1 node initially)y711x7
21Node copying in general (cont) When there is no free extra ptr copy the node.When you copy node x, and x points to y, c(x) should point to y or to c(y) if y has been copied, update the corresponding predecessor ptr in y or c(y). Add x to the set S of copied nodes.(S contains 1 node initially)11y711x7
22Node copying in general (cont) In the general step it could be that when we copy x, y has already been copied11y711x7
23Node copying in general (cont) Remove any node x from S,for each node y indicated by a predecessor pointer in xfind in y the live pointer to x.If this ptr has version stamp i, replace it by a ptr to c(x).If this ptr has version stamp less than i, add to y a ptr to c(x) with version stamp i. If there is no room, copy y as before, and add it to S.
24Node copying (analysis) Actual space consumed is |S| = #(used extra fields in live nodes) = -e|S| + p|S|This is smaller than |S| if e > p (Actually e ≥ p suffices if we were more careful)So whether there were any copings or not the amortized space cost of a single update step is O(1)
25The fat node method - full persistence Does it also work for full persistence ?NULL155676We have a navigation problem.
26The fat node method - full persistence (cont) Maintain a total order of the version tree.56789567856789
27The fat node method - full persistence (cont) When a new version is created add it to the list immediately after its parent.==> The list is a preorder of the version tree.
28The fat node method - full persistence (cont) When traversing a field in version i, the relevant value is the one recorded with a version preceding i in the list and closest to it.5678NULL1956567856789
29The fat node method - full persistence (cont) How do we update ?56781056789NULL1957656789
30The fat node method - full persistence (cont) 5678NULL110597610567895107968So what is the algorithm in general ?
31The fat node method - full persistence (cont) Suppose that when we create version i we change field f to have value v.Let i1 (i2) be the first version to the left (right) of i that has a value recorded at field fi1fii2vi1ii2
32The fat node method - full persistence (cont) We add the pair (i,v) to the list of fLet i+ be the version following i in the version listv’i1i+fii2vi1ii+i2If (i+ < i2) or i+ exists and i2 does not exist add the pair (i+,v’) where v’ is the value associated with i1.
33Fully persistent 2-4 trees with the fat node method . .1312141820212816
34Insert into fully persistent 2-4 trees (fat nodes) 111. .1312141820212812141618
35Insert into fully persistent 2-4 trees (fat nodes) 21121. .131214182021282912141618
36Insert into persistent 2-4 trees with node copying 211221. .131214182021281214161820212829
37Insert into persistent 2-4 trees with node copying 2112211. .131214182021281214161820212829
38Fat node method (cont)How do we efficiently find the right value of a field in version i ?Store the values sorted by the order determined by the version list. Use a search tree to represent this sorted list.To carry out a find on such a search tree we need in each node to answer an order query on the version list.Use Dietz and Sleator’s data structure for the version list.
39Fat node method (summary) We can find the value to traverse in O(log(m)) where m is the number of versionsWe get O(1) space increase per ephemeral update stepO(log m) time slowdown per ephemeral access step
40Node splitting Similar to node copying. (slightly more evolved) Allows to avoid the O(log m) time slowdown.Converts any pointer based data structure with constant indegrees and outdegrees to a fully persistent one.The time slowdown per access step is O(1) (amortized).The space blowup per update step is O(1) (amortized)
41Search trees via node splitting You get fully persistent search trees in which each operation takes O(log n) amortized time and space.Why is the space O(log n) ?Since in the ephemeral settings the space consumption is O(1) only amortized.
42Search trees via node splitting So what do we need in order to get persistent search trees with O(1) space cost per update (amortized) ?We need an ephemeral structure in which the space consumption per update is O(1) on the worst case.You can do it !==> Red-black trees with lazy recoloring
43What about deques ?We can apply node splitting to get fully persistent deques with O(1) time per operation.We can also transform the simulation by stacks into a real time simulation and get O(1) time solution.What if we want to add the operation concatenate ?None of the methods seems to extend...