Fossil SCM

Modified the changeset class to move handling of the changeset lists to fully after their creation and storage. This is item (3) in cvsfossil.txt. The results do not satisfy however. During the creation of each changeset memory usage is (fractonally) lower, however at the end, after all changesets haven been loaded memory usage is consistently higher. The reason for that is not known. I am saving this for possible future evolution and usage, but will not pursue this further right now. The gains seem to be too small compared to the overall loss. InitializeBreakstate is likely a better target, despite its complexity.

aku 2008-02-20 06:03 trunk
Commit faf57d7462b47d78ff41924e14497a313d0147c7
Parent f46458d5bdc2218…
1 file changed +22 -7
~ tools/cvs2fossil/lib/c2f_prev.tcl
M tools/cvs2fossil/lib/c2f_prev.tcl
+22 -7
--- tools/cvs2fossil/lib/c2f_prev.tcl
+++ tools/cvs2fossil/lib/c2f_prev.tcl
@@ -50,19 +50,33 @@
5050
 set myitems $items
5151
 set mypos {} ; # Commit location is not known yet.
5252
5353
 # Keep track of the generated changesets and of the inverse
5454
 # mapping from items to them.
55
- lappend mychangesets $self
56
- lappend mytchangesets($cstype) $self
55
+ #lappend mychangesets $self
56
+ #lappend mytchangesets($cstype) $self
5757
 set myidmap($myid) $self
5858
 foreach iid $items {
5959
 set key [list $cstype $iid]
60
- set myitemmap($key) $self
60
+ #set myitemmap($key) $self
6161
 lappend mytitems $key
6262
 log write 8 csets {MAP+ item <$key> $self = [$self str]}
6363
 }
64
+ return
65
+ }
66
+
67
+ method loadmaps {} {
68
+ # Keep track of the generated changesets and of the inverse
69
+ # mapping from items to them.
70
+ lappend mychangesets $self
71
+ lappend mytchangesets($mytype) $self
72
+ set myidmap($myid) $self
73
+ foreach iid $myitems {
74
+ set key [list $mytype $iid]
75
+ set myitemmap($key) $self
76
+ #log write 8 csets {MAP+ item <$key> $self = [$self str]}
77
+ }
6478
 return
6579
 }
6680
6781
 destructor {
6882
 # The main thing is to keep track of the itemmap and remove
@@ -71,11 +85,11 @@
7185
 # moment. We may be able to get rid of this entirely, at least
7286
 # for (de)construction and pass InitCSets.
7387
7488
 foreach iid $myitems {
7589
 set key [list $mytype $iid]
76
- unset myitemmap($key)
90
+ #unset myitemmap($key)
7791
 log write 8 csets {MAP- item <$key> $self = [$self str]}
7892
 }
7993
 return
8094
 }
8195
@@ -282,11 +296,11 @@
282296
 # is enough, we have no symbol changesets at this time, and
283297
 # thus never more than one reference in the list.
284298
285299
 foreach iid $myitems {
286300
 set key [list $mytype $iid]
287
- unset myitemmap($key)
301
+ #unset myitemmap($key)
288302
 log write 8 csets {MAP- item <$key> $self = [$self str]}
289303
 }
290304
291305
 # Create changesets for the fragments, reusing the current one
292306
 # for the first fragment. We sort them in order to allow
@@ -325,11 +339,11 @@
325339
326340
 set myitems [lrange $myitems 0 $firste]
327341
 set mytitems [lrange $mytitems 0 $firste]
328342
 foreach iid $myitems {
329343
 set key [list $mytype $iid]
330
- set myitemmap($key) $self
344
+ #set myitemmap($key) $self
331345
 log write 8 csets {MAP+ item <$key> $self = [$self str]}
332346
 }
333347
334348
 return 1
335349
 }
@@ -778,10 +792,11 @@
778792
 SELECT C.iid
779793
 FROM csitem C
780794
 WHERE C.cid = $id
781795
 ORDER BY C.pos
782796
 }] $id]
797
+ $r loadmaps
783798
 incr n
784799
 }
785800
 return
786801
 }
787802
@@ -1024,11 +1039,11 @@
10241039
 typevariable myidmap -array {} ; # Map from changeset id to
10251040
 # changeset.
10261041
10271042
 typemethod all {} { return $mychangesets }
10281043
 typemethod of {cid} { return $myidmap($cid) }
1029
- typemethod ofitem {iid} { return $myitemmap($iid) }
1044
+ #typemethod ofitem {iid} { return $myitemmap($iid) }
10301045
10311046
 typemethod rev {} { return $mytchangesets(rev) }
10321047
 typemethod sym {} { return [concat \
10331048
 ${mytchangesets(sym::branch)} \
10341049
 ${mytchangesets(sym::tag)}] }
10351050
--- tools/cvs2fossil/lib/c2f_prev.tcl
+++ tools/cvs2fossil/lib/c2f_prev.tcl
@@ -50,19 +50,33 @@
50 set myitems $items
51 set mypos {} ; # Commit location is not known yet.
52
53 # Keep track of the generated changesets and of the inverse
54 # mapping from items to them.
55 lappend mychangesets $self
56 lappend mytchangesets($cstype) $self
57 set myidmap($myid) $self
58 foreach iid $items {
59 set key [list $cstype $iid]
60 set myitemmap($key) $self
61 lappend mytitems $key
62 log write 8 csets {MAP+ item <$key> $self = [$self str]}
63 }
 
 
 
 
 
 
 
 
 
 
 
 
 
 
64 return
65 }
66
67 destructor {
68 # The main thing is to keep track of the itemmap and remove
@@ -71,11 +85,11 @@
71 # moment. We may be able to get rid of this entirely, at least
72 # for (de)construction and pass InitCSets.
73
74 foreach iid $myitems {
75 set key [list $mytype $iid]
76 unset myitemmap($key)
77 log write 8 csets {MAP- item <$key> $self = [$self str]}
78 }
79 return
80 }
81
@@ -282,11 +296,11 @@
282 # is enough, we have no symbol changesets at this time, and
283 # thus never more than one reference in the list.
284
285 foreach iid $myitems {
286 set key [list $mytype $iid]
287 unset myitemmap($key)
288 log write 8 csets {MAP- item <$key> $self = [$self str]}
289 }
290
291 # Create changesets for the fragments, reusing the current one
292 # for the first fragment. We sort them in order to allow
@@ -325,11 +339,11 @@
325
326 set myitems [lrange $myitems 0 $firste]
327 set mytitems [lrange $mytitems 0 $firste]
328 foreach iid $myitems {
329 set key [list $mytype $iid]
330 set myitemmap($key) $self
331 log write 8 csets {MAP+ item <$key> $self = [$self str]}
332 }
333
334 return 1
335 }
@@ -778,10 +792,11 @@
778 SELECT C.iid
779 FROM csitem C
780 WHERE C.cid = $id
781 ORDER BY C.pos
782 }] $id]
 
783 incr n
784 }
785 return
786 }
787
@@ -1024,11 +1039,11 @@
1024 typevariable myidmap -array {} ; # Map from changeset id to
1025 # changeset.
1026
1027 typemethod all {} { return $mychangesets }
1028 typemethod of {cid} { return $myidmap($cid) }
1029 typemethod ofitem {iid} { return $myitemmap($iid) }
1030
1031 typemethod rev {} { return $mytchangesets(rev) }
1032 typemethod sym {} { return [concat \
1033 ${mytchangesets(sym::branch)} \
1034 ${mytchangesets(sym::tag)}] }
1035
--- tools/cvs2fossil/lib/c2f_prev.tcl
+++ tools/cvs2fossil/lib/c2f_prev.tcl
@@ -50,19 +50,33 @@
50 set myitems $items
51 set mypos {} ; # Commit location is not known yet.
52
53 # Keep track of the generated changesets and of the inverse
54 # mapping from items to them.
55 #lappend mychangesets $self
56 #lappend mytchangesets($cstype) $self
57 set myidmap($myid) $self
58 foreach iid $items {
59 set key [list $cstype $iid]
60 #set myitemmap($key) $self
61 lappend mytitems $key
62 log write 8 csets {MAP+ item <$key> $self = [$self str]}
63 }
64 return
65 }
66
67 method loadmaps {} {
68 # Keep track of the generated changesets and of the inverse
69 # mapping from items to them.
70 lappend mychangesets $self
71 lappend mytchangesets($mytype) $self
72 set myidmap($myid) $self
73 foreach iid $myitems {
74 set key [list $mytype $iid]
75 set myitemmap($key) $self
76 #log write 8 csets {MAP+ item <$key> $self = [$self str]}
77 }
78 return
79 }
80
81 destructor {
82 # The main thing is to keep track of the itemmap and remove
@@ -71,11 +85,11 @@
85 # moment. We may be able to get rid of this entirely, at least
86 # for (de)construction and pass InitCSets.
87
88 foreach iid $myitems {
89 set key [list $mytype $iid]
90 #unset myitemmap($key)
91 log write 8 csets {MAP- item <$key> $self = [$self str]}
92 }
93 return
94 }
95
@@ -282,11 +296,11 @@
296 # is enough, we have no symbol changesets at this time, and
297 # thus never more than one reference in the list.
298
299 foreach iid $myitems {
300 set key [list $mytype $iid]
301 #unset myitemmap($key)
302 log write 8 csets {MAP- item <$key> $self = [$self str]}
303 }
304
305 # Create changesets for the fragments, reusing the current one
306 # for the first fragment. We sort them in order to allow
@@ -325,11 +339,11 @@
339
340 set myitems [lrange $myitems 0 $firste]
341 set mytitems [lrange $mytitems 0 $firste]
342 foreach iid $myitems {
343 set key [list $mytype $iid]
344 #set myitemmap($key) $self
345 log write 8 csets {MAP+ item <$key> $self = [$self str]}
346 }
347
348 return 1
349 }
@@ -778,10 +792,11 @@
792 SELECT C.iid
793 FROM csitem C
794 WHERE C.cid = $id
795 ORDER BY C.pos
796 }] $id]
797 $r loadmaps
798 incr n
799 }
800 return
801 }
802
@@ -1024,11 +1039,11 @@
1039 typevariable myidmap -array {} ; # Map from changeset id to
1040 # changeset.
1041
1042 typemethod all {} { return $mychangesets }
1043 typemethod of {cid} { return $myidmap($cid) }
1044 #typemethod ofitem {iid} { return $myitemmap($iid) }
1045
1046 typemethod rev {} { return $mytchangesets(rev) }
1047 typemethod sym {} { return [concat \
1048 ${mytchangesets(sym::branch)} \
1049 ${mytchangesets(sym::tag)}] }
1050

Keyboard Shortcuts

Open search /
Next entry (timeline) j
Previous entry (timeline) k
Open focused entry Enter
Show this help ?
Toggle theme Top nav button