X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/56048e3bbbccaeb0c3f1ec9d0105048d7e122af1..6a6209ae617ba25152ddd80cd3b79d72748d7bd5:/src/mc/mc_request.c diff --git a/src/mc/mc_request.c b/src/mc/mc_request.c index 9ccfcb921b..1033bfcfde 100644 --- a/src/mc/mc_request.c +++ b/src/mc/mc_request.c @@ -11,11 +11,9 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(mc_request, mc, static char* pointer_to_string(void* pointer); static char* buff_size_to_string(size_t size); -int MC_request_depend(smx_simcall_t r1, smx_simcall_t r2) -{ - if(_surf_do_model_check == 2) +int MC_request_depend(smx_simcall_t r1, smx_simcall_t r2) { + if(mc_reduce_kind == e_mc_reduce_none) return TRUE; - if (r1->issuer == r2->issuer) return FALSE; @@ -26,130 +24,130 @@ int MC_request_depend(smx_simcall_t r1, smx_simcall_t r2) if(r1->call == SIMCALL_COMM_IRECV && r2->call == SIMCALL_COMM_ISEND) return FALSE; - if( (r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV) - && r2->call == SIMCALL_COMM_WAIT){ + /*if( (r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV) + && r2->call == SIMCALL_COMM_WAIT){ - if(r2->comm_wait.comm->comm.rdv == NULL) + if(simcall_comm_wait__get__comm(r2)->comm.rdv == NULL) return FALSE; - smx_rdv_t rdv = r1->call == SIMCALL_COMM_ISEND ? r1->comm_isend.rdv : r1->comm_irecv.rdv; + smx_rdv_t rdv = r1->call == SIMCALL_COMM_ISEND ? simcall_comm_isend__get__rdv(r1) : simcall_comm_irecv__get__rdv(r1); - if(r2->comm_wait.comm->comm.rdv != rdv) + if(simcall_comm_wait__get__comm(r2)->comm.rdv != rdv) return FALSE; - if(r2->comm_wait.comm->comm.type == SIMIX_COMM_SEND && r1->call == SIMCALL_COMM_ISEND) + if(simcall_comm_wait__get__comm(r2)->comm.type == SIMIX_COMM_SEND && r1->call == SIMCALL_COMM_ISEND) return FALSE; - if(r2->comm_wait.comm->comm.type == SIMIX_COMM_RECEIVE && r1->call == SIMCALL_COMM_IRECV) + if(simcall_comm_wait__get__comm(r2)->comm.type == SIMIX_COMM_RECEIVE && r1->call == SIMCALL_COMM_IRECV) return FALSE; } if( (r2->call == SIMCALL_COMM_ISEND || r2->call == SIMCALL_COMM_IRECV) - && r1->call == SIMCALL_COMM_WAIT){ + && r1->call == SIMCALL_COMM_WAIT){ - if(r1->comm_wait.comm->comm.rdv != NULL) + if(simcall_comm_wait__get__comm(r1)->comm.rdv != NULL) return FALSE; - smx_rdv_t rdv = r2->call == SIMCALL_COMM_ISEND ? r2->comm_isend.rdv : r2->comm_irecv.rdv; + smx_rdv_t rdv = r2->call == SIMCALL_COMM_ISEND ? simcall_comm_isend__get__rdv(r2) : simcall_comm_irecv__get__rdv(r2); - if(r1->comm_wait.comm->comm.rdv != rdv) + if(simcall_comm_wait__get__comm(r1)->comm.rdv != rdv) return FALSE; - if(r1->comm_wait.comm->comm.type == SIMIX_COMM_SEND && r2->call == SIMCALL_COMM_ISEND) + if(simcall_comm_wait__get__comm(r1)->comm.type == SIMIX_COMM_SEND && r2->call == SIMCALL_COMM_ISEND) return FALSE; - if(r1->comm_wait.comm->comm.type == SIMIX_COMM_RECEIVE && r2->call == SIMCALL_COMM_IRECV) + if(simcall_comm_wait__get__comm(r1)->comm.type == SIMIX_COMM_RECEIVE && r2->call == SIMCALL_COMM_IRECV) return FALSE; - } + }*/ /* FIXME: the following rule assumes that the result of the * isend/irecv call is not stored in a buffer used in the * test call. */ - if( (r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV) - && r2->call == SIMCALL_COMM_TEST) - return FALSE; + /*if( (r1->call == SIMCALL_COMM_ISEND || r1->call == SIMCALL_COMM_IRECV) + && r2->call == SIMCALL_COMM_TEST) + return FALSE;*/ /* FIXME: the following rule assumes that the result of the * isend/irecv call is not stored in a buffer used in the * test call.*/ - if( (r2->call == SIMCALL_COMM_ISEND || r2->call == SIMCALL_COMM_IRECV) - && r1->call == SIMCALL_COMM_TEST) - return FALSE; + /*if( (r2->call == SIMCALL_COMM_ISEND || r2->call == SIMCALL_COMM_IRECV) + && r1->call == SIMCALL_COMM_TEST) + return FALSE;*/ if(r1->call == SIMCALL_COMM_ISEND && r2->call == SIMCALL_COMM_ISEND - && r1->comm_isend.rdv != r2->comm_isend.rdv) + && simcall_comm_isend__get__rdv(r1) != simcall_comm_isend__get__rdv(r2)) return FALSE; if(r1->call == SIMCALL_COMM_IRECV && r2->call == SIMCALL_COMM_IRECV - && r1->comm_irecv.rdv != r2->comm_irecv.rdv) + && simcall_comm_irecv__get__rdv(r1) != simcall_comm_irecv__get__rdv(r2)) return FALSE; if(r1->call == SIMCALL_COMM_WAIT && (r2->call == SIMCALL_COMM_WAIT || r2->call == SIMCALL_COMM_TEST) - && (r1->comm_wait.comm->comm.src_proc == NULL - || r1->comm_wait.comm->comm.dst_proc == NULL)) + && (simcall_comm_wait__get__comm(r1)->comm.src_proc == NULL + || simcall_comm_wait__get__comm(r1)->comm.dst_proc == NULL)) return FALSE; if(r2->call == SIMCALL_COMM_WAIT && (r1->call == SIMCALL_COMM_WAIT || r1->call == SIMCALL_COMM_TEST) - && (r2->comm_wait.comm->comm.src_proc == NULL - || r2->comm_wait.comm->comm.dst_proc == NULL)) + && (simcall_comm_wait__get__comm(r2)->comm.src_proc == NULL + || simcall_comm_wait__get__comm(r2)->comm.dst_proc == NULL)) return FALSE; if(r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_WAIT - && r1->comm_wait.comm->comm.src_buff == r2->comm_wait.comm->comm.src_buff - && r1->comm_wait.comm->comm.dst_buff == r2->comm_wait.comm->comm.dst_buff) + && simcall_comm_wait__get__comm(r1)->comm.src_buff == simcall_comm_wait__get__comm(r2)->comm.src_buff + && simcall_comm_wait__get__comm(r1)->comm.dst_buff == simcall_comm_wait__get__comm(r2)->comm.dst_buff) return FALSE; if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_WAIT - && r1->comm_wait.comm->comm.src_buff != NULL - && r1->comm_wait.comm->comm.dst_buff != NULL - && r2->comm_wait.comm->comm.src_buff != NULL - && r2->comm_wait.comm->comm.dst_buff != NULL - && r1->comm_wait.comm->comm.dst_buff != r2->comm_wait.comm->comm.src_buff - && r1->comm_wait.comm->comm.dst_buff != r2->comm_wait.comm->comm.dst_buff - && r2->comm_wait.comm->comm.dst_buff != r1->comm_wait.comm->comm.src_buff) + && simcall_comm_wait__get__comm(r1)->comm.src_buff != NULL + && simcall_comm_wait__get__comm(r1)->comm.dst_buff != NULL + && simcall_comm_wait__get__comm(r2)->comm.src_buff != NULL + && simcall_comm_wait__get__comm(r2)->comm.dst_buff != NULL + && simcall_comm_wait__get__comm(r1)->comm.dst_buff != simcall_comm_wait__get__comm(r2)->comm.src_buff + && simcall_comm_wait__get__comm(r1)->comm.dst_buff != simcall_comm_wait__get__comm(r2)->comm.dst_buff + && simcall_comm_wait__get__comm(r2)->comm.dst_buff != simcall_comm_wait__get__comm(r1)->comm.src_buff) return FALSE; if(r1->call == SIMCALL_COMM_TEST && - (r1->comm_test.comm == NULL - || r1->comm_test.comm->comm.src_buff == NULL - || r1->comm_test.comm->comm.dst_buff == NULL)) + (simcall_comm_test__get__comm(r1) == NULL + || simcall_comm_test__get__comm(r1)->comm.src_buff == NULL + || simcall_comm_test__get__comm(r1)->comm.dst_buff == NULL)) return FALSE; if(r2->call == SIMCALL_COMM_TEST && - (r2->comm_test.comm == NULL - || r2->comm_test.comm->comm.src_buff == NULL - || r2->comm_test.comm->comm.dst_buff == NULL)) + (simcall_comm_test__get__comm(r2) == NULL + || simcall_comm_test__get__comm(r2)->comm.src_buff == NULL + || simcall_comm_test__get__comm(r2)->comm.dst_buff == NULL)) return FALSE; if(r1->call == SIMCALL_COMM_TEST && r2->call == SIMCALL_COMM_WAIT - && r1->comm_test.comm->comm.src_buff == r2->comm_wait.comm->comm.src_buff - && r1->comm_test.comm->comm.dst_buff == r2->comm_wait.comm->comm.dst_buff) + && simcall_comm_test__get__comm(r1)->comm.src_buff == simcall_comm_wait__get__comm(r2)->comm.src_buff + && simcall_comm_test__get__comm(r1)->comm.dst_buff == simcall_comm_wait__get__comm(r2)->comm.dst_buff) return FALSE; if(r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_TEST - && r1->comm_wait.comm->comm.src_buff == r2->comm_test.comm->comm.src_buff - && r1->comm_wait.comm->comm.dst_buff == r2->comm_test.comm->comm.dst_buff) + && simcall_comm_wait__get__comm(r1)->comm.src_buff == simcall_comm_test__get__comm(r2)->comm.src_buff + && simcall_comm_wait__get__comm(r1)->comm.dst_buff == simcall_comm_test__get__comm(r2)->comm.dst_buff) return FALSE; if (r1->call == SIMCALL_COMM_WAIT && r2->call == SIMCALL_COMM_TEST - && r1->comm_wait.comm->comm.src_buff != NULL - && r1->comm_wait.comm->comm.dst_buff != NULL - && r2->comm_test.comm->comm.src_buff != NULL - && r2->comm_test.comm->comm.dst_buff != NULL - && r1->comm_wait.comm->comm.dst_buff != r2->comm_test.comm->comm.src_buff - && r1->comm_wait.comm->comm.dst_buff != r2->comm_test.comm->comm.dst_buff - && r2->comm_test.comm->comm.dst_buff != r1->comm_wait.comm->comm.src_buff) + && simcall_comm_wait__get__comm(r1)->comm.src_buff != NULL + && simcall_comm_wait__get__comm(r1)->comm.dst_buff != NULL + && simcall_comm_test__get__comm(r2)->comm.src_buff != NULL + && simcall_comm_test__get__comm(r2)->comm.dst_buff != NULL + && simcall_comm_wait__get__comm(r1)->comm.dst_buff != simcall_comm_test__get__comm(r2)->comm.src_buff + && simcall_comm_wait__get__comm(r1)->comm.dst_buff != simcall_comm_test__get__comm(r2)->comm.dst_buff + && simcall_comm_test__get__comm(r2)->comm.dst_buff != simcall_comm_wait__get__comm(r1)->comm.src_buff) return FALSE; if (r1->call == SIMCALL_COMM_TEST && r2->call == SIMCALL_COMM_WAIT - && r1->comm_test.comm->comm.src_buff != NULL - && r1->comm_test.comm->comm.dst_buff != NULL - && r2->comm_wait.comm->comm.src_buff != NULL - && r2->comm_wait.comm->comm.dst_buff != NULL - && r1->comm_test.comm->comm.dst_buff != r2->comm_wait.comm->comm.src_buff - && r1->comm_test.comm->comm.dst_buff != r2->comm_wait.comm->comm.dst_buff - && r2->comm_wait.comm->comm.dst_buff != r1->comm_test.comm->comm.src_buff) - return FALSE; + && simcall_comm_test__get__comm(r1)->comm.src_buff != NULL + && simcall_comm_test__get__comm(r1)->comm.dst_buff != NULL + && simcall_comm_wait__get__comm(r2)->comm.src_buff != NULL + && simcall_comm_wait__get__comm(r2)->comm.dst_buff != NULL + && simcall_comm_test__get__comm(r1)->comm.dst_buff != simcall_comm_wait__get__comm(r2)->comm.src_buff + && simcall_comm_test__get__comm(r1)->comm.dst_buff != simcall_comm_wait__get__comm(r2)->comm.dst_buff + && simcall_comm_wait__get__comm(r2)->comm.dst_buff != simcall_comm_test__get__comm(r1)->comm.src_buff) + return FALSE; return TRUE; @@ -180,68 +178,78 @@ char *MC_request_to_string(smx_simcall_t req, int value) switch(req->call){ case SIMCALL_COMM_ISEND: - type = xbt_strdup("iSend"); - p = pointer_to_string(req->comm_isend.src_buff); - bs = buff_size_to_string(req->comm_isend.src_buff_size); - args = bprintf("src=%s, buff=%s, size=%s", req->issuer->name, p, bs); - break; - case SIMCALL_COMM_IRECV: - size = req->comm_irecv.dst_buff_size ? *req->comm_irecv.dst_buff_size : 0; - type = xbt_strdup("iRecv"); - p = pointer_to_string(req->comm_irecv.dst_buff); - bs = buff_size_to_string(size); - args = bprintf("dst=%s, buff=%s, size=%s", req->issuer->name, p, bs); - break; - case SIMCALL_COMM_WAIT: - act = req->comm_wait.comm; - if(value == -1){ - type = xbt_strdup("WaitTimeout"); - p = pointer_to_string(act); - args = bprintf("comm=%p", p); - }else{ - type = xbt_strdup("Wait"); - p = pointer_to_string(act); - args = bprintf("comm=%s [(%lu)%s -> (%lu)%s]", p, - act->comm.src_proc ? act->comm.src_proc->pid : 0, - act->comm.src_proc ? act->comm.src_proc->name : "", - act->comm.dst_proc ? act->comm.dst_proc->pid : 0, - act->comm.dst_proc ? act->comm.dst_proc->name : ""); - } - break; - case SIMCALL_COMM_TEST: - act = req->comm_test.comm; - if(act->comm.src_proc == NULL || act->comm.dst_proc == NULL){ - type = xbt_strdup("Test FALSE"); - p = pointer_to_string(act); - args = bprintf("comm=%s", p); - }else{ - type = xbt_strdup("Test TRUE"); - p = pointer_to_string(act); - args = bprintf("comm=%s [(%lu)%s -> (%lu)%s]", p, - act->comm.src_proc->pid, act->comm.src_proc->name, - act->comm.dst_proc->pid, act->comm.dst_proc->name); - } - break; - - case SIMCALL_COMM_WAITANY: - type = xbt_strdup("WaitAny"); - p = pointer_to_string(xbt_dynar_get_as(req->comm_waitany.comms, value, smx_action_t)); - args = bprintf("comm=%s (%d of %lu)", p, - value+1, xbt_dynar_length(req->comm_waitany.comms)); - break; - - case SIMCALL_COMM_TESTANY: - if(value == -1){ - type = xbt_strdup("TestAny FALSE"); - args = xbt_strdup("-"); - }else{ - type = xbt_strdup("TestAny"); - args = bprintf("(%d of %lu)", value+1, xbt_dynar_length(req->comm_testany.comms)); - } - break; - - default: - THROW_UNIMPLEMENTED; + type = xbt_strdup("iSend"); + p = pointer_to_string(simcall_comm_isend__get__src_buff(req)); + bs = buff_size_to_string(simcall_comm_isend__get__src_buff_size(req)); + args = bprintf("src=%s, buff=%s, size=%s", req->issuer->name, p, bs); + break; + case SIMCALL_COMM_IRECV: + size = simcall_comm_irecv__get__dst_buff_size(req) ? *simcall_comm_irecv__get__dst_buff_size(req) : 0; + type = xbt_strdup("iRecv"); + p = pointer_to_string(simcall_comm_irecv__get__dst_buff(req)); + bs = buff_size_to_string(size); + args = bprintf("dst=%s, buff=%s, size=%s", req->issuer->name, p, bs); + break; + case SIMCALL_COMM_WAIT: + act = simcall_comm_wait__get__comm(req); + if(value == -1){ + type = xbt_strdup("WaitTimeout"); + p = pointer_to_string(act); + args = bprintf("comm=%p", p); + }else{ + type = xbt_strdup("Wait"); + p = pointer_to_string(act); + args = bprintf("comm=%s [(%lu)%s -> (%lu)%s]", p, + act->comm.src_proc ? act->comm.src_proc->pid : 0, + act->comm.src_proc ? act->comm.src_proc->name : "", + act->comm.dst_proc ? act->comm.dst_proc->pid : 0, + act->comm.dst_proc ? act->comm.dst_proc->name : ""); + } + break; + case SIMCALL_COMM_TEST: + act = simcall_comm_test__get__comm(req); + if(act->comm.src_proc == NULL || act->comm.dst_proc == NULL){ + type = xbt_strdup("Test FALSE"); + p = pointer_to_string(act); + args = bprintf("comm=%s", p); + }else{ + type = xbt_strdup("Test TRUE"); + p = pointer_to_string(act); + args = bprintf("comm=%s [(%lu)%s -> (%lu)%s]", p, + act->comm.src_proc->pid, act->comm.src_proc->name, + act->comm.dst_proc->pid, act->comm.dst_proc->name); + } + break; + + case SIMCALL_COMM_WAITANY: + type = xbt_strdup("WaitAny"); + p = pointer_to_string(xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), value, smx_action_t)); + args = bprintf("comm=%s (%d of %lu)", p, + value+1, xbt_dynar_length(simcall_comm_waitany__get__comms(req))); + break; + + case SIMCALL_COMM_TESTANY: + if(value == -1){ + type = xbt_strdup("TestAny FALSE"); + args = xbt_strdup("-"); + }else{ + type = xbt_strdup("TestAny"); + args = bprintf("(%d of %lu)", value+1, xbt_dynar_length(simcall_comm_testany__get__comms(req))); + } + break; + + case SIMCALL_MC_SNAPSHOT: + type = xbt_strdup("MC_SNAPSHOT"); + args = '\0'; + break; + + case SIMCALL_MC_COMPARE_SNAPSHOTS: + type = xbt_strdup("MC_COMPARE_SNAPSHOTS"); + args = '\0'; + break; + + default: + THROW_UNIMPLEMENTED; } str = bprintf("[(%lu)%s] %s (%s)", req->issuer->pid ,req->issuer->name, type, args); @@ -257,7 +265,7 @@ unsigned int MC_request_testany_fail(smx_simcall_t req) unsigned int cursor; smx_action_t action; - xbt_dynar_foreach(req->comm_testany.comms, cursor, action){ + xbt_dynar_foreach(simcall_comm_testany__get__comms(req), cursor, action){ if(action->comm.src_proc && action->comm.dst_proc) return FALSE; } @@ -268,11 +276,13 @@ unsigned int MC_request_testany_fail(smx_simcall_t req) int MC_request_is_visible(smx_simcall_t req) { return req->call == SIMCALL_COMM_ISEND - || req->call == SIMCALL_COMM_IRECV - || req->call == SIMCALL_COMM_WAIT - || req->call == SIMCALL_COMM_WAITANY - || req->call == SIMCALL_COMM_TEST - || req->call == SIMCALL_COMM_TESTANY; + || req->call == SIMCALL_COMM_IRECV + || req->call == SIMCALL_COMM_WAIT + || req->call == SIMCALL_COMM_WAITANY + || req->call == SIMCALL_COMM_TEST + || req->call == SIMCALL_COMM_TESTANY + || req->call == SIMCALL_MC_SNAPSHOT + || req->call == SIMCALL_MC_COMPARE_SNAPSHOTS; } int MC_request_is_enabled(smx_simcall_t req) @@ -282,33 +292,38 @@ int MC_request_is_enabled(smx_simcall_t req) switch (req->call) { - case SIMCALL_COMM_WAIT: - /* FIXME: check also that src and dst processes are not suspended */ + case SIMCALL_COMM_WAIT: + /* FIXME: check also that src and dst processes are not suspended */ - /* If it has a timeout it will be always be enabled, because even if the - * communication is not ready, it can timeout and won't block. - * On the other hand if it hasn't a timeout, check if the comm is ready.*/ - if(req->comm_wait.timeout >= 0){ + /* If it has a timeout it will be always be enabled, because even if the + * communication is not ready, it can timeout and won't block. + * On the other hand if it hasn't a timeout, check if the comm is ready.*/ + if(simcall_comm_wait__get__timeout(req) >= 0){ + if(_sg_mc_timeout == 1){ return TRUE; }else{ - act = req->comm_wait.comm; + act = simcall_comm_wait__get__comm(req); return (act->comm.src_proc && act->comm.dst_proc); } - break; - - case SIMCALL_COMM_WAITANY: - /* Check if it has at least one communication ready */ - xbt_dynar_foreach(req->comm_waitany.comms, index, act) { - if (act->comm.src_proc && act->comm.dst_proc){ - return TRUE; - } + }else{ + act = simcall_comm_wait__get__comm(req); + return (act->comm.src_proc && act->comm.dst_proc); + } + break; + + case SIMCALL_COMM_WAITANY: + /* Check if it has at least one communication ready */ + xbt_dynar_foreach(simcall_comm_waitany__get__comms(req), index, act) { + if (act->comm.src_proc && act->comm.dst_proc){ + return TRUE; } - return FALSE; - break; + } + return FALSE; + break; - default: - /* The rest of the request are always enabled */ - return TRUE; + default: + /* The rest of the request are always enabled */ + return TRUE; } } @@ -318,24 +333,24 @@ int MC_request_is_enabled_by_idx(smx_simcall_t req, unsigned int idx) switch (req->call) { - case SIMCALL_COMM_WAIT: - /* FIXME: check also that src and dst processes are not suspended */ - act = req->comm_wait.comm; - return (act->comm.src_proc && act->comm.dst_proc); - break; + case SIMCALL_COMM_WAIT: + /* FIXME: check also that src and dst processes are not suspended */ + act = simcall_comm_wait__get__comm(req); + return (act->comm.src_proc && act->comm.dst_proc); + break; - case SIMCALL_COMM_WAITANY: - act = xbt_dynar_get_as(req->comm_waitany.comms, idx, smx_action_t); - return (act->comm.src_proc && act->comm.dst_proc); - break; + case SIMCALL_COMM_WAITANY: + act = xbt_dynar_get_as(simcall_comm_waitany__get__comms(req), idx, smx_action_t); + return (act->comm.src_proc && act->comm.dst_proc); + break; - case SIMCALL_COMM_TESTANY: - act = xbt_dynar_get_as(req->comm_testany.comms, idx, smx_action_t); - return (act->comm.src_proc && act->comm.dst_proc); - break; + case SIMCALL_COMM_TESTANY: + act = xbt_dynar_get_as(simcall_comm_testany__get__comms(req), idx, smx_action_t); + return (act->comm.src_proc && act->comm.dst_proc); + break; - default: - return TRUE; + default: + return TRUE; } }