Ejemplo n.º 1
0
void
cndfs_shared_init   (run_t *run)
{
    HREassert (GRED.g == 0);
    HREassert (GGREEN.g == 1);
    HREassert (GDANGEROUS.g == 2);

    set_alg_local_init      (run->alg, cndfs_local_init);
    set_alg_global_init     (run->alg, cndfs_global_init);
    set_alg_global_deinit   (run->alg, cndfs_global_deinit);
    set_alg_local_deinit    (run->alg, cndfs_local_deinit);
    set_alg_print_stats     (run->alg, cndfs_print_stats);
    set_alg_run             (run->alg, endfs_blue);
    set_alg_state_seen      (run->alg, cndfs_state_seen);
    set_alg_reduce          (run->alg, cndfs_reduce);

    if (run->shared != NULL)
        return;

    run->shared = RTmallocZero (sizeof(alg_shared_t));
    run->shared->color_bit_shift = 0;
    run->shared->top_level = run;
    run->shared->run_is_stopped = run_get_is_stopped (run);
    run->shared->run_stop = run_get_stop (run);

    run_set_is_stopped (run, cndfs_is_stopped);
    run_set_stop (run, cndfs_stop);

    int             i = 1;
    run_t          *previous = run;
    run_t          *next = NULL;
    while (strategy[i] != Strat_None) {
        next = run_create (false);
        next->shared = RTmallocZero (sizeof(alg_shared_t));
        next->shared->previous = previous;
        next->shared->top_level = run;
        next->shared->rec = NULL;
        run_set_is_stopped (next, cndfs_is_stopped);
        run_set_stop (next, cndfs_stop);
        next->shared->color_bit_shift = previous->shared->color_bit_shift +
                                        num_global_bits (strategy[i]);

        alg_shared_init_strategy (next, strategy[i]);

        previous->shared->rec = next;
        previous = next;
        i++;
    }
}
Ejemplo n.º 2
0
void
ndfs_reduce  (run_t *run, wctx_t *ctx)
{
    if (run->reduced == NULL) {
        run->reduced = RTmallocZero (sizeof (alg_reduced_t));
    }
    alg_reduced_t          *reduced = run->reduced;
    counter_t              *blue = &ctx->local->counters;
    counter_t              *red = &ctx->local->red;
    work_counter_t         *blue_work = ctx->counters;
    work_counter_t         *red_work = &ctx->local->red_work;

    add_results (&reduced->blue, blue);
    add_results (&reduced->red, red);
    work_add_results (&reduced->red_work, red_work);

    // publish local memory statistics for run class
    run->total.local_states += blue_work->level_max + red_work->level_max;

    if (W >= 4 || !log_active(infoLong)) return;

    // print some local info
    float                   runtime = RTrealTime(ctx->timer);
    Warning (info, "Nested depth-first search worker ran %.3f sec", runtime);
    work_report ("[Blue]", blue_work);
    work_report ("[Red ]", red_work);
}
Ejemplo n.º 3
0
void
cndfs_reduce  (run_t *run, wctx_t *ctx)
{
    if (run->reduced == NULL) {
        run->reduced = RTmallocZero (sizeof (cndfs_reduced_t));
        cndfs_reduced_t        *reduced = (cndfs_reduced_t *) run->reduced;
        reduced->waittime = 0;
    }
    cndfs_reduced_t        *reduced = (cndfs_reduced_t *) run->reduced;
    cndfs_alg_local_t      *cloc = (cndfs_alg_local_t *) ctx->local;
    float                   waittime = RTrealTime(cloc->timer);
    reduced->waittime   += waittime;
    reduced->rec        += cloc->counters.rec;
    reduced->max_load   += fset_max_load (cloc->pink);

    ndfs_reduce (run, ctx);

    if (log_active(infoLong)) {
        fset_print_statistics (cloc->pink, "Pink stack set:");
    }

    if (run->shared->rec != NULL) {
        alg_global_t           *sm = ctx->global;
        alg_reduce (run->shared->rec, sm->rec);
    }
}
Ejemplo n.º 4
0
void
tarjan_local_init (run_t *run, wctx_t *ctx)
{
    ctx->local         = RTmallocZero (sizeof (alg_local_t));
    ctx->local->target = state_info_create ();

    // extend state_info with tarjan_state information
    state_info_add_simple (ctx->local->target, sizeof (uint32_t),
                          &ctx->local->target_tarjan.index);
    state_info_add_simple (ctx->local->target, sizeof (uint32_t),
                          &ctx->local->target_tarjan.lowlink);

    state_info_add_simple (ctx->state, sizeof (uint32_t),
                          &ctx->local->state_tarjan.index);
    state_info_add_simple (ctx->state, sizeof (uint32_t),
                          &ctx->local->state_tarjan.lowlink);

    size_t len = state_info_serialize_int_size (ctx->state);
    ctx->local->search_stack = dfs_stack_create (len);
    ctx->local->tarjan_stack = dfs_stack_create (len);

    ctx->local->cnt.scc_count       = 0;
    ctx->local->cnt.tarjan_counter  = 0;

    ctx->local->visited_states =
            fset_create (sizeof (ref_t), sizeof (raw_data_t), 10, dbs_size);

#ifdef SEARCH_COMPLETE_GRAPH
    // provide the input file name to dlopen_setup
    dlopen_setup (files[0]);
#endif

    (void) run; 
}
Ejemplo n.º 5
0
void
cndfs_global_init   (run_t *run, wctx_t *ctx)
{
    ctx->global = RTmallocZero (sizeof(alg_global_t));
    ctx->global->work = SIZE_MAX;
    (void) run;
}
Ejemplo n.º 6
0
void
cndfs_local_init   (run_t *run, wctx_t *ctx)
{
    alg_local_t        *loc = RTmallocZero (sizeof(cndfs_alg_local_t));
    ctx->local = loc;

    cndfs_local_setup (run, ctx);
}
Ejemplo n.º 7
0
void
timed_local_init   (run_t *run, wctx_t *ctx)
{
    ta_alg_local_t     *loc = RTmallocZero (sizeof(ta_alg_local_t));

    ctx->local = (alg_local_t *) loc;
    reach_local_setup (run, ctx);
    statistics_init (&loc->counters.lattice_ratio);
}
Ejemplo n.º 8
0
static stream_t stream_zip(stream_t parent,int compress,int level,int bufsize){
    stream_t s=(stream_t)RTmallocZero(sizeof(struct stream_s));
    stream_init(s);
    s->bufsize=bufsize;
    s->s=parent;
    s->compress=compress;
    if(stream_writable(parent)){
        s->procs.write=gzip_write;
        //s->procs.flush= TO DO
        s->wr.zalloc = Z_NULL;
        s->wr.zfree = Z_NULL;
        s->wr.opaque = Z_NULL;
        s->wr_buf=(char*)RTmalloc(bufsize);
        s->wr.next_in=Z_NULL;
        s->wr.avail_in=0;
        s->wr.next_out=s->wr_buf;
        s->wr.avail_out=bufsize;
        if (compress) {
            if (deflateInit(&s->wr, level)!= Z_OK) {
                Abort("gzip init failed");
            }
        } else {
            if (inflateInit(&s->wr)!= Z_OK) {
                Abort("gzip init failed");
            }
        }
    } else {
        s->wr_buf=NULL;
    }
    if(stream_readable(parent)){
        s->procs.read_max=gzip_read_max;
        s->procs.read=gzip_read;
        //s->procs.empty= TO DO
        s->rd.zalloc = Z_NULL;
        s->rd.zfree = Z_NULL;
        s->rd.opaque = Z_NULL;
        s->rd.next_in=Z_NULL;
        s->rd.avail_in=0;
        s->rd.next_out=Z_NULL;
        s->rd.avail_out=0;
        s->rd_buf=(char*)RTmalloc(bufsize);
        if (compress) {
            if (inflateInit(&s->rd)!= Z_OK) {
                Abort("gzip init failed");
            }
        } else {
            if (deflateInit(&s->rd, level)!= Z_OK) {
                Abort("gzip init failed");
            }
        }
    } else {
        s->rd_buf=NULL;
    }
    s->procs.close=gzip_close;
    s->procs.close_z=gzip_close_z;
    return stream_buffer(s,4096);
}
Ejemplo n.º 9
0
void
tarjan_reduce (run_t *run, wctx_t *ctx)
{
    if (run->reduced == NULL) {
        run->reduced = RTmallocZero (sizeof (counter_t));
    }
    counter_t          *reduced = (counter_t *) run->reduced;
    counter_t          *cnt     = &ctx->local->cnt;

    reduced->scc_count += cnt->scc_count;
}
Ejemplo n.º 10
0
void
timed_reduce (run_t *run, wctx_t *ctx)
{
    if (run->reduced == NULL) {
        run->reduced = RTmallocZero (sizeof (ta_reduced_t) + CACHE_LINE_SIZE);
    }
    ta_reduced_t           *reduced = (ta_reduced_t *) run->reduced;
    ta_alg_local_t         *ta_loc = (ta_alg_local_t *) ctx->local;

    ta_add_results (&reduced->counters, &ta_loc->counters);

    reach_reduce (run, ctx);
}
Ejemplo n.º 11
0
void
timed_global_init   (run_t *run, wctx_t *ctx)
{
    if (PINS_POR)
        Abort ("POR not compatible with timed automata");
    ctx->global = RTmallocZero (sizeof(ta_alg_global_t));
    ta_alg_global_t    *sm = (ta_alg_global_t *) ctx->global;

    // Extend state info with a lattice location
    state_info_add_simple (ctx->state, sizeof(lm_loc_t), &sm->lloc);
    state_info_add_simple (ctx->initial, sizeof(lm_loc_t), &sm->lloc);
    state_info_t       *si_perm = permute_state_info(ctx->permute);
    state_info_add_simple (si_perm, sizeof(lm_loc_t), &sm->lloc);

    reach_global_setup (run, ctx);
}
Ejemplo n.º 12
0
void
timed_shared_init      (run_t *run)
{
    set_alg_local_init (run->alg, timed_local_init);
    set_alg_global_init (run->alg, timed_global_init);
    set_alg_global_deinit (run->alg, timed_destroy);
    set_alg_local_deinit (run->alg, timed_destroy_local);
    set_alg_print_stats (run->alg, timed_print_stats);
    set_alg_run (run->alg, timed_run);
    set_alg_reduce (run->alg, timed_reduce);

    run->shared = RTmallocZero (sizeof (ta_alg_shared_t));
    reach_init_shared (run);
    ta_alg_shared_t    *shared = (ta_alg_shared_t *) run->shared;
    shared->lmap = state_store_lmap (global->store);
}
Ejemplo n.º 13
0
lts_file_t lts_writer(lts_t lts,int segments,lts_file_t settings){
    lts_file_t file=lts_file_bare("<heap>",lts->ltstype,segments,settings,sizeof(struct lts_file_s));
    file->lts=lts;
    file->segments=segments;
    file->state_perseg=(uint32_t*)RTmallocZero(segments*sizeof(uint32_t));
    file->edge_labels=lts_type_get_edge_label_count(lts->ltstype);
    lts_file_set_write_init(file,write_init);
    lts_file_set_write_state(file,write_state);
    lts_file_set_write_edge(file,write_edge);
    lts_file_set_close(file,write_close);
    lts_file_complete(file);
    lts_set_type(file->lts,LTS_LIST);
    int T=lts_type_get_type_count(lts->ltstype);
    for(int i=0;i<T;i++){
        lts_file_set_table(file,i,lts->values[i]);
    }
    return file;
}
Ejemplo n.º 14
0
string_index_t SIcreate(){
	int i;
	string_index_t si;
	si=(string_index_t)RTmallocZero(sizeof(struct stringindex));
	si->count=0;
	si->free_list=END_OF_LIST;
	si->man=create_manager(DATA_BLOCK_SIZE);
	//si->next=(int*)RTmalloc(DATA_BLOCK_SIZE*sizeof(int));
	ADD_ARRAY_CB(si->man,si->next,int,next_resize,NULL);
	//si->len=(int*)RTmalloc(DATA_BLOCK_SIZE*sizeof(int));
	ADD_ARRAY_CB(si->man,si->len,int,len_resize,si);
	//si->data=(char**)RTmalloc(DATA_BLOCK_SIZE*sizeof(char*));
	ADD_ARRAY(si->man,si->data,char*);
	//create_free_list(si);
	si->table=(int*)RTmalloc((TABLE_INITIAL+1)*sizeof(int));
	si->mask=TABLE_INITIAL;
	for(i=0;i<=TABLE_INITIAL;i++){
		si->table[i]=END_OF_LIST;
	}
	return si;
};
Ejemplo n.º 15
0
/*
 * Sanitizes and caches all type symbols of an etf_model_t. Should only be
 * called once.
 */
void sanitize_types(etf_model_t model) {
    lts_type_t ltstype = etf_type(model);
    int n_types = lts_type_get_type_count(ltstype);
    sanitized_types = (char***)RTmallocZero(n_types*sizeof(char**));
    for (int i=0;i<n_types;i++) {
	int v_count = etf_get_value_count(model, i);
	if (v_count) {
	    sanitized_types[i] = (char**)RTmalloc(v_count*sizeof(char*));
	    for (int j=0;j<v_count;j++) {
		chunk ch = etf_get_value(model, i, j);
		char tmp[ch.len+1];
		strncpy(tmp,ch.data,ch.len);
		tmp[ch.len] = '\0';
		int len = ch.len+2;
		sanitized_types[i][j] = (char*)RTmalloc(len);
		sanitize_ID(tmp,len,sanitized_types[i][j]);
		Debug("Sanitizing type %s to %s", tmp, sanitized_types[i][j]);
	    }
	}
    }
}
Ejemplo n.º 16
0
ci_list *
ci_create (size_t size)
{
    return RTmallocZero (sizeof(int[size + 1]));
}
Ejemplo n.º 17
0
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);
}
Ejemplo n.º 18
0
void
ndfs_local_init   (run_t *run, wctx_t *ctx)
{
    ctx->local = RTmallocZero (sizeof(alg_local_t));
    ndfs_local_setup (run, ctx);
}