/** Follows the pattern of couple_to_ice()
@param sbuf the (filled) array of ice grid values for this MPI node. */
void GCMCoupler::get_initial_state(
std::vector<giss::VectorSparseVector<int,double>> &gcm_ivals) // Root node only: Already-allocated space to put output values. Members as defined by the CouplingContract GCMCoupler::gcm_inputs
{
int const rank = gcm_params.gcm_rank;
printf("[%d] BEGIN GCMCoupler::get_initial_state()\n", gcm_params.gcm_rank);
if (am_i_root()) {
// (ONLY ON GCM ROOT)
// NOTE: call_ice_model() is called (below) even on NON-ROOT
// Call all our ice models
for (auto model = models.begin(); model != models.end(); ++model) {
int sheetno = model.key();
model->get_initial_state();
// Record what the ice model produced.
// NOTE: This shouldn't change model->ice_ovals_I
IceModel_Writer *owriter = model->owriter();
const double time_s = gcm_params.time_start_s;
if (owriter) {
printf("BEGIN owriter->run_timestep()\n");
owriter->run_decoded(time_s, model->ice_ovals_I);
printf("END owriter->run_timestep()\n");
}
// Convert to variables the GCM wants (but still on the ice grid)
model->set_gcm_inputs(contracts::INITIAL); // Fills in gcm_ivals_I
// Free ice_ovals_I
model->free_ice_ovals_I();
}
// Fill in gcm_ivals
regrid_gcm_inputs_onroot(gcm_ivals, contracts::INITIAL);
} else {
// (NOT GCM ROOT)
// We're not root --- we have no data to send to ice
// models, we just call through anyway because we will
// receive data in an upcomming MPI_Scatter
// Call all our ice models
for (auto model = models.begin(); model != models.end(); ++model) {
model->get_initial_state();
} // if (gcm_params.gcm_rank == gcm_params.gcm_root)
}
printf("[%d] END GCMCoupler::get_initial_state()\n", gcm_params.gcm_rank);
}
static E_MATCHING_STATUS get_status(SingleGraph g) {
if (g->number_of_states==0) {
return CHK_DOES_NOT_MATCH_E;
}
int i=get_initial_state(g);
if (i<0) {
fatal_error("Internal error in get_status: invalid negative initial state %d\n",i);
}
SingleGraphState s=g->states[i];
if (is_final_state(s)) {
/* If the initial state is final, it means that we can reach it without matching
* anything in the text */
return CHK_MATCHES_E;
}
return CHK_DONT_KNOW;
}
/**
* Returns 0 if no left recursion is found. Otherwise, prints a message that
* describes the loop and returns 1.
*/
static int is_left_recursion(GrfCheckInfo* chk,int graph,int* mark_graph,struct list_pointer* transitions) {
if (mark_graph[graph]==1) {
/* The graph has already been tested for left recursions */
return 0;
}
if (mark_graph[graph]==2) {
/* We found a left recursion */
error("Left recursion found in graph %S, made of the following tags:\n",chk->fst2->graph_names[graph]);
print_reversed_list(transitions,chk->fst2,-graph,0);
return 1;
}
mark_graph[graph]=2;
SingleGraph g=chk->condition_graphs[graph];
/* 0 means that the state has not been visited at all
* 1 means that the state has already been fully visited
* 2 means that the state is being visited now, so finding such
* a state means that there is an E loop
*/
int* mark_state=(int*)calloc(g->number_of_states,sizeof(int));
int recursion=0;
int initial_state=get_initial_state(g);
if (initial_state==-2) {
fatal_error("Internal error: several initial states in graph %S\n",chk->fst2->graph_names[graph]);
}
if (initial_state==-1) {
/* If the graph could not be loaded, we just ignore */
mark_graph[graph]=1;
free(mark_state);
return 0;
}
if (find_a_left_recursion(mark_graph,mark_state,initial_state,graph,chk,transitions)) {
recursion=1;
}
free(mark_state);
mark_graph[graph]=1;
return recursion;
}
void
DVE2loadGreyboxModel(model_t model, const char *filename)
{
lts_type_t ltstype;
matrix_t *dm_info = RTmalloc(sizeof(matrix_t));
matrix_t *dm_read_info = RTmalloc(sizeof(matrix_t));
matrix_t *dm_actions_read_info = RTmalloc(sizeof(matrix_t));
matrix_t *dm_may_write_info = RTmalloc(sizeof(matrix_t));
matrix_t *dm_must_write_info = RTmalloc(sizeof(matrix_t));
matrix_t *sl_info = RTmalloc(sizeof(matrix_t));
//assume sequential use:
if (NULL == dlHandle) {
char *extension = strrchr (filename, '.');
HREassert (extension != NULL, "No filename extension %s", filename);
++extension;
if (0==strcmp (extension, "dve2C") || 0==strcmp (extension, "so")) {
DVE2loadDynamicLib(model, filename);
} else {
DVE2compileGreyboxModel(model, filename);
}
}
gb_context_t ctx=(gb_context_t)RTmalloc(sizeof(struct grey_box_context));
GBsetContext(model,ctx);
// get ltstypes
int state_length = get_state_variable_count();
ltstype=lts_type_create();
// adding types
int ntypes = get_state_variable_type_count();
for(int i = 0; i < ntypes; i++) {
const char* type_name = get_state_variable_type_name(i);
HREassert (type_name != NULL, "invalid type name");
if (lts_type_add_type(ltstype, type_name, NULL) != i) {
Abort("wrong type number");
}
int type_value_count = get_state_variable_type_value_count(i);
if (0 == type_value_count) {
lts_type_set_format (ltstype, i, LTStypeDirect);
} else {
lts_type_set_format (ltstype, i, LTStypeEnum);
}
}
int guard_type = lts_type_add_type (ltstype, "guard", NULL);
lts_type_set_format (ltstype, guard_type, LTStypeTrilean);
lts_type_set_state_length(ltstype, state_length);
// set state name & type
for(int i=0; i < state_length; ++i)
{
const char* name = get_state_variable_name(i);
const int type = get_state_variable_type(i);
lts_type_set_state_name(ltstype,i,name);
lts_type_set_state_typeno(ltstype,i,type);
}
// compute state label names
int nguards = get_guard_count(); // TODO: should be in model has guards block..?
int sl_size = 0 +
nguards +
(have_property() ? 1 : 0);
// assumption on state labels:
// state labels (idx): 0 - nguards-1 = guard state labels
// state label (idx): nguards = property state label
lts_type_set_state_label_count (ltstype, sl_size);
char buf[256];
for(int i=0; i < nguards; i++) {
snprintf(buf, 256, "%s_%d", LTSMIN_LABEL_TYPE_GUARD_PREFIX, i);
lts_type_set_state_label_name (ltstype, i, buf);
lts_type_set_state_label_typeno (ltstype, i, guard_type);
}
if (have_property()) {
lts_type_set_state_label_name (ltstype, nguards, LTSMIN_STATE_LABEL_ACCEPTING);
lts_type_set_state_label_typeno (ltstype, nguards, guard_type);
ctx->accepting_state_label_idx = nguards;
} else {
ctx->accepting_state_label_idx = -1;
}
GBsetLTStype(model, ltstype);
// setting values for types
for(int i=0; i < ntypes; i++) {
int type_value_count = get_state_variable_type_value_count(i);
if (lts_type_get_format(ltstype, i) != LTStypeChunk &&
lts_type_get_format(ltstype, i) != LTStypeEnum) {
Debug ("Skipping type values for non-chunk type %s", lts_type_get_type(ltstype, i));
continue;
}
for(int j=0; j < type_value_count; ++j) {
const char* type_value = get_state_variable_type_value(i, j);
pins_chunk_put_at (model, i, chunk_str((char*)type_value), j);
}
}
lts_type_validate(ltstype);
int ngroups = get_transition_count();
dm_create(dm_info, ngroups, state_length);
dm_create(dm_read_info, ngroups, state_length);
dm_create(dm_actions_read_info, ngroups, state_length);
dm_create(dm_may_write_info, ngroups, state_length);
dm_create(dm_must_write_info, ngroups, state_length);
for(int i=0; i < dm_nrows(dm_info); i++) {
int* proj = (int*)get_transition_read_dependencies(i);
for(int j=0; j<state_length; j++) {
if (proj[j]) {
dm_set(dm_info, i, j);
dm_set(dm_read_info, i, j);
}
}
proj = (int*)get_transition_actions_read_dependencies(i);
for(int j=0; j<state_length; j++) {
if (proj[j]) {
dm_set(dm_actions_read_info, i, j);
}
}
proj = (int*)get_transition_may_write_dependencies(i);
for(int j=0; j<state_length; j++) {
if (proj[j]) {
dm_set(dm_info, i, j);
dm_set(dm_may_write_info, i, j);
}
}
proj = (int*)get_transition_must_write_dependencies(i);
for(int j=0; j<state_length; j++) {
if (proj[j]) {
dm_set(dm_must_write_info, i, j);
}
}
}
GBsetDMInfo(model, dm_info);
GBsetDMInfoRead(model, dm_read_info);
GBsetMatrix(model, LTSMIN_MATRIX_ACTIONS_READS, dm_actions_read_info, PINS_MAY_SET,
PINS_INDEX_GROUP, PINS_INDEX_STATE_VECTOR);
GBsetDMInfoMayWrite(model, dm_may_write_info);
GBsetDMInfoMustWrite(model, dm_must_write_info);
// set state label matrix (accepting label and guards)
get_label_method_t sl_long = NULL;
get_label_all_method_t sl_all = NULL;
dm_create(sl_info, sl_size, state_length);
// if the model exports a property, reserve first for accepting label
if (have_property()) {
for (int i=0; i<state_length; ++i) {
if (strcmp ("LTL_property", lts_type_get_state_name(ltstype, i)) == 0) {
dm_set(sl_info, ctx->accepting_state_label_idx, i);
}
}
}
// if the model has guards, add guards as state labels
if (have_property()) {
// filter the property
sl_long = sl_long_p_g;
sl_all = sl_all_p_g;
} else {
// pass request directly to dynamic lib
sl_long = (get_label_method_t) get_guard;
sl_all = (get_label_all_method_t) get_guard_all;
}
// set the guards per transition group
GBsetGuardsInfo(model, (guard_t**) get_all_guards());
// initialize state label matrix
// assumption, guards come first (0-nguards)
for(int i=0; i < nguards; i++) {
int* guards = (int*)get_guard_matrix(i);
for(int j=0; j<state_length; j++) {
if (guards[j]) dm_set(sl_info, i, j);
}
}
// set guard may be co-enabled relation
if (get_guard_may_be_coenabled_matrix) {
matrix_t *gce_info = RTmalloc(sizeof(matrix_t));
dm_create(gce_info, nguards, nguards);
for(int i=0; i < nguards; i++) {
int* guardce = (int*)get_guard_may_be_coenabled_matrix(i);
for(int j=0; j<nguards; j++) {
if (guardce[j]) dm_set(gce_info, i, j);
}
}
GBsetGuardCoEnabledInfo(model, gce_info);
}
// set guard necessary enabling set info
if (get_guard_nes_matrix) {
matrix_t *gnes_info = RTmalloc(sizeof(matrix_t));
dm_create(gnes_info, nguards, ngroups);
for(int i=0; i < nguards; i++) {
int* guardnes = (int*)get_guard_nes_matrix(i);
for(int j=0; j<ngroups; j++) {
if (guardnes[j]) dm_set(gnes_info, i, j);
}
}
GBsetGuardNESInfo(model, gnes_info);
}
// set guard necessary disabling set info
if (get_guard_nds_matrix) {
matrix_t *gnds_info = RTmalloc(sizeof(matrix_t));
dm_create(gnds_info, nguards, ngroups);
for(int i=0; i < nguards; i++) {
int* guardnds = (int*)get_guard_nds_matrix(i);
for(int j=0; j<ngroups; j++) {
if (guardnds[j]) dm_set(gnds_info, i, j);
}
}
GBsetGuardNDSInfo(model, gnds_info);
}
if (!get_dna_matrix) {
Warning (info, "*** Warning ***");
Warning (info, "You are using an old version of our patched DiVinE compiler.");
Warning (info, "This might influence the performance of partial order reduction negatively.");
Warning (info, "Please download the latest from: http://fmt.cs.utwente.nl/tools/ltsmin/");
Warning (info, "*** Warning ***");
} else {
matrix_t *dna_info = RTmalloc(sizeof(matrix_t));
dm_create(dna_info, ngroups, ngroups);
for(int i=0; i < ngroups; i++) {
int* dna = (int*)get_dna_matrix(i);
for(int j=0; j<ngroups; j++) {
if (dna[j]) dm_set(dna_info, i, j);
}
}
GBsetDoNotAccordInfo(model, dna_info);
}
// set the group implementation
sl_group_t* sl_group_all = RTmallocZero(sizeof(sl_group_t) + sl_size * sizeof(int));
sl_group_all->count = sl_size;
for(int i=0; i < sl_group_all->count; i++) sl_group_all->sl_idx[i] = i;
sl_group_t* sl_group_guards = RTmallocZero(sizeof(sl_group_t) + nguards * sizeof(int));
sl_group_guards->count = nguards;
for(int i=0; i < sl_group_guards->count; i++) sl_group_guards->sl_idx[i] = i;
GBsetStateLabelGroupInfo(model, GB_SL_ALL, sl_group_all);
GBsetStateLabelGroupInfo(model, GB_SL_GUARDS, sl_group_guards);
GBsetStateLabelsGroup(model, sl_group);
GBsetStateLabelInfo(model, sl_info);
if (sl_long != NULL) GBsetStateLabelLong(model, sl_long);
if (sl_all != NULL) GBsetStateLabelsAll(model, sl_all);
// get initial state
int state[state_length];
get_initial_state((char*)state);
GBsetInitialState(model,state);
GBsetNextStateAll (model, (next_method_black_t) get_successors);
GBsetNextStateLong (model, (next_method_grey_t) get_successor);
GBsetActionsLong (model, (next_method_grey_t) get_action);
}