Merge pull request #658 from zickgraf/compiler_improvements

Compiler improvements

Author: zickgraf

CAP/gap/DerivedMethods.gi

@@ -1317,6 +1317,7 @@ AddDerivationToCAP( LiftAlongMonomorphism,
   function( cat, alpha, beta )
 
     ## Caution with the order of the arguments!
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
     return Lift( beta, alpha );
 
 end : Description := "LiftAlongMonomorphism using Lift" );
@@ -1327,6 +1328,7 @@ AddDerivationToCAP( ProjectiveLift,
 
   function( cat, alpha, beta )
 
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
     return Lift( alpha, beta );
 
 end : Description := "ProjectiveLift using Lift" );
@@ -1338,6 +1340,7 @@ AddDerivationToCAP( ColiftAlongEpimorphism,
 
   function( cat, alpha, beta )
 
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
     return Colift( alpha, beta );
 
 end : Description := "ColiftAlongEpimorphism using Colift" );
@@ -1348,6 +1351,7 @@ AddDerivationToCAP( InjectiveColift,
 
   function( cat, alpha, beta )
 
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
     return Colift( alpha, beta );
 
 end : Description := "InjectiveColift using Colift" );

CompilerForCAP/TODO

@@ -9,7 +9,6 @@ Features:
 
 * list expressions for logic templates
 * do not inline variables but only a reference to them for the logic to use
-* support for KeyDependentOperation
 * support compilation of operations
 * support assigning a variable multiple times, at least in different if branches
 * handle WithGiven derivations explicitely (Note: The WithGiven derivations use CallFuncList with the second argument

CompilerForCAP/doc/Extension.autodoc

@@ -26,6 +26,11 @@ To simplify the handling of syntax trees, the CAP compiler enhances syntax trees
 * Branches of STAT_IF etc. are given the type BRANCH_IF.
 * If the body of a BRANCH_IF is not a STAT_SEQ_STAT, the body is wrapped in a STAT_SEQ_STAT.
 * The key-value pairs of EXPR_RECs are given the type REC_KEY_VALUE_PAIR.
+* Statements of the form `if condition then return expr_if_true; else return expr_if_false; fi` and
+  `if condition then var := expr_if_true; else var := expr_if_false; fi` are coded using
+  a new expression type `EXPR_CONDITIONAL` with components `condition`, `expr_if_true`, and `expr_if_false`.
+  This makes such statements easier to handle. Hopefully, GAP will support conditional expressions
+  (i.e. `condition ? expr_if_true : expr_if_false`) natively in the future.
 * A globally unique ID is assigned to each function.
 * The handling of local variables and higher variables is unified by the concept of function variables:
   function variables (FVARs) reference local variables in functions via the function id (`func_id`) and

CompilerForCAP/doc/Usage.autodoc

@@ -39,6 +39,11 @@ During the resolving phase, operations and global variables are resolved:
   are considered, and those do not have to be annotated with `CAP_JIT_RESOLVE_FUNCTION`. In particular, caching, pre functions, etc.
   are bypassed.
 * References to global functions are resolved if the function is annotated with the pragma `CAP_JIT_RESOLVE_FUNCTION`.
+* If a call of a global function or operation (occuring as the right hand side of a variable assignment or as the return value of a function)
+  is annotated with the pragma `CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL`, the compiler assumes that the resolved function never returns `fail`
+  and thus simply removes any code of the form `if condition then return fail; fi;` (or similar) from the resolved function.
+  The pragma has to be placed right before the variable assignment or the return statement.
+* If a KeyDependentOperation is detected, the corresponding `Op` method is resolved.
 For details see <Ref Func="CapJitResolvedOperations" /> and <Ref Func="CapJitResolvedGlobalVariables" />.
 If no operation or global variable can be resolved anymore, we continue with the rule phase.
 

CompilerForCAP/examples/CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL.g

@@ -0,0 +1,81 @@
+#! @Chapter Examples and tests
+
+#! @Section Tests
+
+LoadPackage( "LinearAlgebraForCAP" );
+
+#! @Example
+
+Q := HomalgFieldOfRationals();;
+rows := MatrixCategory( Q );;
+
+MyKernelLift := function( cat, mor, test_morphism )
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
+    return Lift( cat, test_morphism, KernelEmbedding( cat, mor ) ); end;;
+
+V := VectorSpaceObject( 2, Q );;
+compiled_func := CapJitCompiledFunction(
+    MyKernelLift,
+    [ rows, ZeroMorphism( V, V ), IdentityMorphism( V ) ]
+);;
+tree := SYNTAX_TREE( compiled_func );;
+# check that the fail has been compiled away,
+# that is, we simply return a CAP morphism
+Length( tree.stats.statements ) = 1;
+#! true
+tree.stats.statements[1].type = "STAT_RETURN_OBJ";
+#! true
+StartsWith( tree.stats.statements[1].obj.type, "EXPR_FUNCCALL" );
+#! true
+tree.stats.statements[1].obj.funcref.type = "EXPR_REF_GVAR";
+#! true
+tree.stats.statements[1].obj.funcref.gvar = "ObjectifyWithAttributes";
+#! true
+
+func1 := function( x )
+    #% CAP_JIT_RESOLVE_FUNCTION
+    if x = 1 then return fail; fi; return 1; end;;
+
+func2 := function( x )
+    #% CAP_JIT_RESOLVE_FUNCTION
+    if x = 1 then return fail; else return 1; fi; end;;
+
+# we have to work hard to not write semicolons so AutoDoc
+# does not begin a new statement
+func3 := EvalString( ReplacedString( """function( x )
+    local y@
+    #% CAP_JIT_RESOLVE_FUNCTION
+    if x = 1 then
+        y := fail@
+    else
+        y := 1@
+    fi@
+    return y@
+end""", "@", ";" ) );;
+
+call_func1 := function( x )
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
+    return func1( x ); end;;
+
+call_func2 := function( x )
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
+    return func2( x ); end;;
+
+call_func3 := function( x )
+    #% CAP_JIT_NEXT_FUNCCALL_DOES_NOT_RETURN_FAIL
+    return func3( x ); end;;
+
+Display( CapJitCompiledFunction( call_func1, [ 2 ] ) );
+#! function ( x )
+#!     return 1;
+#! end
+Display( CapJitCompiledFunction( call_func2, [ 2 ] ) );
+#! function ( x )
+#!     return 1;
+#! end
+Display( CapJitCompiledFunction( call_func3, [ 2 ] ) );
+#! function ( x )
+#!     return 1;
+#! end
+
+#! @EndExample

CompilerForCAP/examples/EXPR_CONDITIONAL.g

@@ -0,0 +1,110 @@
+#! @Chapter Examples and tests
+
+#! @Section Tests
+
+LoadPackage( "CompilerForCAP" );
+
+#! @Example
+
+func1 := function( x )
+    if x = 1 then return 1; else return 2; fi; end;;
+
+tree1 := ENHANCED_SYNTAX_TREE( func1 );;
+tree1.stats.statements[1].obj.type = "EXPR_CONDITIONAL";
+#! true
+
+coded_func1 := ENHANCED_SYNTAX_TREE_CODE( tree1 );;
+String( func1 ) = String( coded_func1 );
+#! true
+
+func2 := function( x )
+  local y; if x = 1 then y := 1; else y := 2; fi; return y; end;;
+
+tree2 := ENHANCED_SYNTAX_TREE( func2 );;
+tree2.stats.statements[1].rhs.type = "EXPR_CONDITIONAL";
+#! true
+
+coded_func2 := ENHANCED_SYNTAX_TREE_CODE( tree2 );;
+String( func2 ) = String( coded_func2 );
+#! true
+
+tree3 := rec(
+    type := "EXPR_FUNC",
+    id := 1,
+    nams := [ ],
+    narg := 0,
+    nloc := 0,
+    variadic := false,
+    stats := rec(
+        type := "STAT_SEQ_STAT",
+        statements := [
+            rec(
+                type := "STAT_RETURN_OBJ",
+                obj := rec(
+                    type := "EXPR_FUNCCALL",
+                    funcref := rec(
+                        type := "EXPR_REF_GVAR",
+                        gvar := "IdFunc",
+                    ),
+                    args := [
+                        rec(
+                            type := "EXPR_CONDITIONAL",
+                            condition := rec(
+                                type := "EXPR_FALSE",
+                            ),
+                            expr_if_true := rec(
+                                type := "EXPR_INT",
+                                value := 1,
+                            ),
+                            expr_if_false := rec(
+                                type := "EXPR_INT",
+                                value := 2,
+                            ),
+                        ),
+                    ],
+                ),
+            ),
+        ],
+    ),
+);;
+
+coded_func3 := ENHANCED_SYNTAX_TREE_CODE( tree3 );;
+Display( coded_func3 );
+#! function (  )
+#!     return IdFunc( function (  )
+#!               if false then
+#!                   return 1;
+#!               else
+#!                   return 2;
+#!               fi;
+#!               return;
+#!           end(  ) );
+#! end
+
+coded_func3();
+#! 2
+
+func4 := function( x )
+  local y; if x then y := 1; else y := 2; fi; return IdFunc( y ); end;;
+
+compiled_func4 := CapJitCompiledFunction( func4, [ true ] );;
+Display( compiled_func4 );
+#! function ( x )
+#!     if x then
+#!         return ID_FUNC( 1 );
+#!     else
+#!         return ID_FUNC( 2 );
+#!     fi;
+#!     return;
+#! end
+
+func5 := function( x )
+  local y; if x then return 1; else return 1; fi; end;;
+
+compiled_func5 := CapJitCompiledFunction( func5, [ true ] );;
+Display( compiled_func5 );
+#! function ( x )
+#!     return 1;
+#! end
+
+#! @EndExample

CompilerForCAP/examples/KeyDependentOperation.g

@@ -0,0 +1,32 @@
+#! @Chapter Examples and tests
+
+#! @Section Tests
+
+LoadPackage( "CompilerForCAP" );
+
+#! @Example
+
+KeyDependentOperation( "MyKeyDependentOperation",
+                       IsGroup, IsInt, ReturnTrue );;
+
+InstallMethod( MyKeyDependentOperationOp,
+    [ IsGroup, IsInt ],
+    function( G, int )
+        #% CAP_JIT_RESOLVE_FUNCTION
+        return int; end );;
+
+G := SymmetricGroup(3);;
+
+MyKeyDependentOperation( G, 2 ) = 2;
+#! true
+
+MyFunction := G -> MyKeyDependentOperation( G, 2 );;
+
+compiled_func := CapJitCompiledFunction( MyFunction, [ G ] );;
+
+Display( compiled_func );
+#! function ( G )
+#!     return 2;
+#! end
+
+#! @EndExample

CompilerForCAP/examples/LinearAlgebraForCAP.g

@@ -2,6 +2,8 @@
 
 #! @Section Examples
 
+LoadPackage( "LinearAlgebra" );
+
 #! @Example
 
 Q := HomalgFieldOfRationals();;
@@ -22,7 +24,7 @@ tree1 := SYNTAX_TREE(
     vec!.compiled_functions.MorphismBetweenDirectSums[3]
 );;
 # fixup nams
-tree1.stats.statements[1].branches[2].body.statements[1].
+tree1.stats.statements[1].branches[2].body.
     obj.args[12].args[1].args[2].nams := [ "row" ];;
 Display( SYNTAX_TREE_CODE( tree1 ) );
 #! function ( cat, S, morphism_matrix, T )
@@ -47,7 +49,7 @@ tree2 := SYNTAX_TREE( CapJitCompiledFunction(
     [ vec, W, morphism_matrix, W  ]
 ) );;
 # fixup nams
-tree2.stats.statements[1].branches[2].body.statements[1].
+tree2.stats.statements[1].branches[2].body.
     obj.args[12].args[1].args[2].nams := [ "row" ];;
 Display( SYNTAX_TREE_CODE( tree2 ) );
 #! function ( cat, S, morphism_matrix, T )

CompilerForCAP/examples/rapid_rassignment.g

@@ -0,0 +1,20 @@
+#! @Chapter Examples and tests
+
+#! @Section Tests
+
+LoadPackage( "CompilerForCAP" );
+
+#! @Example
+
+func1 := function( x, y )
+    #% CAP_JIT_RESOLVE_FUNCTION
+    return x; end;;
+
+func2 := function( )
+  local var; var := 1; var := func1( 2, var ); return var; end;;
+
+compiled_func := CapJitCompiledFunction( func2, [] );;
+compiled_func();
+#! 2
+
+#! @EndExample

CompilerForCAP/gap/CompilerForCAP.gi

@@ -73,6 +73,14 @@ InstallGlobalFunction( CapJitCompiledFunction, function ( func, jit_args )
 
         tree := CapJitAppliedLogicTemplates( tree, jit_args, true );
 
+        if debug then
+            compiled_func := ENHANCED_SYNTAX_TREE_CODE( tree );
+            Display( compiled_func );
+            Error( "apply CapJitInlinedVariableAssignments (for rapid reassignments only)" );
+        fi;
+        
+        tree := CapJitInlinedVariableAssignments( tree : inline_rapid_reassignments_only := true );
+        
         # new functions might be resolved -> test for side effects
         CapJitThrowErrorOnSideEffects( tree );
 
@@ -95,10 +103,10 @@ InstallGlobalFunction( CapJitCompiledFunction, function ( func, jit_args )
         if debug then
             compiled_func := ENHANCED_SYNTAX_TREE_CODE( tree );
             Display( compiled_func );
-            Error( "apply CapJitInlinedVariableAssignments" );
+            Error( "apply CapJitInlinedVariableAssignments (for global variables only)" );
         fi;
 
-        tree := CapJitInlinedVariableAssignments( tree, true );
+        tree := CapJitInlinedVariableAssignments( tree : inline_gvars_only := true );
 
         if debug then
             compiled_func := ENHANCED_SYNTAX_TREE_CODE( tree );

CompilerForCAP/gap/DropHandledEdgeCases.gi

@@ -65,7 +65,7 @@ InstallGlobalFunction( CapJitDroppedHandledEdgeCases, function ( tree )
 
                         branch := branches[j];
 
-                        if Last( branch.body.statements ).type = "STAT_RETURN_OBJ" then
+                        if Length( branch.body.statements ) > 0 and Last( branch.body.statements ).type = "STAT_RETURN_OBJ" then
 
                             # we are in the main sequence of statements of a function => we are not inside of a loop
                             # and this branch ends with a return statement