//=============================================================
// 태스크 리스트 초기화
CTaskList::CTaskList(int max_task_size, int max_num_task)
: MaxTaskSize(max_task_size), MaxNumTask(max_num_task),
NumFreeTask(max_num_task)
{
// 태스크 초기화용 매크로
#define TASK(INDEX) ((CTask*)(buf+max_task_size*(INDEX)))
// 태스크용 메모리 확보
char* buf=new char[max_task_size*(max_num_task+2)];
// 액티브 태스크 리스트의 초기화
ActiveTask=TASK(0);
ActiveTask->Prev=ActiveTask->Next=ActiveTask;
// 프리 태스크 리스트의 초기화
FreeTask=TASK(1);
for (int i=1; i<max_num_task+1; i++) {
TASK(i)->Next=TASK(i+1);
}
TASK(max_num_task+1)->Next=FreeTask;
}
/**
* Package init and quit functions
*/
void
sylvan_init_package(size_t tablesize, size_t maxsize, size_t cachesize, size_t max_cachesize)
{
if (tablesize > maxsize) tablesize = maxsize;
if (cachesize > max_cachesize) cachesize = max_cachesize;
if (maxsize > 0x000003ffffffffff) {
fprintf(stderr, "sylvan_init_package error: tablesize must be <= 42 bits!\n");
exit(1);
}
nodes = llmsset_create(tablesize, maxsize);
cache_create(cachesize, max_cachesize);
gc = 0;
barrier_init(&gcbar, lace_workers());
#if SYLVAN_AGGRESSIVE_RESIZE
gc_hook = TASK(sylvan_gc_aggressive_resize);
#else
gc_hook = TASK(sylvan_gc_default_hook);
#endif
sylvan_gc_add_mark(10, TASK(sylvan_gc_mark_cache));
sylvan_gc_add_mark(19, TASK(sylvan_gc_destroy_unmarked));
sylvan_gc_add_mark(20, TASK(sylvan_gc_call_hook));
sylvan_gc_add_mark(30, TASK(sylvan_gc_rehash));
LACE_ME;
sylvan_stats_init();
}
static void task_get_property (GObject * object, guint property_id, GValue * value, GParamSpec * pspec) {
Task * self;
self = TASK (object);
switch (property_id) {
case TASK_SECONDS:
g_value_set_double (value, task_get_seconds (self));
break;
case TASK_ARGUMENTS:
g_value_set_boxed (value, task_get_arguments (self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
int
main (int argc, char *argv[])
{
struct args_t args = (struct args_t){argc, argv};
#ifdef HAVE_SYLVAN
poptContext optCon = poptGetContext(NULL, argc, (const char**)argv, lace_options, 0);
while(poptGetNextOpt(optCon) != -1 ) { /* ignore errors */ }
poptFreeContext(optCon);
#if defined(PROB)
if (lace_n_workers != 1) lace_n_workers = 1;
Warning(info, "Falling back to 1 LACE worker, since the ProB front-end is not yet compatible with HRE.");
#endif
lace_init(lace_n_workers, lace_dqsize);
lace_startup(lace_stacksize, TASK(actual_main), (void*)&args);
#else
actual_main((void*)&args);
#endif
return 0;
}
{
TRACE( "enter; this task should run first\n" );
for( ;; task_2_iteration++ )
{
TRACE( "%d\n", task_2_iteration );
yield();
TRACE( "context should not be switched here\n" );
sleep(1);
}
}
TCB( task_1, 4096 );
TCB( task_2, 4096 );
TASK_GROUP( low_priority_tasks ) {
TASK( 0, task_1, task_1_func )
};
TASK_GROUP( high_priority_tasks ) {
TASK( 1, task_2, task_2_func )
};
TASKS_BEGIN
TASKS_ITEM( low_priority_tasks ),
TASKS_ITEM( high_priority_tasks )
TASKS_END;
int main( int argc, char* argv[] )
{
if( argc > 1 )
{
int
main(int argc, char **argv)
{
argp_parse(&argp, argc, argv, 0, 0, 0);
// Init Lace
lace_init(workers, 1000000); // auto-detect number of workers, use a 1,000,000 size task queue
lace_startup(0, NULL, NULL); // auto-detect program stack, do not use a callback for startup
LACE_ME;
size_t max = 16LL<<30;
if (max > getMaxMemory()) max = getMaxMemory()/10*9;
printf("Setting Sylvan main tables memory to ");
print_h(max);
printf(" max.\n");
// Init Sylvan
sylvan_set_limits(max, 1, 10);
sylvan_init_package();
sylvan_init_ldd();
sylvan_init_mtbdd();
sylvan_gc_hook_pregc(TASK(gc_start));
sylvan_gc_hook_postgc(TASK(gc_end));
// Obtain operation ids for the operation cache
compute_highest_id = cache_next_opid();
compute_highest_action_id = cache_next_opid();
bdd_from_ldd_id = cache_next_opid();
bdd_from_ldd_rel_id = cache_next_opid();
// Open file
FILE *f = fopen(model_filename, "r");
if (f == NULL) Abort("Cannot open file '%s'!\n", model_filename);
// Read integers per vector
if (fread(&vector_size, sizeof(int), 1, f) != 1) Abort("Invalid input file!\n");
// Read initial state
if (verbose) printf("Loading initial state.\n");
set_t initial = set_load(f);
// Read number of transitions
if (fread(&next_count, sizeof(int), 1, f) != 1) Abort("Invalid input file!\n");
next = (rel_t*)malloc(sizeof(rel_t) * next_count);
// Read transitions
if (verbose) printf("Loading transition relations.\n");
for (int i=0; i<next_count; i++) next[i] = rel_load_proj(f);
for (int i=0; i<next_count; i++) rel_load(f, next[i]);
// Read whether reachable states are stored
int has_reachable = 0;
if (fread(&has_reachable, sizeof(int), 1, f) != 1) Abort("Input file missing reachable states!\n");
if (has_reachable == 0) Abort("Input file missing reachable states!\n");
// Read reachable states
if (verbose) printf("Loading reachable states.\n");
set_t states = set_load(f);
// Read number of action labels
int action_labels_count = 0;
if (fread(&action_labels_count, sizeof(int), 1, f) != 1) action_labels_count = 0;
// ignore: Abort("Input file missing action label count!\n");
// Read action labels
char *action_labels[action_labels_count];
for (int i=0; i<action_labels_count; i++) {
uint32_t len;
if (fread(&len, sizeof(uint32_t), 1, f) != 1) Abort("Invalid input file!\n");
action_labels[i] = (char*)malloc(sizeof(char[len+1]));
if (fread(action_labels[i], sizeof(char), len, f) != len) Abort("Invalid input file!\n");
action_labels[i][len] = 0;
}
// Close file
fclose(f);
// Report that we have read the input file
printf("Read file %s.\n", argv[1]);
// Report statistics
if (verbose) {
printf("%d integers per state, %d transition groups\n", vector_size, next_count);
printf("LDD nodes:\n");
printf("Initial states: %zu LDD nodes\n", lddmc_nodecount(initial->dd));
for (int i=0; i<next_count; i++) {
printf("Transition %d: %zu LDD nodes\n", i, lddmc_nodecount(next[i]->dd));
}
}
// Report that we prepare BDD conversion
if (verbose) printf("Preparing conversion to BDD...\n");
// Compute highest value at each level (from reachable states)
uint32_t highest[vector_size];
for (int i=0; i<vector_size; i++) highest[i] = 0;
compute_highest(states->dd, highest);
// Compute highest action label value (from transition relations)
uint32_t highest_action = 0;
for (int i=0; i<next_count; i++) {
compute_highest_action(next[i]->dd, next[i]->meta, &highest_action);
}
// Compute number of bits for each level
int bits[vector_size];
for (int i=0; i<vector_size; i++) {
bits[i] = 0;
while (highest[i] != 0) {
bits[i]++;
highest[i]>>=1;
}
if (bits[i] == 0) bits[i] = 1;
}
// Compute number of bits for action label
actionbits = 0;
while (highest_action != 0) {
actionbits++;
highest_action>>=1;
}
if (actionbits == 0 && has_actions) actionbits = 1;
// Report number of bits
if (verbose) {
printf("Bits per level: ");
for (int i=0; i<vector_size; i++) {
if (i>0) printf(", ");
printf("%d", bits[i]);
}
printf("\n");
printf("Action bits: %d.\n", actionbits);
}
// Compute bits MDD
MDD bits_dd = lddmc_true;
for (int i=0; i<vector_size; i++) {
bits_dd = lddmc_makenode(bits[vector_size-i-1], bits_dd, lddmc_false);
}
lddmc_ref(bits_dd);
// Compute total number of bits
int totalbits = 0;
for (int i=0; i<vector_size; i++) {
totalbits += bits[i];
}
// Compute state variables
MTBDD state_vars = mtbdd_true;
for (int i=0; i<totalbits; i++) {
state_vars = mtbdd_makenode(2*(totalbits-i-1), mtbdd_false, state_vars);
}
mtbdd_protect(&state_vars);
// Report that we begin the actual conversion
if (verbose) printf("Converting to BDD...\n");
// Create BDD file
f = fopen(bdd_filename, "w");
if (f == NULL) Abort("Cannot open file '%s'!\n", bdd_filename);
// Write domain...
fwrite(&vector_size, sizeof(int), 1, f);
fwrite(bits, sizeof(int), vector_size, f);
fwrite(&actionbits, sizeof(int), 1, f);
// Write initial state...
MTBDD new_initial = bdd_from_ldd(initial->dd, bits_dd, 0);
assert((size_t)mtbdd_satcount(new_initial, totalbits) == (size_t)lddmc_satcount_cached(initial->dd));
mtbdd_refs_push(new_initial);
{
int k = -1;
fwrite(&k, sizeof(int), 1, f);
mtbdd_writer_tobinary(f, &new_initial, 1);
}
// Custom operation that converts to BDD given number of bits for each level
MTBDD new_states = bdd_from_ldd(states->dd, bits_dd, 0);
assert((size_t)mtbdd_satcount(new_states, totalbits) == (size_t)lddmc_satcount_cached(states->dd));
mtbdd_refs_push(new_states);
// Report size of BDD
if (verbose) {
printf("Initial states: %zu BDD nodes\n", mtbdd_nodecount(new_initial));
printf("Reachable states: %zu BDD nodes\n", mtbdd_nodecount(new_states));
}
// Write number of transitions
fwrite(&next_count, sizeof(int), 1, f);
// Write meta for each transition
for (int i=0; i<next_count; i++) {
fwrite(&next[i]->r_k, sizeof(int), 1, f);
fwrite(&next[i]->w_k, sizeof(int), 1, f);
fwrite(next[i]->r_proj, sizeof(int), next[i]->r_k, f);
fwrite(next[i]->w_proj, sizeof(int), next[i]->w_k, f);
}
// Write BDD for each transition
for (int i=0; i<next_count; i++) {
// Compute new transition relation
MTBDD new_rel = bdd_from_ldd_rel(next[i]->dd, bits_dd, 0, next[i]->meta);
mtbdd_refs_push(new_rel);
mtbdd_writer_tobinary(f, &new_rel, 1);
// Report number of nodes
if (verbose) printf("Transition %d: %zu BDD nodes\n", i, mtbdd_nodecount(new_rel));
if (check_results) {
// Compute new <variables> for the current transition relation
MTBDD new_vars = meta_to_bdd(next[i]->meta, bits_dd, 0);
mtbdd_refs_push(new_vars);
// Test if the transition is correctly converted
MTBDD test = sylvan_relnext(new_states, new_rel, new_vars);
mtbdd_refs_push(test);
MDD succ = lddmc_relprod(states->dd, next[i]->dd, next[i]->meta);
lddmc_refs_push(succ);
MTBDD test2 = bdd_from_ldd(succ, bits_dd, 0);
if (test != test2) Abort("Conversion error!\n");
lddmc_refs_pop(1);
mtbdd_refs_pop(2);
}
mtbdd_refs_pop(1);
}
// Write reachable states
if (no_reachable) has_reachable = 0;
fwrite(&has_reachable, sizeof(int), 1, f);
if (has_reachable) {
int k = -1;
fwrite(&k, sizeof(int), 1, f);
mtbdd_writer_tobinary(f, &new_states, 1);
}
mtbdd_refs_pop(1); // new_states
// Write action labels
fwrite(&action_labels_count, sizeof(int), 1, f);
for (int i=0; i<action_labels_count; i++) {
uint32_t len = strlen(action_labels[i]);
fwrite(&len, sizeof(uint32_t), 1, f);
fwrite(action_labels[i], sizeof(char), len, f);
}
// Close the file
fclose(f);
// Report to the user
printf("Written file %s.\n", bdd_filename);
// Report Sylvan statistics (if SYLVAN_STATS is set)
if (verbose) sylvan_stats_report(stdout);
return 0;
}
static void task_finalize (GObject* obj) {
Task * self;
self = TASK (obj);
_g_value_array_free0 (self->priv->_arguments);
G_OBJECT_CLASS (task_parent_class)->finalize (obj);
}
int clock_handler(int irq){
if(TASK(leading)->ucount) TASK(leading)->ucount--;
if(!(jiffies % 10)) doint(CLOCK_PID,HARDWARE,0,0,0); /*!-------!*/
return OK;
}
