/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
* @author Mikhail Y. Fursov
*/
#define LOG_DOMAIN "em"
#include "cxxlog.h"

#include "DrlEMImpl.h"

#include "EBProfileCollector.h"
#include "EdgeProfileCollector.h"
#include "NValueProfileCollector.h"

#include "open/vm_properties.h"
#include "open/vm_ee.h"
#include "open/ee_em_intf.h"
#include "em_intf.h"
#include "open/vm.h"
#include "open/vm_method_access.h"
#include "open/vm_class_manipulation.h"
#include "ini.h"

#include "vm_properties.h"

#include <algorithm>
#include <sstream>
#include <fstream>
#include "port_threadunsafe.h"
#include "port_mutex.h"

#define EDGE_PROFILER_STR  "EDGE_PROFILER"
#define VALUE_PROFILER_STR  "VALUE_PROFILER"
#define ENTRY_BACKEDGE_PROFILER_STR  "EB_PROFILER"

#define EM_CONFIG_EXT std::string(".emconf")

DrlEMImpl* DrlEMFactory::emInstance = NULL;

// TODO you may get a question why we get the same execution manager
// for multiple VM instances the proper way is to get rid of static emInstance
DrlEMImpl* DrlEMFactory::createAndInitEMInstance() {
    if (emInstance == NULL) {
        emInstance = new DrlEMImpl();
        if (!emInstance->init()) {
            delete emInstance;
            emInstance = NULL;
        }
    }
    return emInstance;
}

DrlEMImpl* DrlEMFactory::getEMInstance() {
    assert(emInstance!=NULL);
    return emInstance;
}   

void DrlEMFactory::deinitEMInstance() {
    assert(emInstance!=NULL);
    emInstance->deinit();
    delete emInstance;
    emInstance = NULL;
}

static EM_PCTYPE get_pc_type(EM_Handle _this, PC_Handle pc) {
    assert(_this!=NULL);
    assert(pc!=NULL);
    return ((ProfileCollector*)pc)->type;
}

static PC_Handle get_pc(EM_Handle _this,  EM_PCTYPE profile_type,  JIT_Handle jh,  EM_JIT_PC_Role jit_role) {
    assert(_this!=NULL);
    assert(jh!=NULL);
    DrlEMImpl* em = (DrlEMImpl*) _this;
    return (PC_Handle)em->getProfileCollector(profile_type, jh, jit_role);
}

static Method_Profile_Handle 
get_method_profile(EM_Handle _this, PC_Handle pch, Method_Handle mh) {
    assert(_this!=NULL);
    assert(pch!=NULL);
    assert(mh!=NULL);
    ProfileCollector* pc  = (ProfileCollector*)pch;
    return (Method_Profile_Handle)pc->getMethodProfile(mh);
}


RStep::RStep(JIT_Handle _jit, const std::string& _jitName, RChain* _chain, apr_dso_handle_t* _libHandle)
: jit(_jit), jitName(_jitName), catName(std::string(LOG_DOMAIN)+"."+_jitName), 
chain(_chain), loggingEnabled(false), enable_profiling(NULL),
libHandle(_libHandle)
{}


//todo!! replace inlined strings with defines!!
DrlEMImpl::DrlEMImpl() : jh(NULL), _execute_method(NULL), method_lookup_table() {
    nMethodsCompiled=0;
    nMethodsRecompiled=0;
    tick=0;
    port_mutex_create(&recompilationLock, APR_THREAD_MUTEX_NESTED);
    initProfileAccess();
}

DrlEMImpl::~DrlEMImpl() {
    deallocateResources();
    port_mutex_destroy(&recompilationLock);
}

void DrlEMImpl::initProfileAccess() {
    profileAccessInterface.get_pc_type = get_pc_type;
    profileAccessInterface.get_pc = get_pc;
    profileAccessInterface.get_method_profile =  get_method_profile;

    //EB profile
    profileAccessInterface.eb_profiler_create_profile = eb_profiler_create_profile;
    profileAccessInterface.eb_profiler_get_entry_counter_addr=eb_profiler_get_entry_counter_addr;
    profileAccessInterface.eb_profiler_get_backedge_counter_addr = eb_profiler_get_backedge_counter_addr;
    profileAccessInterface.eb_profiler_is_in_sync_mode= eb_profiler_is_in_sync_mode;
    profileAccessInterface.eb_profiler_get_entry_threshold = eb_profiler_get_entry_threshold;
    profileAccessInterface.eb_profiler_sync_mode_callback = (void (*)(Method_Profile_Handle))vm_create_helper_for_function((void *(*)(void *))eb_profiler_sync_mode_callback);
    profileAccessInterface.eb_profiler_get_backedge_threshold = eb_profiler_get_backedge_threshold;

    
    //EDGE profile
    profileAccessInterface.edge_profiler_create_profile = edge_profiler_create_profile;
    profileAccessInterface.edge_profiler_get_num_counters = edge_profiler_get_num_counters;
    profileAccessInterface.edge_profiler_get_checksum = edge_profiler_get_checksum;
    profileAccessInterface.edge_profiler_get_counter_addr = edge_profiler_get_counter_addr;
    profileAccessInterface.edge_profiler_get_entry_counter_addr = edge_profiler_get_entry_counter_addr;
    profileAccessInterface.edge_profiler_get_entry_threshold = edge_profiler_get_entry_threshold;
    profileAccessInterface.edge_profiler_get_backedge_threshold = edge_profiler_get_backedge_threshold;
    
    
    //Value profile
    profileAccessInterface.value_profiler_create_profile = value_profiler_create_profile;
    profileAccessInterface.value_profiler_add_value = value_profiler_add_value;
    profileAccessInterface.value_profiler_get_top_value = value_profiler_get_top_value;
    profileAccessInterface.value_profiler_dump_values = value_profiler_dump_values;
    
    return;
}



void DrlEMImpl::deallocateResources() {
    tbsClients.clear();

    for (RChains::const_iterator cit = chains.begin(), cend = chains.end(); cit!=cend; ++cit) {
        RChain* chain = *cit;
        for (RSteps::const_iterator sit = chain->steps.begin(), send = chain->steps.end(); sit!=send; ++sit) {
            RStep* step = *sit;
            //todo:call deinit on JIT instance
            delete step;
        }
        delete chain;
    }
    chains.clear();

    for (ProfileCollectors::iterator it = collectors.begin(), end = collectors.end(); it!=end; ++it) {
        ProfileCollector* pc = *it;
        delete pc;
    }    
    collectors.clear();
}

//_____________________________________________________________________
// Reading and parsing configuration

static bool endsWith(const std::string& str, const std::string& suffix) {
    if (str.length() < suffix.length()) {
        return false;
    }
    return std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
}
    
std::string prepareLibPath(const std::string& origPath) {
#ifdef PLATFORM_NT
    std::string separator("\\"), libPrefix(""), libSuffix(".dll");
#else
    std::string separator("/"), libPrefix("lib"), libSuffix(".so");
#endif

    std::string path = origPath;
    if (path.find('/') == path.npos && path.find('\\') == path.npos ) {
        char* c_string_tmp_value = vm_properties_get_value(O_A_H_VM_VMDIR, JAVA_PROPERTIES);
        std::string dir = c_string_tmp_value == NULL ? "" : c_string_tmp_value;
        vm_properties_destroy_value(c_string_tmp_value);
        if (libPrefix.length() > 0 && !startsWith(path, libPrefix)) {
            path = libPrefix + path;
        }
        
        if (!dir.empty()) {
            path = dir + separator + path;
        }
    }
    if (!endsWith(path, libSuffix)) {
        path+=libSuffix;
    }
    return path;
  }



static std::string getParam(const std::string& config, const std::string& name) {
    std::istringstream is(config);
    std::string propPrefix = name+"=";
    size_t prefixLen = propPrefix.length();
    std::string line;
    while (std::getline(is, line)) {
        if (line.length() > prefixLen && std::equal(propPrefix.begin(),propPrefix.end(), line.begin())) {
            return line.substr(prefixLen);
        }
    }
    return "";
}


typedef std::vector<std::string> StringList;
static StringList getParamAsList(const std::string& config, const std::string& name, char listSeparator, bool notEmpty) {
    std::string value = getParam(config, name);
    StringList res;
    std::string token;
    for (std::string::const_iterator it = value.begin(), end = value.end(); it!=end; ++it) {
        char c = *it;
        if (c == listSeparator) {
            if (token.empty() && notEmpty) {
                continue;
            }
            res.push_back(token);
            token.clear();
        } else {
            token.push_back(c);
        }
    }
    if (!token.empty()) { //last value
        res.push_back(token);
    }
    return res;
}

static StringList getAllParamsAsList(const std::string& config, const std::string& name) {
    StringList res;
    std::istringstream is(config);
    std::string propPrefix = name+"=";
    size_t prefixLen = propPrefix.length();
    std::string line;
    while (std::getline(is, line)) {
        if (line.length() > prefixLen && std::equal(propPrefix.begin(),propPrefix.end(), line.begin())) {
            res.push_back(line.substr(prefixLen));
        }
    }
    return res;
}


static std::string readFile(const std::string& fileName) {
    std::string config;
    std::ifstream configFile;
    configFile.open(fileName.c_str(), std::ios::in);
    bool rc = false;
    if (configFile.is_open()) {
        std::string line;
        size_t idx = std::string::npos;
        while (getline(configFile, line)) {
            if (startsWith(line, "#")) {
                continue;
            } else if (startsWith(line, "-D") && (idx = line.find('=')) != std::string::npos) {
                std::string name = line.substr(2, idx-2);                   
                std::string value = line.substr(idx+1);
                if (!vm_property_is_set(name.c_str(), JAVA_PROPERTIES)) {
                    vm_properties_set_value(name.c_str(), value.c_str(), JAVA_PROPERTIES);
                }
                continue;
            } else if (startsWith(line, "-XD") && (idx = line.find('=')) != std::string::npos) {
                std::string name = line.substr(3, idx-3);                   
                std::string value = line.substr(idx+1);
                if (!vm_property_is_set(name.c_str(),VM_PROPERTIES)) {
                    vm_properties_set_value(name.c_str(), value.c_str(), VM_PROPERTIES);
                }
                continue;
            } else if (startsWith(line, "-XX:") && line.length() >= 5) {
                idx = line.find('=');
                std::string name;
                std::string value;
                if (idx != std::string::npos) {
                    name = line.substr(4, idx-4);                   
                    value = line.substr(idx+1);
                } else {
                    if (line[4] == '-' ) {
                        value = "off";
                        name = line.substr(5);
                    } else if (line[4] == '+') {
                        value = "on";
                        name = line.substr(5);
                    } else {
                        value = "";
                        name = line.substr(4);
                    }
                }

                if (!vm_property_is_set(name.c_str(),VM_PROPERTIES)) {
                    vm_properties_set_value(name.c_str(), value.c_str(), VM_PROPERTIES);
                }
                continue;
            } 
 
            config+=line + "\n";
        }
        rc = !config.empty();
    } 
    if (!rc) {
        LECHO(1, "EM: Can't read configuration from '{0}'" << fileName.c_str());
    }
    return config;
}

std::string DrlEMImpl::readConfiguration() {
    char* c_string_tmp_value = vm_properties_get_value("em.properties", VM_PROPERTIES);
    std::string  configFileName = c_string_tmp_value == NULL ? "" : c_string_tmp_value;
    vm_properties_destroy_value(c_string_tmp_value);
    if (configFileName.empty()) {
        bool jitTiMode = vm_property_get_boolean("vm.jvmti.enabled", FALSE, VM_PROPERTIES);
        bool interpreterMode = vm_property_get_boolean("vm.use_interpreter", FALSE, VM_PROPERTIES);
        configFileName = interpreterMode ? "interpreter" : (jitTiMode ? "ti" : "client");
    } 
    if (!endsWith(configFileName, EM_CONFIG_EXT)) {
        configFileName = configFileName+EM_CONFIG_EXT;
    }

    if (configFileName.find('/') == configFileName.npos && configFileName.find('\\') == configFileName.npos ) {
        c_string_tmp_value = vm_properties_get_value(O_A_H_VM_VMDIR, JAVA_PROPERTIES);
        std::string defaultConfigDir = c_string_tmp_value == NULL ? "" : c_string_tmp_value;
        vm_properties_destroy_value(c_string_tmp_value);
        
        configFileName = defaultConfigDir + "/" + configFileName;
    }
    std::string config = readFile(configFileName);
    return config;
}

//_______________________________________________________________________
// EM initialization methods

bool DrlEMImpl::init() {
    _execute_method = JIT_execute_method_default;

    std::string config = readConfiguration();
    if (!config.empty()) {
        buildChains(config);
    }
    return !chains.empty();
}


static bool enable_profiling_stub(JIT_Handle jit, PC_Handle pc, EM_JIT_PC_Role role) {
    return false;
}

static void profile_notification_callback_stub(JIT_Handle, PC_Handle, Method_Handle) {
}

bool DrlEMImpl::initJIT(const std::string& libName, apr_dso_handle_t* libHandle, RStep& step) {
    apr_dso_handle_sym_t fn = NULL;
    if (apr_dso_sym(&fn, libHandle, "JIT_init") != APR_SUCCESS) {
        LECHO(2, "EM: Not a JIT shared lib: '{0}'" << libName.c_str());
        return false;
    }

    void (*_init)(JIT_Handle, const char*, vm_adaptor_t) = 
        (void (*)(JIT_Handle, const char*, vm_adaptor_t)) fn;
    _init(step.jit, step.jitName.c_str(), vm_get_interface);

    bool pcEnabled = false;
    if (apr_dso_sym(&fn, libHandle, "JIT_set_profile_access_interface") == APR_SUCCESS) {
        pcEnabled =  true;
        void (*_setPAInterface)(JIT_Handle, EM_Handle, struct EM_ProfileAccessInterface*) = (void (*)(JIT_Handle, EM_Handle, struct EM_ProfileAccessInterface*))fn;
        _setPAInterface(step.jit, (EM_Handle)this, &profileAccessInterface);
    } 

    if (pcEnabled && apr_dso_sym(&fn, libHandle, "JIT_enable_profiling") == APR_SUCCESS) {
        step.enable_profiling = (bool(*)(JIT_Handle, PC_Handle, EM_JIT_PC_Role))fn;
    } else {
        step.enable_profiling = enable_profiling_stub;
    }

    if (pcEnabled && apr_dso_sym(&fn, libHandle, "JIT_profile_notification_callback") == APR_SUCCESS) {
        step.profile_notification_callback = (void(*)(JIT_Handle, PC_Handle, Method_Handle))fn;
    } else {
        step.profile_notification_callback = profile_notification_callback_stub;
    }

    return true;
}

std::string DrlEMImpl::getJITLibFromCmdLine(const std::string& jitName) const {
    std::string propName = std::string("em.")+jitName+".jitPath";
    char* c_string_tmp_value = vm_properties_get_value(propName.c_str(), VM_PROPERTIES);
    std::string jitLib  = c_string_tmp_value == NULL ? "" : c_string_tmp_value;
    vm_properties_destroy_value(c_string_tmp_value);
    if (jitLib.empty()) {
        c_string_tmp_value = vm_properties_get_value("em.jitPath", VM_PROPERTIES);
        jitLib = c_string_tmp_value == NULL ? "" : c_string_tmp_value;
        vm_properties_destroy_value(c_string_tmp_value);
    }
    return jitLib;
}

void DrlEMImpl::buildChains(std::string& config) {
    bool loggingEnabled =  log_is_info_enabled(LOG_DOMAIN);
    StringList chainNames = getParamAsList(config, "chains", ',', true);
    if (chainNames.empty()) {
        LECHO(3, "EM: No 'chains' property found in configuration");
        return;
    }
    bool failed = false;
    for (StringList::const_iterator chainIt = chainNames.begin(), chainEnd = chainNames.end(); chainIt!=chainEnd; ++chainIt) {
        std::string chainName = *chainIt;
        if (std::count(chainNames.begin(), chainNames.end(), chainName)!=1) {
            failed = true;
            break;
        }
        RChain* chain = new RChain();
        chains.push_back(chain);
        StringList jitsInChain= getParamAsList(config, chainName + ".jits", ',', true);
        for (StringList::const_iterator jitIt = jitsInChain.begin(), jitEnd = jitsInChain.end(); jitIt!=jitEnd; ++jitIt) {
            std::string jitName= *jitIt;
            std::string jitLib = getJITLibFromCmdLine(jitName);
            if (jitLib.empty()) {
                jitLib = getParam(config, jitName+".file");
            } 
            if (jitLib.empty()) {
                LECHO(4, "EM: No JIT library specified for JIT :'{0}'" << jitLib.c_str());
                failed = true;
                break;
            }
            std::string fullJitLibPath = prepareLibPath(jitLib);
            apr_dso_handle_t* libHandle;
            JIT_Handle jh = vm_load_jit(fullJitLibPath.c_str(), &libHandle); //todo: do not load the same dll twice!!!
            if (jh == NULL) {
                LECHO(5, "EM: JIT library loading error:'{0}'" << fullJitLibPath.c_str());
                failed = true;
                break;
            }
            RStep* step = new RStep(jh, jitName, chain, libHandle);
            step->loggingEnabled = loggingEnabled || log_is_info_enabled(step->catName.c_str());
            chain->steps.push_back(step);

            if (!initJIT(fullJitLibPath, libHandle, *step)) {
                failed = true;
                break;
            }
        }
        failed = failed || chain->steps.empty();
        if (!failed) { 
            // reading chain filters
            StringList filters = getAllParamsAsList(config, chainName+".filter");
            for (StringList::const_iterator filterIt = filters.begin(), filterEnd = filters.end(); filterIt!=filterEnd; ++filterIt) {
                const std::string& filter = *filterIt;
                bool res = chain->addMethodFilter(filter);
                if (!res) {
                    LECHO(6, "EM: Invalid filter :'{0}'" << filter.c_str());
                }
            }
        }
        if (failed) {
            break;
        }
    }
    if (!failed) { //initialize profile collectors
        for (RChains::const_iterator it = chains.begin(), end = chains.end(); it!=end; ++it) {
            RChain* chain = *it;
            failed = !initProfileCollectors(chain, config);
            if (failed) {
                break;
            }
        }
    }

    //The next lines do the following:
    //If we have only 1 execution engine in CFG - check if it have JIT_execute_method
    //This way interpreter mode is supported today.
    //This code must be refactored when mixed (JIT/interpreter) mode is implemented
    if (!failed && chains.size()==1) {
        RChain* chain = *chains.begin();
        assert(chain->steps.size() > 0);
        RStep* step = *chain->steps.begin();
        
        apr_dso_handle_sym_t fn = NULL;
        apr_dso_sym(&fn, step->libHandle, "JIT_execute_method");
        if (fn!=NULL) {
            _execute_method = (void(*)(JIT_Handle,jmethodID, jvalue*, jvalue*)) fn;    
        }
    }


    if (failed) {
        deallocateResources();
    }
}

void DrlEMImpl::deinit() {
}

//______________________________________________________________________________
// EM runtime
void DrlEMImpl::executeMethod(jmethodID meth, jvalue  *return_value, jvalue *args) {
    //do not choose JIT here, this method will call-back from vm with compileMethod request.
    _execute_method(0, meth, return_value, args);
}

JIT_Result DrlEMImpl::compileMethod(Method_Handle mh) {
    //initial method compilation. Select chain to use.

    UNSAFE_REGION_START
    // May affect logging statistics, also used in debug-intended method filter
    // Does not affect normal execution
    nMethodsCompiled++;
    UNSAFE_REGION_END

    //these vars are used for logging
    const char* methodName = NULL;
    const char* className = NULL;
    const char* signature = NULL;
    size_t n = nMethodsCompiled;

    assert(!chains.empty());
    for (RChains::const_iterator it = chains.begin(), end = chains.end(); it!=end; ++it) {
        RChain* chain = *it;
        if (chain->acceptMethod(mh, nMethodsCompiled)) {
            assert(!chain->steps.empty());
            for (size_t i=0;i<chain->steps.size(); i++) {
                RStep* step = chain->steps[i];
                if (step->loggingEnabled) {
                    methodName = method_get_name(mh);
                    Class_Handle ch = method_get_class(mh);
                    className = class_get_name(ch);
                    signature = method_get_descriptor(mh);
                    std::ostringstream msg;
                    msg <<"EM: compile start:["<<step->jitName.c_str()<<" n="<<n<<"] "
                        <<className<<"."<<methodName<<signature;
                    INFO2(step->catName.c_str(), msg.str().c_str());
                }

                JIT_Result res = vm_compile_method(step->jit, mh);

                if (step->loggingEnabled) {
                    std::ostringstream msg;
                    msg << "EM: compile done:["<<step->jitName.c_str()<<" n="<<n<<": "
                        <<(res ==JIT_SUCCESS ? "OK" : "FAILED")<<"] "<<className<<"."<<methodName<<signature;
                    INFO2(step->catName.c_str(), msg.str().c_str());
                }

                if (res == JIT_SUCCESS) {
                    return JIT_SUCCESS;
                }
            }
        }
    }
    return JIT_FAILURE;
}



//______________________________________________________________________________
// Profile collectors initialization and recompilation

static U_32 toNum(const std::string& numStr, bool *rc ) {
    if (isNum(numStr)) {
        *rc = true;
        return atoi(numStr.c_str());
    }
    *rc = false;
    return 0;
}

ProfileCollector* DrlEMImpl::createProfileCollector(const std::string& profilerName, const std::string& config, RStep* step)  {
    ProfileCollector* pc = getProfileCollector(profilerName);
    if (pc != NULL){
        return NULL;
    }    
    std::string profilerType = getParam(config, profilerName+".profilerType");
    if (profilerType!=ENTRY_BACKEDGE_PROFILER_STR && profilerType!=EDGE_PROFILER_STR  && profilerType!=VALUE_PROFILER_STR) {
        LECHO(7, "EM: Unsupported profiler type");
        return NULL;
    }

    if (profilerType == ENTRY_BACKEDGE_PROFILER_STR || profilerType == EDGE_PROFILER_STR) {
        EBProfileCollector::EB_ProfilerMode ebMode = EBProfileCollector::EB_PCMODE_SYNC;
        std::string mode = profilerType==EDGE_PROFILER_STR ? "ASYNC" : getParam(config, profilerName+".mode");
        
        if (mode == "ASYNC") {
            ebMode = EBProfileCollector::EB_PCMODE_ASYNC;
        }  else if (mode!="SYNC") {
            LECHO(8, "EM: unsupported profiler mode");
            return NULL;
        }
        
        bool ok = false;
        U_32 eThreshold = toNum(getParam(config, profilerName+".entryThreshold"), &ok);//todo: default values..
            if (!ok) {
            LECHO(9, "EM: illegal '{0}' value" << "entryThreshold");
            return NULL;
            }
                U_32 bThreshold = toNum(getParam(config, profilerName+".backedgeThreshold"), &ok);
        if (!ok) {
            LECHO(9, "EM: illegal '{0}' value" << "backedgeThreshold");
            return NULL;
        }
        U_32 tbsTimeout = 0, tbsInitialTimeout = 0;
        if (ebMode == EBProfileCollector::EB_PCMODE_ASYNC) {
            tbsTimeout= toNum(getParam(config, profilerName+".tbsTimeout"), &ok);
            if (!ok) {
                LECHO(9, "EM: illegal '{0}' value" << "tbsTimeout");
                return NULL;
                }
            tbsInitialTimeout= toNum(getParam(config, profilerName+".tbsInitialTimeout"), &ok);
            if (!ok) {
                LECHO(9, "EM: illegal '{0}' value" << "tbsInitialTimeout");
                return NULL;
            }
        }
        if (profilerType == EDGE_PROFILER_STR) {
            pc = new EdgeProfileCollector(this, profilerName, step->jit, tbsInitialTimeout, tbsTimeout, eThreshold, bThreshold);
        } else {
            pc = new EBProfileCollector(this, profilerName, step->jit, ebMode, eThreshold, bThreshold, tbsInitialTimeout, tbsTimeout);
        }
    } else if (profilerType == VALUE_PROFILER_STR) {
        typedef ValueProfileCollector VPC;
        int vpSteadySize = 4, vpClearSize = 0, vpClearInterval = 0;
        std::string vpalgo = getParam(config, profilerName+".vpalgo");
        VPC::algotypes vpMode = VPC::TNV_FIRST_N;
        if (vpalgo == "TNV_DIVIDED") {
            vpMode = VPC::TNV_DIVIDED;
        } else if (vpalgo != "TNV_FIRST_N") {
            LECHO(10, "EM: unsupported value profiler algotype");
            return NULL;
        }

        std::string strategy = getParam(config, profilerName+".updateStrategy");
        ProfileUpdateStrategy updateStrategy = UPDATE_LOCKED;
        if (strategy == "FLAGGED_ALL") {
            updateStrategy = UPDATE_FLAGGED_ALL;
        }else if (strategy == "FLAGGED_INSERT") {
            updateStrategy = UPDATE_FLAGGED_INSERT;
        }else if (strategy == "UNSAFE") {
            updateStrategy = UPDATE_UNSAFE;
        }else if (strategy == "LOCKED_INSERT") {
            updateStrategy = UPDATE_LOCKED_INSERT;
        }else if (strategy != "LOCKED") {
            LECHO(10, "EM: unsupported value profiler updateStrategy");
            return NULL;
        }

        if (vpMode != VPC::TNV_FIRST_N && updateStrategy != UPDATE_LOCKED) {
            LECHO(10, "EM: unsupported value profiler combination of "
                    "vpalgo and updateStrategy, only TNV_FIRST_N vpalgo "
                    "curretly sypports other than LOCKED strategy");
            return NULL;
        }

        bool ok = false;
        vpSteadySize = toNum(getParam(config, profilerName+".vpSteadySize"), &ok);
        if (!ok) {
            LECHO(9, "EM: illegal '{0}' value" << "SteadySize");
            return NULL;
        }
        if (vpMode == VPC::TNV_DIVIDED) {
            vpClearSize = toNum(getParam(config, profilerName+".vpClearSize"), &ok);
            if (!ok) {
                LECHO(9, "EM: illegal '{0}' value" << "ClearSize");
                return NULL;
            }
            vpClearInterval = toNum(getParam(config, profilerName+".vpClearInterval"), &ok);
            if (!ok) {
                LECHO(9, "EM: illegal '{0}' value" << "ClearInterval");
                return NULL;
            }
        }
        pc = new ValueProfileCollector(this, profilerName, step->jit, vpSteadySize,
                vpClearSize, vpClearInterval, vpMode, updateStrategy);
    }
    return pc;
}

ProfileCollector* DrlEMImpl::getProfileCollector(const std::string& name) const {
    for (ProfileCollectors::const_iterator it = collectors.begin(), end = collectors.end(); it!=end; ++it) {
        ProfileCollector* c = *it;
        if (c->name == name) {
            return c;
        }
    }
    return NULL;
}

bool DrlEMImpl::initProfileCollectors(RChain* chain, const std::string& config) {
    bool failed = false;
    for (RSteps::const_iterator it = chain->steps.begin(), end = chain->steps.end(); it!=end; ++it) {
        RStep* step = *it;
        StringList genProfNames = getParamAsList(config, step->jitName + ".genProfile", ',', false);
        for (StringList::const_iterator profIt = genProfNames.begin(), profEnd = genProfNames.end(); profIt!=profEnd; ++profIt) {
            std::string profilerName = *profIt;
            if (!profilerName.empty()) {
                ProfileCollector* pc = createProfileCollector(profilerName, config, step);
                if (pc == NULL) {
                    LECHO(11, "EM: profile configuration failed: {0}" << profilerName.c_str());
                    failed = true;
                    break;
                }
                bool genOk = step->enable_profiling(step->jit, (PC_Handle)pc, EM_JIT_PROFILE_ROLE_GEN);
                if (genOk) {
                    collectors.push_back(pc);
                    TbsEMClient* tbsClient = pc->getTbsEmClient();
                    if (tbsClient!=NULL) {
                        assert(tbsClient->getTimeout() != 0 && tbsClient->getTimeout()!=0);
                        tbsClient->setNextTick(tbsClient->getInitialTimeout());
                        tbsClients.push_back(tbsClient);
                    }
                } else {
                    LECHO(12, "EM: profile generation is not supported: {0}" << profilerName.c_str());
                    delete pc;
                    failed = true;
                    break;
                }

            }
        }
        StringList useProfNames = getParamAsList(config, step->jitName + ".useProfile", ',', false);
        for (StringList::const_iterator profIt = useProfNames.begin(), profEnd = useProfNames.end(); profIt!=profEnd; ++profIt) {
            std::string profilerName = *profIt;
            if (!profilerName.empty()) {
                ProfileCollector* pc = getProfileCollector(profilerName);
                bool invalidChain = true;
                if (pc!=NULL) {
                    for(RSteps::const_iterator it2=chain->steps.begin(); it2 <it; ++it2) {
                        RStep* prevStep = *it2;
                        if (prevStep->jit == pc->genJit) {
                            invalidChain = false;
                            break;
                        }
                    }
                }
                bool useOk = !invalidChain && (pc!=NULL && step->enable_profiling(step->jit, (PC_Handle)pc, EM_JIT_PROFILE_ROLE_USE));
                if (useOk) {
                    pc->addUseJit(step->jit);
                } else {
                    if (pc == NULL) {
                        LECHO(13, "EM: profile not found: {0}" << profilerName.c_str());
                    } else if (invalidChain) {
                        LECHO(14, "EM: illegal use of profile: {0}" << profilerName.c_str());
                    } else {
                        LECHO(15, "EM: profile usage is not supported: {0}" << profilerName.c_str());
                    }
                }
            }
        }
    }
    if (!failed && !tbsClients.empty()) {
        //timer.start(this);
    }
    return !failed;
}

void DrlEMImpl::methodProfileIsReady(MethodProfile* mp) {
    
    port_mutex_lock(&recompilationLock);
    if (methodsInRecompile.find((Method_Profile_Handle)mp)!=methodsInRecompile.end()) {
        //method is already recompiling by another thread or by this thread(recursion)
        port_mutex_unlock(&recompilationLock);
        return;
    }
    
    methodsInRecompile.insert((Method_Profile_Handle)mp);
    nMethodsRecompiled++;
    port_mutex_unlock(&recompilationLock);

    const char* methodName = NULL;
    const char* className = NULL;
    const char* signature = NULL;
    size_t n = nMethodsRecompiled;

    JIT_Handle jit = mp->pc->genJit;
    for (RChains::const_iterator it = chains.begin(), end = chains.end(); it!=end; ++it) {
        RChain* chain = *it;
        for (RSteps::const_iterator sit = chain->steps.begin(), send = chain->steps.end(); sit!=send; ++sit) {
            RStep* step = *sit;
            if (step->jit == jit) {

                //notify JIT which has generated this profile that profile is ready.
                step->profile_notification_callback(step->jit, mp->pc, mp->mh);

                ++sit;
                RStep* nextStep = sit!=send ? *sit: NULL;
                if (nextStep != NULL) {
                    if (nextStep->loggingEnabled) {
                        methodName = method_get_name(mp->mh);
                        Class_Handle ch = method_get_class(mp->mh);
                        className = class_get_name(ch);
                        signature = method_get_descriptor(mp->mh);
                        std::ostringstream msg;
                        msg <<"EM: recompile start:["<<nextStep->jitName.c_str()<<" n="<<n<<"] "
                            <<className<<"."<<methodName<<signature;
                        INFO2(nextStep->catName.c_str(), msg.str().c_str());
                    } 

                    JIT_Result res = vm_compile_method(nextStep->jit, mp->mh);

                    if (nextStep->loggingEnabled) {
                        std::ostringstream msg;
                        msg << "EM: recompile done:["<<nextStep->jitName.c_str()<<" n="<<n<<": "
                            <<(res ==JIT_SUCCESS ? "OK" : "FAILED")<<"] "<<className<<"."<<methodName<<signature;
                        INFO2(nextStep->catName.c_str(), msg.str().c_str());
                    }

                }
            }
        }
    }
    port_mutex_lock(&recompilationLock);
    methodsInRecompile.erase((Method_Profile_Handle)mp);
    port_mutex_unlock(&recompilationLock);
}

ProfileCollector* DrlEMImpl::getProfileCollector(EM_PCTYPE type, JIT_Handle jh, EM_JIT_PC_Role jitRole) const {
    for (ProfileCollectors::const_iterator it = collectors.begin(), end = collectors.end(); it!=end; ++it) {
        ProfileCollector* pc = *it;
        if (pc->type == type) {
            bool matched = false;
            if (jitRole == EM_JIT_PROFILE_ROLE_GEN) {
                matched =  pc->genJit == jh;
            } else {
                matched =  std::find(pc->useJits.begin(), pc->useJits.end(), jh)!=pc->useJits.end();
            }
            if (matched) {
                return pc;
            }
        }
    }
    return NULL;
}

bool DrlEMImpl::needTbsThreadSupport() const {
    return !tbsClients.empty();
}

void DrlEMImpl::tbsTimeout() {
    for (TbsClients::const_iterator it = tbsClients.begin(), end = tbsClients.end(); it!=end; ++it) {
        TbsEMClient* c = *it;
        if (c->getNextTick() == tick) {
//            printf("tick!\n");
            c->onTimeout();
            c->setNextTick(tick + c->getTimeout());
        }
    }
    tick++;
}

int DrlEMImpl::getTbsTimeout() const {
    return 100;
}   



void DrlEMImpl::classloaderUnloadingCallback(Class_Loader_Handle class_handle) {
    //notify every profile collector about classloader unloading
}

void DrlEMImpl::registerCodeChunk(Method_Handle method_handle, void *code_addr,
    size_t size, void *data)
{
    method_lookup_table.add(method_handle, code_addr, size, data);
}

Method_Handle DrlEMImpl::lookupCodeChunk(void *ip, Boolean is_ip_past,
    void **code_addr, size_t *size, void **data)
{
    return method_lookup_table.find(ip, is_ip_past, code_addr, size, data);
}

Boolean DrlEMImpl::unregisterCodeChunk(void *addr)
{
    return method_lookup_table.remove(addr);
}