effective compilation of higher order programs
play

Effective Compilation of Higher-Order Programs Roland Leia Klaas - PowerPoint PPT Presentation

Dec 21, 2023 •374 likes •1.79k views

Effective Compilation of Higher-Order Programs Roland Leia Klaas Boesche Sebastian Hack Richard Membarth Arsne Prard-Gayot Philipp Slusallek http://compilers.cs.uni-saarland.de https://github.com/AnyDSL/thorin Compiler Design Lab

  1. post_order_visit with clang -O3 -fno-exceptions define internal fastcc void @_ZL16post_order_visitP4NodeSt8functionIFviEE ( %struct . Node* nocapture readonly %n , % "class.std::function" * %f ) unnamed_addr #3 { entry : %__args . addr . i = alloca i32 , align 4 %agg . tmp = alloca % "class.std::function" , align 8 %agg . tmp5 = alloca % "class.std::function" , align 8 %left = getelementptr inbounds %struct . Node , %struct . Node* %n , i64 0 , i32 1 %0 = load %struct . Node* , %struct . Node** %left , align 8 , ! tbaa !8 %tobool = icmp eq %struct . Node* %0 , null br i 1 %tobool , label %if . end , label %if . then i f . then : ; preds = %entry %_M_manager . i . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp , i64 0 , i32 0 , i32 1 store i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* null , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i , align 8 , ! tbaa !6 %_M_manager . i . i . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 0 , i32 1 %1 = load i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i . i , align 8 , ! tbaa !6 %lnot . i . i = icmp eq i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* %1 , null br i 1 %lnot . i . i , label %_ZNSt8functionIFviEEC2ERKS1_ . exit , label %if . then . i i f . then . i : ; preds = %if . then %_M_functor . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp , i64 0 , i32 0 , i32 0 %_M_functor2 . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 0 , i32 0 %call3 . i = c a l l zeroext i 1 %1 ( % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i , % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor2 . i , i32 2) #2 %2 = bitcas t i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i . i to <2 x i64 >* %3 = load <2 x i64 > , <2 x i64 >* %2 , align 8 , ! tbaa ! 1 1 %4 = bitcas t i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i to <2 x i64 >* store <2 x i64 > %3 , <2 x i64 >* %4 , align 8 , ! tbaa ! 1 1 br label %_ZNSt8functionIFviEEC2ERKS1_ . e x i t _ZNSt8functionIFviEEC2ERKS1_ . e x i t : ; preds = %if . then , %if . then . i c a l l fastcc void @_ZL16post_order_visitP4NodeSt8functionIFviEE ( %struct . Node* nonnull %0 , % "class.std::function" * nonnull %agg . tmp) %5 = load i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i , align 8 , ! tbaa !6 %tobool . i = icmp eq i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* %5 , null br i 1 %tobool . i , label %if . end , label %if . then . i 1 7 i f . then . i 1 7 : ; preds = %_ZNSt8functionIFviEEC2ERKS1_ . e x i t %_M_functor . i16 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp , i64 0 , i32 0 , i32 0 %call . i = c a l l zeroext i 1 %5 ( % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i16 , % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i16 , i32 3) #2 br label %if . end i f . end : ; preds = %if . then . i17 , %_ZNSt8functionIFviEEC2ERKS1_ . exit , %entry %right = getelementptr inbounds %struct . Node , %struct . Node* %n , i64 0 , i32 2 %6 = load %struct . Node* , %struct . Node** %right , align 8 , ! tbaa ! 1 2 %tobool2 = icmp eq %struct . Node* %6 , null br i 1 %tobool2 , label %if . end . i f . end6_crit_edge , label %if . then3 i f . end . i f . end6_crit_edge : ; preds = %if . end % . pre = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 0 , i32 1 br label %if . end6 i f . then3 : ; preds = %if . end %_M_manager . i . i18 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp5 , i64 0 , i32 0 , i32 1 store i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* null , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i18 , align 8 , ! tbaa !6 %_M_manager . i . i . i19 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 0 , i32 1 %7 = load i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i . i19 , align 8 , ! tbaa !6 %lnot . i . i20 = icmp eq i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* %7 , null br i 1 %lnot . i . i20 , label %_ZNSt8functionIFviEEC2ERKS1_ . exit27 , label %if . then . i26 i f . then . i26 : ; preds = %if . then3 %_M_functor . i 2 1 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp5 , i64 0 , i32 0 , i32 0 %_M_functor2 . i22 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 0 , i32 0 %call3 . i23 = c a l l zeroext i 1 %7 ( % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i21 , % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor2 . i22 , i32 2) #2 %8 = bitcas t i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i . i19 to <2 x i64 >* %9 = load <2 x i64 > , <2 x i64 >* %8 , align 8 , ! tbaa ! 1 1 %10 = bitcas t i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i18 to <2 x i64 >* store <2 x i64 > %9 , <2 x i64 >* %10 , align 8 , ! tbaa ! 1 1 br label %_ZNSt8functionIFviEEC2ERKS1_ . e x i t 2 7 _ZNSt8functionIFviEEC2ERKS1_ . e x i t 2 7 : ; preds = %if . then3 , %if . then . i26 c a l l fastcc void @_ZL16post_order_visitP4NodeSt8functionIFviEE ( %struct . Node* nonnull %6 , % "class.std::function" * nonnull %agg . tmp5 ) %11 = load i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i18 , align 8 , ! tbaa !6 %tobool . i29 = icmp eq i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* %11 , null br i 1 %tobool . i29 , label %if . end6 , label %if . then . i32 i f . then . i32 : ; preds = %_ZNSt8functionIFviEEC2ERKS1_ . e x i t 2 7 %_M_functor . i30 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp5 , i64 0 , i32 0 , i32 0 %call . i 3 1 = c a l l zeroext i 1 %11 ( % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i30 , % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i30 , i32 3) #2 br label %if . end6 i f . end6 : ; preds = %if . end . i f . end6_crit_edge , %if . then . i32 , %_ZNSt8functionIFviEEC2ERKS1_ . e x i t 2 7 %_M_manager . i . i 1 1 . pre_phi = phi i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * [ % . pre , %if . end . i f . end6_crit_edge ] , [ %_M_manager . i . i . i19 , %if . then . i32 ] , [ %_M_manager . i . i . i19 , %_ZNSt8functionIFviEEC2ERKS1_ . e x i t 2 7 ] %data = getelementptr inbounds %struct . Node , %struct . Node* %n , i64 0 , i32 0 %12 = load i32 , i32 * %data , align 8 , ! tbaa ! 1 3 %13 = bitcas t i32 * %__args . addr . i to i8 * c a l l void @llvm . l i f e t i m e . s t a r t ( i64 4 , i8 * %13 ) store i32 %12 , i32 * %__args . addr . i , align 4 , ! tbaa ! 1 4 %14 = load i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i 1 1 . pre_phi , align 8 , ! tbaa !6 %lnot . i . i 1 2 = icmp eq i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* %14 , null br i 1 %lnot . i . i12 , label %if . then . i13 , label %_ZNKSt8functionIFviEEclEi . e x i t i f . then . i 1 3 : ; preds = %if . end6 c a l l void @_ZSt25__throw_bad_function_callv ( ) #7 unreachable _ZNKSt8functionIFviEEclEi . e x i t : ; preds = %if . end6 %_M_invoker . i1 4 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 1 %15 = load void ( % "union.std::_Any_data" * , i32 * ) * , void ( % "union.std::_Any_data" * , i32 * ) * * %_M_invoker . i14 , align 8 , ! tbaa ! 1 %_M_functor . i 1 5 = getelementptr inbounds % "class.std::function" , % "class.std::function" * %f , i64 0 , i32 0 , i32 0 c a l l void %15 ( % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i15 , i32 * nonnull dereferenceable ( 4 ) %__args . addr . i ) #2 c a l l void @llvm . l i f e t i m e . end ( i64 4 , i8 * %13 ) ret void }

  2. print with clang -O3 -fno-exceptions define void @_Z5printP4Node ( %struct . Node* nocapture readonly %n ) #3 { entry : %agg . tmp = alloca % "class.std::function" , align 8 %_M_manager . i . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp , i64 0 , i32 0 , i32 1 %_M_invoker . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp , i64 0 , i32 1 store void ( % "union.std::_Any_data" * , i32 * ) * @ "_ZNSt17_Function_handlerIFviEZ5printP4NodeE3$_0E9_M_invokeERKSt9_Any_dataOi" , void ( % "union.std::_Any_data" * , i32 * ) * * %_M_invoker . i , align 8 , ! tbaa ! 1 store i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* @ "_ZNSt14_Function_base13_Base_managerIZ5printP4NodeE3$_0E10_M_managerERSt9_Any_dataRKS5_St18_Manager_operation" , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i , align 8 , ! tbaa !6 c a l l fastcc void @_ZL16post_order_visitP4NodeSt8functionIFviEE ( %struct . Node* %n , % "class.std::function" * nonnull %agg . tmp) %0 = load i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * , i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 ) * * %_M_manager . i . i , align 8 , ! tbaa !6 %tobool . i = icmp eq i 1 ( % "union.std::_Any_data" * , % "union.std::_Any_data" * , i32 )* %0 , null br i 1 %tobool . i , label %_ZNSt14_Function_baseD2Ev . exit , label %if . then . i i f . then . i : ; preds = %entry %_M_functor . i = getelementptr inbounds % "class.std::function" , % "class.std::function" * %agg . tmp , i64 0 , i32 0 , i32 0 %call . i = c a l l zeroext i 1 %0 ( % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i , % "union.std::_Any_data" * dereferenceable ( 1 6 ) %_M_functor . i , i32 3) #2 br label %_ZNSt14_Function_baseD2Ev . e x i t _ZNSt14_Function_baseD2Ev . e x i t : ; preds = %entry , %if . then . i ret void } define internal void @ "_ZNSt17_Function_handlerIFviEZ5printP4NodeE3$_0E9_M_invokeERKSt9_Any_dataOi" ( % "union.std::_Any_data" * nocapture readnone dereferenceable ( 1 6 ) %__functor , i32 * nocapture readonly dereferenceable ( 4 ) %__args ) #3 align 2 { entry : %0 = load i32 , i32 * %__args , align 4 , ! tbaa ! 1 4 %call . i = t a i l c a l l dereferenceable ( 2 7 2 ) % "class.std::basic_ostream" * @_ZNSolsEi ( % "class.std::basic_ostream" * nonnull @_ZSt4cout , i32 %0 ) #2 %1 = bitcas t % "class.std::basic_ostream" * %call . i to i8 ** %vtable . i . i = load i8 * , i8 ** %1 , align 8 , ! tbaa ! 1 5 %vbase . offset . ptr . i . i = getelementptr i8 , i8 * %vtable . i . i , i64 _24 %2 = bitcas t i8 * %vbase . offset . ptr . i . i to i64 * %vbase . offset . i . i = load i64 , i64 * %2 , align 8 %3 = bitcas t % "class.std::basic_ostream" * %call . i to i8 * %add . ptr . i . i = getelementptr inbounds i8 , i8 * %3 , i64 %vbase . offset . i . i %_M_ctype . i . i = getelementptr inbounds i8 , i8 * %add . ptr . i . i , i64 240 %4 = bitcas t i8 * %_M_ctype . i . i to % "class.std::ctype" ** %5 = load % "class.std::ctype" * , % "class.std::ctype" ** %4 , align 8 , ! tbaa ! 1 7 %tobool . i5 . i = icmp eq % "class.std::ctype" * %5 , null br i 1 %tobool . i5 . i , label %if . then . i6 . i , label %_ZSt13__check_facetISt5ctypeIcEERKT_PS3_ . e x i t . i i f . then . i6 . i : ; preds = %entry t a i l c a l l void @_ZSt16__throw_bad_castv ( ) #7 unreachable _ZSt13__check_facetISt5ctypeIcEERKT_PS3_ . e x i t . i : ; preds = %entry %_M_widen_ok . i . i = getelementptr inbounds % "class.std::ctype" , % "class.std::ctype" * %5 , i64 0 , i32 8 %6 = load i8 , i8 * %_M_widen_ok . i . i , align 8 , ! tbaa !20 %tobool . i . i = icmp eq i8 %6 , 0 br i 1 %tobool . i . i , label %if . end . i . i , label %if . then . i . i i f . then . i . i : ; preds = %_ZSt13__check_facetISt5ctypeIcEERKT_PS3_ . e x i t . i %arrayidx . i . i = getelementptr inbounds % "class.std::ctype" , % "class.std::ctype" * %5 , i64 0 , i32 9 , i64 10 %7 = load i8 , i8 * %arrayidx . i . i , align 1 , ! tbaa ! 22 br label % "_ZZ5printP4NodeENK3$_0clEi.exit" i f . end . i . i : ; preds = %_ZSt13__check_facetISt5ctypeIcEERKT_PS3_ . e x i t . i t a i l c a l l void @_ZNKSt5ctypeIcE13_M_widen_initEv ( % "class.std::ctype" * nonnull %5 ) #2 %8 = bitcas t % "class.std::ctype" * %5 to i8 ( % "class.std::ctype" * , i8 ) * * * %vtable . i3 . i = load i8 ( % "class.std::ctype" * , i8 ) * * , i8 ( % "class.std::ctype" * , i8 ) * * * %8 , align 8 , ! tbaa ! 1 5 %vfn . i . i = getelementptr inbounds i8 ( % "class.std::ctype" * , i8 ) * , i8 ( % "class.std::ctype" * , i8 ) * * %vtable . i3 . i , i64 6 %9 = load i8 ( % "class.std::ctype" * , i8 ) * , i8 ( % "class.std::ctype" * , i8 ) * * %vfn . i . i , align 8 %call . i4 . i = t a i l c a l l signext i8 %9 ( % "class.std::ctype" * nonnull %5 , i8 signext 10) #2 br label % "_ZZ5printP4NodeENK3$_0clEi.exit" "_ZZ5printP4NodeENK3$_0clEi.exit" : ; preds = %if . then . i . i , %if . end . i . i %retval . 0 . i . i = phi i8 [ %7 , %if . then . i . i ] , [ %call . i4 . i , %if . end . i . i ] %call1 . i . i = t a i l c a l l dereferenceable ( 2 7 2 ) % "class.std::basic_ostream" * @_ZNSo3putEc ( % "class.std::basic_ostream" * nonnull %call . i , i8 signext %retval . 0 . i . i ) #2 %call . i . i = t a i l c a l l dereferenceable ( 2 7 2 ) % "class.std::basic_ostream" * @_ZNSo5flushEv ( % "class.std::basic_ostream" * nonnull %call1 . i . i ) #2 ret void } define internal zeroext i 1 @ "_ZNSt14_Function_base13_Base_managerIZ5printP4NodeE3$_0E10_M_managerERSt9_Any_dataRKS5_St18_Manager_operation" ( % "union.std::_Any_data" * nocapture dereferenceable ( 1 6 ) %__dest , % "union.std::_Any_data" * dereferenceable ( 1 6 ) %__source , i32 %__op ) #5 align 2 { entry : switch i32 %__op , label %sw . epilog [ i32 0 , label %sw . bb i32 1 , label %sw . bb1 ] sw . bb : ; preds = %entry %0 = bitcas t % "union.std::_Any_data" * %__dest to % "class.std::type_info" ** store % "class.std::type_info" * bitcas t ( { i8 * , i8 * }* @ "_ZTIZ5printP4NodeE3$_0" to % "class.std::type_info" * ) , % "class.std::type_info" ** %0 , align 8 , ! tbaa ! 1 1 br label %sw . epilog sw . bb1 : ; preds = %entry %1 = bitcas t % "union.std::_Any_data" * %__dest to % "union.std::_Any_data" ** store % "union.std::_Any_data" * %__source , % "union.std::_Any_data" ** %1 , align 8 , ! tbaa ! 1 1 br label %sw . epilog sw . epilog : ; preds = %entry , %sw . bb1 , %sw . bb ret i 1 false }

  3. • Shallow Embedding of DSLs via Online Partial Evaluation Leißa, Boesche, Hack, Membarth, and Slusallek. GPCE 2015. Working with higher-order Functions • A Graph-Based Higher-Order Intermediate Representation Leißa, Köster, and Hack. CGO 2015 9

  4. Working with higher-order Functions • A Graph-Based Higher-Order Intermediate Representation Leißa, Köster, and Hack. CGO 2015 • Shallow Embedding of DSLs via Online Partial Evaluation Leißa, Boesche, Hack, Membarth, and Slusallek. GPCE 2015. 9

  5. Closure Conversion

  6. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  7. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  8. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  9. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  10. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  11. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  12. struct closurebase { void (*f)( void * c, int i); }; struct closure { closurebase base; int n; }; void lambda( void * c, int i) { use(i, (closure* c)->n); } void range( int a, int b, void * c) { if (a < b) { ((closurebase*) c)->f(c, a); range(a+1, b, c); } } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); } Closure Conversion void range( int a, int b, function< void ( int )> f) { if (a < b) { f(a); range(a+1, b, f); } } void foo( int n) { range(0, n, [=] ( int i) { use(i, n); }); }

  13. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  14. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  15. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  16. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  17. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  18. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  19. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  20. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  21. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  22. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  23. struct closurebase { Closure Conversion void (*f)( void * c, int i); }; struct closure { closurebase base; int n; void range( int a, int b, }; function< void ( int )> f) { void lambda( void * c, int i) { if (a < b) { use(i, (closure* c)->n); f(a); } range(a+1, b, f); } void range( int a, int b, void * c) { } if (a < b) { ((closurebase*) c)->f(c, a); void foo( int n) { range(a+1, b, c); range(0, n, [=] ( int i) { } use(i, n); } }); } void foo( int n) { closure c = {{&lambda}, n}; range(0, n, &c); }

  24. • SSA-construct the closure struct • dissolve the struct to scalar values (Scalar Replacement of Aggregates) • usually works well for typical STL algorithms • fails for recursive higher-order functions like • range • post_order_visit What does LLVM do? • inline the call to the closure’s function pointer 11

  25. • usually works well for typical STL algorithms • fails for recursive higher-order functions like • range • post_order_visit What does LLVM do? • inline the call to the closure’s function pointer • SSA-construct the closure struct • dissolve the struct to scalar values (Scalar Replacement of Aggregates) 11

  26. • fails for recursive higher-order functions like • range • post_order_visit What does LLVM do? • inline the call to the closure’s function pointer • SSA-construct the closure struct • dissolve the struct to scalar values (Scalar Replacement of Aggregates) • usually works well for typical STL algorithms 11

  27. • range • post_order_visit What does LLVM do? • inline the call to the closure’s function pointer • SSA-construct the closure struct • dissolve the struct to scalar values (Scalar Replacement of Aggregates) • usually works well for typical STL algorithms • fails for recursive higher-order functions like 11

  28. What does LLVM do? • inline the call to the closure’s function pointer • SSA-construct the closure struct • dissolve the struct to scalar values (Scalar Replacement of Aggregates) • usually works well for typical STL algorithms • fails for recursive higher-order functions like • range • post_order_visit 11

  29. Closure Conversion closure clang AST LLVM BE conversion • reimplement for every front-end • taints the IR with implementation of higher-order functions • bloats the IR • set of finely tuned analyses & transformations needed for optimization 12

  30. Closure Conversion impala AST Thorin LLVM • Thorin = higher-order + CPS + ”sea of nodes” • directly translate higher-order functions and calls to Thorin • keep higher-order functions till late during compilation • powerful closure-elimination phase 12

  31. Thorin

  32. int foo( int n) { branch (n==0, then, else) then: goto next; else: goto next; next: int a = (23 [then], 42 [else]); return a; } SSA-Form int foo( int n) { int a; if (n==0) { a = 23; } else { a = 42; } return a; } 13

  33. SSA-Form int foo( int n) { int foo( int n) { int a; branch (n==0, then, else) if (n==0) { then: a = 23; goto next; } else { else: a = 42; goto next; } next: int a = φ (23 [then], 42 [else]); return a; return a; } } 13

  34. foo(n: int , ret: int ) : let then() : next(23) else() : next(42) next(a: int ) : ret(a) in branch (n==0, then, else) CPS int foo( int n) { branch (n==0, then, else) then: goto next; else: goto next; next: int a = φ (23 [then], 42 [else]); return a; } 14

  35. CPS int foo( int n) { foo(n: int , ret: int → ⊥ ) → ⊥ : branch (n==0, then, else) let then: then() → ⊥ : goto next; next(23) else: else() → ⊥ : goto next; next(42) next: next(a: int ) → ⊥ : int a = φ (23 [then], 42 [else]); ret(a) return a; in } branch (n==0, then, else) 14

  36. foo(n: int , ret: cn ( int )): n==0 branch ( , then, else) then(): next(23) else(): next(42) next(a: int ): ret(a) Thorin foo(n: int , ret: int → ⊥ ) → ⊥ : let then() → ⊥ : next(23) else() → ⊥ : next(42) next(a: int ) → ⊥ : ret(a) in branch (n==0, then, else) 15

  37. Thorin foo(n: int , ret: cn ( int )): n==0 branch ( • , then, else) foo(n: int , ret: int → ⊥ ) → ⊥ : then(): let then() → ⊥ : next(23) next(23) else() → ⊥ : next(42) else(): next(a: int ) → ⊥ : ret(a) next(42) in branch (n==0, then, else) next(a: int ): ret(a) 15

  38. Thorin foo(n: int , ret: cn ( int )): n==0 branch ( • , then, else) foo(n: int , ret: int → ⊥ ) → ⊥ : then(): let then() → ⊥ : next(23) next(23) else() → ⊥ : next(42) else(): next(a: int ) → ⊥ : ret(a) next(42) in branch (n==0, then, else) next(a: int ): ret(a) 15

  39. Thorin foo(n: int , ret: cn ( int )): n==0 branch ( • , then, else) foo(n: int , ret: int → ⊥ ) → ⊥ : then(): let then() → ⊥ : next(23) next(23) else() → ⊥ : next(42) else(): next(a: int ) → ⊥ : ret(a) next(42) in branch (n==0, then, else) next(a: int ): ret(a) 15

  40. Thorin foo(n: int , ret: cn ( int )): n==0 branch ( • , then, else) foo(n: int , ret: int → ⊥ ) → ⊥ : then(): let then() → ⊥ : next(23) next(23) else() → ⊥ : next(42) else(): next(a: int ) → ⊥ : ret(a) next(42) in branch (n==0, then, else) next(a: int ): ret(a) 15

  41. let graph edge (acyclic graph) letrec graph edge (cyclic graph) block nesting implicit name resolution graph edge name capture - Classic CPS vs Thorin Classic CPS Thorin 16

  42. block nesting implicit name resolution graph edge name capture - Classic CPS vs Thorin Classic CPS Thorin let graph edge (acyclic graph) letrec graph edge (cyclic graph) 16

  43. Classic CPS vs Thorin Classic CPS Thorin let graph edge (acyclic graph) letrec graph edge (cyclic graph) block nesting implicit name resolution graph edge name capture - 16

  44. parameter terminator -arg call parameter call primop function basic block instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } continuation

  45. parameter terminator -arg call call primop function basic block instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter continuation

  46. parameter terminator -arg call primop function basic block instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter call continuation

  47. parameter terminator -arg call primop basic block instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter call continuation function

  48. parameter terminator -arg call primop instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter call continuation function basic block

  49. terminator -arg call primop instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter parameter call continuation function basic block

  50. terminator -arg call primop instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter Φ parameter call continuation function basic block

  51. terminator -arg primop instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter call Φ parameter call continuation function basic block

  52. -arg primop instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter terminator call Φ parameter call continuation function basic block

  53. primop instruction SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter terminator Φ -arg call Φ parameter call continuation function basic block

  54. SSA vs Thorin int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } parameter terminator Φ -arg call Φ parameter call primop continuation function basic block instruction

  55. Lambda Mangling

  56. • first-order continuation basic block • top-level, continuation with “return” function • straightforward to translate to SSA form [Kelsey95] • no closures needed Control-Flow Form int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } • Thorin program in CFF if

  57. • top-level, continuation with “return” function • straightforward to translate to SSA form [Kelsey95] • no closures needed Control-Flow Form int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } • Thorin program in CFF if • first-order continuation ⇒ basic block

  58. • straightforward to translate to SSA form [Kelsey95] • no closures needed Control-Flow Form int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } • Thorin program in CFF if • first-order continuation ⇒ basic block • top-level, continuation with “return” ⇒ function

  59. Control-Flow Form int foo( int n) { foo(n: int , ret: cn ( int )): branch (n==0, then, else) branch (n==0, then, else) then: then(): goto next; next(23) else: else(): goto next; next(42) next: next(a: int ): int a = φ (23 [then], 42 [else]); ret(a) return a; } • Thorin program in CFF if • first-order continuation ⇒ basic block • top-level, continuation with “return” ⇒ function • straightforward to translate to SSA form [Kelsey95] • no closures needed

  60. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  61. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  62. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  63. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  64. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  65. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  66. Not in CFF void range( int a, int b, function< void ( int )> f) { //... range(a+1, b, f); } range(a: int , b: int , f: cn ( int , cn ()), ret: cn ()): /* * ... */ range(a+1, b, f, ret) CFF-convertible if • recursion-free or • tail-recursive 19

  67. explicit closures CFF-convertible lambda mangling Classes of Thorin Programs CFF 20

  68. explicit closures lambda mangling Classes of Thorin Programs CFF-convertible CFF 20

  69. lambda mangling Classes of Thorin Programs explicit closures CFF-convertible CFF 20

  70. Classes of Thorin Programs explicit closures CFF-convertible lambda mangling CFF 20

  71. • clone basic blocks/functions • loop peeling • loop unrolling • tail-recursion elimination • … Lambda Mangling = partial inlining/outlining • (partial) inlining • (partial) outlining 21

  72. • loop peeling • loop unrolling • tail-recursion elimination • … Lambda Mangling = partial inlining/outlining • (partial) inlining • (partial) outlining • clone basic blocks/functions 21

  73. • tail-recursion elimination • … Lambda Mangling = partial inlining/outlining • (partial) inlining • (partial) outlining • clone basic blocks/functions • loop peeling • loop unrolling 21

Recommend

A Higher-Order Abstract Syntax Approach to Verified Compilation of Functional Programs Yuting

A Higher-Order Abstract Syntax Approach to Verified Compilation of Functional Programs Yuting

A Higher-Order Abstract Syntax Approach to Verified Compilation of Functional Programs Yuting Wang and Gopalan Nadathur Department of Computer Science and Engineering University of Minnesota, Minneapolis ESOP 2016, Eindhoven, Netherlands

1.06k views • 88 slides
York University www.cs.york.ac.uk/~ndm First order vs Higher order Higher order:

York University www.cs.york.ac.uk/~ndm First order vs Higher order Higher order:

First Order Haskell Neil Mitchell York University www.cs.york.ac.uk/~ndm First order vs Higher order Higher order: functions are values Can be passed around Stored in data structure Harder for reasoning and analysis More

483 views • 15 slides
Learning higher-order logic programs through abstraction and invention [IJCAI16] T T C T C

Learning higher-order logic programs through abstraction and invention [IJCAI16] T T C T C

Learning higher-order logic programs through abstraction and invention [IJCAI16] T T C T C Initial state: Final state: First-order recursive solution [MLJ2015] f(A,B):-f3(A,B),at_end(B). f(A,B):-f3(A,C),f(C,B).

195 views • 15 slides
Why higher-order logic? Higher-Order logic Expressive Mathematics Verification

Why higher-order logic? Higher-Order logic Expressive Mathematics Verification

Extending SMT solvers to higher-order logic Haniel Barbosa Andrew Reynolds Daniel El Ouraoui Clark Barrett Cesare Tinelli SMT 2019 20190707, Lisbon, PT To be published in the proceedings of CADE 2019 Why higher-order logic?

569 views • 25 slides
On Congruence Property of Scope Equivalence for Concurrent Programs with Higher-Order

On Congruence Property of Scope Equivalence for Concurrent Programs with Higher-Order

On Congruence Property of Scope Equivalence for Concurrent Programs with Higher-Order Communication Masaki Murakami Okayama University JAPAN A Formal Model of Concurrent Systems the model presented here is a translation of asynchronous

847 views • 31 slides
Higher order complexity Hugo Fre Mathieu Hoyrup CCA 2013 Hugo Fre Higher order

Higher order complexity Hugo Fre Mathieu Hoyrup CCA 2013 Hugo Fre Higher order

Background &amp; motivation Higher order strategies Higher order Turing machines Computable analysis Conclusion Higher order complexity Hugo Fre Mathieu Hoyrup CCA 2013 Hugo Fre Higher order complexity 1/12 Background &amp;

383 views • 15 slides
Higher-order Interpretations for Higher-order Complexity Emmanuel Hainry &amp; Romain Pchoux

Higher-order Interpretations for Higher-order Complexity Emmanuel Hainry &amp; Romain Pchoux

Higher-order Interpretations for Higher-order Complexity Emmanuel Hainry &amp; Romain Pchoux DICE-FOPARA, 22-23 april 2017 CNRS, INRIA, Universit de Lorraine &amp; LORIA, Nancy, France 1 Introduction First-order computability and

801 views • 46 slides
Constructing Subtle Higher Order Mutants from Java and AspectJ Programs Elmahdi Omar,

Constructing Subtle Higher Order Mutants from Java and AspectJ Programs Elmahdi Omar,

Constructing Subtle Higher Order Mutants from Java and AspectJ Programs Elmahdi Omar, Sudipto Ghosh and Darrell Whitley Department of Computer Science Colorado State University

477 views • 37 slides
Higher-Order Concurrent Separation Logic: Why and How Lars Birkedal Aarhus University Nijmegen,

Higher-Order Concurrent Separation Logic: Why and How Lars Birkedal Aarhus University Nijmegen,

Higher-Order Concurrent Separation Logic: Why and How Lars Birkedal Aarhus University Nijmegen, Netherlands Dec, 2015 Modular Reasoning about Higher-Order Concurrent Imperative Programs 1 / 33 Introduction Goal Program logics for

1.02k views • 63 slides
The Compilation Process Preprocessing: o processes include-files, conditional compilation and

The Compilation Process Preprocessing: o processes include-files, conditional compilation and

4/1/14 The Compilation Process Preprocessing: o processes include-files, conditional compilation and macros. Compilation: Writing Large Programs o takes the output of the preprocessor and the source code, and generates assembler

271 views • 6 slides
Higher-order Interpretations for Higher-order Complexity Emmanuel Hainry &amp; Romain Pchoux

Higher-order Interpretations for Higher-order Complexity Emmanuel Hainry &amp; Romain Pchoux

Higher-order Interpretations for Higher-order Complexity Emmanuel Hainry &amp; Romain Pchoux LPAR, 11 may 2017 CNRS, INRIA, Universit de Lorraine &amp; LORIA, Nancy, France 1 Introduction First-order computability and complexity

665 views • 39 slides
First-Order Knowledge Compilation Guy Van den Broeck Dagstuhl Sept 18, 2017 Overview 1.

First-Order Knowledge Compilation Guy Van den Broeck Dagstuhl Sept 18, 2017 Overview 1.

First-Order Knowledge Compilation Guy Van den Broeck Dagstuhl Sept 18, 2017 Overview 1. Propositional Refresher 2. Primer: A First-Order Tractable Language 3. Probabilistic Databases 4. Symmetric First-Order Model Counting 5. Lots of

2.09k views • 181 slides
A Relational Logic for Higher-Order Programs Alejandro Aguirre 1 Gilles Barthe 1 Marco Gaboardi 2

A Relational Logic for Higher-Order Programs Alejandro Aguirre 1 Gilles Barthe 1 Marco Gaboardi 2

A Relational Logic for Higher-Order Programs Alejandro Aguirre 1 Gilles Barthe 1 Marco Gaboardi 2 Deepak Garg 3 Pierre-Yves Strub 4 ICFP, Sep 5 2017 1 Imdea Software; 2 University at Buffalo, SUNY; 3 MPI-SWS; 4 cole Polytechnique 1 Relational

469 views • 45 slides
Outline Higher Order Statistics First, second and higher-order statistics Matthias Hennig

Outline Higher Order Statistics First, second and higher-order statistics Matthias Hennig

Outline Higher Order Statistics First, second and higher-order statistics Matthias Hennig Generative models, recognition models Neural Information Processing Sparse Coding School of Informatics, University of Edinburgh Independent Components

358 views • 9 slides
Fair Termination of Higher-Order Functional Programs Keiichi Watanabe , Ryosuke Sato Takeshi

Fair Termination of Higher-Order Functional Programs Keiichi Watanabe , Ryosuke Sato Takeshi

Automatically Disproving Fair Termination of Higher-Order Functional Programs Keiichi Watanabe , Ryosuke Sato Takeshi Tsukada, Naoki Kobayashi The University of Tokyo September 20 th , 2016 ICFP 2016 at Nara 1 2 Our Goal Automated method for

923 views • 54 slides
Higher-Order Model Checking III: Reducing Model Checking to Type Inference IV: Applications:

Higher-Order Model Checking III: Reducing Model Checking to Type Inference IV: Applications:

Higher-Order Model Checking III: Reducing Model Checking to Type Inference IV: Applications: Verifying Higher-order Functional Programs Luke Ong University of Oxford http://www.cs.ox.ac.uk/people/luke.ong/personal/ http://mjolnir.cs.ox.ac.uk

856 views • 26 slides
Semantics and A utomation of Higher-Order Logic Some Remarks Christoph Benzm uller

Semantics and A utomation of Higher-Order Logic Some Remarks Christoph Benzm uller

Semantics and A utomation of Higher-Order Logic Some Remarks Christoph Benzm uller Department of Computer Science, Saarland University Workshop on Logic, Proofs and Programs 17 18 June 2004, Nancy First-order Logic c

607 views • 42 slides
Pushdown Control-Flow Analysis of Higher Order Programs Christopher Earl 1 Matthew Might 1 David

Pushdown Control-Flow Analysis of Higher Order Programs Christopher Earl 1 Matthew Might 1 David

Pushdown Control-Flow Analysis of Higher Order Programs Christopher Earl 1 Matthew Might 1 David Van Horn 2 1 University of Utah { cwearl,might } @cs.utah.edu 2 Northeastern University dvanhorn@ccs.neu.edu August 21, 2010 Who uses function

831 views • 57 slides
Knowledge Compilation Guy Van den Broeck Beyond NP Workshop Feb 12, 2016 Overview 1. Why

Knowledge Compilation Guy Van den Broeck Beyond NP Workshop Feb 12, 2016 Overview 1. Why

On First-Order Knowledge Compilation Guy Van den Broeck Beyond NP Workshop Feb 12, 2016 Overview 1. Why first-order model counting? 2. Why first-order model counters? 3. What first-order circuit languages? 4. How first-order knowledge

1.5k views • 107 slides
Outline Higher order is commonly used on convergence and on derivatives in opti- Trust Region with

Outline Higher order is commonly used on convergence and on derivatives in opti- Trust Region with

Workshop AD Higher Order Workshop AD Higher Order Outline Higher order is commonly used on convergence and on derivatives in opti- Trust Region with a Cubic Model mization. First order methods are gradient based and have

468 views • 7 slides
A new algorithm for Higher-order model checking Jrmy Ledent Martin Hofmann 1 / 25 For first

A new algorithm for Higher-order model checking Jrmy Ledent Martin Hofmann 1 / 25 For first

A new algorithm for Higher-order model checking Jrmy Ledent Martin Hofmann 1 / 25 For first order programs (M. Hofmann &amp; W. Chen) Let be a set of events and F a set of procedure identifiers. Syntax of expressions: e ::= a | f | e

1.13k views • 75 slides
On Higher-Order Program Verification and Two Notions of Higher-Order Model Checking Naoki

On Higher-Order Program Verification and Two Notions of Higher-Order Model Checking Naoki

On Higher-Order Program Verification and Two Notions of Higher-Order Model Checking Naoki Kobayashi University of Tokyo Summaries of papers from POPL09, POPL17 (joint work with Etienne Lozes, Florian Bruse), and more recent work (joint work

963 views • 65 slides
v1 v2 vn (if (null? xs) null F F F (cons ( f (first xs)) (F vn) (F v2) (F v1) (my-map f

v1 v2 vn (if (null? xs) null F F F (cons ( f (first xs)) (F vn) (F v2) (F v1) (my-map f

Higher-order List Func2ons Higher-Order List Functions A function is higher-order if it takes another in Racket function as an input and/or returns another function as a result. E.g. app-3-5 , make-linear-function , flip2 . We will now study

300 views • 6 slides
v1 v2 vn my-map : (define (my-map f xs) F F F (F v2) (F vn) (F v1) (if (null? xs) null

v1 v2 vn my-map : (define (my-map f xs) F F F (F v2) (F vn) (F v1) (if (null? xs) null

Higher-order List Func2ons Higher-Order List Functions A function is higher-order if it takes another in Racket function as an input and/or returns another function as a result. E.g. app-3-5 , make-linear-function , flip2 from the previous

519 views • 6 slides

More recommend