/************************************************************************* * * * Extension for YAP Prolog * * * * Copyright G.S.Oliveira, A.F.Silva and Universidade Estadual de Maringá * * * * Yap Prolog was developed at NCCUP - Universidade do Porto * * Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 * * * ************************************************************************** * * * File: jit_configpreds.c * * comments: JIT Compiler Configuration predicates * * * * Last rev: 2013-10-18 * *************************************************************************/ #include "jit_predicates.hh" #include // Enable any (passed by argument) execution mode static Int p_execution_mode(void); // Enable 'just interpreted' mode. static Int p_interpreted_mode(void); // Enable 'smart jit' mode. static Int p_smartjit_mode(void); // Enable 'continuous compilation' mode. static Int p_continuouscompilation_mode(void); // Enable 'just compiled' mode. static Int p_justcompiled_mode(void); // Enable one (passed by argument) of all available frequency types: counter or time. Frequency bound is default. // Just for 'smart jit' or 'continuous compilation' mode static Int p_frequencyty1(void); // Enable one (1st argument) of all available frequency types: counter and time. Frequency bound is 2nd argument // Just for 'smart jit' or 'continuous compilation' mode static Int p_frequencyty2(void); // Enable frequency bound // Just for 'smart jit' or 'continuous compilation' mode static Int p_frequency_bound(void); // Enable value for starting profiling // Just for 'smart jit' or 'continuous compilation' mode static Int p_profiling_start_point(void); // Choose type of clause that can be main on traces // Just for 'smart jit' or 'continuous compilation' mode static Int p_main_clause_ty(void); // Choose amount of compilation threads // Just for 'smart jit' or 'continuous compilation' mode static Int p_compilation_threads(void); // Enable recompilation // Just for 'smart jit' or 'continuous compilation' mode static Int p_enable_recompilation(void); // Disable recompilation // Just for 'smart jit' or 'continuous compilation' mode static Int p_disable_recompilation(void); // Just code interpretation. Don't compile // Just for 'smart jit' or 'continuous compilation' mode static Int p_only_profiled_interpreter(void); // Disable 'p_only_profiled_interpreter' // Just for 'smart jit' or 'continuous compilation' mode static Int p_noonly_profiled_interpreter(void); #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wimplicit-function-declaration" static Int p_execution_mode(void) { enumExecModes mode; // valid values for ARG1 are 'integer' and 'atom' Term t = Deref(ARG1); if (IsIntTerm(t)) { // ARG1 is integer Int v = IntOfTerm(t); if (v < 0 || v > 3) { // value passed by argument is out of known range (valid values are: 0 -- interpreted; 1 -- smart jit; 2 -- continuous compilation; 3 -- just compiled) Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } // storing mode mode = (enumExecModes)v; } else if (IsAtomTerm(t)) { // ARG1 is atom int i = 0, j = 0; char *tmp; // gets string from atom and stores it on 'str' char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); // Makes upper characters of 'str' (for comparison) UPPER_ENTRY(str); // Detecting mode according to 'str' if (strcmp(str, "INTERPRETED") == 0) mode = JUST_INTERPRETED; else if (strcmp(str, "SMARTJIT") == 0) mode = SMART_JIT; else if (strcmp(str, "CONTINUOUSCOMPILATION") == 0) mode = CONTINUOUS_COMPILATION; else if (strcmp(str, "JUSTCOMPILED") == 0) mode = JUST_COMPILED; else { // value passed by argument is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } } else { // ARG1 is not an integer or atom Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Execution mode"); return FALSE; } // setting execution mode ExpEnv.config_struc.execution_mode = mode; /* setting execution mode parameters */ switch (mode) { case JUST_INTERPRETED: { if (Yap_ExecutionMode == INTERPRETED) { // execution mode only can be 'JUST_INTERPRETED' if 'Yap_ExecutionMode == INTERPRETED' (passing -J0 on command line) // 'JUST_INTERPRETED' does not use these parameters ExpEnv.config_struc.frequency_type = NO_FREQ; ExpEnv.config_struc.frequency_bound = 0.0; ExpEnv.config_struc.profiling_startp = 0.0; ExpEnv.config_struc.mainclause_ty = UNUSED; ExpEnv.config_struc.compilation_threads = 0; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to INTERPRETED!!\n"); #endif } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"INTERPRETED"); return FALSE; } } break; case SMART_JIT: { if (Yap_ExecutionMode == MIXED_MODE) { // execution mode only can be 'SMART_JIT' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) ExpEnv.config_struc.frequency_type = COUNTER; ExpEnv.config_struc.frequency_bound = 1024.0; ExpEnv.config_struc.profiling_startp = 0.72; ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; ExpEnv.config_struc.compilation_threads = 0; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to SMART JIT!!\n"); #endif } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"SMART JIT"); return FALSE; } } break; case CONTINUOUS_COMPILATION: { if (Yap_ExecutionMode == MIXED_MODE) { // execution mode only can be 'CONTINUOUS_COMPILATION' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) ExpEnv.config_struc.frequency_type = COUNTER; ExpEnv.config_struc.frequency_bound = 1024.0; ExpEnv.config_struc.profiling_startp = 0.72; ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; ExpEnv.config_struc.compilation_threads = ExpEnv.config_struc.ncores-1; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to CONTINUOUS COMPILATION!!\n"); #endif } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"CONTINUOUS COMPILATION"); return FALSE; } } break; case JUST_COMPILED: { if (Yap_ExecutionMode == COMPILED) { // execution mode only can be 'JUST_COMPILED' if 'Yap_ExecutionMode == COMPILED' (passing -J2 on command line) // 'JUST_COMPILED' does not use these parameters ExpEnv.config_struc.frequency_type = NO_FREQ; ExpEnv.config_struc.frequency_bound = 0.0; ExpEnv.config_struc.profiling_startp = 0.0; ExpEnv.config_struc.mainclause_ty = UNUSED; ExpEnv.config_struc.compilation_threads = 0; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to JUST COMPILED!!\n"); #endif } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"JUST COMPILED"); return FALSE; } } break; } /***/ return TRUE; } static Int p_interpreted_mode(void) { // Same as 'execution_mode(0)' or 'execution_mode(interpreted)' if (Yap_ExecutionMode == INTERPRETED) { // execution mode only can be 'JUST_INTERPRETED' if 'Yap_ExecutionMode == INTERPRETED' (passing -J0 on command line) ExpEnv.config_struc.execution_mode = JUST_INTERPRETED; // setting mode ExpEnv.config_struc.frequency_type = NO_FREQ; // does not use frequency type ExpEnv.config_struc.frequency_bound = 0.0; // does not use frequency bound ExpEnv.config_struc.profiling_startp = 0.0; // does not use profiling startp ExpEnv.config_struc.mainclause_ty = UNUSED; // does not use mainclause ty ExpEnv.config_struc.compilation_threads = 0; // does not use compilation threads #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to INTERPRETED!!\n"); #endif return TRUE; } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"INTERPRETED"); return FALSE; } } static Int p_smartjit_mode(void) { // Same as 'execution_mode(1)' or 'execution_mode(smartjit)' if (Yap_ExecutionMode == MIXED_MODE) { // execution mode only can be 'SMART_JIT' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) ExpEnv.config_struc.execution_mode = SMART_JIT; // setting mode ExpEnv.config_struc.frequency_type = COUNTER; // default value ExpEnv.config_struc.frequency_bound = 1024.0; // default value ExpEnv.config_struc.profiling_startp = 0.72; // default value ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; // default value /* does not use compilation threads */ ExpEnv.config_struc.compilation_threads = 0; ExpEnv.config_struc.threaded_compiler_threads = NULL; ExpEnv.config_struc.posthreads = NULL; /***/ #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to SMART JIT!!\n"); if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "trace"); #endif return TRUE; } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"SMART JIT"); return FALSE; } } static Int p_continuouscompilation_mode(void) { // Same as 'execution_mode(2)' or 'execution_mode(continuouscompilation)' if (Yap_ExecutionMode == MIXED_MODE) { // execution mode only can be 'CONTINUOUS_COMPILATION' if 'Yap_ExecutionMode == MIXED_MODE' (passing -J1 on command line) ExpEnv.config_struc.execution_mode = CONTINUOUS_COMPILATION; // setting mode ExpEnv.config_struc.frequency_type = COUNTER; // default value ExpEnv.config_struc.frequency_bound = 1024.0; // default value ExpEnv.config_struc.profiling_startp = 0.72; // default value ExpEnv.config_struc.mainclause_ty = HOT_AND_CALLEE; // default value ExpEnv.config_struc.compilation_threads = ExpEnv.config_struc.ncores-1; // default value for this mode /* initializing structures which will handle compilation threads */ { if (ExpEnv.config_struc.threaded_compiler_threads) free(ExpEnv.config_struc.threaded_compiler_threads); if (ExpEnv.config_struc.posthreads) free(ExpEnv.config_struc.posthreads); ExpEnv.config_struc.threaded_compiler_threads = (pthread_t*)malloc(ExpEnv.config_struc.compilation_threads*sizeof(pthread_t)); ExpEnv.config_struc.posthreads = (CELL*)malloc(ExpEnv.config_struc.compilation_threads*sizeof(CELL)); int i; for (i = 0; i < ExpEnv.config_struc.compilation_threads; i++) ExpEnv.config_struc.posthreads[i] = 0; } /***/ #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to CONTINUOUS COMPILATION!!\n"); if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "trace"); #endif return TRUE; } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"CONTINUOUS COMPILATION"); return FALSE; } } static Int p_justcompiled_mode(void) { // Same as 'execution_mode(3)' or 'execution_mode(justcompiled)' if (Yap_ExecutionMode == COMPILED) { // execution mode only can be 'JUST_COMPILED' if 'Yap_ExecutionMode == COMPILED' (passing -J2 on command line) ExpEnv.config_struc.execution_mode = JUST_COMPILED; // setting mode ExpEnv.config_struc.frequency_type = NO_FREQ; // does not use frequency type ExpEnv.config_struc.frequency_bound = 0.0; // does not use frequency bound ExpEnv.config_struc.profiling_startp = 0.0; // does not use profiling startp ExpEnv.config_struc.mainclause_ty = UNUSED; // does not use mainclause ty ExpEnv.config_struc.compilation_threads = 0; // does not use compilation threads #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," YAP Execution mode changed to JUST COMPILED!!\n"); if (ExpEnv.debug_struc.pprint_intermediate.print_to_file) strcpy(((char*)ExpEnv.debug_struc.pprint_intermediate.file_name), "clause"); #endif return TRUE; } else { // 'Yap_ExecutionMode' is not compatible Yap_NilError(INCOMPATIBLE_CODEMODE_WARNING,"JUST COMPILED"); return FALSE; } } static Int p_frequencyty1(void) { // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); // valid value for ARG1 is just 'atom' if (IsAtomTerm(t)) { // ARG1 is atom int i = 0, j = 0; char *tmp; // gets string from atom and stores it on 'str' char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); // Makes upper characters of 'str' (for comparison) UPPER_ENTRY(str); // Detectng frequency type according to 'str' if (strcmp(str, "COUNTER") == 0 || strcmp(str, "COUNT") == 0) { ExpEnv.config_struc.frequency_type = COUNTER; // setting frequency type to 'counter' ExpEnv.config_struc.frequency_bound = 1024.0; // if 'counter', frequency bound is '1024.0' return TRUE; } else if (strcmp(str, "TIME") == 0 || strcmp(str, "TIMING") == 0) { ExpEnv.config_struc.frequency_type = TIME; // setting frequency type to 'time' ExpEnv.config_struc.frequency_bound = 0.02; // if 'time', frequency bound is '0.02' return TRUE; } else { // value passed by argument is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } } else { // ARG1 is not an atom Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"Frequency type"); return FALSE; } } else { // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } } static Int p_frequencyty2(void) { // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); // valid value for ARG1 is just 'atom' if (IsAtomTerm(t)) { Term u = Deref(ARG2); // valid values for ARG2 are 'integer' and 'float' if (IsIntTerm(u) || IsFloatTerm(u)) { // ARG1 is atom and ARG2 is integer or float int i = 0, j = 0; char *tmp; // getting string from atom and stores it on 'str' char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); // Making upper characters of 'str' (for comparison) UPPER_ENTRY(str); // getting ARG2 value Float v; if (IsIntTerm(u)) v = (Float)IntOfTerm(u); if (IsFloatTerm(u)) v = FloatOfTerm(u); // setting 'frequency type' and 'frequency bound' if 'COUNTER' if (strcmp(str, "COUNTER") == 0 || strcmp(str, "COUNT") == 0) { if (v < 20.0) { // Very low frequency bound to apply on 'COUNTER' fprintf(stderr,"%.2f is a very low value for the active frequency type. Reconsider its value...\n", v); return FALSE; } ExpEnv.config_struc.frequency_type = COUNTER; ExpEnv.config_struc.frequency_bound = roundf(v); return TRUE; } // setting 'frequency type' and 'frequency bound' if 'TIME' else if (strcmp(str, "TIME") == 0 || strcmp(str, "TIMING") == 0) { if (v <= 0.0 || v > 0.49) { // Very low frequency bound to apply on 'COUNTER' fprintf(stderr,"%.2f is an invalid or a very high value for the active frequency type. Reconsider its value...\n", v); return FALSE; } ExpEnv.config_struc.frequency_type = TIME; ExpEnv.config_struc.frequency_bound = v; return TRUE; } else { // value passed by argument (ARG1) is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } } else { // ARG2 is not an 'integer' or 'float' Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"frequencyty/2 (2nd arg)"); return FALSE; } } else { // ARG1 is not an atom Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"frequencyty/2 (1st arg)"); return FALSE; } } else { // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } } static Int p_frequency_bound(void) { // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); // valid values for ARG1 are 'integer' and 'float' if (IsIntTerm(t) || IsFloatTerm(t)) { // ARG1 is integer or float // getting ARG1 value Float v; if (IsIntTerm(t)) v = (Float)IntOfTerm(t); if (IsFloatTerm(t)) v = FloatOfTerm(t); // setting 'frequency bound' if 'frequency type' is 'COUNTER' if (ExpEnv.config_struc.frequency_type == COUNTER) { if (v < 20.0) { fprintf(stderr,"%.2f is a very low value for the active frequency type. Reconsider its value...\n", v); return FALSE; } ExpEnv.config_struc.frequency_bound = roundf(v); return TRUE; } // setting 'frequency bound' if 'frequency type' is 'TIME' else { if (v <= 0.0 || v > 0.49) { fprintf(stderr,"%.2f is an invalid or a very high value for the active frequency type. Reconsider its value...\n", v); return FALSE; } ExpEnv.config_struc.frequency_bound = v; return TRUE; } } else { // ARG1 is not an 'integer' or 'float' Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"frequency_bound/1 (1st arg)"); return FALSE; } } else { // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } } static Int p_profiling_start_point(void) { // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); Float v; // valid value for ARG1 is just 'float' if (IsFloatTerm(t)) { v = FloatOfTerm(t); if (v < 0.0 || v >= 1.0) { // value passed by argument is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } ExpEnv.config_struc.profiling_startp = v; return TRUE; } else { // ARG1 is not float Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"profiling_start_point/1 (1st arg)"); return FALSE; } } else { // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } } static Int p_main_clause_ty(void) { // this predicate works only 'SMART_JIT' and 'CONTINUOUS_COMPILATION' modes if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); // valid values for ARG1 are 'integer' and 'atom' if (IsIntTerm(t)) { // ARG1 is integer Int v; v = IntOfTerm(t); if (v < 0 || v > 3) { // value passed by argument is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) { switch(v) { case 0: fprintf(stderr," Type of main clause was changed to JUST HOT!!\n"); break; case 1: fprintf(stderr," Type of main clause was changed to HOT AND CALLEE!!\n"); break; case 2: fprintf(stderr," Type of main clause was changed to HOT AND GREATER!!\n"); break; case 3: fprintf(stderr," Type of main clause was changed to HOT AND FEWER!!\n"); break; } } #endif // setting 'mainclause_ty' -- I should de add '1' because the first enum of 'enumMainClauseType' is 'UNUSED', used just for control ExpEnv.config_struc.mainclause_ty = (enumMainClauseType)(v+1); return TRUE; } else if (IsAtomTerm(t)) { // ARG1 is atom enumMainClauseType v; int i = 0, j = 0; char *tmp; // gets string from atom and stores it on 'str' char *str = (char*)malloc(YAP_AtomNameLength(AtomOfTerm(t))*sizeof(char)); strcpy(str, AtomName(AtomOfTerm(t))); // Makes upper characters of 'str' (for comparison) UPPER_ENTRY(str); // Detecting mainclause type chosen by user according to 'str' if (strcmp(str, "JUSTHOT") == 0) { v = JUST_HOT; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to JUST HOT!!\n"); #endif } else if (strcmp(str, "HOTANDCALLEE") == 0) { v = HOT_AND_CALLEE; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND CALLEE!!\n"); #endif } else if (strcmp(str, "HOTANDGREATER") == 0) { v = HOT_AND_GREATER; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND GREATER!!\n"); #endif } else if (strcmp(str, "HOTANDFEWER") == 0) { v = HOT_AND_FEWER; #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND FEWER!!\n"); #endif } else { // value passed by argument is out of known range Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } ExpEnv.config_struc.mainclause_ty = v; return TRUE; } else { // ARG1 is not an integer or atom Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"main_clause_ty/1 (1st arg)"); return FALSE; } } else { // current execution mode differs of 'SMART_JIT' and 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } } static Int p_compilation_threads(void) { // this predicate works only 'CONTINUOUS_COMPILATION' mode if (ExpEnv.config_struc.execution_mode == SMART_JIT || ExpEnv.config_struc.execution_mode == CONTINUOUS_COMPILATION) { Term t = Deref(ARG1); Int v; // valid value for ARG1 is 'integer' (because it defines number of threads) if (IsIntTerm(t)) { // ARG1 is integer v = IntOfTerm(t); if (v < 1) { // ERROR: number of threads is negative!! Yap_Error(OUT_OF_KNOWNRANGE_ERROR,t,""); return FALSE; } if (v >= ExpEnv.config_struc.ncores) { // WARNING: number of threads is not ideal -- real parallelism won't occur!! fprintf(stderr, " It was detected %ld cores on this computer, therefore it is ideally to set just %ld compilation thread. Reconsider its value...\n", ExpEnv.config_struc.ncores, ExpEnv.config_struc.ncores-1); } // setting compilation threads ExpEnv.config_struc.compilation_threads = v; /* initializing structures which will handle compilation threads */ { if (ExpEnv.config_struc.threaded_compiler_threads) free(ExpEnv.config_struc.threaded_compiler_threads); if (ExpEnv.config_struc.posthreads) free(ExpEnv.config_struc.posthreads); ExpEnv.config_struc.threaded_compiler_threads = (pthread_t*)malloc(v*sizeof(pthread_t)); ExpEnv.config_struc.posthreads = (CELL*)malloc(v*sizeof(CELL)); int i; for (i = 0; i < v; i++) ExpEnv.config_struc.posthreads[i] = 0; } /***/ #if YAP_DBG_PREDS if (ExpEnv.debug_struc.act_predicate_msgs.success_msgs) fprintf(stderr," Type of main clause was changed to HOT AND FEWER!!\n"); #endif return TRUE; } else { // ARG1 is not an integer Yap_NilError(INVALID_PARAMETER_TYPE_ERROR,"compilation_threads/1 (1st arg)"); return FALSE; } } else { // current execution mode differs of 'CONTINUOUS_COMPILATION' Yap_NilError(INCOMPATIBLEMODE_WARNING,""); return FALSE; } } static Int p_enable_recompilation(void) { ExpEnv.config_struc.torecompile = 1; return TRUE; } static Int p_disable_recompilation(void) { ExpEnv.config_struc.torecompile = 0; return TRUE; } static Int p_only_profiled_interpreter(void) { ExpEnv.config_struc.useonlypi = 1; return TRUE; } static Int p_noonly_profiled_interpreter(void) { ExpEnv.config_struc.useonlypi = 0; return TRUE; } #pragma GCC diagnostic pop void Yap_InitJitConfigPreds(void) { Yap_InitCPred("execution_mode", 1, p_execution_mode, SafePredFlag); Yap_InitCPred("interpreted_mode", 0, p_interpreted_mode, SafePredFlag); Yap_InitCPred("smartjit_mode", 0, p_smartjit_mode, SafePredFlag); Yap_InitCPred("continuouscompilation_mode", 0, p_continuouscompilation_mode, SafePredFlag); Yap_InitCPred("justcompiled_mode", 0, p_justcompiled_mode, SafePredFlag); Yap_InitCPred("frequencyty1", 1, p_frequencyty1, SafePredFlag); Yap_InitCPred("frequencyty2", 2, p_frequencyty2, SafePredFlag); Yap_InitCPred("frequency_bound", 1, p_frequency_bound, SafePredFlag); Yap_InitCPred("profiling_start_point", 1, p_profiling_start_point, SafePredFlag); Yap_InitCPred("main_clause_ty", 1, p_main_clause_ty, SafePredFlag); Yap_InitCPred("compilation_threads", 1, p_compilation_threads, SafePredFlag); Yap_InitCPred("enable_recompilation", 0, p_enable_recompilation, SafePredFlag); Yap_InitCPred("disable_recompilation", 0, p_disable_recompilation, SafePredFlag); Yap_InitCPred("only_profiled_interpreter", 0, p_only_profiled_interpreter, SafePredFlag); Yap_InitCPred("noonly_profiled_interpreter", 0, p_noonly_profiled_interpreter, SafePredFlag); }