compiler.cfg.linear.scan.*: makes it so ranges and uses are guaranteed

to be vectors

Simplifies the code and makes it a little faster.

diff --git a/basis/compiler/cfg/linear-scan/allocation/allocation-tests.factor b/basis/compiler/cfg/linear-scan/allocation/allocation-tests.factor
index fad769d7617268e04fa51db520048a5ecc9a6a66..a6714eb9d70351739fb511562bc98c1531f1e474 100644 (file)
--- a/basis/compiler/cfg/linear-scan/allocation/allocation-tests.factor
+++ b/basis/compiler/cfg/linear-scan/allocation/allocation-tests.factor
@@ -8,9 +8,9 @@ IN: compiler.cfg.linear-scan.allocation.tests
 : interval-[30,46] ( -- live-interval )
     T{ live-interval-state
        { vreg 49 }
-       { ranges { { 30 46 } } }
+       { ranges V{ { 30 46 } } }
        { uses
-         {
+         V{
              T{ vreg-use { n 30 } { def-rep double-rep } }
              T{ vreg-use { n 46 } { use-rep double-rep } }
          }
@@ -20,7 +20,7 @@ IN: compiler.cfg.linear-scan.allocation.tests
 : interval-[30,60] ( -- live-interval )
     T{ live-interval-state
        { vreg 25 }
-       { ranges { { 30 60 } } }
+       { ranges V{ { 30 60 } } }
        { reg RAX }
     } ;
 
@@ -76,16 +76,16 @@ cpu x86.64? [
         { int-regs V{
             T{ live-interval-state
                { vreg 1 }
-               { ranges { { 30 40 } } }
+               { ranges V{ { 30 40 } } }
                { uses
-                 { T{ vreg-use { n 32 } { def-rep double-rep } } }
+                 V{ T{ vreg-use { n 32 } { def-rep double-rep } } }
                }
             }
             T{ live-interval-state
                { vreg 50 }
-               { ranges { { 5 10 } } }
+               { ranges V{ { 5 10 } } }
                { uses
-                 { T{ vreg-use { n 8 } { def-rep double-rep } } }
+                 V{ T{ vreg-use { n 8 } { def-rep double-rep } } }
                }
             }
         } }

diff --git a/basis/compiler/cfg/linear-scan/allocation/spilling/spilling-tests.factor b/basis/compiler/cfg/linear-scan/allocation/spilling/spilling-tests.factor
index a72939685c90d0054abc36aa021cdc5f7cb303f1..62e429d60bd083f5cf41171d9ed6eba5bd570457 100644 (file)
--- a/basis/compiler/cfg/linear-scan/allocation/spilling/spilling-tests.factor
+++ b/basis/compiler/cfg/linear-scan/allocation/spilling/spilling-tests.factor
@@ -11,9 +11,9 @@ IN: compiler.cfg.linear-scan.allocation.spilling.tests
        { vreg 45 }
        { spill-to T{ spill-slot { n 8 } } }
        { spill-rep double-rep }
-       { ranges { { 22 47 } { 67 68 } { 69 72 } } }
+       { ranges V{ { 22 47 } { 67 68 } { 69 72 } } }
        { uses
-         {
+         V{
              T{ vreg-use
                 { n 28 }
                 { use-rep double-rep }
@@ -39,25 +39,25 @@ IN: compiler.cfg.linear-scan.allocation.spilling.tests
 ! trim-after-ranges
 {
     T{ live-interval-state
-       { ranges { { 25 30 } { 40 50 } } }
-       { uses { T{ vreg-use { n 25 } } } }
+       { ranges V{ { 25 30 } { 40 50 } } }
+       { uses V{ T{ vreg-use { n 25 } } } }
     }
 } [
     T{ live-interval-state
-       { ranges { { 0 10 } { 20 30 } { 40 50 } } }
-       { uses { T{ vreg-use { n 25 } } } }
+       { ranges V{ { 0 10 } { 20 30 } { 40 50 } } }
+       { uses V{ T{ vreg-use { n 25 } } } }
     } dup trim-after-ranges
 ] unit-test
 
 {
     T{ live-interval-state
-       { ranges { { 10 23 } } }
-       { uses { T{ vreg-use { n 10 } } } }
+       { ranges V{ { 10 23 } } }
+       { uses V{ T{ vreg-use { n 10 } } } }
     }
 } [
     T{ live-interval-state
-       { ranges { { 20 23 } } }
-       { uses { T{ vreg-use { n 10 } } } }
+       { ranges V{ { 20 23 } } }
+       { uses V{ T{ vreg-use { n 10 } } } }
     }
     dup trim-after-ranges
 ] unit-test
@@ -65,12 +65,12 @@ IN: compiler.cfg.linear-scan.allocation.spilling.tests
 ! trim-before-ranges
 {
     T{ live-interval-state
-       { ranges { { 0 10 } { 20 21 } } }
-       { uses { T{ vreg-use { n 20 } } } }
+       { ranges V{ { 0 10 } { 20 21 } } }
+       { uses V{ T{ vreg-use { n 20 } } } }
     }
 } [
     T{ live-interval-state
-       { ranges { { 0 10 } { 20 30 } { 40 50 } } }
-       { uses { T{ vreg-use { n 20 } } } }
+       { ranges V{ { 0 10 } { 20 30 } { 40 50 } } }
+       { uses V{ T{ vreg-use { n 20 } } } }
     } dup trim-before-ranges
 ] unit-test

diff --git a/basis/compiler/cfg/linear-scan/allocation/spilling/spilling.factor b/basis/compiler/cfg/linear-scan/allocation/spilling/spilling.factor
index 8da9c2ec3b8c93fe7435f62ac2360fbc16d9bd03..d1901a35091e458ef3b04ab4976e8d6200ebf8f1 100644 (file)
--- a/basis/compiler/cfg/linear-scan/allocation/spilling/spilling.factor
+++ b/basis/compiler/cfg/linear-scan/allocation/spilling/spilling.factor
@@ -3,9 +3,9 @@
 USING: accessors assocs combinators
 compiler.cfg.linear-scan.allocation.splitting
 compiler.cfg.linear-scan.allocation.state
-compiler.cfg.linear-scan.live-intervals compiler.cfg.linear-scan.ranges
-compiler.cfg.registers compiler.utilities fry kernel linked-assocs locals
-math namespaces sequences ;
+compiler.cfg.linear-scan.live-intervals
+compiler.cfg.linear-scan.ranges compiler.utilities fry kernel
+linked-assocs locals math namespaces sequences ;
 IN: compiler.cfg.linear-scan.allocation.spilling
 
 : trim-before-ranges ( live-interval -- )

diff --git a/basis/compiler/cfg/linear-scan/allocation/splitting/splitting-tests.factor b/basis/compiler/cfg/linear-scan/allocation/splitting/splitting-tests.factor
index 12010e9fa440c9efe8bc2b84014214a4c3ac040b..c235062a62c0ccb16eff6b91762be62892dff7d5 100644 (file)
--- a/basis/compiler/cfg/linear-scan/allocation/splitting/splitting-tests.factor
+++ b/basis/compiler/cfg/linear-scan/allocation/splitting/splitting-tests.factor
@@ -5,9 +5,9 @@ IN: compiler.cfg.linear-scan.allocation.splitting.tests
 
 : test-interval-easy ( -- interval )
     T{ live-interval-state
-       { ranges { { 5 8 } { 12 20 } } }
+       { ranges V{ { 5 8 } { 12 20 } } }
        { uses
-         {
+         V{
              T{ vreg-use { n 3 } { def-rep int-rep } }
              T{ vreg-use { n 15 } { def-rep int-rep } }
          }
@@ -17,12 +17,12 @@ IN: compiler.cfg.linear-scan.allocation.splitting.tests
 ! split-interval
 {
     T{ live-interval-state
-       { ranges { { 5 8 } } }
-       { uses { T{ vreg-use { n 3 } { def-rep int-rep } } } }
+       { ranges V{ { 5 8 } } }
+       { uses V{ T{ vreg-use { n 3 } { def-rep int-rep } } } }
     }
     T{ live-interval-state
-       { ranges { { 12 20 } } }
-       { uses { T{ vreg-use { n 15 } { def-rep int-rep } } } }
+       { ranges V{ { 12 20 } } }
+       { uses V{ T{ vreg-use { n 15 } { def-rep int-rep } } } }
     }
 } [
     test-interval-easy 10 split-interval

diff --git a/basis/compiler/cfg/linear-scan/allocation/state/state-tests.factor b/basis/compiler/cfg/linear-scan/allocation/state/state-tests.factor
index b914440c004ced157198f148df07de05c7af1354..002018af343303f2ef4eff8a88da34c7b1221b47 100644 (file)
--- a/basis/compiler/cfg/linear-scan/allocation/state/state-tests.factor
+++ b/basis/compiler/cfg/linear-scan/allocation/state/state-tests.factor
@@ -115,7 +115,7 @@ ${
     40 progress set
     T{ live-interval-state
        { vreg 123 }
-       { ranges { { 0 0 } { 30 34 } } }
+       { ranges V{ { 0 0 } { 30 34 } } }
     }
     check-handled
 ] unit-test
@@ -144,7 +144,7 @@ ${ cell } [
 { { 0 34 123 } } [
     T{ live-interval-state
        { vreg 123 }
-       { ranges { { 0 0 } { 30 34 } } }
+       { ranges V{ { 0 0 } { 30 34 } } }
     } interval/sync-point-key
 ] unit-test
 
@@ -166,24 +166,24 @@ ${ cell } [
         { { 5 1/0. 1/0. } T{ sync-point { n 5 } } }
         {
             { 20 28 f }
-            T{ live-interval-state { ranges { { 20 28 } } } }
+            T{ live-interval-state { ranges V{ { 20 28 } } } }
         }
         {
             { 20 30 f }
-            T{ live-interval-state { ranges { { 20 30 } } } }
+            T{ live-interval-state { ranges V{ { 20 30 } } } }
         }
         {
             { 33 999 f }
-            T{ live-interval-state { ranges { { 33 999 } } } }
+            T{ live-interval-state { ranges V{ { 33 999 } } } }
         }
         { { 33 1/0. 1/0. } T{ sync-point { n 33 } } }
         { { 100 1/0. 1/0. } T{ sync-point { n 100 } } }
     }
 } [
     {
-        T{ live-interval-state { ranges { { 20 30 } } } }
-        T{ live-interval-state { ranges { { 20 28 } } } }
-        T{ live-interval-state { ranges { { 33 999 } } } }
+        T{ live-interval-state { ranges V{ { 20 30 } } } }
+        T{ live-interval-state { ranges V{ { 20 28 } } } }
+        T{ live-interval-state { ranges V{ { 33 999 } } } }
         T{ sync-point { n 5 } }
         T{ sync-point { n 33 } }
         T{ sync-point { n 100 } }
@@ -193,7 +193,7 @@ ${ cell } [
 
 { 2 } [
     {
-        T{ live-interval-state { ranges { { 20 30 } } } }
-        T{ live-interval-state { ranges { { 20 30 } } } }
+        T{ live-interval-state { ranges V{ { 20 30 } } } }
+        T{ live-interval-state { ranges V{ { 20 30 } } } }
     } >unhandled-min-heap heap-size
 ] unit-test

diff --git a/basis/compiler/cfg/linear-scan/linear-scan-tests.factor b/basis/compiler/cfg/linear-scan/linear-scan-tests.factor
index 9951cdb2120f7fb2eb5344ab0a9bbe2f695946d9..475552d6abb7069e249d9261b762d97b39fc5ea0 100644 (file)
--- a/basis/compiler/cfg/linear-scan/linear-scan-tests.factor
+++ b/basis/compiler/cfg/linear-scan/linear-scan-tests.factor
@@ -298,7 +298,7 @@ H{
               T{ live-interval-state
                  { vreg 1 }
                  { reg 1 }
-                 { ranges { { 1 15 } } }
+                 { ranges V{ { 1 15 } } }
                  { uses
                    V{
                        T{ vreg-use f 1 int-rep f }
@@ -312,7 +312,7 @@ H{
               T{ live-interval-state
                  { vreg 2 }
                  { reg 2 }
-                 { ranges { { 3 8 } } }
+                 { ranges V{ { 3 8 } } }
                  { uses
                    V{
                        T{ vreg-use f 3 int-rep f }
@@ -324,7 +324,7 @@ H{
               T{ live-interval-state
                  { vreg 3 }
                  { reg 3 }
-                 { ranges { { 3 10 } } }
+                 { ranges V{ { 3 10 } } }
                  { uses V{ T{ vreg-use f 3 int-rep f } T{ vreg-use f 10 f int-rep } } }
               }
           }
@@ -333,7 +333,7 @@ H{
     H{ } inactive-intervals set
     T{ live-interval-state
        { vreg 1 }
-       { ranges { { 5 5 } } }
+       { ranges V{ { 5 5 } } }
        { uses V{ T{ vreg-use f 5 int-rep f } } }
     }
     spill-status
@@ -351,7 +351,7 @@ H{
               T{ live-interval-state
                  { vreg 1 }
                  { reg 1 }
-                 { ranges { { 1 15 } } }
+                 { ranges V{ { 1 15 } } }
                  { uses V{ T{ vreg-use f 1 int-rep f } } }
               }
               T{ live-interval-state
@@ -365,7 +365,7 @@ H{
     H{ } inactive-intervals set
     T{ live-interval-state
        { vreg 3 }
-       { ranges { { 5 5 } } }
+       { ranges V{ { 5 5 } } }
        { uses V{ T{ vreg-use f 5 int-rep f } } }
     }
     spill-status

diff --git a/basis/compiler/cfg/linear-scan/live-intervals/live-intervals-tests.factor b/basis/compiler/cfg/linear-scan/live-intervals/live-intervals-tests.factor
index 936f7e6456cb9ca2acd38edb32dfc4c694ce3a63..59787f2f820b60705193527d5cfc2cc57988afe5 100644 (file)
--- a/basis/compiler/cfg/linear-scan/live-intervals/live-intervals-tests.factor
+++ b/basis/compiler/cfg/linear-scan/live-intervals/live-intervals-tests.factor
@@ -25,6 +25,14 @@ IN: compiler.cfg.linear-scan.live-intervals.tests
     25 T{ live-interval-state { uses V{ T{ vreg-use { n 25 } } } } } find-use
 ] unit-test
 
+! finish-live-interval
+{
+    V{ { 5 10 } { 21 30 } }
+} [
+    { { 21 30 } { 5 10 } } <live-interval-for-ranges>
+    dup finish-live-interval ranges>>
+] unit-test
+
 ! intervals-intersect?
 { t f f } [
     { { 4 20 } } <live-interval-for-ranges>
@@ -79,6 +87,15 @@ IN: compiler.cfg.linear-scan.live-intervals.tests
 ] unit-test
 
 ! record-def
-{ } [
-    H{ { 37 37 } } leader-map set H{ { 37 int-rep } } representations set
+{
+    T{ live-interval-state
+       { vreg 37 }
+       { ranges V{ { 20 20 } } }
+       { uses V{ T{ vreg-use { n 20 } { def-rep int-rep } } } }
+    }
+} [
+    H{ { 37 37 } } leader-map set
+    H{ { 37 int-rep } } representations set
+    37 20 f record-def
+    37 vreg>live-interval
 ] unit-test

diff --git a/basis/compiler/cfg/linear-scan/live-intervals/live-intervals.factor b/basis/compiler/cfg/linear-scan/live-intervals/live-intervals.factor
index e1f2e34d6c6741391c4cc48289518d06447636fb..c612129b74aeff439fa60df86830a52cccddf255 100644 (file)
--- a/basis/compiler/cfg/linear-scan/live-intervals/live-intervals.factor
+++ b/basis/compiler/cfg/linear-scan/live-intervals/live-intervals.factor
@@ -15,7 +15,7 @@ TUPLE: vreg-use n def-rep use-rep spill-slot? ;
 TUPLE: live-interval-state
     vreg
     reg spill-to spill-rep reload-from reload-rep
-    ranges uses ;
+    { ranges vector } { uses vector } ;
 
 : first-use ( live-interval -- use ) uses>> first ; inline
 
@@ -133,14 +133,11 @@ ERROR: bad-live-interval live-interval ;
 : check-start ( live-interval -- )
     dup live-interval-start -1 = [ bad-live-interval ] [ drop ] if ;
 
+: finish-live-interval ( live-interval -- )
+    [ ranges>> reverse! drop ] [ uses>> reverse! drop ] [ check-start ] tri ;
+
 : finish-live-intervals ( live-intervals -- )
-    [
-        {
-            [ [ { } like reverse! ] change-ranges drop ]
-            [ [ { } like reverse! ] change-uses drop ]
-            [ check-start ]
-        } cleave
-    ] each ;
+    [ finish-live-interval ] each ;
 
 TUPLE: sync-point n keep-dst? ;