poke-devel
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Patch] PVM low-level cleanup and optimization, good version [Was: R


From: Luca Saiu
Subject: Re: [Patch] PVM low-level cleanup and optimization, good version [Was: Re: [Patch, first version] PVM low-level cleanup and optimization]
Date: Sun, 01 Dec 2019 14:49:54 +0100
User-agent: Gnus (Gnus v5.13), GNU Emacs 27.0.50, x86_64-pc-linux-gnu

On 2019-12-01 at 13:40 +0100, Jose E. Marchesi wrote:

>     I am waiting for your approval before porting and preparing a final
>     version.
>
> Thanks.

Here it is.

-- 
Luca Saiu
* My personal web site:  http://ageinghacker.net
* GNU epsilon:           http://www.gnu.org/software/epsilon
* Jitter:                http://ageinghacker.net/projects/jitter

I support everyone's freedom of mocking any opinion or belief, no
matter how deeply held, with open disrespect and the same unrelented
enthusiasm of a toddler who has just learned the word "poo".
commit b30c5527f25a3619fa30968f71eb1ddcc00db886
Author: Luca Saiu <address@hidden>
Date:   Sun Dec 1 14:47:31 2019 +0100

    low-level PVM optimization and cleanup
    
    * Update jitter submodule.
    * src/pkl-insn.def (PKL_INSN_TUCK): Define new instruction.
    * src/pvm.jitter (rot, nrot): Simplify definition using Jitter
    macro.
    (tuck): New instruction.
    (revn): Add specialized arguments.  Use unsigned JITTER_ARGU0 to
    catch bugs more easily.
    (swap-over-to-tuck): New rewrite rule.
    (rot-swap-to-quake): Re-introduce deleted rewrite rule, which was
    actually correct.
    * pkl-asm.pks (remap, write, addo, subo, mulo, divo, modo, atrim)
    (cdivo, ais, bconc): Simplify and optimize using new instructions.
    * src/pkl-gen.pks (struct_field_mapper): Likewise.

diff --git a/ChangeLog b/ChangeLog
index 47db99c..6490c0c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,18 @@
+2019-12-01 Luca Saiu <address@hidden>
+       * src/pkl-insn.def (PKL_INSN_TUCK): Define new instruction.
+       * src/pvm.jitter (rot, nrot): Simplify definition using Jitter
+       macro.
+       (tuck): New instruction.
+       (revn): Add specialized arguments.  Use unsigned JITTER_ARGU0 to
+       catch bugs more easily.
+       (swap-over-to-tuck): New rewrite rule.
+       (rot-swap-to-quake): Re-introduce deleted rewrite rule, which was
+       actually correct.
+       * pkl-asm.pks (remap, write, addo, subo, mulo, divo, modo, atrim)
+       (cdivo, ais, bconc): Simplify and optimize using new instructions.
+       * src/pkl-gen.pks (struct_field_mapper): Likewise.
+
+       
 2019-12-01 John Darrington <address@hidden>
 
        * src/pk_dump.pk (dump): New parameter cluster_by
Submodule jitter 6f53a42..e095305:
  > new stack operation bulge
  > stack header: move comment to a better position
  > new stack operation whirl
  > align snippet code to a conservatively safe power of 2
  > new stack operation: slide
  > stack macros: accept unsigned depths
  > uninspired VM: make debugging instructions non-relocatable
  > cosmetic changes
  > comment changes
  > jitterlisp bug fix
  > add windows support
  > rename misnamed feature macro
  > build system sanity check
  > lots of portability improvements
  > manual change
  > comment fix
  > make support for .section .note.GNU-stack conditional even on GNU
  > cosmetic change
  > stack: tentative optimization for over in the TOS case
  > new stack primitive: tuck
diff --git a/src/pkl-asm.pks b/src/pkl-asm.pks
index 60e36ea..ed1b263 100644
--- a/src/pkl-asm.pks
+++ b/src/pkl-asm.pks
@@ -58,8 +58,7 @@
         mgetsiz                 ; WCLS MCLS IOS OFF EBOUND VAL SBOUND
         swap                    ; WCLS MCLS IOS OFF EBOUND SBOUND VAL
         mgetm                   ; WCLS MCLS IOS OFF EBOUND SBOUND VAL MCLS
-        swap                    ; WCLS MCLS IOS OFF EBOUND SBOUND MCLS VAL
-        drop                    ; WCLS MCLS IOS OFF EBOUND SBOUND MCLS
+        nip                     ; WCLS MCLS IOS OFF EBOUND SBOUND MCLS
         call                    ; WCLS MCLS NVAL
         swap                    ; WCLS NVAL MCLS
         msetm                   ; WCLS NVAL
@@ -88,7 +87,7 @@
         nrot                    ; VAL IOS OFF VAL [WCLS]
         fromr                   ; VAL IOS OFF VAL WCLS
         call                    ; VAL null
-        push null               ; VAL null null
+        dup                     ; VAL null null
 .label:
         drop                    ; VAL (VAL|null)
         drop                    ; VAL
@@ -184,10 +183,9 @@
         rot                     ; OFF1 OFF1M OFF2
         ogetm                   ; OFF1 OFF1M OFF2 OFF2M
         rot                     ; OFF1 OFF2 OFF2M OFF1M
-        swap                    ; OFF1 OFF2 OFF1M OFF2M
         add @base_type
-        nip2                    ; OFF1 OFF2 (OFF1M+OFF2M)
-        push #unit              ; OFF1 OFF2 (OFF1M+OFF2M) UNIT
+        nip2                    ; OFF1 OFF2 (OFF2M+OFF1M)
+        push #unit              ; OFF1 OFF2 (OFF2M+OFF1M) UNIT
         mko                     ; OFF1 OFF2 OFFR
         .end
 
@@ -208,8 +206,7 @@
         ogetm                   ; OFF2 OFF1 OFF1M
         rot                     ; OFF1 OFF1M OFF2
         ogetm                   ; OFF1 OFF1M OFF2 OFF2M
-        rot                     ; OFF1 OFF2 OFF2M OFF1M
-        swap                    ; OFF1 OFF2 OFF1M OFF2M
+        quake                   ; OFF1 OFF2 OFF1M OFF2M
         sub @base_type
         nip2                    ; OFF1 OFF2 (OFF1M+OFF2M)
         push #unit              ; OFF1 OFF2 (OFF1M+OFF2M) UNIT
@@ -236,8 +233,7 @@
         nip2                    ; OFF (OFFM*VAL)
         swap                    ; (OFFM*VAL) OFF
         ogetu                   ; (OFFM*VAL) OFF UNIT
-        rot                     ; OFF UNIT (OFFM*VAL)
-        swap                    ; OFF (OFFM*VAL) UNIT
+        quake                   ; OFF (OFFM*VAL) UNIT
         mko                     ; OFF OFFR
         fromr                   ; OFF OFFR VAL
         swap                    ; OFF VAL OFFR
@@ -259,8 +255,7 @@
         ogetm                   ; OFF2 OFF1 OFF1M
         rot                     ; OFF1 OFF1M OFF2
         ogetm                   ; OFF1 OFF1M OFF2 OFF2M
-        rot                     ; OFF1 OFF2 OFF2M OFF1M
-        swap                    ; OFF1 OFF2 OFF1M OFF2M
+        quake                   ; OFF1 OFF2 OFF1M OFF2M
         div @base_type
         nip2                    ; OFF1 OFF2 (OFF1M/OFF2M)
         .end
@@ -283,8 +278,7 @@
         ogetm                   ; OFF2 OFF1 OFF1M
         rot                     ; OFF1 OFF1M OFF2
         ogetm                   ; OFF1 OFF1M OFF2 OFF2M
-        rot                     ; OFF1 OFF2 OFF2M OFF1M
-        swap                    ; OFF1 OFF2 OFF1M OFF2M
+        quake                   ; OFF1 OFF2 OFF1M OFF2M
         mod @base_type
         nip2                    ; OFF1 OFF2 (OFF1M%OFF2M)
         push #unit              ; OFF1 OFF2 (OFF1M%OFF2M) UNIT
@@ -354,8 +348,7 @@
         rot                     ; ... NULL IDX EVAL ARR
         drop                    ; ... NULL IDX EVAL
         pushvar $from           ; ... NULL IDX EVAL FROM
-        rot                     ; ... NULL EVAL FROM IDX
-        swap                    ; ... NULL EVAL IDX FROM
+        quake                   ; ... NULL EVAL IDX FROM
         sublu
         nip2                    ; ... NULL EVAL (IDX-FROM)
         swap                    ; ... NULL (IDX-FROM) EVAL
@@ -397,8 +390,7 @@
         nip                     ; TARR BOFFSET ARR BOFF(FROM)
         rot                     ; TARR ARR BOFF(FROM) BOFFSET
         dup                     ; TARR ARR BOFF(FROM) BOFFSET BOFFSET
-        rot                     ; TARR ARR BOFFSET BOFFSET BOFF(FROM)
-        swap                    ; TARR ARR BOFFSET BOFF(FROM) BOFFSET
+        quake                   ; TARR ARR BOFFSET BOFF(FROM) BOFFSET
         sublu
         nip2                    ; TARR ARR BOFFSET (BOFF(FROM)-BOFFSET)
         addlu
@@ -531,8 +523,7 @@
         ogetm                   ; OFF2 OFF1 OFF1M
         rot                     ; OFF1 OFF1M OFF2
         ogetm                   ; OFF1 OFF1M OFF2 OFF2M
-        rot                     ; OFF1 OFF2 OFF2M OFF1M
-        swap                    ; OFF1 OFF2 OFF1M OFF2M
+        quake                   ; OFF1 OFF2 OFF1M OFF2M
         cdiv @type
         nip2                    ; OFF1 OFF2 (OFF1M/^OFF2M)
         .end
@@ -581,17 +572,15 @@
         push ulong<64>1
         addlu                   ; SEL ELEM VAL IDX 1UL (IDX+1UL) [ARR NRES]
         nip2                    ; SEL ELEM VAL NIDX [ARR NRES]
-        rot                     ; SEL VAL NIDX ELEM [ARR NRES]
-        drop                    ; SEL VAL NIDX [ARR NREGS]
-        nrot                    ; NIDX SEL VAL [ARR NREGS]
-        swap                    ; NIDX VAL SEL [ARR NRES]
-        rot                     ; VAL SEL NIDX [ARR NRES]
+        tor                     ; SEL ELEM VAL [ARR NRES NIDX]
+        nip                     ; SEL VAL [ARR NRES NIDX]
+        swap                    ; VAL SEL [ARR NRES NIDX]
+        fromr                   ; VAL SEL NIDX [ARR NRES]
         ba .loop
 .foundit:
         tor                     ; SEL ELEM VAL IDX [ARR NRES]
-        rot                     ; SEL VAL IDX ELEM [ARR NRES]
-        drop                    ; SEL VAL IDX [ARR NRES]
-        tor                     ; SEL VAL [ARR NRES IDX]
+        tor                     ; SEL ELEM VAL [ARR NRES IDX]
+        nip                     ; SEL VAL [ARR NRES IDX]
         swap                    ; VAL SEL [ARR NRES IDX]
         fromr                   ; VAL SEL IDX [ARR NRES]
         dup                     ; VAL SEL IDX IDX [ARR NRES]
@@ -621,10 +610,9 @@
 ;;;   AST node with the type of the result.
 
         .macro bconc #op2_type_size @op1_type @op2_type @res_type
-        dup                       ; OP1 OP2 OP2
-        rot                       ; OP2 OP2 OP1
-        dup                       ; OP2 OP2 OP1 OP1
-        rot                       ; OP2 OP1 OP1 OP2
+        tuck                      ; OP2 OP1 OP2
+        over                      ; OP2 OP1 OP2 OP1
+        swap                      ; OP2 OP1 OP1 OP2
         ;; Convert the second operand to the result type.
         nton @op2_type, @res_type ; ... OP1 OP2 OP2C
         nip                       ; ... OP1 OP2C
diff --git a/src/pkl-gen.pks b/src/pkl-gen.pks
index 68cfbe5..73203bc 100644
--- a/src/pkl-gen.pks
+++ b/src/pkl-gen.pks
@@ -545,11 +545,9 @@
         .e check_struct_field_constraint
         ;; Calculate the offset marking the end of the field, which is
         ;; the field's offset plus it's size.
-        rot                    ; STR VAL BOFF
-        swap                   ; STR BOFF VAL
+        quake                  ; STR BOFF VAL
         siz                    ; STR BOFF VAL SIZ
-        rot                    ; STR VAL SIZ BOFF
-        swap                   ; STR VAL BOFF SIZ
+        quake                  ; STR VAL BOFF SIZ
         addlu
         nip                    ; STR VAL BOFF (BOFF+SIZ)
         tor                    ; STR VAL BOFF
diff --git a/src/pkl-insn.def b/src/pkl-insn.def
index 28a93e3..f33a8d4 100644
--- a/src/pkl-insn.def
+++ b/src/pkl-insn.def
@@ -55,6 +55,7 @@ PKL_DEF_INSN (PKL_INSN_DUP, "", "dup")
 PKL_DEF_INSN (PKL_INSN_OVER, "", "over")
 PKL_DEF_INSN (PKL_INSN_ROT, "", "rot")
 PKL_DEF_INSN (PKL_INSN_NROT, "", "nrot")
+PKL_DEF_INSN (PKL_INSN_TUCK, "", "tuck")
 PKL_DEF_INSN (PKL_INSN_SAVER, "r", "saver")
 PKL_DEF_INSN (PKL_INSN_RESTORER, "r", "restorer")
 PKL_DEF_INSN (PKL_INSN_TOR, "", "tor")
diff --git a/src/pvm.jitter b/src/pvm.jitter
index 94b6118..d05b240 100644
--- a/src/pvm.jitter
+++ b/src/pvm.jitter
@@ -950,31 +950,19 @@ end
 
 instruction rot () # ( A B C -- B C A )
   code
-   pvm_val a, b, c;
-
-   c = JITTER_TOP_STACK ();
-   JITTER_DROP_STACK ();
-   b = JITTER_TOP_STACK ();
-   a = JITTER_UNDER_TOP_STACK ();
-
-   JITTER_UNDER_TOP_STACK () = b;
-   JITTER_TOP_STACK () = c;
-   JITTER_PUSH_STACK (a);
+    JITTER_ROT_STACK ();
   end
 end
 
 instruction nrot () # ( A B C -- C A B )
   code
-   pvm_val a, b, c;
-
-   c = JITTER_TOP_STACK ();
-   JITTER_DROP_STACK ();
-   b = JITTER_TOP_STACK ();
-   a = JITTER_UNDER_TOP_STACK ();
+    JITTER_MROT_STACK ();
+  end
+end
 
-   JITTER_UNDER_TOP_STACK () = c;
-   JITTER_TOP_STACK () = a;
-   JITTER_PUSH_STACK (b);
+instruction tuck () #  ( A B -- B A B )
+  code
+    JITTER_TUCK_STACK ();
   end
 end
 
@@ -1033,9 +1021,9 @@ instruction sel () # ( VAL -- VAL ULONG )
   end
 end
 
-instruction revn (?n popf_printer) # ( VAL{N} -- VAL{N} )
+instruction revn (?n 3 4 popf_printer) # ( VAL{N} -- VAL{N} )
   code
-    JITTER_REVERSE_STACK (JITTER_ARGN0);
+    JITTER_REVERSE_STACK (JITTER_ARGU0);
   end
 end
 
@@ -2768,3 +2756,14 @@ into
   drop4
 end
 
+rule swap-over-to-tuck rewrite
+  swap; over
+into
+  tuck
+end
+
+rule rot-swap-to-quake rewrite
+  rot; swap
+into
+  quake
+end

Attachment: signature.asc
Description: PGP signature


reply via email to

[Prev in Thread] Current Thread [Next in Thread]