benchmark-data-pair

Vocabulary

tools.time.struct

Definition

USING: classes.struct vm ;

IN: tools.time.struct

STRUCT: benchmark-data-pair
    {
        start benchmark-data initial: S{ benchmark-data
            { time 0 }
            { data-room
                S{ data-heap-room
                    { nursery
                        S{ copying-sizes
                            { size 0 }
                            { occupied 0 }
                            { free 0 }
                        }
                    }
                    { aging
                        S{ copying-sizes
                            { size 0 }
                            { occupied 0 }
                            { free 0 }
                        }
                    }
                    { tenured
                        S{ mark-sweep-sizes
                            { size 0 }
                            { occupied 0 }
                            { total-free 0 }
                            { contiguous-free 0 }
                            { free-block-count 0 }
                        }
                    }
                    { cards 0 }
                    { decks 0 }
                    { mark-stack 0 }
                }
            }
            { code-room
                S{ mark-sweep-sizes
                    { size 0 }
                    { occupied 0 }
                    { total-free 0 }
                    { contiguous-free 0 }
                    { free-block-count 0 }
                }
            }
            { callback-room
                S{ mark-sweep-sizes
                    { size 0 }
                    { occupied 0 }
                    { total-free 0 }
                    { contiguous-free 0 }
                    { free-block-count 0 }
                }
            }
        }
    } {
        stop benchmark-data initial: S{ benchmark-data
            { time 0 }
            { data-room
                S{ data-heap-room
                    { nursery
                        S{ copying-sizes
                            { size 0 }
                            { occupied 0 }
                            { free 0 }
                        }
                    }
                    { aging
                        S{ copying-sizes
                            { size 0 }
                            { occupied 0 }
                            { free 0 }
                        }
                    }
                    { tenured
                        S{ mark-sweep-sizes
                            { size 0 }
                            { occupied 0 }
                            { total-free 0 }
                            { contiguous-free 0 }
                            { free-block-count 0 }
                        }
                    }
                    { cards 0 }
                    { decks 0 }
                    { mark-stack 0 }
                }
            }
            { code-room
                S{ mark-sweep-sizes
                    { size 0 }
                    { occupied 0 }
                    { total-free 0 }
                    { contiguous-free 0 }
                    { free-block-count 0 }
                }
            }
            { callback-room
                S{ mark-sweep-sizes
                    { size 0 }
                    { occupied 0 }
                    { total-free 0 }
                    { contiguous-free 0 }
                    { free-block-count 0 }
                }
            }
        }
    } ;

Methods

USING: classes.struct classes.struct.private kernel
tools.time.struct ;

M: benchmark-data-pair clone
    clone-underlying \ benchmark-data-pair memory>struct ;
    inline


USING: accessors classes.struct combinators.smart
tools.time.struct ;

M: benchmark-data-pair struct-slot-values
    { [ start>> ] [ stop>> ] } cleave>array ; inline