Continuation based Cの GCC 4.6 上の実装について

  • 大城 信康
  • 琉球大学 並列信頼研究室

    目的と背景(1)

  • 当研究室ではコードセグメント単位で記述するプログラミング言語Continuation based C (以下CbC)を開発している。
  • コードセグメントは並列実行の単位として使うことができ、プログラムの正しさを示す単位としても使用することができる。
  • Many Core での並列実行を高い性能と高い信頼性で実現することができると考えている。
  • 目的と背景(2)

  • CbC のコンパイラは2001年に Micro-C 版、2008年には GCC-4.2 をベースとしたコンパイラが開発された。
  • GCC をベースとした CbC コンパイラは、修正・追加されていく最適化の機能を使用する為に、 GCC のアップデートに合わせ変更する必要がある。
  • 本研究ではCbC コンパイラを GCC-4.6 へとアップデートを行った。
  • 発表内容

    1. CbC の紹介
    2. GCC でのコンパイルの流れ
    3. CbC の実装
    4. Micro-C との性能比較
    5. まとめ

    Continuation based C

    コードセグメント単位での記述と継続を基本としたプログラミング言語。

    Continuation based C

    継続:現在の処理を実行していく為の情報

    Cの継続 CbCの継続(軽量継続)
    • 続く命令のアドレス
    • 命令に必要なデータ
    • スタックに積まれている値(環境)
    • Cの継続から環境を除外
    • 続く命令とその命令に必要なデータのみ
  • コードセグメントへの継続はcallではなくjmp命令で行われる
  • Continuation based C

    階乗を求めるCbCのプログラム
    
    __code print_factorial(int prod) {
      printf("factorial = %d\n",prod);
      exit(0); 
    }
    
    __code factorial0(int prod, int x) {
      if ( x >= 1) {
        goto factorial0(prod*x, x-1);
      }else{
        goto print_factorial(prod);
      } 
    }
    	  
    
    __code factorial(int x) {
      goto factorial0(1, x); 
    }
    
    int main(int argc, char **argv) {
      int i;
      i = atoi(argv[1]);
      goto factorial(i); 
      return 0;
    }
    
  • 以上がCbCについての紹介となる。
  • GCC

    GCC:Generic Tree

  • CALL_EXPRE、MODIFY_EXPR等といった表現で扱われる。
  • ソースコード Generic Treeでの表現
    int main() {
      int a, b;
      a = 3;
      b = func(a, 10);
      return b;
    }
    	
  • CbCの実装においてこのGeneric Treeの生成を意識していくことになる。
  • CbCの実装

    CbCの実装:__codeシンタックスの追加

    const struct c_common_resword c_common_reswords[] =
    {
     { "_Bool",            RID_BOOL,      D_CONLY },
         :
     { "__code",         RID_CbC_CODE,   0 },		
    	      
    case RID_CbC_CODE:     
          :
     specs->typespec_word = cts_CbC_code;		
                     
    case cts_CbC_code: 
           :
         specs->type = void_type_node; 
         break;
                    

    CbCの実装:gotoシンタックスの追加

  • goto によるコードセグメントへの継続
  • 追加したgotoシンタックスの実際のソースは次のようになる。
  •  case RID_GOTO:
       c_parser_consume_token (parser);
       if ( c_parser_next_token_is (parser, CPP_NAME)
    	&& c_parser_peek_2nd_token (parser)->type == CPP_SEMICOLON )
         {
           stmt = c_finish_goto_label (loc,
    				   c_parser_peek_token (parser)->value);
           c_parser_consume_token (parser);
         }
       else if (c_parser_next_token_is (parser, CPP_MULT))
         {
           tree val;
    
           c_parser_consume_token (parser);
           val = c_parser_expression (parser).value;
           mark_exp_read (val);
           stmt = c_finish_goto_ptr (loc, val);
         }
       else
         expr = c_parser_expr_no_commas (parser, NULL);
       if (TREE_CODE(expr.value) == CALL_EXPR )
         {
           location_t loc = c_parser_peek_token (parser)->location;
           cbc_replace_arguments (loc, expr.value);
           TREE_TYPE(expr.value) = void_type_node;
           CbC_IS_CbC_GOTO (expr.value) = 1;
           CALL_EXPR_TAILCALL (expr.value) = 1;
           add_stmt(expr.value);
           stmt = c_finish_return(loc, NULL_TREE, NULL_TREE);
         }
    	

    CbCの実装:gotoシンタックスの追加

    実際のコード GCC内で処理されるコード
    
    __code test() {
       :
      goto factorial0(1, x); 
    }
    	    
    
    void test() {
       :
      factorial0(1, x); 
      return;
    }
    	    

    CbCの実装:TCE(末尾除去)

    末尾除去:Tail Call Elimination(TCE)

  • 以下のソースの場合 関数g から関数f へjmp命令で処理が移る。

  • 
    void f(int a, int b) {
      printf("f: a=%d b=%d\n",a,b);
      return ;
    }
    void g(int a, int b){
      printf("g: a=%d b=%d\n",a,b);
      f(a,b);
      return;
    }
    
    int main() {
      g(3,4);
      return 0;
    }
    	    
    	  

    CbCの実装:TCE(末尾除去)

    CbCの実装:TCE(末尾除去)

  • TCEの条件はexpand_call関数で調べられる。
  • CbCの実装:TCE(末尾除去)

  • try_tail_callフラグが落とされる部分
  • 
      if (currently_expanding_call++ != 0
          || ((!fndecl || !CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl))) 
             && !flag_optimize_sibling_calls)
          || args_size.var
          || dbg_cnt (tail_call) == false)
        try_tail_call = 0;
    
         :
    
      if (
    #ifdef HAVE_sibcall_epilogue
          !HAVE_sibcall_epilogue
    #else
          1
    #endif
          || !try_tail_call
          || structure_value_addr != NULL_RTX
    #ifdef REG_PARM_STACK_SPACE
          || (OUTGOING_REG_PARM_STACK_SPACE (funtype)
              != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl)))
          || (reg_parm_stack_space != REG_PARM_STACK_SPACE (fndecl))
    #endif
          || !targetm.function_ok_for_sibcall (fndecl, exp)
          || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
          || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
          || (fndecl && decl_function_context (fndecl) == current_function_decl)
          || args_size.constant > (crtl->args.size
                                   - crtl->args.pretend_args_size)
          || (targetm.calls.return_pops_args (fndecl, funtype, args_size.constant)
              != targetm.calls.return_pops_args (current_function_decl,
                                                 TREE_TYPE (current_function_decl),
                                                 crtl->args.size))
          || !lang_hooks.decls.ok_for_sibcall (fndecl))
        try_tail_call = 0;
    
          :
    
      /* Check if caller and callee disagree in promotion of function                                                                                                                      
         return value.  */
    #ifndef noCbC
      if (try_tail_call && (!fndecl || !CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl))))
    #else
        if (try_tail_call)
    #endif
        {
          enum machine_mode caller_mode, caller_promoted_mode;
          enum machine_mode callee_mode, callee_promoted_mode;
          int caller_unsignedp, callee_unsignedp;
          tree caller_res = DECL_RESULT (current_function_decl);
    
          caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
          caller_mode = DECL_MODE (caller_res);
          callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
          callee_mode = TYPE_MODE (TREE_TYPE (funtype));
          caller_promoted_mode
            = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
                                     &caller_unsignedp,
                                     TREE_TYPE (current_function_decl), 1);
          callee_promoted_mode
            = promote_function_mode (TREE_TYPE (funtype), callee_mode,
                                     &callee_unsignedp,
                                     funtype, 1);
          if (caller_mode != VOIDmode
              && (caller_promoted_mode != callee_promoted_mode
                  || ((caller_mode != caller_promoted_mode
                       || callee_mode != callee_promoted_mode)
                      && (caller_unsignedp != callee_unsignedp
                          || GET_MODE_BITSIZE (caller_mode)
                             < GET_MODE_BITSIZE (callee_mode)))))
            try_tail_call = 0;
        }
    	
  • !CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl)により条件を回避
  • CbCの実装:TCE(末尾除去)

  • try_tail_callフラグ矯正付与のソースコード
  • #ifndef noCbC
      if (fndecl && CbC_IS_CODE_SEGMENT (TREE_TYPE (fndecl))
          && CbC_IS_CODE_SEGMENT (TREE_TYPE (current_function_decl))
          && try_tail_call == 0)
        {
          location_t loc = EXPR_LOCATION (exp);
          char *name_callee = IDENTIFIER_POINTER(DECL_NAME(fndecl));
          warning_at (loc, 0, "transition to code segment \"%s\" with CbC goto, but tail call optimization was cut.",
                            name_callee);
          try_tail_call = 1;
        }
    #endif
    	

    CbCの実装:TCE(末尾除去)の実装について

    CbCの実装:引数渡し

  • GCC版コンパイラー開発当初、コンパイルしたCbCのプログラムはMicro-C版に速度面で勝てなかった。
  • そこで、GCC版CbCコンパイラの引数渡しもできるだけレジスタで行うことに。
  • CbCの実装:引数渡し(fastcall)

    fastcall

  • __codeで宣言された関数は自動でfastcall属性が付与されるように以下のコードを追加。
  • if(!TARGET_64BIT) {
      attrs = build_tree_list (get_identifier("fastcall"), NULL_TREE); 
      declspecs_add_attrs(specs, attrs);
     }	  
    	

    Intel64 ではレジスタが増えている為、fastcallは標準でつくようになっている。

    CbCの実装:引数渡し


    引数渡しに使われるレジスタの数(gcc)
    arch int(整数型) float(浮動小数点型) double(浮動小数点型)
    i386 2 0
    (stackを使用)
    0
    (stackを使用)
    x64 6 8 8

    CbCの実装:環境付き継続

  • 以下の使い方の場合は1を返す。
  • __code c1(__code ret(int,void *),void *env) {
     goto ret(1,env);
    }
    int main() {
     goto c1(__return, __environment);
    }
    	

    __environmentキーワードは関数の環境を保持する(Micro-Cの場合)。

    CbCの実装:環境付き継続

    生成しているコード 生成されるTree
    
    //goto c1(__return, __environment);
    goto c1(({
    	  __label__ _cbc_exit0;
    	  static int retval;
    	  void _cbc_internal_return(int retval_, void *_envp) {
    	    retval = retval_;
    	    goto _cbc_exit0; 
              }
    	  if (0) { 
                _cbc_exit0:
    	    return retval; 
              }
    	  _cbc_internal_return;
    	}), __environment);
    	  
  • retval変数の型は継続を行った関数と同じ戻値の型となる。
  • CbCの実装:環境付き継続

    生成されるTree 生成する為のコード
    
        case RID_CbC_RET:
    {
      tree value, stmt, label, tlab, decl;
      c_parser_consume_token (parser);
    
      stmt = c_begin_stmt_expr ();
      cbc_return_f = c_parser_peek_token (parser)->value;
      location_t location = c_parser_peek_token (parser)->location;
    
      /* create label. (__label__ _cbc_exit0;) */
      label = get_identifier ("_cbc_exit0");
      tlab = declare_label (label);
      C_DECLARED_LABEL_FLAG (tlab) = 1;
      add_stmt (build_stmt (location, DECL_EXPR, tlab));
    
      /* declare retval.  (int retval;) */
      tree decl_cond =
        build_decl (location, VAR_DECL, get_identifier ("retval"),
    		TREE_TYPE (TREE_TYPE (current_function_decl)));
      TREE_STATIC (decl_cond) = 1;
      TREE_USED (decl_cond) = 1;
    
      /* Use thread-local */
      DECL_TLS_MODEL (decl_cond) = decl_default_tls_model (decl_cond);
      DECL_NONLOCAL (decl_cond) = 1;
      add_stmt (build_stmt(location, DECL_EXPR,  pushdecl (decl_cond)));
    
      /* define nested function.  */
      decl =
        cbc_finish_nested_function (location, label, decl_cond);
      TREE_USED(decl) = 1;
    
      /* define if-ed goto label and return statement. */
      cbc_finish_labeled_goto (location, label, decl_cond);
    
      /* get pointer to nested function.  */
      value = build_addr (decl , current_function_decl);
      TREE_USED (current_function_decl) = 1;
      SET_EXPR_LOCATION (value, location);
      add_stmt (value);
    
      TREE_SIDE_EFFECTS (stmt) = 1;
      expr.value = c_finish_stmt_expr (location, stmt);
      expr.original_code = ERROR_MARK;
    }
    			 

    環境付き継続:実装の問題

  • 重要な部分
  • 次の方法が考えられる。
  • 環境付き継続:実装の問題

    環境付き継続:実装の問題

    Micro-Cとの比較

  • Micro-C,GCC-4.4とGCC-4.6のCbCコンパイラでコンパイルしたプログラムの実行の速度
  • GCC版の最適化無しの場合、引数を全て一時変数に代入するという処理が入る。 その為に明らかに遅くなっていることが分かる。
  • だがGCCの最適化有りの場合はMicro-C版よりも早い。
  • まとめ

    今後の予定


    ご清聴ありがとうございました。

    CbCの実装:TCE(末尾除去)の動作

  • スタック:呼び出し元関数と同じ範囲を使うことになる。
    • func_bの引数はfunc_aのスタックに上書する
    • func_bの為にスタックポインタは伸ばされない
  • CbCにおけるコードセグメントへの継続はこのTCEを用いて実装されている。
  • CbCの機能の拡張:__rectype の実装

    CbCの機能の拡張:selftype

    selftypeの実装

  • 以下の宣言が行えるようにしたい。
  • typedef sturct node {
     selftype *left;
     selftype *right;
     int num;
    }*NODE
    	

    selftype は struct node を指す。