2014-07-13 05:30:14 +01:00
/*************************************************************************
* *
* 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 *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2015-01-18 02:46:03 +00:00
# include "jit_predicates.hpp"
2014-07-13 05:30:14 +01:00
# include <math.h>
// Enable any (passed by argument) execution mode
2015-01-18 02:46:03 +00:00
static Int p_execution_mode ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable 'just interpreted' mode.
2015-01-18 02:46:03 +00:00
static Int p_interpreted_mode ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable 'smart jit' mode.
2015-01-18 02:46:03 +00:00
static Int p_smartjit_mode ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable 'continuous compilation' mode.
2015-01-18 02:46:03 +00:00
static Int p_continuouscompilation_mode ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable 'just compiled' mode.
2015-01-18 02:46:03 +00:00
static Int p_justcompiled_mode ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// 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
2015-01-18 02:46:03 +00:00
static Int p_frequencyty1 ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// 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
2015-01-18 02:46:03 +00:00
static Int p_frequencyty2 ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable frequency bound
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_frequency_bound ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable value for starting profiling
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_profiling_start_point ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Choose type of clause that can be main on traces
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_main_clause_ty ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Choose amount of compilation threads
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_compilation_threads ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Enable recompilation
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_enable_recompilation ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Disable recompilation
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_disable_recompilation ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Just code interpretation. Don't compile
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_only_profiled_interpreter ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
// Disable 'p_only_profiled_interpreter'
// Just for 'smart jit' or 'continuous compilation' mode
2015-01-18 02:46:03 +00:00
static Int p_noonly_profiled_interpreter ( USES_REGS1 ) ;
2014-07-13 05:30:14 +01:00
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wimplicit-function-declaration"
static Int
2015-01-18 02:46:03 +00:00
p_execution_mode ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
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 ;
2015-01-18 01:32:13 +00:00
2014-07-13 05:30:14 +01:00
/* 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
2015-01-18 02:46:03 +00:00
p_interpreted_mode ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_smartjit_mode ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_continuouscompilation_mode ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_justcompiled_mode ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_frequencyty1 ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_frequencyty2 ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_frequency_bound ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_profiling_start_point ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_main_clause_ty ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_compilation_threads ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
// 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
2015-01-18 02:46:03 +00:00
p_enable_recompilation ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
ExpEnv . config_struc . torecompile = 1 ;
return TRUE ;
}
static Int
2015-01-18 02:46:03 +00:00
p_disable_recompilation ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
ExpEnv . config_struc . torecompile = 0 ;
return TRUE ;
}
static Int
2015-01-18 02:46:03 +00:00
p_only_profiled_interpreter ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
ExpEnv . config_struc . useonlypi = 1 ;
return TRUE ;
}
static Int
2015-01-18 02:46:03 +00:00
p_noonly_profiled_interpreter ( USES_REGS1 )
2014-07-13 05:30:14 +01:00
{
ExpEnv . config_struc . useonlypi = 0 ;
return TRUE ;
}
2015-01-26 04:02:46 +00:00
2014-07-13 05:30:14 +01:00
# pragma GCC diagnostic pop
void
2015-01-18 02:46:03 +00:00
Yap_InitJitConfigPreds ( void )
2014-07-13 05:30:14 +01:00
{
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 ) ;
}
2015-01-26 04:02:46 +00:00
