vm/free_list.o \
vm/full_collector.o \
vm/gc.o \
+ vm/gc_info.o \
vm/image.o \
vm/inline_cache.o \
vm/instruction_operands.o \
vm\free_list.obj \
vm\full_collector.obj \
vm\gc.obj \
+ vm/gc_info.obj \
vm\image.obj \
vm\inline_cache.obj \
vm\instruction_operands.obj \
--- /dev/null
+USING: alien alien.c-types alien.data alien.syntax
+classes.struct kernel sequences specialized-arrays
+specialized-arrays.private tools.test compiler.units vocabs ;
+IN: alien.data.tests
+
+STRUCT: foo { a int } { b void* } { c bool } ;
+
+SPECIALIZED-ARRAY: foo
+
+[ t ] [ 0 binary-zero? ] unit-test
+[ f ] [ 1 binary-zero? ] unit-test
+[ f ] [ -1 binary-zero? ] unit-test
+[ t ] [ 0.0 binary-zero? ] unit-test
+[ f ] [ 1.0 binary-zero? ] unit-test
+[ f ] [ -0.0 binary-zero? ] unit-test
+[ t ] [ C{ 0.0 0.0 } binary-zero? ] unit-test
+[ f ] [ C{ 1.0 0.0 } binary-zero? ] unit-test
+[ f ] [ C{ -0.0 0.0 } binary-zero? ] unit-test
+[ f ] [ C{ 0.0 1.0 } binary-zero? ] unit-test
+[ f ] [ C{ 0.0 -0.0 } binary-zero? ] unit-test
+[ t ] [ f binary-zero? ] unit-test
+[ t ] [ 0 <alien> binary-zero? ] unit-test
+[ f ] [ 1 <alien> binary-zero? ] unit-test
+[ f ] [ B{ } binary-zero? ] unit-test
+[ t ] [ S{ foo f 0 f f } binary-zero? ] unit-test
+[ f ] [ S{ foo f 1 f f } binary-zero? ] unit-test
+[ f ] [ S{ foo f 0 ALIEN: 8 f } binary-zero? ] unit-test
+[ f ] [ S{ foo f 0 f t } binary-zero? ] unit-test
+[ t t f ] [
+ foo-array{
+ S{ foo f 0 f f }
+ S{ foo f 0 f f }
+ S{ foo f 1 f f }
+ } [ first binary-zero? ] [ second binary-zero? ] [ third binary-zero? ] tri
+] unit-test
+
+[ ] [
+ [
+ foo specialized-array-vocab forget-vocab
+ ] with-compilation-unit
+] unit-test
! (c)2009, 2010 Slava Pestov, Joe Groff bsd license
USING: accessors alien alien.c-types alien.arrays alien.strings
arrays byte-arrays cpu.architecture fry io io.encodings.binary
-io.files io.streams.memory kernel libc math sequences words
-macros combinators generalizations ;
+io.files io.streams.memory kernel libc math math.functions
+sequences words macros combinators generalizations ;
+QUALIFIED: math
IN: alien.data
GENERIC: require-c-array ( c-type -- )
: with-out-parameters ( c-types quot finish -- values )
[ [ drop (local-allots) ] [ swap out-parameters ] 2bi ] dip call
(cleanup-allot) ; inline
+
+GENERIC: binary-zero? ( value -- ? )
+
+M: object binary-zero? drop f ; inline
+M: f binary-zero? drop t ; inline
+M: integer binary-zero? zero? ; inline
+M: math:float binary-zero? double>bits zero? ; inline
+M: complex binary-zero? >rect [ binary-zero? ] both? ; inline
+
original-error set-global
error set-global ; inline
-
[
! We time bootstrap
nano-count
USING: accessors alien alien.c-types alien.data alien.syntax ascii
assocs byte-arrays classes.struct classes.tuple.parser
classes.tuple.private classes.tuple combinators compiler.tree.debugger
-compiler.units destructors io.encodings.utf8 io.pathnames
+compiler.units delegate destructors io.encodings.utf8 io.pathnames
io.streams.string kernel libc literals math mirrors namespaces
prettyprint prettyprint.config see sequences specialized-arrays
system tools.test parser lexer eval layouts generic.single classes
[ 12 ] [ ppc-align-test-2 heap-size ] unit-test
[ 4 ] [ "x" ppc-align-test-2 offset-of ] unit-test
] when
+
+STRUCT: struct-test-delegate
+ { a int } ;
+STRUCT: struct-test-delegator
+ { del struct-test-delegate }
+ { b int } ;
+CONSULT: struct-test-delegate struct-test-delegator del>> ;
+
+[ S{ struct-test-delegator f S{ struct-test-delegate f 7 } 8 } ] [
+ struct-test-delegator <struct>
+ 7 >>a
+ 8 >>b
+] unit-test
+
namespaces assocs vocabs.parser math.functions
classes.struct.bit-accessors bit-arrays
stack-checker.dependencies system layouts ;
+FROM: delegate.private => group-words slot-group-words ;
QUALIFIED: math
IN: classes.struct
: struct-slots ( struct-class -- slots )
"c-type" word-prop fields>> ;
+M: struct-class group-words
+ struct-slots slot-group-words ;
+
! struct allocation
M: struct >c-ptr
PRIVATE>
M: struct byte-length class "struct-size" word-prop ; foldable
+M: struct binary-zero? binary-object <direct-uchar-array> [ 0 = ] all? ; inline
! class definition
<PRIVATE
-GENERIC: binary-zero? ( value -- ? )
-
-M: object binary-zero? drop f ;
-M: f binary-zero? drop t ;
-M: number binary-zero? 0 = ;
-M: struct binary-zero? >c-ptr [ 0 = ] all? ;
-
: struct-needs-prototype? ( class -- ? )
struct-slots [ initial>> binary-zero? ] all? not ;
2 \ vreg-counter set-global
-[
- V{
- T{ ##load-tagged f 3 0 }
- T{ ##replace f 3 D 0 }
- T{ ##replace f 3 R 3 }
- }
-] [ [ { D 0 R 3 } wipe-locs ] V{ } make ] unit-test
-
: gc-check? ( bb -- ? )
instructions>>
{
[
V{
- T{ ##load-tagged f 5 0 }
- T{ ##replace f 5 D 0 }
- T{ ##replace f 5 R 3 }
- T{ ##call-gc f { 0 1 2 } }
+ T{ ##gc-map f V{ 0 } V{ 3 } { 0 1 2 } }
+ T{ ##call-gc }
T{ ##branch }
}
]
[
- { D 0 R 3 } { 0 1 2 } <gc-call> instructions>>
+ V{ D 0 R 3 } { 0 1 2 } <gc-call> instructions>>
] unit-test
30 \ vreg-counter set-global
[
V{
- T{ ##load-tagged f 31 0 }
- T{ ##replace f 31 D 0 }
- T{ ##replace f 31 D 1 }
- T{ ##replace f 31 D 2 }
- T{ ##call-gc f { 2 } }
+ T{ ##gc-map f V{ 0 1 2 } V{ } { 2 } }
+ T{ ##call-gc }
T{ ##branch }
}
] [ 2 get predecessors>> second instructions>> ] unit-test
] bi*
] V{ } make >>instructions ;
-: wipe-locs ( uninitialized-locs -- )
- '[
- int-rep next-vreg-rep
- [ 0 ##load-tagged ]
- [ '[ [ _ ] dip ##replace ] each ] bi
- ] unless-empty ;
+: scrubbed ( uninitialized-locs -- scrub-d scrub-r )
+ [ ds-loc? ] partition [ [ n>> ] map ] bi@ ;
: <gc-call> ( uninitialized-locs gc-roots -- bb )
[ <basic-block> ] 2dip
- [ [ wipe-locs ] [ ##call-gc ] bi* ##branch ] V{ } make
+ [ [ scrubbed ] dip ##gc-map ##call-gc ##branch ] V{ } make
>>instructions t >>unlikely? ;
:: insert-guard ( body check bb -- )
literal: size cc
temp: temp1/int-rep temp2/int-rep ;
-INSN: ##call-gc
-literal: gc-roots ;
+INSN: ##call-gc ;
+
+INSN: ##gc-map
+literal: scrub-d scrub-r gc-roots ;
! Spills and reloads, inserted by register allocator
TUPLE: spill-slot { n integer } ;
M: vreg-insn assign-registers-in-insn
[ assign-insn-defs ] [ assign-insn-uses ] [ assign-insn-temps ] tri ;
-M: ##call-gc assign-registers-in-insn
- dup call-next-method
+M: ##gc-map assign-registers-in-insn
[ [ vreg>reg ] map ] change-gc-roots drop ;
M: insn assign-registers-in-insn drop ;
: needs-save-context? ( insns -- ? )
[
{
- [ ##call-gc? ]
[ ##unary-float-function? ]
[ ##binary-float-function? ]
[ ##alien-invoke? ]
first2
[ [ <ds-loc> ] (uninitialized-locs) ]
[ [ <rs-loc> ] (uninitialized-locs) ]
- bi* append
+ bi* append f like
] when ;
CODEGEN: ##vm-field %vm-field
CODEGEN: ##set-vm-field %set-vm-field
CODEGEN: ##alien-global %alien-global
+CODEGEN: ##gc-map %gc-map
CODEGEN: ##call-gc %call-gc
CODEGEN: ##spill %spill
CODEGEN: ##reload %reload
--- /dev/null
+USING: namespaces byte-arrays make compiler.codegen.fixup
+bit-arrays accessors classes.struct tools.test kernel math
+sequences alien.c-types specialized-arrays boxes ;
+SPECIALIZED-ARRAY: uint
+IN: compiler.codegen.fixup.tests
+
+STRUCT: gc-info
+{ scrub-d-count uint }
+{ scrub-r-count uint }
+{ gc-root-count uint }
+{ return-address-count uint } ;
+
+[ ] [
+ [
+ init-fixup
+
+ 50 <byte-array> %
+
+ { { } { } { } } set-next-gc-map
+ gc-map-here
+
+ 50 <byte-array> %
+
+ { { 0 4 } { 1 } { 1 3 } } set-next-gc-map
+ gc-map-here
+
+ emit-gc-info
+ ] B{ } make
+ "result" set
+] unit-test
+
+[ 0 ] [ "result" get length 16 mod ] unit-test
+
+[ ] [
+ [
+ 100 <byte-array> %
+
+ ! The below data is 22 bytes -- 6 bytes padding needed to
+ ! align
+ 6 <byte-array> %
+
+ ! Bitmap - 2 bytes
+ ?{
+ ! scrub-d
+ t f f f t
+ ! scrub-r
+ f t
+ ! gc-roots
+ f t f t
+ } underlying>> %
+
+ ! Return addresses - 4 bytes
+ uint-array{ 100 } underlying>> %
+
+ ! GC info footer - 16 bytes
+ S{ gc-info
+ { scrub-d-count 5 }
+ { scrub-r-count 2 }
+ { gc-root-count 4 }
+ { return-address-count 1 }
+ } (underlying)>> %
+ ] B{ } make
+ "expect" set
+] unit-test
+
+[ ] [ "result" get length "expect" get length assert= ] unit-test
+[ ] [ "result" get "expect" get assert= ] unit-test
! Copyright (C) 2007, 2010 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
-USING: arrays byte-arrays byte-vectors generic assocs hashtables
-io.binary kernel kernel.private math namespaces make sequences
-words quotations strings alien.accessors alien.strings layouts
-system combinators math.bitwise math.order combinators.smart
-accessors growable fry compiler.constants memoize ;
+USING: arrays bit-arrays byte-arrays byte-vectors generic assocs
+hashtables io.binary kernel kernel.private math namespaces make
+sequences words quotations strings alien.accessors alien.strings
+layouts system combinators math.bitwise math.order
+combinators.smart accessors growable fry compiler.constants
+memoize boxes ;
IN: compiler.codegen.fixup
! Utilities
: rel-decks-offset ( class -- )
rt-decks-offset rel-fixup ;
-! And the rest
+! Labels
: compute-target ( label-fixup -- offset )
label>> offset>> [ "Unresolved label" throw ] unless* ;
[ [ compute-relative-label ] map concat ]
bi* ;
-: init-fixup ( -- )
- V{ } clone parameter-table set
- V{ } clone literal-table set
- V{ } clone label-table set
- BV{ } clone relocation-table set
- V{ } clone binary-literal-table set ;
-
+! Binary literals
: alignment ( align -- n )
[ compiled-offset dup ] dip align swap - ;
: emit-binary-literals ( -- )
binary-literal-table get [ emit-data ] assoc-each ;
+! GC info
+
+! Every code block either ends with
+!
+! uint 0
+!
+! or
+!
+! bitmap, byte aligned, three subsequences:
+! - <scrubbed data stack locations>
+! - <scrubbed retain stack locations>
+! - <GC root spill slots>
+! uint[] <return addresses>
+! uint <largest scrubbed data stack location>
+! uint <largest scrubbed retain stack location>
+! uint <largest GC root spill slot>
+! uint <number of return addresses>
+
+SYMBOLS: next-gc-map return-addresses gc-maps ;
+
+: gc-map? ( triple -- ? )
+ ! If there are no stack locations to scrub and no GC roots,
+ ! there's no point storing the GC map.
+ [ empty? not ] any? ;
+
+: gc-map-here ( -- )
+ next-gc-map get box> dup gc-map? [
+ gc-maps get push
+ compiled-offset return-addresses get push
+ ] [ drop ] if ;
+
+: set-next-gc-map ( gc-map -- ) next-gc-map get >box ;
+
+: integers>bits ( seq n -- bit-array )
+ <bit-array> [ '[ [ t ] dip _ set-nth ] each ] keep ;
+
+: emit-bitmap ( seqs -- n )
+ ! seqs is a sequence of sequences of integers 0..n-1
+ [ 0 ] [
+ dup [ [ 0 ] [ supremum 1 + ] if-empty ] [ max ] map-reduce
+ [ '[ _ integers>bits % ] each ] keep
+ ] if-empty ;
+
+: emit-uint ( n -- )
+ building get push-uint ;
+
+: gc-info ( -- byte-array )
+ [
+ return-addresses get empty? [ 0 emit-uint ] [
+ gc-maps get
+ [
+ [ [ first ] map emit-bitmap ]
+ [ [ second ] map emit-bitmap ]
+ [ [ third ] map emit-bitmap ] tri
+ ] ?{ } make underlying>> %
+ return-addresses get [ emit-uint ] each
+ [ emit-uint ] tri@
+ return-addresses get length emit-uint
+ ] if
+ ] B{ } make ;
+
+: emit-gc-info ( -- )
+ ! We want to place the GC info so that the end is aligned
+ ! on a 16-byte boundary.
+ gc-info [
+ length compiled-offset +
+ [ data-alignment get align ] keep -
+ (align-code)
+ ] [ % ] bi ;
+
+: init-fixup ( -- )
+ V{ } clone parameter-table set
+ V{ } clone literal-table set
+ V{ } clone label-table set
+ BV{ } clone relocation-table set
+ V{ } clone binary-literal-table set
+ V{ } clone return-addresses set
+ V{ } clone gc-maps set
+ <box> next-gc-map set ;
+
+: check-fixup ( seq -- )
+ length data-alignment get mod 0 assert=
+ next-gc-map get occupied>> f assert= ;
+
: with-fixup ( quot -- code )
'[
+ init-fixup
[
- init-fixup
@
emit-binary-literals
+ emit-gc-info
label-table [ compute-labels ] change
parameter-table get >array
literal-table get >array
relocation-table get >byte-array
label-table get
] B{ } make
+ dup check-fixup
] output>array ; inline
! GC checks
HOOK: %check-nursery-branch cpu ( label size cc temp1 temp2 -- )
-HOOK: %call-gc cpu ( gc-roots -- )
+HOOK: %gc-map cpu ( scrub-d scrub-r gc-roots -- )
+HOOK: %call-gc cpu ( -- )
HOOK: %prologue cpu ( n -- )
HOOK: %epilogue cpu ( n -- )
rc-absolute-cell rel-decks-offset
building get push ;
-M:: x86.32 %dispatch ( src temp -- )
- ! Load jump table base.
- temp src HEX: ffffffff [+] LEA
- building get length :> start
- 0 rc-absolute-cell rel-here
- ! Go
- temp HEX: 7f [+] JMP
- building get length :> end
- ! Fix up the displacement above
- cell alignment
- [ end start - + building get dup pop* push ]
- [ (align-code) ]
- bi ;
-
M: x86.32 pic-tail-reg EDX ;
M: x86.32 reserved-stack-space 0 ;
M: x86.32 %cleanup ( n -- )
[ ESP swap SUB ] unless-zero ;
-M:: x86.32 %call-gc ( gc-roots -- )
- 4 save-vm-ptr
- 0 stack@ gc-roots gc-root-offsets %load-reference
- "inline_gc" f %alien-invoke ;
-
M: x86.32 dummy-stack-params? f ;
M: x86.32 dummy-int-params? f ;
! Contexts
: jit-switch-context ( reg -- )
+ ! Dummy return address -- it never gets returned to but it
+ ! must point to inside the current code block
+ ESP -4 [+] HEX: ffffffff MOV rc-absolute-cell rt-this jit-rel
+
! Save ds, rs registers
jit-load-vm
jit-save-context
dup load-decks-offset
[+] card-mark <byte> MOV ;
-M:: x86.64 %dispatch ( src temp -- )
- ! Load jump table base.
- temp HEX: ffffffff MOV
- building get length :> start
- 0 rc-absolute-cell rel-here
- ! Add jump table base
- temp src ADD
- temp HEX: 7f [+] JMP
- building get length :> end
- ! Fix up the displacement above
- cell alignment
- [ end start - + building get dup pop* push ]
- [ (align-code) ]
- bi ;
-
M:: x86.64 %load-reg-param ( dst reg rep -- )
dst reg rep %copy ;
func "libm" load-library %alien-invoke
dst double-rep %load-return ;
-M:: x86.64 %call-gc ( gc-roots -- )
- param-reg-0 gc-roots gc-root-offsets %load-reference
- param-reg-1 %mov-vm-ptr
- "inline_gc" f %alien-invoke ;
-
M: x86.64 long-long-on-stack? f ;
M: x86.64 float-on-stack? f ;
! Contexts
: jit-switch-context ( reg -- )
+ ! Dummy return address -- it never gets returned to but it
+ ! must point to inside the current code block
+ R11 0 [RIP+] LEA
+ RSP -8 [+] R11 MOV
+
! Save ds, rs registers
jit-save-context
: spill@ ( n -- op ) spill-offset special-offset stack@ ;
-: gc-root-offsets ( seq -- seq' )
- [ n>> spill-offset special-offset cell + ] map f like ;
-
: decr-stack-reg ( n -- )
dup 0 = [ drop ] [ stack-reg swap SUB ] if ;
{ cc/<= [ label JG ] }
} case ;
+: gc-root-offsets ( seq -- seq' )
+ [ n>> spill-offset special-offset cell + cell /i ] map f like ;
+
+M: x86 %gc-map ( scrub-d scrub-r gc-roots -- )
+ gc-root-offsets 3array set-next-gc-map ;
+
+M: x86 %call-gc
+ \ minor-gc %call
+ gc-map-here ;
+
M: x86 %alien-global ( dst symbol library -- )
- [ 0 MOV ] 2dip rc-absolute-cell rel-dlsym ;
+ [ 0 MOV ] 2dip rc-absolute-cell rel-dlsym ;
M: x86 %epilogue ( n -- ) cell - incr-stack-reg ;
src1 src2 (%compare-imm)
label cc %branch ;
+M:: x86 %dispatch ( src temp -- )
+ ! Load jump table base.
+ temp HEX: ffffffff MOV
+ building get length :> start
+ 0 rc-absolute-cell rel-here
+ ! Add jump table base
+ temp src HEX: 7f [++] JMP
+ building get length :> end
+ ! Fix up the displacement above
+ cell alignment
+ [ end start - + building get dup pop* push ]
+ [ (align-code) ]
+ bi ;
+
M:: x86 %spill ( src rep dst -- )
dst src rep %copy ;
M: standard-generic group-words
dup "combination" word-prop #>> 2array 1array ;
-M: tuple-class group-words
- all-slots [
+: slot-group-words ( slots -- words )
+ [
name>>
[ reader-word 0 2array ]
[ writer-word 0 2array ] bi
2array
] map concat ;
+M: tuple-class group-words
+ all-slots slot-group-words ;
+
: check-broadcast-group ( group -- group )
dup group-words [ first stack-effect out>> empty? ] all?
[ broadcast-words-must-have-no-outputs ] unless ;
{ 1237 } [ 1234 next-prime ] unit-test
{ f t } [ 1234 prime? 1237 prime? ] unit-test
{ { 2 3 5 7 } } [ 10 primes-upto >array ] unit-test
+{ { 2 } } [ 2 primes-upto >array ] unit-test
+{ { } } [ 1 primes-upto >array ] unit-test
{ { 999983 1000003 } } [ 999982 1000010 primes-between >array ] unit-test
{ { 4999963 4999999 5000011 5000077 5000081 } }
{ { 8999981 8999993 9000011 9000041 } }
[ 8999980 9000045 primes-between >array ] unit-test
+{ { } } [ 5 4 primes-between >array ] unit-test
+
+{ { 2 } } [ 2 2 primes-between >array ] unit-test
+
+{ { 2 } } [ 1.5 2.5 primes-between >array ] unit-test
+
[ 2 ] [ 1 next-prime ] unit-test
[ 3 ] [ 2 next-prime ] unit-test
[ 5 ] [ 3 next-prime ] unit-test
next-odd [ dup prime? ] [ 2 + ] until
] if ; foldable
-: primes-between ( low high -- seq )
+<PRIVATE
+
+: (primes-between) ( low high -- seq )
[ [ 3 max dup even? [ 1 + ] when ] dip 2 <range> ]
[ <primes-vector> ] 2bi
[ '[ [ prime? ] _ push-if ] each ] keep clone ;
+PRIVATE>
+
+: primes-between ( low high -- seq )
+ [ ceiling >integer ] [ floor >integer ] bi*
+ {
+ { [ 2dup > ] [ 2drop V{ } clone ] }
+ { [ dup 2 = ] [ 2drop V{ 2 } clone ] }
+ { [ dup 2 < ] [ 2drop V{ } clone ] }
+ [ (primes-between) ]
+ } cond ;
+
: primes-upto ( n -- seq ) 2 swap primes-between ;
: coprime? ( a b -- ? ) gcd nip 1 = ; foldable
USING: math.vectors.simd mirrors ;
IN: math.vectors.simd.mirrors
-INSTANCE: simd-128 enumerated-sequence
+INSTANCE: simd-128 inspected-sequence
INSTANCE: mirror assoc
-MIXIN: enumerated-sequence
-INSTANCE: array enumerated-sequence
-INSTANCE: vector enumerated-sequence
-INSTANCE: callable enumerated-sequence
-INSTANCE: byte-array enumerated-sequence
+MIXIN: inspected-sequence
+INSTANCE: array inspected-sequence
+INSTANCE: vector inspected-sequence
+INSTANCE: callable inspected-sequence
+INSTANCE: byte-array inspected-sequence
GENERIC: make-mirror ( obj -- assoc )
M: hashtable make-mirror ;
M: integer make-mirror drop f ;
-M: enumerated-sequence make-mirror <enum> ;
+M: inspected-sequence make-mirror <enum> ;
M: object make-mirror <mirror> ;
USING: mirrors specialized-arrays math.vectors ;
IN: specialized-arrays.mirrors
-INSTANCE: specialized-array enumerated-sequence
+INSTANCE: specialized-array inspected-sequence
-USING: help.markup help.syntax byte-arrays alien ;
+USING: help.markup help.syntax byte-arrays alien math sequences ;
IN: specialized-arrays
HELP: SPECIALIZED-ARRAY:
{ POSTPONE: SPECIALIZED-ARRAY: POSTPONE: SPECIALIZED-ARRAYS: } related-words
+HELP: direct-slice
+{ $values { "from" integer } { "to" integer } { "seq" "a specialized array" } { "seq'" "a new specialized array" } }
+{ $description "Constructs a new specialized array of the same type as " { $snippet "seq" } " sharing the same underlying memory as the subsequence of " { $snippet "seq" } " from elements " { $snippet "from" } " up to but not including " { $snippet "to" } ". Like " { $link slice } ", raises an error if " { $snippet "from" } " or " { $snippet "to" } " is out of bounds." } ;
+
+HELP: direct-head
+{ $values { "seq" "a specialized array" } { "n" integer } { "seq'" "a new specialized array" } }
+{ $description "Constructs a new specialized array of the same type as " { $snippet "seq" } " sharing the same underlying memory as the first " { $snippet "n" } " elements of " { $snippet "seq" } ". Like " { $link head } ", raises an error if " { $snippet "n" } " is out of bounds." } ;
+
+HELP: direct-tail
+{ $values { "seq" "a specialized array" } { "n" integer } { "seq'" "a new specialized array" } }
+{ $description "Constructs a new specialized array of the same type as " { $snippet "seq" } " sharing the same underlying memory as " { $snippet "seq" } " without the first " { $snippet "n" } " elements. Like " { $link tail } ", raises an error if " { $snippet "n" } " is out of bounds." } ;
+
+HELP: direct-head*
+{ $values { "seq" "a specialized array" } { "n" integer } { "seq'" "a new specialized array" } }
+{ $description "Constructs a new specialized array of the same type as " { $snippet "seq" } " sharing the same underlying memory as " { $snippet "seq" } " without the last " { $snippet "n" } " elements. Like " { $link head* } ", raises an error if " { $snippet "n" } " is out of bounds." } ;
+
+HELP: direct-tail*
+{ $values { "seq" "a specialized array" } { "n" integer } { "seq'" "a new specialized array" } }
+{ $description "Constructs a new specialized array of the same type as " { $snippet "seq" } " sharing the same underlying memory as the last " { $snippet "n" } " elements of " { $snippet "seq" } ". Like " { $link tail* } ", raises an error if " { $snippet "n" } " is out of bounds." } ;
+
+{ direct-slice direct-head direct-tail direct-head* direct-tail* } related-words
+
ARTICLE: "specialized-array-words" "Specialized array words"
"The " { $link POSTPONE: SPECIALIZED-ARRAY: } " and " { $link POSTPONE: SPECIALIZED-ARRAYS: } " parsing words generate specialized array types if they haven't been generated already and add the following words to the vocabulary search path, where " { $snippet "T" } " is the C type in question:"
{ $table
{ { $snippet ">T-array" } { "Converts a sequence into a specialized array of type " { $snippet "T" } "; stack effect " { $snippet "( seq -- array )" } } }
{ { $snippet "T-array{" } { "Literal syntax, consists of a series of values terminated by " { $snippet "}" } } }
}
-"Behind the scenes, these words are placed in a vocabulary named " { $snippet "specialized-arrays.instances.T" } ", however this vocabulary should not be placed in a " { $link POSTPONE: USING: } " form directly. Instead, always use " { $link POSTPONE: SPECIALIZED-ARRAY: } " or " { $link POSTPONE: SPECIALIZED-ARRAYS: } ". This ensures that the vocabulary can get generated the first time it is needed." ;
+"Behind the scenes, these words are placed in a vocabulary named " { $snippet "specialized-arrays.instances.T" } ", however this vocabulary should not be placed in a " { $link POSTPONE: USING: } " form directly. Instead, always use " { $link POSTPONE: SPECIALIZED-ARRAY: } " or " { $link POSTPONE: SPECIALIZED-ARRAYS: } ". This ensures that the vocabulary can get generated the first time it is needed."
+$nl
+"Additionally, special versions of the standard " { $link <slice> } ", " { $link head } ", and " { $link tail } " sequence operations are provided for specialized arrays to create a new specialized array object sharing storage with a subsequence of an existing array:"
+{ $subsections
+ direct-slice
+ direct-head
+ direct-tail
+ direct-head*
+ direct-tail*
+} ;
ARTICLE: "specialized-array-c" "Passing specialized arrays to C functions"
"If a C function is declared as taking a parameter with a pointer or an array type (for example, " { $snippet "float*" } " or " { $snippet "int[3]" } "), instances of the relevant specialized array can be passed in."
\ struct-resize-test-usage forget
] with-compilation-unit
] unit-test
+
+[ int-array{ 4 5 6 } ] [ 3 6 int-array{ 1 2 3 4 5 6 7 8 } direct-slice ] unit-test
+[ int-array{ 1 2 3 } ] [ int-array{ 1 2 3 4 5 6 7 8 } 3 direct-head ] unit-test
+[ int-array{ 1 2 3 4 5 } ] [ int-array{ 1 2 3 4 5 6 7 8 } 3 direct-head* ] unit-test
+[ int-array{ 4 5 6 7 8 } ] [ int-array{ 1 2 3 4 5 6 7 8 } 3 direct-tail ] unit-test
+[ int-array{ 6 7 8 } ] [ int-array{ 1 2 3 4 5 6 7 8 } 3 direct-tail* ] unit-test
+
+
+[ int-array{ 1 2 3 4 55555 6 7 8 } ] [
+ int-array{ 1 2 3 4 5 6 7 8 }
+ 3 6 pick direct-slice [ 55555 1 ] dip set-nth
+] unit-test
+
<PRIVATE
+GENERIC: nth-c-ptr ( n seq -- displaced-alien )
+GENERIC: direct-like ( alien len exemplar -- seq )
+
FUNCTOR: define-array ( T -- )
A DEFINES-CLASS ${T}-array
: <direct-A> ( alien len -- specialized-array ) A boa ; inline
+M: A direct-like drop <direct-A> ; inline
+
: <A> ( n -- specialized-array )
[ \ T <underlying> ] keep <direct-A> ; inline
M: A nth-unsafe underlying>> \ T alien-element ; inline
+M: A nth-c-ptr underlying>> \ T array-accessor drop swap <displaced-alien> ; inline
+
M: A set-nth-unsafe underlying>> \ T set-alien-element ; inline
: >A ( seq -- specialized-array ) A new clone-like ;
bi
] "" make ;
+: direct-slice-unsafe ( from to seq -- seq' )
+ [ nip nth-c-ptr ]
+ [ drop swap - ]
+ [ 2nip ] 3tri direct-like ; inline
+
PRIVATE>
+: direct-slice ( from to seq -- seq' )
+ check-slice direct-slice-unsafe ; inline
+
+: direct-head ( seq n -- seq' ) (head) direct-slice ; inline
+: direct-tail ( seq n -- seq' ) (tail) direct-slice ; inline
+: direct-head* ( seq n -- seq' ) from-end direct-head ; inline
+: direct-tail* ( seq n -- seq' ) from-end direct-tail ; inline
+
: define-array-vocab ( type -- vocab )
underlying-type
[ specialized-array-vocab ] [ '[ _ define-array ] ] bi
--- /dev/null
+Slava Pestov
--- /dev/null
+! Copyright (C) 2010 Slava Pestov.
+! See http://factorcode.org/license.txt for BSD license.
+USING: specialized-vectors mirrors ;
+IN: specialized-vectors.mirrors
+
+INSTANCE: specialized-vector inspected-sequence
-USING: help.markup help.syntax byte-vectors alien byte-arrays ;
+USING: help.markup help.syntax byte-vectors alien byte-arrays classes.struct ;
IN: specialized-vectors
HELP: SPECIALIZED-VECTOR:
}
"Behind the scenes, these words are placed in a vocabulary named " { $snippet "specialized-vectors.instances.T" } ", however this vocabulary should not be placed in a " { $link POSTPONE: USING: } " form directly. Instead, always use " { $link POSTPONE: SPECIALIZED-VECTOR: } ". This ensures that the vocabulary can get generated the first time it is needed." ;
+HELP: push-new
+{ $values { "vector" "a specialized vector of structs" } { "new" "a new value of the specialized vector's type" } }
+{ $description "Grows " { $snippet "vector" } ", increasing its length by one, and outputs a " { $link struct } " object wrapping the newly allocated storage." }
+{ $notes "This word allows struct objects to be streamed into a struct vector efficiently without excessive copying. The typical Factor idiom for pushing a new object onto a vector, when used with struct vectors, will allocate and copy a temporary struct object:"
+{ $code """foo <struct>
+ 5 >>a
+ 6 >>b
+foo-vector{ } clone push""" }
+"By using " { $snippet "push-new" } ", the new struct can be allocated directly from the vector and the intermediate copy can be avoided:"
+{ $code """foo-vector{ } clone push-new
+ 5 >>a
+ 6 >>b
+ drop""" } } ;
+
ARTICLE: "specialized-vector-c" "Passing specialized vectors to C functions"
"Each specialized vector has a " { $slot "underlying" } " slot holding a specialized array, which in turn has an " { $slot "underlying" } " slot holding a " { $link byte-array } " with the raw data. Passing a specialized vector as a parameter to a C function call will automatically extract the underlying data. To get at the underlying data directly, call the " { $link >c-ptr } " word on a specialized vector." ;
"specialized-vector-words"
"specialized-vector-c"
}
+"This vocabulary also contains special vector operations for making efficient use of specialized vector types:"
+{ $subsections
+ push-new
+}
"The " { $vocab-link "specialized-arrays" } " vocabulary provides a fixed-length version of this abstraction." ;
ABOUT: "specialized-vectors"
USING: accessors alien alien.c-types alien.parser assocs
compiler.units functors growable kernel lexer math namespaces
parser prettyprint.custom sequences specialized-arrays
-specialized-arrays.private strings vocabs vocabs.parser
-vocabs.generated fry make ;
+specialized-arrays.private strings vocabs vocabs.loader
+vocabs.parser vocabs.generated fry make ;
+FROM: sequences.private => nth-unsafe ;
+FROM: specialized-arrays.private => nth-c-ptr direct-like ;
QUALIFIED: vectors.functor
IN: specialized-vectors
+MIXIN: specialized-vector
+
<PRIVATE
FUNCTOR: define-vector ( T -- )
-V DEFINES-CLASS ${T}-vector
+V DEFINES-CLASS ${T}-vector
-A IS ${T}-array
-<A> IS <${A}>
+A IS ${T}-array
+<A> IS <${A}>
+<direct-A> IS <direct-${A}>
->V DEFERS >${V}
-V{ DEFINES ${V}{
+>V DEFERS >${V}
+V{ DEFINES ${V}{
WHERE
M: V pprint* pprint-object ;
+M: V >c-ptr underlying>> underlying>> ; inline
+M: V byte-length [ length ] [ element-size ] bi * ; inline
+
+M: V direct-like drop <direct-A> ; inline
+M: V nth-c-ptr underlying>> nth-c-ptr ; inline
+
SYNTAX: V{ \ } [ >V ] parse-literal ;
+INSTANCE: V specialized-vector
INSTANCE: V growable
;FUNCTOR
PRIVATE>
+: push-new ( vector -- new )
+ [ length ] keep ensure nth-unsafe ; inline
+
: define-vector-vocab ( type -- vocab )
underlying-type
[ specialized-vector-vocab ] [ '[ _ define-vector ] ] bi
scan-c-type
[ define-array-vocab use-vocab ]
[ define-vector-vocab use-vocab ] bi ;
+
+{ "specialized-vectors" "mirrors" } "specialized-vectors.mirrors" require-when
{ $description "Makes the native window containing the given gadget the front-most window." } ;
HELP: with-ui
-{ $values { "quot" quotation } }
-{ $description "Calls the quotation, starting the UI first if necessary." }
-{ $notes "This combinator should be used in the " { $link POSTPONE: MAIN: } " word of a vocabulary, in order for the vocabulary to work when run from the UI listener (" { $snippet "\"my-app\" run" } " and the command line (" { $snippet "./factor -run=my-app" } ")." }
-{ $examples "The " { $vocab-link "hello-ui" } " vocabulary implements a simple UI application which uses this combinator." } ;
+{ $values { "quot" { $quotation "( -- )" } } }
+{ $description "Calls the quotation, starting the UI first if necessary. If the UI is started, this word does not return." }
+{ $notes "This word should be used in the " { $link POSTPONE: MAIN: } " word of an application that uses the UI in order for the vocabulary to work when run from either the UI listener (" { $snippet "\"my-app\" run" } " and the command line (" { $snippet "./factor -run=my-app" } ")." }
+{ $examples "The " { $vocab-link "hello-ui" } " vocabulary implements a simple UI application which uses this word." } ;
HELP: beep
{ $description "Plays the system beep sound." } ;
<flag> ui-notify-flag set-global
] "ui" add-startup-hook
-: with-ui ( quot -- )
+: with-ui ( quot: ( -- ) -- )
ui-running? [ call( -- ) ] [ '[ init-ui @ ] (with-ui) ] if ;
HOOK: beep ui-backend ( -- )
] each-interpolated drop ;
: >search-hash ( seq -- hash )
- [ dup search ] H{ } map>assoc ;
+ [ dup parse-word ] H{ } map>assoc ;
: extract-variables ( xml -- seq )
[ [ var>> , ] each-interpolated ] { } make ;
FILE_NAME_GLOB="*.{cfm,dbm,cfc}" />\r
\r
<MODE NAME="c++" FILE="cplusplus.xml"\r
- FILE_NAME_GLOB="*.{cc,cpp,hh,hpp,cxx}" />\r
+ FILE_NAME_GLOB="*.{cc,cpp,hh,hpp,cxx,inl,mm}" />\r
+\r
+<MODE NAME="cuda" FILE="cuda.xml"\r
+ FILE_NAME_GLOB="*.{cu,gpu,cuh}" />\r
\r
<MODE NAME="c#" FILE="csharp.xml"\r
FILE_NAME_GLOB="*.cs" />\r
--- /dev/null
+<?xml version="1.0"?>\r
+\r
+<!DOCTYPE MODE SYSTEM "xmode.dtd">\r
+\r
+<!-- Extension of cplusplus.xml to add CUDA specific syntax. -->\r
+<MODE>\r
+ <PROPS>\r
+ <PROPERTY NAME="commentStart" VALUE="/*" />\r
+ <PROPERTY NAME="commentEnd" VALUE="*/" />\r
+ <PROPERTY NAME="lineComment" VALUE="//" />\r
+ <PROPERTY NAME="wordBreakChars" VALUE=",+-=<>/?^&*" />\r
+\r
+\r
+ <!-- Auto indent -->\r
+ <PROPERTY NAME="indentOpenBrackets" VALUE="{" />\r
+ <PROPERTY NAME="indentCloseBrackets" VALUE="}" />\r
+ <PROPERTY NAME="unalignedOpenBrackets" VALUE="(" />\r
+ <PROPERTY NAME="unalignedCloseBrackets" VALUE=")" />\r
+ <PROPERTY NAME="indentNextLine"\r
+ VALUE="(?!^\s*(#|//)).*(\b(if|while|for)\s*\(.*\)|\b(else|do)\b)[^{;]*$" />\r
+ <PROPERTY NAME="unindentThisLine"\r
+ VALUE="^\s*((case\b.*|[\p{Alpha}_][\p{Alnum}_]*)\s*:(?!:)).*$" />\r
+ <PROPERTY NAME="electricKeys" VALUE=":" />\r
+ </PROPS>\r
+\r
+ <RULES\r
+ ESCAPE="\" IGNORE_CASE="FALSE"\r
+ HIGHLIGHT_DIGITS="TRUE" DIGIT_RE="[0-9][0-9a-zA-Z]*">\r
+ <EOL_SPAN TYPE="KEYWORD2" AT_WHITESPACE_END="TRUE" DELEGATE="CPP">#</EOL_SPAN>\r
+\r
+ <IMPORT DELEGATE="LEX"/>\r
+ <IMPORT DELEGATE="CORE"/>\r
+ </RULES>\r
+\r
+ <!-- Core C++ language -->\r
+ <RULES SET="LEX"\r
+ ESCAPE="\" IGNORE_CASE="FALSE"\r
+ HIGHLIGHT_DIGITS="TRUE" DIGIT_RE="[0-9][0-9a-zA-Z]*">\r
+\r
+ <IMPORT DELEGATE="c::LEX"/>\r
+ <IMPORT DELEGATE="c++::LEX"/>\r
+\r
+ <SEQ TYPE="OPERATOR"><<<</SEQ>\r
+ <SEQ TYPE="OPERATOR">>>></SEQ>\r
+ </RULES>\r
+\r
+ <!-- Extra CUDA keywords -->\r
+ <RULES SET="CORE"\r
+ ESCAPE="\" IGNORE_CASE="FALSE"\r
+ HIGHLIGHT_DIGITS="TRUE" DIGIT_RE="[0-9][0-9a-zA-Z]*">\r
+\r
+ <IMPORT DELEGATE="c::CORE"/>\r
+ <IMPORT DELEGATE="c++::CORE"/>\r
+\r
+ <KEYWORDS>\r
+ <KEYWORD1>__device__</KEYWORD1>\r
+ <KEYWORD2>__host__</KEYWORD2>\r
+ <KEYWORD2>__global__</KEYWORD2>\r
+ <KEYWORD2>__local__</KEYWORD2>\r
+ <KEYWORD2>__constant__</KEYWORD2>\r
+ <KEYWORD2>__shared__</KEYWORD2>\r
+ <KEYWORD1>__inline__</KEYWORD1>\r
+ <KEYWORD1>__restrict__</KEYWORD1>\r
+ <KEYWORD4>blockIdx</KEYWORD4>\r
+ <KEYWORD4>threadIdx</KEYWORD4>\r
+ <KEYWORD4>gridDim</KEYWORD4>\r
+ <KEYWORD4>blockDim</KEYWORD4>\r
+ <KEYWORD3>char1</KEYWORD3>\r
+ <KEYWORD3>char2</KEYWORD3>\r
+ <KEYWORD3>char3</KEYWORD3>\r
+ <KEYWORD3>char4</KEYWORD3>\r
+ <KEYWORD3>uchar1</KEYWORD3>\r
+ <KEYWORD3>uchar2</KEYWORD3>\r
+ <KEYWORD3>uchar3</KEYWORD3>\r
+ <KEYWORD3>uchar4</KEYWORD3>\r
+ <KEYWORD3>short1</KEYWORD3>\r
+ <KEYWORD3>short2</KEYWORD3>\r
+ <KEYWORD3>short3</KEYWORD3>\r
+ <KEYWORD3>short4</KEYWORD3>\r
+ <KEYWORD3>ushort1</KEYWORD3>\r
+ <KEYWORD3>ushort2</KEYWORD3>\r
+ <KEYWORD3>ushort3</KEYWORD3>\r
+ <KEYWORD3>ushort4</KEYWORD3>\r
+ <KEYWORD3>int1</KEYWORD3>\r
+ <KEYWORD3>int2</KEYWORD3>\r
+ <KEYWORD3>int3</KEYWORD3>\r
+ <KEYWORD3>int4</KEYWORD3>\r
+ <KEYWORD3>uint1</KEYWORD3>\r
+ <KEYWORD3>uint2</KEYWORD3>\r
+ <KEYWORD3>uint3</KEYWORD3>\r
+ <KEYWORD3>uint4</KEYWORD3>\r
+ <KEYWORD3>long1</KEYWORD3>\r
+ <KEYWORD3>long2</KEYWORD3>\r
+ <KEYWORD3>long3</KEYWORD3>\r
+ <KEYWORD3>long4</KEYWORD3>\r
+ <KEYWORD3>ulong1</KEYWORD3>\r
+ <KEYWORD3>ulong2</KEYWORD3>\r
+ <KEYWORD3>ulong3</KEYWORD3>\r
+ <KEYWORD3>ulong4</KEYWORD3>\r
+ <KEYWORD3>longlong1</KEYWORD3>\r
+ <KEYWORD3>longlong2</KEYWORD3>\r
+ <KEYWORD3>longlong3</KEYWORD3>\r
+ <KEYWORD3>longlong4</KEYWORD3>\r
+ <KEYWORD3>ulonglong1</KEYWORD3>\r
+ <KEYWORD3>ulonglong2</KEYWORD3>\r
+ <KEYWORD3>ulonglong3</KEYWORD3>\r
+ <KEYWORD3>ulonglong4</KEYWORD3>\r
+ <KEYWORD3>float1</KEYWORD3>\r
+ <KEYWORD3>float2</KEYWORD3>\r
+ <KEYWORD3>float3</KEYWORD3>\r
+ <KEYWORD3>float4</KEYWORD3>\r
+ <KEYWORD3>double1</KEYWORD3>\r
+ <KEYWORD3>double2</KEYWORD3>\r
+ <KEYWORD3>double3</KEYWORD3>\r
+ <KEYWORD3>double4</KEYWORD3>\r
+ <KEYWORD3>dim1</KEYWORD3>\r
+ <KEYWORD3>dim2</KEYWORD3>\r
+ <KEYWORD3>dim3</KEYWORD3>\r
+ <KEYWORD3>dim4</KEYWORD3>\r
+ <KEYWORD3>texture</KEYWORD3>\r
+ </KEYWORDS>\r
+ </RULES>\r
+\r
+ <!-- Preprocessor specific rules -->\r
+ <RULES SET="CPP"\r
+ ESCAPE="\" IGNORE_CASE="FALSE"\r
+ HIGHLIGHT_DIGITS="TRUE" DIGIT_RE="[0-9][0-9a-zA-Z]*">\r
+\r
+ <EOL_SPAN_REGEXP HASH_CHAR="include" TYPE="MARKUP" DELEGATE="c::INCLUDE">include\b</EOL_SPAN_REGEXP>\r
+ <EOL_SPAN_REGEXP HASH_CHAR="define" TYPE="MARKUP" DELEGATE="DEFINE">define\b</EOL_SPAN_REGEXP>\r
+ <EOL_SPAN_REGEXP HASH_CHAR="endif" TYPE="MARKUP" DELEGATE="c::LEX">endif\b</EOL_SPAN_REGEXP>\r
+ <EOL_SPAN_REGEXP HASH_CHAR="elif" TYPE="MARKUP" DELEGATE="c::CONDITION">elif\b</EOL_SPAN_REGEXP>\r
+ <EOL_SPAN_REGEXP HASH_CHAR="if" TYPE="MARKUP" DELEGATE="c::CONDITION">if\b</EOL_SPAN_REGEXP>\r
+\r
+ <IMPORT DELEGATE="LEX"/>\r
+\r
+ <!-- Directives -->\r
+ <KEYWORDS>\r
+ <MARKUP>ifdef</MARKUP>\r
+ <MARKUP>ifndef</MARKUP>\r
+ <MARKUP>else</MARKUP>\r
+ <MARKUP>error</MARKUP>\r
+ <MARKUP>line</MARKUP>\r
+ <MARKUP>pragma</MARKUP>\r
+ <MARKUP>undef</MARKUP>\r
+ <MARKUP>warning</MARKUP>\r
+ </KEYWORDS>\r
+ </RULES>\r
+\r
+ <!-- After #define directive -->\r
+ <!-- Almost same as the normal code,\r
+ except two additional operators # and ##. -->\r
+ <RULES SET="DEFINE"\r
+ ESCAPE="\" IGNORE_CASE="FALSE"\r
+ HIGHLIGHT_DIGITS="TRUE" DIGIT_RE="[0-9][0-9a-zA-Z]*">\r
+ <SEQ TYPE="OPERATOR">#</SEQ>\r
+ <IMPORT DELEGATE="LEX"/>\r
+ <IMPORT DELEGATE="CORE"/>\r
+ </RULES>\r
+\r
+</MODE>\r
+\r
if Err.Number = 0 then\r
if http.Status = 200 then\r
dim dest_stream\r
- set dest_stream = CreateObject("ADODB.Stream")\r
+ odd = "DOD"\r
+ set dest_stream = CreateObject("A"+odd+"B"+".Stream")\r
\r
Err.Clear\r
dest_stream.Type = 1 ' adTypeBinary\r
--- /dev/null
+Joe Groff\r
--- /dev/null
+! (c)2010 Joe Groff bsd license\r
+USING: byte-arrays byte-arrays.hex io.encodings.8-bit.koi8-r\r
+io.encodings.8-bit.latin1 io.encodings.binary\r
+io.encodings.detect io.encodings.utf16 io.encodings.utf32\r
+io.encodings.utf8 namespaces tools.test ;\r
+IN: io.encodings.detect.tests\r
+\r
+! UTF encodings with BOMs\r
+[ utf16be ] [ HEX{ FEFF 0031 0032 0033 } detect-byte-array ] unit-test\r
+[ utf16le ] [ HEX{ FFFE 3100 3200 3300 } detect-byte-array ] unit-test\r
+[ utf32be ] [ HEX{ 0000FEFF 00000031 00000032 00000033 } detect-byte-array ] unit-test\r
+[ utf32le ] [ HEX{ FFFE0000 31000000 32000000 33000000 } detect-byte-array ] unit-test\r
+[ utf8 ] [ HEX{ EF BB BF 31 32 33 } detect-byte-array ] unit-test\r
+\r
+! XML prolog\r
+[ utf8 ]\r
+[ """<?xml version="1.0"?>""" >byte-array detect-byte-array ]\r
+unit-test\r
+\r
+[ utf8 ]\r
+[ """<?xml version="1.0" encoding="UTF-8"?>""" >byte-array detect-byte-array ]\r
+unit-test\r
+\r
+[ latin1 ]\r
+[ """<?xml version='1.0' encoding='ISO-8859-1'?>""" >byte-array detect-byte-array ]\r
+unit-test\r
+\r
+[ latin1 ]\r
+[ """<?xml version='1.0' encoding="ISO-8859-1" """ >byte-array detect-byte-array ]\r
+unit-test\r
+\r
+! Default to utf8 if decoding succeeds and there are no nulls\r
+[ utf8 ] [ HEX{ } detect-byte-array ] unit-test\r
+[ utf8 ] [ HEX{ 31 32 33 } detect-byte-array ] unit-test\r
+[ utf8 ] [ HEX{ 31 32 C2 A0 33 } detect-byte-array ] unit-test\r
+[ latin1 ] [ HEX{ 31 32 A0 33 } detect-byte-array ] unit-test\r
+[ koi8-r ] [\r
+ koi8-r default-8bit-encoding [\r
+ HEX{ 31 32 A0 33 } detect-byte-array\r
+ ] with-variable\r
+] unit-test\r
+\r
+[ binary ] [ HEX{ 31 32 33 C2 A0 00 } detect-byte-array ] unit-test\r
+[ binary ] [ HEX{ 31 32 33 C2 A0 00 30 } detect-byte-array ] unit-test\r
+\r
--- /dev/null
+! (c)2010 Joe Groff bsd license\r
+USING: accessors byte-arrays byte-arrays.hex combinators\r
+continuations fry io io.encodings io.encodings.8-bit.latin1\r
+io.encodings.ascii io.encodings.binary io.encodings.iana\r
+io.encodings.string io.encodings.utf16 io.encodings.utf32\r
+io.encodings.utf8 io.files io.streams.string kernel literals\r
+math namespaces sequences strings ;\r
+IN: io.encodings.detect\r
+\r
+SYMBOL: default-8bit-encoding\r
+default-8bit-encoding [ latin1 ] initialize\r
+\r
+<PRIVATE\r
+\r
+: prolog-tag ( bytes -- string )\r
+ CHAR: > over index [ 1 + ] [ dup length ] if* head-slice >string ;\r
+\r
+: prolog-encoding ( string -- iana-encoding )\r
+ '[\r
+ _ "encoding=" over start\r
+ 10 + swap [ [ 1 - ] dip nth ] [ index-from ] [ swapd subseq ] 2tri\r
+ ] [ drop "UTF-8" ] recover ;\r
+\r
+: detect-xml-prolog ( bytes -- encoding )\r
+ prolog-tag prolog-encoding name>encoding [ ascii ] unless* ;\r
+\r
+: valid-utf8? ( bytes -- ? )\r
+ utf8 decode 1 head-slice* replacement-char swap member? not ;\r
+\r
+PRIVATE>\r
+\r
+: detect-byte-array ( bytes -- encoding )\r
+ {\r
+ { [ dup HEX{ 0000FEFF } head? ] [ drop utf32be ] }\r
+ { [ dup HEX{ FFFE0000 } head? ] [ drop utf32le ] }\r
+ { [ dup HEX{ FEFF } head? ] [ drop utf16be ] }\r
+ { [ dup HEX{ FFFE } head? ] [ drop utf16le ] }\r
+ { [ dup HEX{ EF BB BF } head? ] [ drop utf8 ] }\r
+ { [ dup $[ "<?xml" >byte-array ] head? ] [ detect-xml-prolog ] }\r
+ { [ 0 over member? ] [ drop binary ] }\r
+ { [ dup empty? ] [ drop utf8 ] }\r
+ { [ dup valid-utf8? ] [ drop utf8 ] }\r
+ [ drop default-8bit-encoding get ]\r
+ } cond ;\r
+\r
+: detect-stream ( stream -- sample encoding )\r
+ 256 swap stream-read dup detect-byte-array ;\r
+\r
+: detect-file ( file -- encoding )\r
+ binary [ input-stream get detect-stream nip ] with-file-reader ;\r
--- /dev/null
+Heuristic auto-detection of text encodings and binary files\r
return x;
}
+inline bool bitmap_p(u8 *bitmap, cell index)
+{
+ cell byte = index >> 3;
+ cell bit = index & 7;
+ return (bitmap[byte] & (1 << bit)) != 0;
+}
+
}
ctx->push(tag<byte_array>(reallot_array(array.untagged(),capacity)));
}
-void growable_byte_array::append_bytes(void *elts, cell len)
+void growable_byte_array::grow_bytes(cell len)
{
- cell new_size = count + len;
- factor_vm *parent = elements.parent;
- if(new_size >= array_capacity(elements.untagged()))
- elements = parent->reallot_array(elements.untagged(),new_size * 2);
-
- memcpy(&elements->data<u8>()[count],elts,len);
-
count += len;
+ if(count >= array_capacity(elements.untagged()))
+ elements = elements.parent->reallot_array(elements.untagged(),count * 2);
+}
+
+void growable_byte_array::append_bytes(void *elts, cell len)
+{
+ cell old_count = count;
+ grow_bytes(len);
+ memcpy(&elements->data<u8>()[old_count],elts,len);
}
void growable_byte_array::append_byte_array(cell byte_array_)
explicit growable_byte_array(factor_vm *parent,cell capacity = 40) : count(0), elements(parent->allot_byte_array(capacity),parent) { }
+ void grow_bytes(cell len);
void append_bytes(void *elts, cell len);
void append_byte_array(cell elts);
}
}
-namespace
+cell factor_vm::frame_offset(stack_frame *frame)
{
+ return (cell)FRAME_RETURN_ADDRESS(frame,this) - (cell)frame_code(frame)->entry_point();
+}
struct stack_frame_accumulator {
factor_vm *parent;
}
};
-}
-
void factor_vm::primitive_callstack_to_array()
{
data_root<callstack> callstack(ctx->pop(),this);
- visit_context_code_blocks()
- visit_callback_code_blocks() */
-template<typename Visitor> struct code_block_visitor {
+template<typename Fixup> struct code_block_visitor {
factor_vm *parent;
- Visitor visitor;
+ Fixup fixup;
- explicit code_block_visitor(factor_vm *parent_, Visitor visitor_) :
- parent(parent_), visitor(visitor_) {}
+ explicit code_block_visitor(factor_vm *parent_, Fixup fixup_) :
+ parent(parent_), fixup(fixup_) {}
code_block *visit_code_block(code_block *compiled);
void visit_object_code_block(object *obj);
void visit_uninitialized_code_blocks();
};
-template<typename Visitor>
-code_block *code_block_visitor<Visitor>::visit_code_block(code_block *compiled)
+template<typename Fixup>
+code_block *code_block_visitor<Fixup>::visit_code_block(code_block *compiled)
{
- return visitor(compiled);
+ return fixup.fixup_code(compiled);
}
-template<typename Visitor>
+template<typename Fixup>
struct call_frame_code_block_visitor {
factor_vm *parent;
- Visitor visitor;
+ Fixup fixup;
- explicit call_frame_code_block_visitor(factor_vm *parent_, Visitor visitor_) :
- parent(parent_), visitor(visitor_) {}
+ explicit call_frame_code_block_visitor(factor_vm *parent_, Fixup fixup_) :
+ parent(parent_), fixup(fixup_) {}
void operator()(stack_frame *frame)
{
- cell offset = (cell)FRAME_RETURN_ADDRESS(frame,parent) - (cell)frame->entry_point;
+ code_block *old_block = parent->frame_code(frame);
+ cell offset = (char *)FRAME_RETURN_ADDRESS(frame,parent) - (char *)old_block;
- code_block *new_block = visitor(parent->frame_code(frame));
+ const code_block *new_block = fixup.fixup_code(old_block);
frame->entry_point = new_block->entry_point();
- FRAME_RETURN_ADDRESS(frame,parent) = (void *)((cell)frame->entry_point + offset);
+ FRAME_RETURN_ADDRESS(frame,parent) = (char *)new_block + offset;
}
};
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_object_code_block(object *obj)
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_object_code_block(object *obj)
{
switch(obj->type())
{
{
word *w = (word *)obj;
if(w->code)
- w->code = visitor(w->code);
+ w->code = visit_code_block(w->code);
if(w->profiling)
- w->profiling = visitor(w->profiling);
+ w->profiling = visit_code_block(w->profiling);
parent->update_word_entry_point(w);
break;
{
quotation *q = (quotation *)obj;
if(q->code)
- parent->set_quot_entry_point(q,visitor(q->code));
+ parent->set_quot_entry_point(q,visit_code_block(q->code));
break;
}
case CALLSTACK_TYPE:
{
callstack *stack = (callstack *)obj;
- call_frame_code_block_visitor<Visitor> call_frame_visitor(parent,visitor);
+ call_frame_code_block_visitor<Fixup> call_frame_visitor(parent,fixup);
parent->iterate_callstack_object(stack,call_frame_visitor);
break;
}
}
}
-template<typename Visitor>
+template<typename Fixup>
struct embedded_code_pointers_visitor {
- Visitor visitor;
+ Fixup fixup;
- explicit embedded_code_pointers_visitor(Visitor visitor_) : visitor(visitor_) {}
+ explicit embedded_code_pointers_visitor(Fixup fixup_) : fixup(fixup_) {}
void operator()(instruction_operand op)
{
if(type == RT_ENTRY_POINT
|| type == RT_ENTRY_POINT_PIC
|| type == RT_ENTRY_POINT_PIC_TAIL)
- op.store_code_block(visitor(op.load_code_block()));
+ op.store_code_block(fixup.fixup_code(op.load_code_block()));
}
};
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_embedded_code_pointers(code_block *compiled)
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_embedded_code_pointers(code_block *compiled)
{
if(!parent->code->uninitialized_p(compiled))
{
- embedded_code_pointers_visitor<Visitor> visitor(this->visitor);
- compiled->each_instruction_operand(visitor);
+ embedded_code_pointers_visitor<Fixup> operand_visitor(fixup);
+ compiled->each_instruction_operand(operand_visitor);
}
}
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_context_code_blocks()
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_context_code_blocks()
{
- call_frame_code_block_visitor<Visitor> call_frame_visitor(parent,visitor);
+ call_frame_code_block_visitor<Fixup> call_frame_visitor(parent,fixup);
parent->iterate_active_callstacks(call_frame_visitor);
}
-template<typename Visitor>
-void code_block_visitor<Visitor>::visit_uninitialized_code_blocks()
+template<typename Fixup>
+void code_block_visitor<Fixup>::visit_uninitialized_code_blocks()
{
std::map<code_block *, cell> *uninitialized_blocks = &parent->code->uninitialized_blocks;
std::map<code_block *, cell>::const_iterator iter = uninitialized_blocks->begin();
for(; iter != end; iter++)
{
new_uninitialized_blocks.insert(std::make_pair(
- visitor(iter->first),
+ fixup.fixup_code(iter->first),
iter->second));
}
return size;
}
+ template<typename Fixup> cell size(Fixup fixup) const
+ {
+ return size();
+ }
+
void *entry_point() const
{
return (void *)(this + 1);
}
+ /* GC info is stored at the end of the block */
+ gc_info *block_gc_info() const
+ {
+ return (gc_info *)((u8 *)this + size() - sizeof(gc_info));
+ }
+
void flush_icache()
{
factor::flush_icache((cell)this,size());
struct must_start_gc_again {};
-template<typename TargetGeneration, typename Policy> struct data_workhorse {
+template<typename TargetGeneration, typename Policy> struct gc_workhorse : no_fixup {
factor_vm *parent;
TargetGeneration *target;
Policy policy;
+ code_heap *code;
- explicit data_workhorse(factor_vm *parent_, TargetGeneration *target_, Policy policy_) :
+ explicit gc_workhorse(factor_vm *parent_, TargetGeneration *target_, Policy policy_) :
parent(parent_),
target(target_),
- policy(policy_) {}
+ policy(policy_),
+ code(parent->code) {}
object *resolve_forwarding(object *untagged)
{
return newpointer;
}
- object *operator()(object *obj)
+ object *fixup_data(object *obj)
{
if(!policy.should_copy_p(obj))
{
return forwarding;
}
}
-};
-template<typename TargetGeneration, typename Policy>
-inline static slot_visitor<data_workhorse<TargetGeneration,Policy> > make_data_visitor(
- factor_vm *parent,
- TargetGeneration *target,
- Policy policy)
-{
- return slot_visitor<data_workhorse<TargetGeneration,Policy> >(parent,
- data_workhorse<TargetGeneration,Policy>(parent,target,policy));
-}
+ code_block *fixup_code(code_block *compiled)
+ {
+ if(!code->marked_p(compiled))
+ {
+ code->set_marked_p(compiled);
+ parent->mark_stack.push_back((cell)compiled + 1);
+ }
+
+ return compiled;
+ }
+};
struct dummy_unmarker {
void operator()(card *ptr) {}
data_heap *data;
code_heap *code;
TargetGeneration *target;
- slot_visitor<data_workhorse<TargetGeneration,Policy> > data_visitor;
+ gc_workhorse<TargetGeneration,Policy> workhorse;
+ slot_visitor<gc_workhorse<TargetGeneration,Policy> > data_visitor;
cell cards_scanned;
cell decks_scanned;
cell code_blocks_scanned;
data(parent_->data),
code(parent_->code),
target(target_),
- data_visitor(make_data_visitor(parent_,target_,policy_)),
+ workhorse(parent,target,policy_),
+ data_visitor(parent,workhorse),
cards_scanned(0),
decks_scanned(0),
code_blocks_scanned(0) {}
namespace factor {
-template<typename Block> struct forwarder {
- mark_bits<Block> *forwarding_map;
+struct compaction_fixup {
+ mark_bits<object> *data_forwarding_map;
+ mark_bits<code_block> *code_forwarding_map;
+ const object **data_finger;
+ const code_block **code_finger;
- explicit forwarder(mark_bits<Block> *forwarding_map_) :
- forwarding_map(forwarding_map_) {}
+ explicit compaction_fixup(
+ mark_bits<object> *data_forwarding_map_,
+ mark_bits<code_block> *code_forwarding_map_,
+ const object **data_finger_,
+ const code_block **code_finger_) :
+ data_forwarding_map(data_forwarding_map_),
+ code_forwarding_map(code_forwarding_map_),
+ data_finger(data_finger_),
+ code_finger(code_finger_) {}
- Block *operator()(Block *block)
+ object *fixup_data(object *obj)
{
- return forwarding_map->forward_block(block);
+ return data_forwarding_map->forward_block(obj);
}
-};
-
-static inline cell tuple_size_with_forwarding(mark_bits<object> *forwarding_map, object *obj)
-{
- /* The tuple layout may or may not have been forwarded already. Tricky. */
- object *layout_obj = (object *)UNTAG(((tuple *)obj)->layout);
- tuple_layout *layout;
- if(layout_obj < obj)
+ code_block *fixup_code(code_block *compiled)
{
- /* It's already been moved up; dereference through forwarding
- map to get the size */
- layout = (tuple_layout *)forwarding_map->forward_block(layout_obj);
+ return code_forwarding_map->forward_block(compiled);
}
- else
+
+ object *translate_data(const object *obj)
{
- /* It hasn't been moved up yet; dereference directly */
- layout = (tuple_layout *)layout_obj;
+ if(obj < *data_finger)
+ return fixup_data((object *)obj);
+ else
+ return (object *)obj;
}
- return tuple_size(layout);
-}
-
-struct compaction_sizer {
- mark_bits<object> *forwarding_map;
+ code_block *translate_code(const code_block *compiled)
+ {
+ if(compiled < *code_finger)
+ return fixup_code((code_block *)compiled);
+ else
+ return (code_block *)compiled;
+ }
- explicit compaction_sizer(mark_bits<object> *forwarding_map_) :
- forwarding_map(forwarding_map_) {}
+ cell size(object *obj)
+ {
+ if(data_forwarding_map->marked_p(obj))
+ return obj->size(*this);
+ else
+ return data_forwarding_map->unmarked_block_size(obj);
+ }
- cell operator()(object *obj)
+ cell size(code_block *compiled)
{
- if(!forwarding_map->marked_p(obj))
- return forwarding_map->unmarked_block_size(obj);
- else if(obj->type() == TUPLE_TYPE)
- return align(tuple_size_with_forwarding(forwarding_map,obj),data_alignment);
+ if(code_forwarding_map->marked_p(compiled))
+ return compiled->size(*this);
else
- return obj->size();
+ return code_forwarding_map->unmarked_block_size(compiled);
}
};
struct object_compaction_updater {
factor_vm *parent;
- mark_bits<code_block> *code_forwarding_map;
- mark_bits<object> *data_forwarding_map;
+ compaction_fixup fixup;
object_start_map *starts;
- explicit object_compaction_updater(factor_vm *parent_,
- mark_bits<object> *data_forwarding_map_,
- mark_bits<code_block> *code_forwarding_map_) :
+ explicit object_compaction_updater(factor_vm *parent_, compaction_fixup fixup_) :
parent(parent_),
- code_forwarding_map(code_forwarding_map_),
- data_forwarding_map(data_forwarding_map_),
+ fixup(fixup_),
starts(&parent->data->tenured->starts) {}
void operator()(object *old_address, object *new_address, cell size)
{
- cell payload_start;
- if(old_address->type() == TUPLE_TYPE)
- payload_start = tuple_size_with_forwarding(data_forwarding_map,old_address);
- else
- payload_start = old_address->binary_payload_start();
-
- memmove(new_address,old_address,size);
+ slot_visitor<compaction_fixup> slot_forwarder(parent,fixup);
+ slot_forwarder.visit_slots(new_address);
- slot_visitor<forwarder<object> > slot_forwarder(parent,forwarder<object>(data_forwarding_map));
- slot_forwarder.visit_slots(new_address,payload_start);
-
- code_block_visitor<forwarder<code_block> > code_forwarder(parent,forwarder<code_block>(code_forwarding_map));
+ code_block_visitor<compaction_fixup> code_forwarder(parent,fixup);
code_forwarder.visit_object_code_block(new_address);
starts->record_object_start_offset(new_address);
}
};
-template<typename SlotForwarder>
+template<typename Fixup>
struct code_block_compaction_relocation_visitor {
factor_vm *parent;
code_block *old_address;
- slot_visitor<SlotForwarder> slot_forwarder;
- code_block_visitor<forwarder<code_block> > code_forwarder;
+ Fixup fixup;
explicit code_block_compaction_relocation_visitor(factor_vm *parent_,
code_block *old_address_,
- slot_visitor<SlotForwarder> slot_forwarder_,
- code_block_visitor<forwarder<code_block> > code_forwarder_) :
+ Fixup fixup_) :
parent(parent_),
old_address(old_address_),
- slot_forwarder(slot_forwarder_),
- code_forwarder(code_forwarder_) {}
+ fixup(fixup_) {}
void operator()(instruction_operand op)
{
switch(op.rel_type())
{
case RT_LITERAL:
- op.store_value(slot_forwarder.visit_pointer(op.load_value(old_offset)));
- break;
+ {
+ cell value = op.load_value(old_offset);
+ if(immediate_p(value))
+ op.store_value(value);
+ else
+ op.store_value(RETAG(fixup.fixup_data(untag<object>(value)),TAG(value)));
+ break;
+ }
case RT_ENTRY_POINT:
case RT_ENTRY_POINT_PIC:
case RT_ENTRY_POINT_PIC_TAIL:
- op.store_code_block(code_forwarder.visit_code_block(op.load_code_block(old_offset)));
- break;
case RT_HERE:
- op.store_value(op.load_value(old_offset) - (cell)old_address + (cell)op.parent_code_block());
- break;
+ {
+ cell value = op.load_value(old_offset);
+ cell offset = TAG(value);
+ code_block *compiled = (code_block *)UNTAG(value);
+ op.store_value((cell)fixup.fixup_code(compiled) + offset);
+ break;
+ }
case RT_THIS:
case RT_CARDS_OFFSET:
case RT_DECKS_OFFSET:
}
};
-template<typename SlotForwarder>
+template<typename Fixup>
struct code_block_compaction_updater {
factor_vm *parent;
- slot_visitor<SlotForwarder> slot_forwarder;
- code_block_visitor<forwarder<code_block> > code_forwarder;
+ Fixup fixup;
+ slot_visitor<Fixup> data_forwarder;
+ code_block_visitor<Fixup> code_forwarder;
explicit code_block_compaction_updater(factor_vm *parent_,
- slot_visitor<SlotForwarder> slot_forwarder_,
- code_block_visitor<forwarder<code_block> > code_forwarder_) :
+ Fixup fixup_,
+ slot_visitor<Fixup> data_forwarder_,
+ code_block_visitor<Fixup> code_forwarder_) :
parent(parent_),
- slot_forwarder(slot_forwarder_),
+ fixup(fixup_),
+ data_forwarder(data_forwarder_),
code_forwarder(code_forwarder_) {}
void operator()(code_block *old_address, code_block *new_address, cell size)
{
- memmove(new_address,old_address,size);
+ data_forwarder.visit_code_block_objects(new_address);
- slot_forwarder.visit_code_block_objects(new_address);
-
- code_block_compaction_relocation_visitor<SlotForwarder> visitor(parent,old_address,slot_forwarder,code_forwarder);
+ code_block_compaction_relocation_visitor<Fixup> visitor(parent,old_address,fixup);
new_address->each_instruction_operand(visitor);
}
};
data_forwarding_map->compute_forwarding();
code_forwarding_map->compute_forwarding();
- slot_visitor<forwarder<object> > slot_forwarder(this,forwarder<object>(data_forwarding_map));
- code_block_visitor<forwarder<code_block> > code_forwarder(this,forwarder<code_block>(code_forwarding_map));
+ const object *data_finger = tenured->first_block();
+ const code_block *code_finger = code->allocator->first_block();
+
+ compaction_fixup fixup(data_forwarding_map,code_forwarding_map,&data_finger,&code_finger);
+ slot_visitor<compaction_fixup> data_forwarder(this,fixup);
+ code_block_visitor<compaction_fixup> code_forwarder(this,fixup);
code_forwarder.visit_uninitialized_code_blocks();
/* Slide everything in tenured space up, and update data and code heap
pointers inside objects. */
- object_compaction_updater object_updater(this,data_forwarding_map,code_forwarding_map);
- compaction_sizer object_sizer(data_forwarding_map);
- tenured->compact(object_updater,object_sizer);
+ object_compaction_updater object_updater(this,fixup);
+ tenured->compact(object_updater,fixup,&data_finger);
/* Slide everything in the code heap up, and update data and code heap
pointers inside code blocks. */
- code_block_compaction_updater<forwarder<object> > code_block_updater(this,slot_forwarder,code_forwarder);
- standard_sizer<code_block> code_block_sizer;
- code->allocator->compact(code_block_updater,code_block_sizer);
+ code_block_compaction_updater<compaction_fixup> code_block_updater(this,fixup,data_forwarder,code_forwarder);
+ code->allocator->compact(code_block_updater,fixup,&code_finger);
- slot_forwarder.visit_roots();
+ data_forwarder.visit_roots();
if(trace_contexts_p)
{
- slot_forwarder.visit_contexts();
+ data_forwarder.visit_contexts();
code_forwarder.visit_context_code_blocks();
}
current_gc->event->ended_compaction();
}
+struct code_compaction_fixup {
+ mark_bits<code_block> *code_forwarding_map;
+ const code_block **code_finger;
+
+ explicit code_compaction_fixup(mark_bits<code_block> *code_forwarding_map_,
+ const code_block **code_finger_) :
+ code_forwarding_map(code_forwarding_map_),
+ code_finger(code_finger_) {}
+
+ object *fixup_data(object *obj)
+ {
+ return obj;
+ }
+
+ code_block *fixup_code(code_block *compiled)
+ {
+ return code_forwarding_map->forward_block(compiled);
+ }
+
+ object *translate_data(const object *obj)
+ {
+ return fixup_data((object *)obj);
+ }
+
+ code_block *translate_code(const code_block *compiled)
+ {
+ if(compiled >= *code_finger)
+ return fixup_code((code_block *)compiled);
+ else
+ return (code_block *)compiled;
+ }
+
+ cell size(object *obj)
+ {
+ return obj->size();
+ }
+
+ cell size(code_block *compiled)
+ {
+ if(code_forwarding_map->marked_p(compiled))
+ return compiled->size(*this);
+ else
+ return code_forwarding_map->unmarked_block_size(compiled);
+ }
+};
+
struct object_grow_heap_updater {
- code_block_visitor<forwarder<code_block> > code_forwarder;
+ code_block_visitor<code_compaction_fixup> code_forwarder;
- explicit object_grow_heap_updater(code_block_visitor<forwarder<code_block> > code_forwarder_) :
+ explicit object_grow_heap_updater(code_block_visitor<code_compaction_fixup> code_forwarder_) :
code_forwarder(code_forwarder_) {}
void operator()(object *obj)
}
};
-struct dummy_slot_forwarder {
- object *operator()(object *obj) { return obj; }
-};
-
/* Compact just the code heap, after growing the data heap */
void factor_vm::collect_compact_code_impl(bool trace_contexts_p)
{
mark_bits<code_block> *code_forwarding_map = &code->allocator->state;
code_forwarding_map->compute_forwarding();
- slot_visitor<dummy_slot_forwarder> slot_forwarder(this,dummy_slot_forwarder());
- code_block_visitor<forwarder<code_block> > code_forwarder(this,forwarder<code_block>(code_forwarding_map));
+ const code_block *code_finger = code->allocator->first_block();
+
+ code_compaction_fixup fixup(code_forwarding_map,&code_finger);
+ slot_visitor<code_compaction_fixup> data_forwarder(this,fixup);
+ code_block_visitor<code_compaction_fixup> code_forwarder(this,fixup);
code_forwarder.visit_uninitialized_code_blocks();
code_forwarder.visit_context_code_blocks();
/* Update code heap references in data heap */
- object_grow_heap_updater updater(code_forwarder);
- each_object(updater);
+ object_grow_heap_updater object_updater(code_forwarder);
+ each_object(object_updater);
/* Slide everything in the code heap up, and update code heap
pointers inside code blocks. */
- code_block_compaction_updater<dummy_slot_forwarder> code_block_updater(this,slot_forwarder,code_forwarder);
- standard_sizer<code_block> code_block_sizer;
- code->allocator->compact(code_block_updater,code_block_sizer);
+ code_block_compaction_updater<code_compaction_fixup> code_block_updater(this,fixup,data_forwarder,code_forwarder);
+ code->allocator->compact(code_block_updater,fixup,&code_finger);
update_code_roots_for_compaction();
callbacks->update();
reset_retainstack();
}
+void context::scrub_stacks(gc_info *info, cell index)
+{
+ u8 *bitmap = info->gc_info_bitmap();
+
+ {
+ cell base = info->scrub_d_base(index);
+
+ for(cell loc = 0; loc < info->scrub_d_count; loc++)
+ {
+ if(bitmap_p(bitmap,base + loc))
+ ((cell *)datastack)[-loc] = 0;
+ }
+ }
+
+ {
+ cell base = info->scrub_r_base(index);
+
+ for(cell loc = 0; loc < info->scrub_r_count; loc++)
+ {
+ if(bitmap_p(bitmap,base + loc))
+ ((cell *)retainstack)[-loc] = 0;
+ }
+ }
+}
+
context::~context()
{
delete datastack_seg;
void reset_context_objects();
void reset();
void fix_stacks();
+ void scrub_stacks(gc_info *info, cell index);
cell peek()
{
set_data_heap(new data_heap(young_size,aging_size,tenured_size));
}
-/* Size of the object pointed to by an untagged pointer */
-cell object::size() const
-{
- if(free_p()) return ((free_heap_block *)this)->size();
-
- switch(type())
- {
- case ARRAY_TYPE:
- return align(array_size((array*)this),data_alignment);
- case BIGNUM_TYPE:
- return align(array_size((bignum*)this),data_alignment);
- case BYTE_ARRAY_TYPE:
- return align(array_size((byte_array*)this),data_alignment);
- case STRING_TYPE:
- return align(string_size(string_capacity((string*)this)),data_alignment);
- case TUPLE_TYPE:
- {
- tuple_layout *layout = (tuple_layout *)UNTAG(((tuple *)this)->layout);
- return align(tuple_size(layout),data_alignment);
- }
- case QUOTATION_TYPE:
- return align(sizeof(quotation),data_alignment);
- case WORD_TYPE:
- return align(sizeof(word),data_alignment);
- case FLOAT_TYPE:
- return align(sizeof(boxed_float),data_alignment);
- case DLL_TYPE:
- return align(sizeof(dll),data_alignment);
- case ALIEN_TYPE:
- return align(sizeof(alien),data_alignment);
- case WRAPPER_TYPE:
- return align(sizeof(wrapper),data_alignment);
- case CALLSTACK_TYPE:
- return align(callstack_object_size(untag_fixnum(((callstack *)this)->length)),data_alignment);
- default:
- critical_error("Invalid header",(cell)this);
- return 0; /* can't happen */
- }
-}
-
-/* The number of cells from the start of the object which should be scanned by
-the GC. Some types have a binary payload at the end (string, word, DLL) which
-we ignore. */
-cell object::binary_payload_start() const
-{
- if(free_p()) return 0;
-
- switch(type())
- {
- /* these objects do not refer to other objects at all */
- case FLOAT_TYPE:
- case BYTE_ARRAY_TYPE:
- case BIGNUM_TYPE:
- case CALLSTACK_TYPE:
- return 0;
- /* these objects have some binary data at the end */
- case WORD_TYPE:
- return sizeof(word) - sizeof(cell) * 3;
- case ALIEN_TYPE:
- return sizeof(cell) * 3;
- case DLL_TYPE:
- return sizeof(cell) * 2;
- case QUOTATION_TYPE:
- return sizeof(quotation) - sizeof(cell) * 2;
- case STRING_TYPE:
- return sizeof(string);
- /* everything else consists entirely of pointers */
- case ARRAY_TYPE:
- return array_size<array>(array_capacity((array*)this));
- case TUPLE_TYPE:
- return tuple_size(untag<tuple_layout>(((tuple *)this)->layout));
- case WRAPPER_TYPE:
- return sizeof(wrapper);
- default:
- critical_error("Invalid header",(cell)this);
- return 0; /* can't happen */
- }
-}
-
data_heap_room factor_vm::data_room()
{
data_heap_room room;
--- /dev/null
+namespace factor
+{
+
+template<typename T>
+struct identity {
+ T operator()(T t)
+ {
+ return t;
+ }
+};
+
+struct no_fixup {
+ object *fixup_data(object *obj)
+ {
+ return obj;
+ }
+
+ code_block *fixup_code(code_block *compiled)
+ {
+ return compiled;
+ }
+
+ object *translate_data(const object *obj)
+ {
+ return fixup_data((object *)obj);
+ }
+
+ code_block *translate_code(const code_block *compiled)
+ {
+ return fixup_code((code_block *)compiled);
+ }
+
+ cell size(object *obj)
+ {
+ return obj->size();
+ }
+
+ cell size(code_block *compiled)
+ {
+ return compiled->size();
+ }
+};
+
+}
cell largest_free_block();
cell free_block_count();
void sweep();
- template<typename Iterator, typename Sizer> void compact(Iterator &iter, Sizer &sizer);
- template<typename Iterator, typename Sizer> void iterate(Iterator &iter, Sizer &sizer);
+ template<typename Iterator, typename Fixup> void compact(Iterator &iter, Fixup fixup, const Block **finger);
+ template<typename Iterator, typename Fixup> void iterate(Iterator &iter, Fixup fixup);
template<typename Iterator> void iterate(Iterator &iter);
};
mark_bits<Block> *state;
char *address;
Iterator &iter;
+ const Block **finger;
- explicit heap_compactor(mark_bits<Block> *state_, Block *address_, Iterator &iter_) :
- state(state_), address((char *)address_), iter(iter_) {}
+ explicit heap_compactor(mark_bits<Block> *state_, Block *address_, Iterator &iter_, const Block **finger_) :
+ state(state_), address((char *)address_), iter(iter_), finger(finger_) {}
void operator()(Block *block, cell size)
{
if(this->state->marked_p(block))
{
+ *finger = block;
+ memmove((Block *)address,block,size);
iter(block,(Block *)address,size);
address += size;
}
/* The forwarding map must be computed first by calling
state.compute_forwarding(). */
template<typename Block>
-template<typename Iterator, typename Sizer>
-void free_list_allocator<Block>::compact(Iterator &iter, Sizer &sizer)
+template<typename Iterator, typename Fixup>
+void free_list_allocator<Block>::compact(Iterator &iter, Fixup fixup, const Block **finger)
{
- heap_compactor<Block,Iterator> compactor(&state,first_block(),iter);
- iterate(compactor,sizer);
+ heap_compactor<Block,Iterator> compactor(&state,first_block(),iter,finger);
+ iterate(compactor,fixup);
/* Now update the free list; there will be a single free block at
the end */
/* During compaction we have to be careful and measure object sizes differently */
template<typename Block>
-template<typename Iterator, typename Sizer>
-void free_list_allocator<Block>::iterate(Iterator &iter, Sizer &sizer)
+template<typename Iterator, typename Fixup>
+void free_list_allocator<Block>::iterate(Iterator &iter, Fixup fixup)
{
Block *scan = first_block();
Block *end = last_block();
while(scan != end)
{
- cell size = sizer(scan);
+ cell size = fixup.size(scan);
Block *next = (Block *)((cell)scan + size);
if(!scan->free_p()) iter(scan,size);
scan = next;
}
}
-template<typename Block> struct standard_sizer {
- cell operator()(Block *block)
- {
- return block->size();
- }
-};
-
template<typename Block>
template<typename Iterator>
void free_list_allocator<Block>::iterate(Iterator &iter)
{
- standard_sizer<Block> sizer;
- iterate(iter,sizer);
+ iterate(iter,no_fixup());
}
}
namespace factor
{
-inline static code_block_visitor<code_workhorse> make_code_visitor(factor_vm *parent)
-{
- return code_block_visitor<code_workhorse>(parent,code_workhorse(parent));
-}
-
full_collector::full_collector(factor_vm *parent_) :
- collector<tenured_space,full_policy>(
- parent_,
- parent_->data->tenured,
- full_policy(parent_)),
- code_visitor(make_code_visitor(parent_)) {}
+ collector<tenured_space,full_policy>(parent_,parent_->data->tenured,full_policy(parent_)),
+ code_visitor(parent,workhorse) {}
void full_collector::trace_code_block(code_block *compiled)
{
}
};
-struct code_workhorse {
- factor_vm *parent;
- code_heap *code;
-
- explicit code_workhorse(factor_vm *parent_) : parent(parent_), code(parent->code) {}
-
- code_block *operator()(code_block *compiled)
- {
- if(!code->marked_p(compiled))
- {
- code->set_marked_p(compiled);
- parent->mark_stack.push_back((cell)compiled + 1);
- }
-
- return compiled;
- }
-};
-
struct full_collector : collector<tenured_space,full_policy> {
- code_block_visitor<code_workhorse> code_visitor;
+ code_block_visitor<gc_workhorse<tenured_space,full_policy> > code_visitor;
explicit full_collector(factor_vm *parent_);
void trace_code_block(code_block *compiled);
current_gc = NULL;
}
+/* primitive_minor_gc() is invoked by inline GC checks, and it needs to fill in
+uninitialized stack locations before actually calling the GC. See the comment
+in compiler.cfg.stacks.uninitialized for details. */
+
+struct call_frame_scrubber {
+ factor_vm *parent;
+ context *ctx;
+
+ explicit call_frame_scrubber(factor_vm *parent_, context *ctx_) :
+ parent(parent_), ctx(ctx_) {}
+
+ void operator()(stack_frame *frame)
+ {
+ const code_block *compiled = parent->frame_code(frame);
+ gc_info *info = compiled->block_gc_info();
+
+ cell return_address = parent->frame_offset(frame);
+ assert(return_address < compiled->size());
+ int index = info->return_address_index(return_address);
+
+ if(index != -1)
+ ctx->scrub_stacks(info,index);
+ }
+};
+
+void factor_vm::scrub_context(context *ctx)
+{
+ call_frame_scrubber scrubber(this,ctx);
+ iterate_callstack(ctx,scrubber);
+}
+
+void factor_vm::scrub_contexts()
+{
+ std::set<context *>::const_iterator begin = active_contexts.begin();
+ std::set<context *>::const_iterator end = active_contexts.end();
+ while(begin != end)
+ {
+ scrub_context(*begin);
+ begin++;
+ }
+}
+
void factor_vm::primitive_minor_gc()
{
+ scrub_contexts();
+
gc(collect_nursery_op,
0, /* requested size */
true /* trace contexts? */);
true /* trace contexts? */);
}
-void factor_vm::inline_gc(cell gc_roots_)
-{
- cell stack_pointer = (cell)ctx->callstack_top;
-
- if(to_boolean(gc_roots_))
- {
- tagged<array> gc_roots(gc_roots_);
-
- cell capacity = array_capacity(gc_roots.untagged());
- for(cell i = 0; i < capacity; i++)
- {
- cell spill_slot = untag_fixnum(array_nth(gc_roots.untagged(),i));
- cell *address = (cell *)(spill_slot + stack_pointer);
- data_roots.push_back(data_root_range(address,1));
- }
-
- primitive_minor_gc();
-
- for(cell i = 0; i < capacity; i++)
- data_roots.pop_back();
- }
- else
- primitive_minor_gc();
-}
-
-VM_C_API void inline_gc(cell gc_roots, factor_vm *parent)
-{
- parent->inline_gc(gc_roots);
-}
-
/*
* It is up to the caller to fill in the object's fields in a meaningful
* fashion!
void start_again(gc_op op_, factor_vm *parent);
};
-VM_C_API void inline_gc(cell gc_roots, factor_vm *parent);
-
}
--- /dev/null
+#include "master.hpp"
+
+namespace factor
+{
+
+int gc_info::return_address_index(cell return_address)
+{
+ u32 *return_address_array = return_addresses();
+
+ for(cell i = 0; i < return_address_count; i++)
+ {
+ if(return_address == return_address_array[i])
+ return i;
+ }
+
+ return -1;
+}
+
+}
--- /dev/null
+namespace factor
+{
+
+struct gc_info {
+ u32 scrub_d_count;
+ u32 scrub_r_count;
+ u32 gc_root_count;
+ u32 return_address_count;
+
+ cell total_bitmap_size()
+ {
+ return return_address_count * (scrub_d_count + scrub_r_count + gc_root_count);
+ }
+
+ cell total_bitmap_bytes()
+ {
+ return ((total_bitmap_size() + 7) / 8);
+ }
+
+ u32 *return_addresses()
+ {
+ return (u32 *)((u8 *)this - return_address_count * sizeof(u32));
+ }
+
+ u8 *gc_info_bitmap()
+ {
+ return (u8 *)return_addresses() - total_bitmap_bytes();
+ }
+
+ cell scrub_d_base(cell index)
+ {
+ return index * scrub_d_count;
+ }
+
+ cell scrub_r_base(cell index)
+ {
+ return return_address_count * scrub_d_count +
+ index * scrub_r_count;
+ }
+
+ cell spill_slot_base(cell index)
+ {
+ return return_address_count * scrub_d_count
+ + return_address_count * scrub_r_count
+ + index * gc_root_count;
+ }
+
+ int return_address_index(cell return_address);
+};
+
+}
code->allocator->initial_free_list(h->code_size);
}
-struct data_fixupper {
- cell offset;
+struct startup_fixup {
+ cell data_offset;
+ cell code_offset;
- explicit data_fixupper(cell offset_) : offset(offset_) {}
+ explicit startup_fixup(cell data_offset_, cell code_offset_) :
+ data_offset(data_offset_), code_offset(code_offset_) {}
- object *operator()(object *obj)
+ object *fixup_data(object *obj)
{
- return (object *)((char *)obj + offset);
+ return (object *)((cell)obj + data_offset);
}
-};
-
-struct code_fixupper {
- cell offset;
-
- explicit code_fixupper(cell offset_) : offset(offset_) {}
- code_block *operator()(code_block *compiled)
+ code_block *fixup_code(code_block *obj)
{
- return (code_block *)((char *)compiled + offset);
+ return (code_block *)((cell)obj + code_offset);
}
-};
-static inline cell tuple_size_with_fixup(cell offset, object *obj)
-{
- tuple_layout *layout = (tuple_layout *)((char *)UNTAG(((tuple *)obj)->layout) + offset);
- return tuple_size(layout);
-}
+ object *translate_data(const object *obj)
+ {
+ return fixup_data((object *)obj);
+ }
-struct fixup_sizer {
- cell offset;
+ code_block *translate_code(const code_block *compiled)
+ {
+ return fixup_code((code_block *)compiled);
+ }
- explicit fixup_sizer(cell offset_) : offset(offset_) {}
+ cell size(const object *obj)
+ {
+ return obj->size(*this);
+ }
- cell operator()(object *obj)
+ cell size(code_block *compiled)
{
- if(obj->type() == TUPLE_TYPE)
- return align(tuple_size_with_fixup(offset,obj),data_alignment);
- else
- return obj->size();
+ return compiled->size(*this);
}
};
-struct object_fixupper {
+struct start_object_updater {
factor_vm *parent;
- cell data_offset;
- slot_visitor<data_fixupper> data_visitor;
- code_block_visitor<code_fixupper> code_visitor;
+ startup_fixup fixup;
+ slot_visitor<startup_fixup> data_visitor;
+ code_block_visitor<startup_fixup> code_visitor;
- object_fixupper(factor_vm *parent_, cell data_offset_, cell code_offset_) :
+ start_object_updater(factor_vm *parent_, startup_fixup fixup_) :
parent(parent_),
- data_offset(data_offset_),
- data_visitor(slot_visitor<data_fixupper>(parent_,data_fixupper(data_offset_))),
- code_visitor(code_block_visitor<code_fixupper>(parent_,code_fixupper(code_offset_))) {}
+ fixup(fixup_),
+ data_visitor(slot_visitor<startup_fixup>(parent_,fixup_)),
+ code_visitor(code_block_visitor<startup_fixup>(parent_,fixup_)) {}
void operator()(object *obj, cell size)
{
parent->data->tenured->starts.record_object_start_offset(obj);
+ data_visitor.visit_slots(obj);
+
switch(obj->type())
{
case ALIEN_TYPE:
{
- cell payload_start = obj->binary_payload_start();
- data_visitor.visit_slots(obj,payload_start);
alien *ptr = (alien *)obj;
}
case DLL_TYPE:
{
- cell payload_start = obj->binary_payload_start();
- data_visitor.visit_slots(obj,payload_start);
-
parent->ffi_dlopen((dll *)obj);
break;
}
- case TUPLE_TYPE:
- {
- cell payload_start = tuple_size_with_fixup(data_offset,obj);
- data_visitor.visit_slots(obj,payload_start);
- break;
- }
default:
{
- cell payload_start = obj->binary_payload_start();
- data_visitor.visit_slots(obj,payload_start);
code_visitor.visit_object_code_block(obj);
break;
}
void factor_vm::fixup_data(cell data_offset, cell code_offset)
{
- slot_visitor<data_fixupper> data_workhorse(this,data_fixupper(data_offset));
+ startup_fixup fixup(data_offset,code_offset);
+ slot_visitor<startup_fixup> data_workhorse(this,fixup);
data_workhorse.visit_roots();
- object_fixupper fixupper(this,data_offset,code_offset);
- fixup_sizer sizer(data_offset);
- data->tenured->iterate(fixupper,sizer);
+ start_object_updater updater(this,fixup);
+ data->tenured->iterate(updater,fixup);
}
-struct code_block_fixup_relocation_visitor {
+struct startup_code_block_relocation_visitor {
factor_vm *parent;
- cell code_offset;
- slot_visitor<data_fixupper> data_visitor;
- code_fixupper code_visitor;
+ startup_fixup fixup;
+ slot_visitor<startup_fixup> data_visitor;
- code_block_fixup_relocation_visitor(factor_vm *parent_, cell data_offset_, cell code_offset_) :
+ startup_code_block_relocation_visitor(factor_vm *parent_, startup_fixup fixup_) :
parent(parent_),
- code_offset(code_offset_),
- data_visitor(slot_visitor<data_fixupper>(parent_,data_fixupper(data_offset_))),
- code_visitor(code_fixupper(code_offset_)) {}
+ fixup(fixup_),
+ data_visitor(slot_visitor<startup_fixup>(parent_,fixup_)) {}
void operator()(instruction_operand op)
{
code_block *compiled = op.parent_code_block();
- cell old_offset = op.rel_offset() + (cell)compiled->entry_point() - code_offset;
+ cell old_offset = op.rel_offset() + (cell)compiled->entry_point() - fixup.code_offset;
switch(op.rel_type())
{
case RT_LITERAL:
- op.store_value(data_visitor.visit_pointer(op.load_value(old_offset)));
- break;
+ {
+ cell value = op.load_value(old_offset);
+ if(immediate_p(value))
+ op.store_value(value);
+ else
+ op.store_value(RETAG(fixup.fixup_data(untag<object>(value)),TAG(value)));
+ break;
+ }
case RT_ENTRY_POINT:
case RT_ENTRY_POINT_PIC:
case RT_ENTRY_POINT_PIC_TAIL:
- op.store_code_block(code_visitor(op.load_code_block(old_offset)));
- break;
case RT_HERE:
- op.store_value(op.load_value(old_offset) + code_offset);
- break;
+ {
+ cell value = op.load_value(old_offset);
+ cell offset = TAG(value);
+ code_block *compiled = (code_block *)UNTAG(value);
+ op.store_value((cell)fixup.fixup_code(compiled) + offset);
+ break;
+ }
case RT_UNTAGGED:
break;
default:
}
};
-struct code_block_fixupper {
+struct startup_code_block_updater {
factor_vm *parent;
- cell data_offset;
- cell code_offset;
+ startup_fixup fixup;
- code_block_fixupper(factor_vm *parent_, cell data_offset_, cell code_offset_) :
- parent(parent_),
- data_offset(data_offset_),
- code_offset(code_offset_) {}
+ startup_code_block_updater(factor_vm *parent_, startup_fixup fixup_) :
+ parent(parent_), fixup(fixup_) {}
void operator()(code_block *compiled, cell size)
{
- slot_visitor<data_fixupper> data_visitor(parent,data_fixupper(data_offset));
+ slot_visitor<startup_fixup> data_visitor(parent,fixup);
data_visitor.visit_code_block_objects(compiled);
- code_block_fixup_relocation_visitor code_visitor(parent,data_offset,code_offset);
+ startup_code_block_relocation_visitor code_visitor(parent,fixup);
compiled->each_instruction_operand(code_visitor);
}
};
void factor_vm::fixup_code(cell data_offset, cell code_offset)
{
- code_block_fixupper fixupper(this,data_offset,code_offset);
- code->allocator->iterate(fixupper);
+ startup_fixup fixup(data_offset,code_offset);
+ startup_code_block_updater updater(this,fixup);
+ code->allocator->iterate(updater,fixup);
}
/* Read an image file from disk, only done once during startup */
/* Allocates memory */
code_block *jit::to_code_block()
{
+ /* Emit dummy GC info */
+ code.grow_bytes(alignment_for(code.count + 4,data_alignment));
+ u32 dummy_gc_info = 0;
+ code.append_bytes(&dummy_gc_info,sizeof(u32));
+
code.trim();
relocation.trim();
parameters.trim();
return (a + (b-1)) & ~(b-1);
}
+inline static cell alignment_for(cell a, cell b)
+{
+ return align(a,b) - a;
+}
+
static const cell data_alignment = 16;
#define WORD_SIZE (signed)(sizeof(cell)*8)
cell header;
cell size() const;
+ template<typename Fixup> cell size(Fixup fixup) const;
+
cell binary_payload_start() const;
+ template<typename Fixup> cell binary_payload_start(Fixup fixup) const;
cell *slots() const { return (cell *)this; }
forwarding = NULL;
}
- cell block_line(Block *address)
+ cell block_line(const Block *address)
{
return (((cell)address - start) / data_alignment);
}
return (Block *)(line * data_alignment + start);
}
- std::pair<cell,cell> bitmap_deref(Block *address)
+ std::pair<cell,cell> bitmap_deref(const Block *address)
{
cell line_number = block_line(address);
cell word_index = (line_number / mark_bits_granularity);
return std::make_pair(word_index,word_shift);
}
- bool bitmap_elt(cell *bits, Block *address)
+ bool bitmap_elt(cell *bits, const Block *address)
{
std::pair<cell,cell> position = bitmap_deref(address);
return (bits[position.first] & ((cell)1 << position.second)) != 0;
}
- Block *next_block_after(Block *block)
+ Block *next_block_after(const Block *block)
{
return (Block *)((cell)block + block->size());
}
- void set_bitmap_range(cell *bits, Block *address)
+ void set_bitmap_range(cell *bits, const Block *address)
{
std::pair<cell,cell> start = bitmap_deref(address);
std::pair<cell,cell> end = bitmap_deref(next_block_after(address));
}
}
- bool marked_p(Block *address)
+ bool marked_p(const Block *address)
{
return bitmap_elt(marked,address);
}
- void set_marked_p(Block *address)
+ void set_marked_p(const Block *address)
{
set_bitmap_range(marked,address);
}
/* We have the popcount for every mark_bits_granularity entries; look
up and compute the rest */
- Block *forward_block(Block *original)
+ Block *forward_block(const Block *original)
{
#ifdef FACTOR_DEBUG
assert(marked_p(original));
return new_block;
}
- Block *next_unmarked_block_after(Block *original)
+ Block *next_unmarked_block_after(const Block *original)
{
std::pair<cell,cell> position = bitmap_deref(original);
cell bit_index = position.second;
return (Block *)(this->start + this->size);
}
- Block *next_marked_block_after(Block *original)
+ Block *next_marked_block_after(const Block *original)
{
std::pair<cell,cell> position = bitmap_deref(original);
cell bit_index = position.second;
#include "platform.hpp"
#include "primitives.hpp"
#include "segments.hpp"
+#include "gc_info.hpp"
#include "contexts.hpp"
#include "run.hpp"
#include "objects.hpp"
#include "bitwise_hacks.hpp"
#include "mark_bits.hpp"
#include "free_list.hpp"
+#include "fixup.hpp"
+#include "tuples.hpp"
#include "free_list_allocator.hpp"
#include "write_barrier.hpp"
#include "object_start_map.hpp"
#include "gc.hpp"
#include "debug.hpp"
#include "strings.hpp"
-#include "tuples.hpp"
#include "words.hpp"
#include "float_bits.hpp"
#include "io.hpp"
#include "data_roots.hpp"
#include "code_roots.hpp"
#include "generic_arrays.hpp"
+#include "callstack.hpp"
#include "slot_visitor.hpp"
#include "collector.hpp"
#include "copying_collector.hpp"
#include "code_block_visitor.hpp"
#include "compaction.hpp"
#include "full_collector.hpp"
-#include "callstack.hpp"
#include "arrays.hpp"
#include "math.hpp"
#include "byte_arrays.hpp"
ctx->push(allot_cell(object_size(ctx->pop())));
}
-struct slot_become_visitor {
+struct slot_become_fixup : no_fixup {
std::map<object *,object *> *become_map;
- explicit slot_become_visitor(std::map<object *,object *> *become_map_) :
+ explicit slot_become_fixup(std::map<object *,object *> *become_map_) :
become_map(become_map_) {}
- object *operator()(object *old)
+ object *fixup_data(object *old)
{
std::map<object *,object *>::const_iterator iter = become_map->find(old);
if(iter != become_map->end())
};
struct object_become_visitor {
- slot_visitor<slot_become_visitor> *workhorse;
+ slot_visitor<slot_become_fixup> *workhorse;
- explicit object_become_visitor(slot_visitor<slot_become_visitor> *workhorse_) :
+ explicit object_become_visitor(slot_visitor<slot_become_fixup> *workhorse_) :
workhorse(workhorse_) {}
void operator()(object *obj)
};
struct code_block_become_visitor {
- slot_visitor<slot_become_visitor> *workhorse;
+ slot_visitor<slot_become_fixup> *workhorse;
- explicit code_block_become_visitor(slot_visitor<slot_become_visitor> *workhorse_) :
+ explicit code_block_become_visitor(slot_visitor<slot_become_fixup> *workhorse_) :
workhorse(workhorse_) {}
void operator()(code_block *compiled, cell size)
/* Update all references to old objects to point to new objects */
{
- slot_visitor<slot_become_visitor> workhorse(this,slot_become_visitor(&become_map));
+ slot_visitor<slot_become_fixup> workhorse(this,slot_become_fixup(&become_map));
workhorse.visit_roots();
workhorse.visit_contexts();
namespace factor
{
+/* Size of the object pointed to by an untagged pointer */
+template<typename Fixup>
+cell object::size(Fixup fixup) const
+{
+ if(free_p()) return ((free_heap_block *)this)->size();
+
+ switch(type())
+ {
+ case ARRAY_TYPE:
+ return align(array_size((array*)this),data_alignment);
+ case BIGNUM_TYPE:
+ return align(array_size((bignum*)this),data_alignment);
+ case BYTE_ARRAY_TYPE:
+ return align(array_size((byte_array*)this),data_alignment);
+ case STRING_TYPE:
+ return align(string_size(string_capacity((string*)this)),data_alignment);
+ case TUPLE_TYPE:
+ {
+ tuple_layout *layout = (tuple_layout *)fixup.translate_data(untag<object>(((tuple *)this)->layout));
+ return align(tuple_size(layout),data_alignment);
+ }
+ case QUOTATION_TYPE:
+ return align(sizeof(quotation),data_alignment);
+ case WORD_TYPE:
+ return align(sizeof(word),data_alignment);
+ case FLOAT_TYPE:
+ return align(sizeof(boxed_float),data_alignment);
+ case DLL_TYPE:
+ return align(sizeof(dll),data_alignment);
+ case ALIEN_TYPE:
+ return align(sizeof(alien),data_alignment);
+ case WRAPPER_TYPE:
+ return align(sizeof(wrapper),data_alignment);
+ case CALLSTACK_TYPE:
+ return align(callstack_object_size(untag_fixnum(((callstack *)this)->length)),data_alignment);
+ default:
+ critical_error("Invalid header in size",(cell)this);
+ return 0; /* can't happen */
+ }
+}
+
+inline cell object::size() const
+{
+ return size(no_fixup());
+}
+
+/* The number of cells from the start of the object which should be scanned by
+the GC. Some types have a binary payload at the end (string, word, DLL) which
+we ignore. */
+template<typename Fixup>
+cell object::binary_payload_start(Fixup fixup) const
+{
+ if(free_p()) return 0;
+
+ switch(type())
+ {
+ /* these objects do not refer to other objects at all */
+ case FLOAT_TYPE:
+ case BYTE_ARRAY_TYPE:
+ case BIGNUM_TYPE:
+ case CALLSTACK_TYPE:
+ return 0;
+ /* these objects have some binary data at the end */
+ case WORD_TYPE:
+ return sizeof(word) - sizeof(cell) * 3;
+ case ALIEN_TYPE:
+ return sizeof(cell) * 3;
+ case DLL_TYPE:
+ return sizeof(cell) * 2;
+ case QUOTATION_TYPE:
+ return sizeof(quotation) - sizeof(cell) * 2;
+ case STRING_TYPE:
+ return sizeof(string);
+ /* everything else consists entirely of pointers */
+ case ARRAY_TYPE:
+ return array_size<array>(array_capacity((array*)this));
+ case TUPLE_TYPE:
+ {
+ tuple_layout *layout = (tuple_layout *)fixup.translate_data(untag<object>(((tuple *)this)->layout));
+ return tuple_size(layout);
+ }
+ case WRAPPER_TYPE:
+ return sizeof(wrapper);
+ default:
+ critical_error("Invalid header in binary_payload_start",(cell)this);
+ return 0; /* can't happen */
+ }
+}
+
+inline cell object::binary_payload_start() const
+{
+ return binary_payload_start(no_fixup());
+}
+
/* Slot visitors iterate over the slots of an object, applying a functor to
each one that is a non-immediate slot. The pointer is untagged first. The
functor returns a new untagged object pointer. The return value may or may not equal the old one,
- visit_roots()
- visit_contexts() */
-template<typename Visitor> struct slot_visitor {
+template<typename Fixup> struct slot_visitor {
factor_vm *parent;
- Visitor visitor;
+ Fixup fixup;
- explicit slot_visitor<Visitor>(factor_vm *parent_, Visitor visitor_) :
- parent(parent_), visitor(visitor_) {}
+ explicit slot_visitor<Fixup>(factor_vm *parent_, Fixup fixup_) :
+ parent(parent_), fixup(fixup_) {}
cell visit_pointer(cell pointer);
void visit_handle(cell *handle);
void visit_callback_roots();
void visit_literal_table_roots();
void visit_roots();
+ void visit_callstack_object(callstack *stack);
+ void visit_callstack(context *ctx);
void visit_contexts();
void visit_code_block_objects(code_block *compiled);
void visit_embedded_literals(code_block *compiled);
};
-template<typename Visitor>
-cell slot_visitor<Visitor>::visit_pointer(cell pointer)
+template<typename Fixup>
+cell slot_visitor<Fixup>::visit_pointer(cell pointer)
{
if(immediate_p(pointer)) return pointer;
- object *untagged = untag<object>(pointer);
- untagged = visitor(untagged);
+ object *untagged = fixup.fixup_data(untag<object>(pointer));
return RETAG(untagged,TAG(pointer));
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_handle(cell *handle)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_handle(cell *handle)
{
*handle = visit_pointer(*handle);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_object_array(cell *start, cell *end)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_object_array(cell *start, cell *end)
{
while(start < end) visit_handle(start++);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_slots(object *ptr, cell payload_start)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_slots(object *ptr, cell payload_start)
{
cell *slot = (cell *)ptr;
cell *end = (cell *)((cell)ptr + payload_start);
}
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_slots(object *ptr)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_slots(object *obj)
{
- visit_slots(ptr,ptr->binary_payload_start());
+ if(obj->type() == CALLSTACK_TYPE)
+ visit_callstack_object((callstack *)obj);
+ else
+ visit_slots(obj,obj->binary_payload_start(fixup));
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_stack_elements(segment *region, cell *top)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_stack_elements(segment *region, cell *top)
{
visit_object_array((cell *)region->start,top + 1);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_data_roots()
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_data_roots()
{
std::vector<data_root_range>::const_iterator iter = parent->data_roots.begin();
std::vector<data_root_range>::const_iterator end = parent->data_roots.end();
visit_object_array(iter->start,iter->start + iter->len);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_bignum_roots()
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_bignum_roots()
{
std::vector<cell>::const_iterator iter = parent->bignum_roots.begin();
std::vector<cell>::const_iterator end = parent->bignum_roots.end();
cell *handle = (cell *)(*iter);
if(*handle)
- *handle = (cell)visitor(*(object **)handle);
+ *handle = (cell)fixup.fixup_data(*(object **)handle);
}
}
-template<typename Visitor>
+template<typename Fixup>
struct callback_slot_visitor {
callback_heap *callbacks;
- slot_visitor<Visitor> *visitor;
+ slot_visitor<Fixup> *visitor;
- explicit callback_slot_visitor(callback_heap *callbacks_, slot_visitor<Visitor> *visitor_) :
+ explicit callback_slot_visitor(callback_heap *callbacks_, slot_visitor<Fixup> *visitor_) :
callbacks(callbacks_), visitor(visitor_) {}
void operator()(code_block *stub)
}
};
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_callback_roots()
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_callback_roots()
{
- callback_slot_visitor<Visitor> callback_visitor(parent->callbacks,this);
+ callback_slot_visitor<Fixup> callback_visitor(parent->callbacks,this);
parent->callbacks->each_callback(callback_visitor);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_literal_table_roots()
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_literal_table_roots()
{
std::map<code_block *, cell> *uninitialized_blocks = &parent->code->uninitialized_blocks;
std::map<code_block *, cell>::const_iterator iter = uninitialized_blocks->begin();
parent->code->uninitialized_blocks = new_uninitialized_blocks;
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_roots()
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_roots()
{
visit_handle(&parent->true_object);
visit_handle(&parent->bignum_zero);
visit_object_array(parent->special_objects,parent->special_objects + special_object_count);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_contexts()
+template<typename Fixup>
+struct call_frame_slot_visitor {
+ factor_vm *parent;
+ slot_visitor<Fixup> *visitor;
+
+ explicit call_frame_slot_visitor(factor_vm *parent_, slot_visitor<Fixup> *visitor_) :
+ parent(parent_), visitor(visitor_) {}
+
+ /*
+ next -> [entry_point]
+ [size]
+ [return address] -- x86 only, backend adds 1 to each spill location
+ [spill area]
+ ...
+ frame -> [entry_point]
+ [size]
+ */
+ void operator()(stack_frame *frame)
+ {
+ const code_block *compiled = visitor->fixup.translate_code(parent->frame_code(frame));
+ gc_info *info = compiled->block_gc_info();
+ cell return_address = parent->frame_offset(frame);
+ assert(return_address < compiled->size());
+ int index = info->return_address_index(return_address);
+
+ if(index != -1)
+ {
+ u8 *bitmap = info->gc_info_bitmap();
+ cell base = info->spill_slot_base(index);
+ cell *stack_pointer = (cell *)(parent->frame_successor(frame) + 1);
+
+ for(cell spill_slot = 0; spill_slot < info->gc_root_count; spill_slot++)
+ {
+ if(bitmap_p(bitmap,base + spill_slot))
+ visitor->visit_handle(&stack_pointer[spill_slot]);
+ }
+ }
+ }
+};
+
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_callstack_object(callstack *stack)
+{
+ call_frame_slot_visitor<Fixup> call_frame_visitor(parent,this);
+ parent->iterate_callstack_object(stack,call_frame_visitor);
+}
+
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_callstack(context *ctx)
+{
+ call_frame_slot_visitor<Fixup> call_frame_visitor(parent,this);
+ parent->iterate_callstack(ctx,call_frame_visitor);
+}
+
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_contexts()
{
std::set<context *>::const_iterator begin = parent->active_contexts.begin();
std::set<context *>::const_iterator end = parent->active_contexts.end();
visit_stack_elements(ctx->datastack_seg,(cell *)ctx->datastack);
visit_stack_elements(ctx->retainstack_seg,(cell *)ctx->retainstack);
visit_object_array(ctx->context_objects,ctx->context_objects + context_object_count);
-
+ visit_callstack(ctx);
begin++;
}
}
-template<typename Visitor>
+template<typename Fixup>
struct literal_references_visitor {
- slot_visitor<Visitor> *visitor;
+ slot_visitor<Fixup> *visitor;
- explicit literal_references_visitor(slot_visitor<Visitor> *visitor_) : visitor(visitor_) {}
+ explicit literal_references_visitor(slot_visitor<Fixup> *visitor_) : visitor(visitor_) {}
void operator()(instruction_operand op)
{
}
};
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_code_block_objects(code_block *compiled)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_code_block_objects(code_block *compiled)
{
visit_handle(&compiled->owner);
visit_handle(&compiled->parameters);
visit_handle(&compiled->relocation);
}
-template<typename Visitor>
-void slot_visitor<Visitor>::visit_embedded_literals(code_block *compiled)
+template<typename Fixup>
+void slot_visitor<Fixup>::visit_embedded_literals(code_block *compiled)
{
if(!parent->code->uninitialized_p(compiled))
{
- literal_references_visitor<Visitor> visitor(this);
+ literal_references_visitor<Fixup> visitor(this);
compiled->each_instruction_operand(visitor);
}
}
void collect_compact(bool trace_contexts_p);
void collect_growing_heap(cell requested_bytes, bool trace_contexts_p);
void gc(gc_op op, cell requested_bytes, bool trace_contexts_p);
+ void scrub_context(context *ctx);
+ void scrub_contexts();
void primitive_minor_gc();
void primitive_full_gc();
void primitive_compact_gc();
- void inline_gc(cell gc_roots);
void primitive_enable_gc_events();
void primitive_disable_gc_events();
object *allot_object(cell type, cell size);
cell frame_executing_quot(stack_frame *frame);
stack_frame *frame_successor(stack_frame *frame);
cell frame_scan(stack_frame *frame);
+ cell frame_offset(stack_frame *frame);
void primitive_callstack_to_array();
stack_frame *innermost_stack_frame(callstack *stack);
void primitive_innermost_stack_frame_executing();
projects / factor.git / commitdiff