#### try-compact-in-generation

##### Summary

Compacts the most fragmented segment(s) in a generation in 32-bit LispWorks.

hcl

##### Signature

try-compact-in-generation generation-number time-threshold &optional fraction-threshold => result

##### Arguments

generation-number

0 for the most recent generation, 1 for the most recent two generations, and so on up to a maximum (usually 3). Numbers outside this range signal an error.

time-threshold

A real number.

fraction-threshold

A real number between 0 and 1, defining the minimum fragmentation to actually compact. The default is 0.25.

result

A boolean.

##### Description

``` try-compact-in-generation``` finds the most fragmented segment in the generation specified. If time-threshold is positive, it compacts this segment, and repeats this operation until time-threshold seconds have elapsed. At this point ``` try-compact-in-generation``` returns, with value ``` t``` if at least one segment was compacted and value ``` nil``` otherwise. Because the operation cannot be stopped in the middle, the actual time taken will always be larger than time-threshold.

If fraction-threshold is 1, ``` try-compact-in-generation``` does nothing. If fraction-threshold is 0, ``` try-compact-in-generation``` will compact all uncompacted segments (unless it runs out of time). With the default (0.25) ``` try-compact-in-generation``` compacts only moderately fragmented segments.

If time-threshold is negative, then ``` try-compact-in-generation``` does not actually compact any segments. result is a boolean indicating whether ``` try-compact-in-generation``` would actually try to compact a segment if it were to be called with a positive time-threshold and the other arguments unchanged.

This function is typically used after a call to ``` check-fragmentation``` . For more information, see the LispWorks User Guide.

Note: ``` try-compact-in-generation``` is implemented only in 32-bit LispWorks. It is not relevant to the Memory Management API in 64-bit implementations, where marking-gc with the what-to-copy argument offers similar functionality ( although set-blocking-gen-num is intended to solve the problem of fragmentation automatically).