SHA1 Hash:	faf57d7462b47d78ff41924e14497a313d0147c7
Date:	2008-02-20 06:03:48
User:	aku
Comment:	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.
Timelines:	ancestors | descendants | both | trunk
Other Links:	files | ZIP archive | manifest

• branch=trunk inherited from [a28c83647d]
• sym-trunk inherited from [a28c83647d]

Modified tools/cvs2fossil/lib/c2f_prev.tcl from [cc210d2578] to [604b326cf4].

@@ -50,18 +50,32 @@
 	set myitems     $items
 	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
     }
 
     destructor {
@@ -71,11 +85,11 @@
 	# moment. We may be able to get rid of this entirely, at least
 	# 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
     }
 
@@ -282,11 +296,11 @@
 	# is enough, we have no symbol changesets at this time, and
 	# 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
 	# for the first fragment. We sort them in order to allow
@@ -325,11 +339,11 @@
 
 	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
     }
@@ -778,10 +792,11 @@
 		SELECT C.iid
 		FROM   csitem C
 		WHERE  C.cid = $id
 		ORDER BY C.pos
 	    }] $id]
+	    $r loadmaps
 	    incr n
 	}
 	return
     }
 
@@ -1024,11 +1039,11 @@
     typevariable myidmap   -array {} ; # Map from changeset id to
 				       # 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)} \
 					  ${mytchangesets(sym::tag)}] }