gc-event

Vocabulary

vm

Definition

USING: alien.c-types classes.struct ;

IN: vm

STRUCT: gc-event
    { op uint initial: 0 } {
        data-heap-before data-heap-room initial: 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-heap-before mark-sweep-sizes initial: S{
        mark-sweep-sizes
            { size 0 }
            { occupied 0 }
            { total-free 0 }
            { contiguous-free 0 }
            { free-block-count 0 }
        }
    } {
        data-heap-after data-heap-room initial: 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-heap-after mark-sweep-sizes initial: S{
        mark-sweep-sizes
            { size 0 }
            { occupied 0 }
            { total-free 0 }
            { contiguous-free 0 }
            { free-block-count 0 }
        }
    } { cards-scanned cell_t initial: 0 }
    { decks-scanned cell_t initial: 0 }
    { code-blocks-scanned cell_t initial: 0 }
    { start-time ulonglong initial: 0 }
    { total-time cell_t initial: 0 } { times cell_t[6] }
    { temp-time ulonglong initial: 0 } ;

Methods

USING: classes.struct classes.struct.private kernel vm ;

M: gc-event clone clone-underlying \ gc-event memory>struct
    ; inline


USING: accessors classes.struct combinators.smart vm ;

M: gc-event struct-slot-values
    {
        [ op>> ]
        [ data-heap-before>> ]
        [ code-heap-before>> ]
        [ data-heap-after>> ]
        [ code-heap-after>> ]
        [ cards-scanned>> ]
        [ decks-scanned>> ]
        [ code-blocks-scanned>> ]
        [ start-time>> ]
        [ total-time>> ]
        [ times>> ]
        [ temp-time>> ]
    } cleave>array ; inline