This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
yap-6.3/JIT/jit_configpreds.c

731 lines
27 KiB
C
Raw Normal View History

/*************************************************************************
* *
* 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 <math.h>
// Enable any (passed by argument) execution mode
static Int p_execution_mode( USES_REGS1 );
// Enable 'just interpreted' mode.
static Int p_interpreted_mode( USES_REGS1 );
// Enable 'smart jit' mode.
static Int p_smartjit_mode( USES_REGS1 );
// Enable 'continuous compilation' mode.
static Int p_continuouscompilation_mode( USES_REGS1 );
// Enable 'just compiled' mode.
static Int p_justcompiled_mode( USES_REGS1 );
// 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( USES_REGS1 );
// 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( USES_REGS1 );
// Enable frequency bound
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_frequency_bound( USES_REGS1 );
// Enable value for starting profiling
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_profiling_start_point( USES_REGS1 );
// Choose type of clause that can be main on traces
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_main_clause_ty( USES_REGS1 );
// Choose amount of compilation threads
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_compilation_threads( USES_REGS1 );
// Enable recompilation
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_enable_recompilation( USES_REGS1 );
// Disable recompilation
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_disable_recompilation( USES_REGS1 );
// Just code interpretation. Don't compile
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_only_profiled_interpreter( USES_REGS1 );
// Disable 'p_only_profiled_interpreter'
// Just for 'smart jit' or 'continuous compilation' mode
static Int p_noonly_profiled_interpreter( USES_REGS1 );
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
static Int
p_execution_mode( USES_REGS1 )
{
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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
// 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( USES_REGS1 )
{
ExpEnv.config_struc.torecompile = 1;
return TRUE;
}
static Int
p_disable_recompilation( USES_REGS1 )
{
ExpEnv.config_struc.torecompile = 0;
return TRUE;
}
static Int
p_only_profiled_interpreter( USES_REGS1 )
{
ExpEnv.config_struc.useonlypi = 1;
return TRUE;
}
static Int
p_noonly_profiled_interpreter( USES_REGS1 )
{
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);
}