game-loop-benchmark

Vocabulary

game.loop.benchmark

Definition

USING: alien.c-types classes.struct tools.time.struct vm ;

IN: game.loop.benchmark

STRUCT: game-loop-benchmark
    {
        benchmark-data-pair benchmark-data-pair initial: S{
        benchmark-data-pair
            { start
                S{ benchmark-data
                    { time 0 }
                    { data-room
                        S{ data-heap-room
                            { nursery ~copying-sizes~ }
                            { aging ~copying-sizes~ }
                            { tenured ~mark-sweep-sizes~ }
                            { 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
                S{ benchmark-data
                    { time 0 }
                    { data-room
                        S{ data-heap-room
                            { nursery ~copying-sizes~ }
                            { aging ~copying-sizes~ }
                            { tenured ~mark-sweep-sizes~ }
                            { 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 }
                        }
                    }
                }
            }
        }
    } { tick# ulonglong initial: 0 }
    { frame# ulonglong initial: 0 } ;

Methods

USING: classes.struct classes.struct.private game.loop.benchmark
kernel ;

M: game-loop-benchmark clone
    clone-underlying \ game-loop-benchmark memory>struct ;
    inline


USING: accessors classes.struct combinators.smart
game.loop.benchmark ;

M: game-loop-benchmark struct-slot-values
    { [ benchmark-data-pair>> ] [ tick#>> ] [ frame#>> ] }
    cleave>array ; inline