Differences From:

File tools/cvs2fossil/lib/c2f_prev.tcl part of check-in [f46458d5bd] - Reworked the basic structure of pass InitCSets to keep memory consumption down. Now incremental creates, breaks, saves, and releases changesets, instead of piling them on before saving all at the end. Memory tracking confirms that this changes the accumulating mountain into a near-constant usage, with the expected spikes from the breaking. by aku on 2008-02-17 02:06:19. [view]

To:

File tools/cvs2fossil/lib/c2f_prev.tcl part of check-in [faf57d7462] - 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. by aku on 2008-02-20 06:03:48. [view]

@@ -51,16 +51,30 @@
 	set mypos       {} ; # Commit location is not known yet.
 
 	# Keep track of the generated changesets and of the inverse
 	# mapping from items to them.
-	lappend mychangesets   $self
-	lappend mytchangesets($cstype) $self
+	#lappend mychangesets   $self
+	#lappend mytchangesets($cstype) $self
 	set     myidmap($myid) $self
 	foreach iid $items {
 	    set key [list $cstype $iid]
-	    set myitemmap($key) $self
+	    #set myitemmap($key) $self
 	    lappend mytitems $key
 	    log write 8 csets {MAP+ item <$key> $self = [$self str]}
+	}
+	return
+    }
+
+    method loadmaps {} {
+	# Keep track of the generated changesets and of the inverse
+	# mapping from items to them.
+	lappend mychangesets   $self
+	lappend mytchangesets($mytype) $self
+	set     myidmap($myid) $self
+	foreach iid $myitems {
+	    set key [list $mytype $iid]
+	    set myitemmap($key) $self
+	    #log write 8 csets {MAP+ item <$key> $self = [$self str]}
 	}
 	return
     }
 
@@ -72,9 +86,9 @@
 	# for (de)construction and pass InitCSets.
 
 	foreach iid $myitems {
 	    set key [list $mytype $iid]
-	    unset myitemmap($key)
+	    #unset myitemmap($key)
 	    log write 8 csets {MAP- item <$key> $self = [$self str]}
 	}
 	return
     }
@@ -283,9 +297,9 @@
 	# thus never more than one reference in the list.
 
 	foreach iid $myitems {
 	    set key [list $mytype $iid]
-	    unset myitemmap($key)
+	    #unset myitemmap($key)
 	    log write 8 csets {MAP- item <$key> $self = [$self str]}
 	}
 
 	# Create changesets for the fragments, reusing the current one
@@ -326,9 +340,9 @@
 	set myitems  [lrange $myitems  0 $firste]
 	set mytitems [lrange $mytitems 0 $firste]
 	foreach iid $myitems {
 	    set key [list $mytype $iid]
-	    set myitemmap($key) $self
+	    #set myitemmap($key) $self
 	    log write 8 csets {MAP+ item <$key> $self = [$self str]}
 	}
 
 	return 1
@@ -779,8 +793,9 @@
 		FROM   csitem C
 		WHERE  C.cid = $id
 		ORDER BY C.pos
 	    }] $id]
+	    $r loadmaps
 	    incr n
 	}
 	return
     }
@@ -1025,9 +1040,9 @@
 				       # changeset.
 
     typemethod all    {}    { return $mychangesets }
     typemethod of     {cid} { return $myidmap($cid) }
-    typemethod ofitem {iid} { return $myitemmap($iid) }
+    #typemethod ofitem {iid} { return $myitemmap($iid) }
 
     typemethod rev    {}    { return $mytchangesets(rev) }
     typemethod sym    {}    { return [concat \
 					  ${mytchangesets(sym::branch)} \