python/ctrump/optimizer.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
# Copyright (c) 2009, Fixstars Corporation
# All rights reserved.
# 
# Redistribution and use in source and binary forms, with or without modification, 
# are permitted provided that the following conditions are met:
# 
#   * Redistributions of source code must retain the above copyright notice,
#     this list of conditions and the following disclaimer.
# 
#   * Redistributions in binary form must reproduce the above copyright notice,
#     this list of conditions and the following disclaimer in the documentation
#     and/or other materials provided with the distribution.
# 
#   * Neither the name of Fixstars Corporation nor the names of its contributors
#     may be used to endorse or promote products derived from this software
#     without specific prior written permission.
# 
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
# INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
# THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#

"""
@package Optimizer Inteface 
"""

import optimizer # for extract module path
import os 
import sys
from ctrump import *

class Option:
    """最適化オプション"""
    option_types = [int, str, bool, list]

    class Val:
        def __init__(self,key,opt_type,doc,desc,initial_value):
            self.key = key
            self.opt_type = opt_type
            self.doc = doc
            self.desc = desc
            self.initial_value = initial_value

    def __init__(self,options):
        self.options = []
        for o in options:
            self.append(*o)

    def append(self,key,doc,desc,initial_value):
        opt_type = type(initial_value)
        if not opt_type in self.option_types:
            raise TypeError("option must be a int or string or bool.")
        self.options.append((key,opt_type,doc,desc,initial_value))

    def __iter__(self):
        return self.options.__iter__()

    def initial_value(self):
        ret = {}
        for (key,opt_type,d,de,initial_value) in self.options:
            if opt_type == list:
                (val_key,initial_value) = initial_value[0]

            ret[key] = initial_value
        return ret

    def get_name(self):
        return self.name

class OptionValue:
    def __init__(self, engine, translators):
        self.engine = engine
        self.translators = translators

class OptionSet:
    def __init__(self, engine_option):
        self.engine = engine_option
        self.translators = {}

    def create_initial_value(self):
        engine_value = {}
        translator_values = {}

        engine_value = self.engine.initial_value()

        for k in self.translators:
            v = self.translators[k]
            translator_values[k] = v.initial_value()

        return OptionValue(engine_value, translator_values)

class AnalysisResultBase(object):
    """解析結果オブジェクト"""

    def __init__(self, stmt, errors, warnings, hints, enabled_translators):
        self.stmt = stmt
        self.errors = errors
        self.warnings = warnings
        self.hints = hints
        self.enabled_translators = enabled_translators

    def get_region(self):
        """対象範囲"""
        s = self.stmt
        if ((s.code == ctrump.STMT_FOR
             or s.code == ctrump.STMT_WHILE
             or s.code == ctrump.STMT_FOR_DECL) and 
            (s.body.code == ctrump.STMT_COMPOUND)):
            begin_filename = s.body.lbr_loc.path
            begin_lineno = s.body.lbr_loc.lineno

            end_filename = s.body.rbr_loc.path
            end_lineno = s.body.rbr_loc.lineno
        else:
            (begin_filename, begin_lineno) = ctrump.get_stmt_loc(s)
            end_filename = begin_filename
            begin_lineno = begin_lineno
            end_lineno = begin_lineno
            
        return (begin_filename, begin_lineno, end_filename, end_lineno)

    def get_errors(self):
        """エラーのリストを取得"""
        return self.errors
    def get_warnings(self):
        """警告のリストを取得"""
        return self.warnings
    def get_enabled_translators(self):
        """有効なトランスレータのリストを取得"""
        return self.enabled_translators
    def get_hints(self):
        """ヒントのリストを取得"""
        return self.hints
    def get_stmt(self):
        """対象となっている文を取得"""
        return self.stmt

    def do_translate(self, translator, global_option, translate_option):
        """トランスレートを行う
        :param translator:translator object:
        :param global_option:グローバルオプション + エンジンオプションを合わせたOptionValueの値
        :param translate_option:トランスレートオプションの値
        :return: list of new programs
"""
        raise NotImplementedError(self.do_translate)

    def do_translate_by_name(self, translator_name, global_option, translate_option):
        for i in self.get_enabled_translators():
            if i.get_name() == translator_name:
                return self.do_translate(i, global_option, translate_option)
        raise AttributeError(translator_name)

    def get_enabled_translator_names(self):
        return [x.get_name() for x in self.enabled_translators]

    def __repr__(self):
        ret = "errors = %s\nwarnings=%s\nhints=%s\n"%(
            self.errors, self.warnings, self.hints)
        ret += "enabled_translators = %s"%(
            [x.get_name() for x in self.enabled_translators])
        return ret

class OptimizationMessageBase(object):
    """メッセージオブジェクト"""
    def get_locations(self):
        raise NotImplementedError(self.get_lines())

    def get_message(self):
        raise NotImplementedError(self.get_lines())

    def get_hint(self):
        return None

class OptimizationError(OptimizationMessageBase):
    """エラーオブジェクト"""
    def __init__(self, locs, message):
        super(OptimizationError, self).__init__()
        self.locs = locs
        self.msg = message

    def get_locations(self):
        return self.locs

    def get_message(self):
        return self.msg

    def __repr__(self):
        errors = ""
        for i in self.locs:
            path,lineno = i
            errors += '%s:%s:%s\n'%(path, lineno, self.msg)
        return errors

class TranslatorBase(object):
    """トランスレータオブジェクト"""
    def __init__(self):
        super(TranslatorBase,self).__init__()

    def get_name(self):
        """トランスレータの名前を返す
        :return: string"""
        raise NotImplementedError(self.get_name)

    def get_global_option(self):
        """オプションオブジェクトを返す
        :return: Option"""

        raise NotImplementedError(self.get_global_option)

    def get_translate_option(self):
        """トランスレート時に渡すオプションオブジェクトを返す
        :return: Option"""

        raise NotImplementedError(self.get_translate_option)

class LoopParallelTreeNode:
    """ループツリーの情報"""
    def __init__(self):
        self.dep_vec_dir = 0
        self.error_bits = 0

    def dep(self, vec_dir):
        self.dep_vec_dir |= vec_dir

    def error(self, error_bits):
        error_bits |= error_bits

    def get_stmt(self):
        return self.loop_node.cfg_info.loop_stmt

    FLOW_DEP = (1<<0)
    ANTI_DEP = (1<<1)
    COMPLICATED_DEP = (1<<2)

class ErrorLoopTreeNode:
    """最適化できないループツリーの情報"""
    def __init__(self, error_bits, stmt, errors, warnings, hints):
        self.error_bits = error_bits
        self.stmt = stmt 
        self.errors = errors
        self.warnings = warnings
        self.hints = hints
        self.children = []
        self.dep_vec_dir = 0

    def get_stmt(self):
        return self.stmt


class LoopAnalysisResult(AnalysisResultBase):
    """ループ解析結果"""
    def __init__(self, errors, warnings, hints, enabled_translators, loop_node, cfg, attr, ext_info, prog):
        super(LoopAnalysisResult,self).__init__(loop_node.get_stmt(), errors, warnings,
                                                hints, enabled_translators)
        self.cfg = cfg
        self.attr = attr
        self.ext_info = ext_info
        self.prog = prog
        self.loop_node = loop_node

    def do_translate(self, translator, global_option, translate_option):
        return translator.translate(self.ext_info, self.stmt, self.cfg, self.loop_node, global_option, translate_option, self.prog)

class LoopTranslatorBase(TranslatorBase):
    """ループトランスレータ"""

    def __init__(self):
        super(LoopTranslatorBase,self).__init__()

    def is_enabled(self, analyze_results, stmt, cfg, attr, errors, warnings, hints):
        """トランスレート可能かどうかを返す
        :param analyze_results:result of analyze
        :param stmt:loop stmt
        :param cfg:loop cfg
        :param attr:loop attribute
        :param errors:
        :param warnings:
        :param hints:
        :return:True if enabled"""
        raise NotImplementedError(self.is_enabled)

    def translate(self, analyze_results, stmt, cfg, attr, global_options, translate_options, prog):
        """トランスレートを行う
        :param analyze_results:result of analyze
        :param stmt:loop stmt
        :param cfg:loop cfg
        :param attr:loop attribute
        :param global_options:options
        :param translate_option:options
        :param prog:translation unit
        :return:list of optmized tree"""
        raise NotImplementedError(self.translate)

class LoopAnalyzerBase(object):
    def __init__(self):
        None

def print_stmt_truncate_newline(stmt):
    stmt_str = ctrump.pprint_stmt(stmt)
    stmt_str = stmt_str.rstrip('\n')
    return stmt_str

def get_iv_level(index):
    if index.code == ctrump.LOOP_INDEX_INDUCTIVE:
        return index.iv_level
    elif index.code == ctrump.LOOP_INDEX_POINTER_INC:
        return index.iv_level
    else:
        raise NotImplementedError('get_iv_level %d'%index.code)

class LoopParallelAnalyzer(LoopAnalyzerBase):
    '''ループの並列性を解析する
解析結果として、以下のビットのビット論理和を返す
    HAS_RANDOM_ACCESS = (1<<0)
    HAS_COMPLICATED_CONTROL_FLOW = (1<<1)
    UNPREDICTABLE_COUNTER = (1<<2)
    HAS_CARRY_DEPENDENCY = (1<<3)
    HAS_NESTED_LOOP = (1<<4)
    LOAD_STORE_EMPTY = (1<<5)
    HAS_OUTPUT_DEPENDENCE = (1<<6)
    HAS_DEPEND_ANALYSIS_ERROR = (1<<7)
    NO_INDEPENDENT_LOOP = (1<<8)
'''

    def __init__(self):
        super(LoopParallelAnalyzer,self).__init__()

    HAS_RANDOM_ACCESS = (1<<0)
    HAS_COMPLICATED_CONTROL_FLOW = (1<<1)
    UNPREDICTABLE_COUNTER = (1<<2)
    HAS_CARRY_DEPENDENCY = (1<<3)
    HAS_NESTED_LOOP = (1<<4)
    LOAD_STORE_EMPTY = (1<<5)
    HAS_OUTPUT_DEPENDENCE = (1<<6)
    HAS_DEPEND_ANALYSIS_ERROR = (1<<7)
    NO_INDEPENDENT_LOOP = (1<<8)

    def analyze_loop_node(self, loop_node, result_stack, cfg):
        errors = []
        warnings = []
        hints = []

        result_stack.append(LoopParallelTreeNode())

        error_bits = 0
        ei = loop_node.exit_info

        stmt_loc_path = loop_node.loc.path
        stmt_loc_line = loop_node.loc.lineno

        if ei.code == ctrump.LOOP_COUNT_UNPREDICTABLE:
            errors.append(OptimizationError([(stmt_loc_path, stmt_loc_line)],
                                            "ループ回数が解析不能です"))
            error_bits |= self.UNPREDICTABLE_COUNTER
        elif ei.code == ctrump.LOOP_COUNT_PREDICTABLE:
            if ei.cmp_op != ctrump.EXPR_BIN_LT:
                errors.append(OptimizationError([(stmt_loc_path, stmt_loc_line)],
                                                "ループの条件式の比較が `<' ではありません"))
                error_bits |= self.UNPREDICTABLE_COUNTER

        if loop_node.carry_dep.popcount():
            error_bits |= self.HAS_CARRY_DEPENDENCY
            v = ctrump.bitmap_var_name(cfg.var_info, loop_node.carry_dep).rstrip(',')
            errors.append(OptimizationError([(stmt_loc_path, stmt_loc_line)],
                                            "ループ繰り越し依存があります : %s"%v))

        for i in loop_node.reductions:
            if i.op == ctrump.REDUCTIVE_FADD or i.op == ctrump.REDUCTIVE_FSUB or i.op == ctrump.REDUCTIVE_FMUL:
                reduc_at = i.at
                (reduc_path, reduc_line) = ctrump.get_stmt_loc(reduc_at)
                stmt_str = print_stmt_truncate_newline(reduc_at)
                warnings.append(OptimizationError([(reduc_path, reduc_line)],
                                                  "`%s':浮動小数の結合則を認めると精度が変わります。並列化すると結果が変わるので注意してください"%stmt_str))

        for i in loop_node.parallel_stores:
            all_invariant = True

            for j in i.subscripts:
                for k in j.indices:
                    if k.code != ctrump.LOOP_INDEX_INVARIANT:
                        all_invariant = False

            if all_invariant:
                (path, line) = ctrump.get_stmt_loc(i.at_stmt)
                stmt_str = print_stmt_truncate_newline(i.at_stmt)
                errors.append(OptimizationError([(path, line)],
                                                "`%s':固定インデクスへの出力により出力依存が発生しています"%stmt_str))
                error_bits |= self.HAS_OUTPUT_DEPENDENCE

        for i in loop_node.random_accesses:
            error_bits |= self.HAS_RANDOM_ACCESS

            (access_path, access_line) = ctrump.get_stmt_loc(i.access_at_stmt)

            if i.code == ctrump.RANDOM_ACCESS_POINTER_NOT_INDUCTIVE:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s':ポインタが誘導変数ではありません"%(i.not_inductive_pointer)))
            elif i.code == ctrump.RANDOM_ACCESS_COMPLICATED_POINTER:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s':解析できませんでした"%(i.complicated_pointer)))
            elif i.code == ctrump.RANDOM_ACCESS_ARRAY_NOT_INVARIANT:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s%s':ポインタもしくは配列がループ内定数ではありません"%(i.array,ctrump.format_tree_subscripts(i.subscripts))))
            elif i.code == ctrump.RANDOM_ACCESS_SUBSCRIPT_NOT_INDUCTIVE:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s%s':配列の添字が誘導変数ではありません"%(i.array,ctrump.format_tree_subscripts(i.subscripts))))
            elif i.code == ctrump.RANDOM_ACCESS_COMPLICATED_ARRAY:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s%s':解析できませんでした"%(i.array,ctrump.format_tree_subscripts(i.subscripts[0].expr))))
            elif i.code == ctrump.RANDOM_ACCESS_MULTIPLE_SCALED_INDEX:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s':解析できませんでした。添字式の中に複数の変数に係数があります"%(i.access_at_expr)))
            elif i.code == ctrump.RANDOM_ACCESS_COMPLICATED_SUBSCRIPT:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s':添字式が解析できませんでした。"%(i.complicated_subscript)))
            elif i.code == ctrump.RANDOM_ACCESS_INDEX_VAR_NOT_INDUCTIVE:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "`%s':添字式の中で使われる変数がループ中で計算されています。"%(i.index_var_not_inductive.name)))
            else:
                errors.append(OptimizationError([(access_path, access_line)],
                                                "error:random access"))

        depinfo = loop_node.depinfo
        if depinfo.code == ctrump.LOOP_DEPINFO_HAVE_ERROR_INNER:
            pass
        elif depinfo.code == ctrump.LOOP_DEPINFO_ANALYZE_ERROR:
            error_bits |= self.HAS_DEPEND_ANALYSIS_ERROR
            result_stack[-1].dep(LoopParallelTreeNode.COMPLICATED_DEP)
            for i in depinfo.errors:
                if i.code == ctrump.LOOP_DEPENDENCE_ANALYZE_HAVE_MULTIPLE_INDEX:
                    mes = "'%s' 複数のインデクスによるアクセスがあります。現在のCTRUMPでは解析できません"%i.access.at_expr
                elif i.code == ctrump.LOOP_DEPENDENCE_ANALYZE_HAVE_WEAK_SUBSCRIPT:
                    (p0,l0) = ctrump.get_stmt_loc(i.access0.at_stmt)
                    (p1,l1) = ctrump.get_stmt_loc(i.access1.at_stmt)
                    mes = "二つのメモリ参照'%s'と'%s'の間に複雑な依存関係があります。"%(i.access0.at_expr, i.access1.at_expr)
                    errors.append(OptimizationError([(p0,l0), (p1,l1)], mes))
                elif i.code == ctrump.LOOP_DEPENDENCE_ANALYZE_HAVE_MULTIPLE_OUTPUT:
                    (p0,l0) = ctrump.get_stmt_loc(i.access0.at_stmt)
                    (p1,l1) = ctrump.get_stmt_loc(i.access1.at_stmt)
                    stmt_str = (print_stmt_truncate_newline(i.access0.at_stmt),
                                print_stmt_truncate_newline(i.access1.at_stmt))
                    mes = "ひとつの配列に対する複数の書きこみ('%s', '%s')があります。現在のCTRUMPでは解析できません"%stmt_str
                    errors.append(OptimizationError([(p0,l0), (p1,l1)], mes))
                else:
                    (p0,l0) = ctrump.get_stmt_loc(i.access0.at_stmt)
                    (p1,l1) = ctrump.get_stmt_loc(i.access1.at_stmt)
                    errors.append(OptimizationError([(p0,l0), (p1,l1)], '依存性解析時にエラーがありました'))

        elif depinfo.code == ctrump.LOOP_DEPINFO:
            # 依存関係の無いループを見つける
            for i in depinfo.vectors:
                num_sub = i.num_subscript
                num_vec = i.num_vector
                independent = [True]*num_sub
                vecdata = i.distance_vectors
                for j in range(0,num_vec):
                    for k in range(0,num_sub):
                        d = vecdata[j*num_sub+k]
                        if d.code == ctrump.DEPEND_DISTANCE_STRONG_SIV:
                            if d.distance == 0:
                                # no dependency
                                pass
                            else:
                                if d.distance < 0:
                                    dep_type = LoopParallelTreeNode.FLOW_DEP
                                else:
                                    dep_type = LoopParallelTreeNode.ANTI_DEP

                                idx0 = d.index0
                                idx1 = d.index1

                                result_stack[get_iv_level(idx0)].dep(dep_type)
                                result_stack[get_iv_level(idx1)].dep(dep_type)
                                independent[k] = False
                        else:
                            # not siv
                            independent[k] = False

        children = []
        for i in loop_node.children:
            n = self.analyze_loop_node(i, result_stack, cfg)
            error_bits |= n.error_bits
            children.append(n)

        depinfo = result_stack[-1]

        ret = result_stack[-1]
        ret.children = children
        ret.error_bits = error_bits
        ret.loop_node = loop_node

        ret.errors = errors
        ret.warnings = warnings
        ret.hints = hints

        result_stack.pop()

        return ret


    # result_type = int
    def analyze_loop(self, stmt, cfg, attr):
        error_bits = 0

        (stmt_loc_path, stmt_loc_line) = ctrump.get_stmt_loc(stmt)

        errors = []
        warnings = []
        hints = []

        if attr.code == ctrump.LOOP_UNANALYZED:
            errors.append(OptimizationError([(stmt_loc_path,stmt_loc_line)], 
                                            "occurs unanalyzed loop(maybe bug)."))
        elif attr.code == ctrump.LOOP_COMPLICATED:
            (error_path, error_line) = ctrump.get_stmt_loc(attr.stmt)
            error_bits |= self.HAS_COMPLICATED_CONTROL_FLOW

            if attr.reason == COMPLICATED_LOOP_BREAK:
                errors.append(OptimizationError([(error_path, error_line)],
                                                "ループ中に `break' する箇所があります"))
            elif attr.reason == COMPLICATED_LOOP_GOTO:
                errors.append(OptimizationError([(error_path, error_line)],
                                                "ループ中に goto があります"))
            elif attr.reason == COMPLICATED_LOOP_RETURN:
                errors.append(OptimizationError([(error_path, error_line)],
                                                "ループから return する箇所があります"))
            elif attr.reason == COMPLICATED_LOOP_INVOKE_FUNC:
                errors.append(OptimizationError([(error_path, error_line)],
                                                "外部関数を呼んでいます"))
            elif attr.reason == COMPLICATED_LOOP_HAS_MULTI_ENTRY:
                errors.append(OptimizationError([(error_path, error_line)],
                                                "ループ中にラベルがあります"))

            parallel_loop_tree = ErrorLoopTreeNode(error_bits, stmt, errors, warnings, hints)
            
        elif attr.code == ctrump.LOOP:
            li_root = attr.loop_info_node

            if li_root.num_child != 0:
                error_bits |= self.HAS_NESTED_LOOP

            num_loop_level = li_root.nest_level
            result_stack = []

            parallel_loop_tree = self.analyze_loop_node(li_root, result_stack, cfg)

        return parallel_loop_tree


class LoopOptimizer:
    """ループ最適化エンジン"""
    def __init__(self):
        self.analyzers = {}
        self.translators = []

    def analyze_loop(self, stmt, cfg, attr, prog):
        """loop が最適化できるかどうか調べる
   :param stmt: target stmt
   :param cfg: cfg
   :param attr: loop attribute
   :return: ([errors], [warnings], [hints], [enabled-translator-names])
"""
        analyze_result = {}

        for i in self.analyzers:
            a = self.analyzers[i]
            result = a.analyze_loop(stmt, cfg, attr)
            analyze_result[type(self.analyzers[i])] = result

        analysis_results = []

        def traverse_result(node):
            enabled_translators = []

            for t in self.translators:
                r = t.is_enabled(analyze_result, node.get_stmt(), cfg, node, node.errors, node.warnings, node.hints)
                if r:
                    enabled_translators.append(t)

            analysis_results.append(LoopAnalysisResult(node.errors, node.warnings, node.hints,
                                                       enabled_translators, node,
                                                       cfg, attr, analyze_result, prog))

            for i in node.children:
                traverse_result(i)

        traverse_result(result)
        return analysis_results

    def enable_analyzer(self, analyzer_type):
        if analyzer_type in self.analyzers:
            return self.analyzers[analyzer_type]
        ret = analyzer_type()
        self.analyzers[analyzer_type] = ret
        return ret

    def append_translator(self, trns, required_analyzers):
        for i in required_analyzers:
            self.enable_analyzer(i)
        self.translators.append(trns)

    def get_translators(self):
        return self.translators

engine_options = [
    ('enable_ignore_alias', "エイリアスを考慮しない",
'''同じ型のポインタが指す先がオーバーラップしないことを仮定します。
プログラムによっては不具合の原因になることがあります。
よく理解したうえで有効にしてください(未実装:問答無用で最適化されます)''', False),

    ('enable_float_associativity', "浮動小数演算の結合、分配法則を認める", 
'''浮動小数演算の演算順序を変える変換を有効にします。

例えば、浮動小数の合計を求める、
for (i=0; i<N; i++) {
   sum += x * a[i];
}
このようなループの並列化が可能になりますが、結果の誤差が変わります。(未実装:問答無用で最適化されます)
''', False)
]

class OptimizeEngine:
    """最適化エンジン"""

    def __init__(self):
        module_path = optimizer.__file__
        module_dir = os.path.dirname(module_path)
        optimizer_dir = module_dir + os.sep + 'builtin-optimizers'

        self.loop_optimizer = LoopOptimizer()

        self.optimizers = {}
        self.add_translator_directory(optimizer_dir)

        self.engine_options = Option(engine_options)

    def add_translator_directory(self, plugin_dir_path):
        sys.path.insert(0, plugin_dir_path)

        try:
            files = os.listdir(plugin_dir_path)
            loaded = []
            valid_suffixes = ['.py', '.pyc', '.pyo']

            for i in files:
                base, suffix = os.path.splitext(i)
                if (not base in loaded) and (suffix in valid_suffixes):
                    loaded.append(base)
                    mod = __import__(base)
                    mod.init_optimizer(self)

        except int:
            del sys.path[0]

    def get_loop_optimizer(self):
        return self.loop_optimizer

    def get_all_translators(self):
        ret = []
        ret = ret + self.loop_optimizer.get_translators()

        return ret

    def analyze(self, prog):
        """   :param tree: target translation unit
   :return: [(stmt,([errors], [warnings], [hints], [enabled-optimizer-name]))]"""

        loops = extract_loop(prog)
        results = []

        for (stmt, cfg, attr) in loops:
            i = self.loop_optimizer.analyze_loop(stmt,cfg,attr,prog)
            results += i

        return results

    def get_global_option_initial_value(self):
        set = OptionSet(self.engine_options)

        for i in self.get_all_translators():
            set.translators[i.get_name()] = i.get_global_option()

        return set.create_initial_value()

    def get_engine_option(self):
        return self.engine_options

    def get_translate_option_initial_value(self, translator_name):
        for i in self.loop_optimizer.get_translators():
            if i.get_name() == translator_name:
                return i.get_translate_option().initial_value()

        raise NameError("'%s' is not translator name."%translator_name)

---