:-lib(ic). :-lib(branch_and_bound). init(NROFSLOTS, KL, KH, P, NA, SIM_TIME, RHO, H, NM) :- CYCLE is 5, STATIC is 3, %NROFSLOTS is 120, SLOT is STATIC / NROFSLOTS, BER is 10 ^ (-6), RHO is 1 - 10 ^ (-5), TAU is 1 * (60 * 60 * 1000), %hours to ms O = [2, 1, 0.5, 1, 3, 0.25, 1, 1, 0.5], T = [13, 15, 12, 7, 9, 10, 16, 8, 14], D = [8, 4, 8, 4, 4, 7, 7, 4, 11], W = [250, 255, 275, 290, 245, 250, 255, 260, 276], probs(W, BER, P), write("probs: "), writeln(P), nrOfInstances(T, CYCLE, N), write("nrOfInstances: "), writeln(N), nrOfCycles(O, T, D, N, CYCLE, C), write("nrOfCycles: "), writeln(C), hyperperiod(C, H), write("hyperperiod: "), writeln(H), nrOfRepetitions(C, H, A), write("nrOfRepetitions: "), writeln(A), totalNrOfInstances(N, A, NA), write("totalNrOfInstances: "), writeln(NA), SIM_TIME is TAU / (H * CYCLE), write("SIM_TIME: "), writeln(SIM_TIME), lowerBounds(P, NA, SIM_TIME, RHO, KL), write("lowerBounds: "), writeln(KL), TOTALNROFSLOTS is H * NROFSLOTS, write("TOTALNROFSLOTS: "), writeln(TOTALNROFSLOTS), upperBounds(O, T, D, N, SLOT, STATIC, CYCLE, NA, TOTALNROFSLOTS, KL, KH), write("upperBounds: "), writeln(KH), length(W, NM), write("NM: "), writeln(NM). rhoGoal(K):- %fetchVal([1], [NROFSLOTS], [250]), write("NROFSLOTS: "), writeln(NROFSLOTS), NROFSLOTS is 16, init(NROFSLOTS, KL, KH, PROB, NA, SIM_TIME, RHO, H, NM), nl, length(K, NM), addKCsp(KL, K, KH), fetchVal(KL, K, KH), collection_to_list(K, X), checkRho(X, PROB, NA, SIM_TIME, RHO, PROD), PROD >= RHO, slotPerInst(NA, X, H, NROFSLOTS, SUM), write("SUM: "), writeln(SUM), minimize(search(X, 0, first_fail, indomain, complete, []), SUM), %bb_min(labeling([SUM]), SUM, bb_options{strategy:dichotomic}), DIFF is PROD - RHO, write("DIFF: "), writeln(DIFF), writeln(X). %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% rhoGoal printList([]) :- nl. printList([H | T]) :- write(H), write(" "), printList(T). addKCsp(KL, K, KH) :- (foreach(KIL, KL), foreach(KI, K), foreach(KIH, KH) do KIL $= KIH, KI is KIL; KIL $\= KIH, KIL $=< KI, KI $=< KIH ). selectVal(Min, Max, Val) :- Min $=< Max, Val is Min. selectVal(Min, Max, Val) :- Min $< Max, Min1 is Min + 1, selectVal(Min1, Max, Val). fetchVal(KL, K, KH) :- (foreach(KIL, KL), foreach(KI, K), foreach(KIH, KH) do selectVal(KIL, KIH, KI) ). checkRho(X, PROB, NA, SIM_TIME, RHO, PROD) :- checkRho(X, PROB, NA, SIM_TIME, RHO, 1, PROD). checkRho([], [], [], _, _, PROD, PROD). checkRho([KH | KT], [PROBH | PROBT], [NAH | NAT], SIM_TIME, RHO, PRODTMP, PROD) :- P is (1 - PROBH ^ (KH + 1)) ^ (NAH * SIM_TIME), PRODTMP1 is PRODTMP * P, checkRho(KT, PROBT, NAT, SIM_TIME, RHO, PRODTMP1, PROD). slotPerInst([], [], _, _, 0) . slotPerInst([NAH | NAT], [XH | XT], H, NROFSLOTS, SUM) :- TMP is NAH * (XH + 1), slotPerInst(NAT, XT, H, NROFSLOTS, SUM1), SUM is TMP + SUM1, SUM =< H * NROFSLOTS. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% init probs([], _, []). probs([H | T], BER, P) :- PTMP is 1 - (1 - BER) ^ H, probs(T, BER, P1), P = [PTMP | P1]. nrOfInstances([], _, []). nrOfInstances([H | T], CYCLE, N) :- lcm(CYCLE, H, NTMP), NTMP1 is fix(floor(NTMP / H)), nrOfInstances(T, CYCLE, N1), N = [NTMP1 | N1]. fixCycle(CA, CB, C) :- CA < CB, C is fix(CB - 1). fixCycle(CA, CB, C) :- CA =:= CB, C is fix(CB). nrOfCycles([], [], [], [], _, []). nrOfCycles([OH | OT], [TH | TT], [DH | DT], [NH | NT], CYCLE, C) :- CA is ceiling((OH + (NH - 1) * TH + DH) / CYCLE), CB is ceiling((OH + NH * TH) / CYCLE), fixCycle(CA, CB, CTMP), nrOfCycles(OT, TT, DT, NT, CYCLE, C1), C = [CTMP | C1]. hyperperiod([H | T], X) :- hyperperiod(1, H, T, X). hyperperiod(X, Y, [], Z) :- lcm(X, Y, Z). hyperperiod(A, B, [H | T], X) :- lcm(A, B, C), hyperperiod(C, H, T, X). nrOfRepetitions([], _, []). nrOfRepetitions([H | T], C, A) :- ATMP is fix(floor(C / H)), nrOfRepetitions(T, C, A1), A = [ATMP | A1]. totalNrOfInstances([], [], []). totalNrOfInstances([NH | NT], [AH | AT], NA) :- NATMP is NH * AH, totalNrOfInstances(NT, AT, NA1), NA = [NATMP | NA1]. rhoIneq(PH, NAH, SIM_TIME, RHO, KLTMP) :- rhoIneq(PH, NAH, SIM_TIME, RHO, 0, KLTMP). rhoIneq(PH, NAH, SIM_TIME, RHO, KLS, KLTMP) :- X is (1 - PH ^ (KLS + 1)) ^ (NAH * SIM_TIME), X < RHO, KLS1 is KLS + 1, rhoIneq(PH, NAH, SIM_TIME, RHO, KLS1, KLTMP). rhoIneq(PH, NAH, SIM_TIME, RHO, KLS, KLTMP) :- X is (1 - PH ^ (KLS + 1)) ^ (NAH * SIM_TIME), X >= RHO, KLTMP is KLS. lowerBounds([], [], _, _, []). lowerBounds([PH | PT], [NAH | NAT], SIM_TIME, RHO, KL) :- rhoIneq(PH, NAH, SIM_TIME, RHO, KLTMP), lowerBounds(PT, NAT, SIM_TIME, RHO, KL1), KL = [KLTMP | KL1]. sumSlots(U, V, TINST, SLOT, STATIC, CYCLE, D, S) :- sumSlots(U, V, TINST, SLOT, STATIC, CYCLE, D, 0, S). sumSlots(U, V, TINST, SLOT, STATIC, CYCLE, D, SPREV, S) :- U =< V, A is U * CYCLE, B is A + STATIC, C is TINST + D, max(A, TINST, INF), min(B, C, SUP), SUP >= INF, DELTA is SUP - INF, NR is fix(floor(DELTA / SLOT)), SPREV1 is SPREV + NR, U1 is U + 1, sumSlots(U1, V, TINST, SLOT, STATIC, CYCLE, D, SPREV1, S). sumSlots(U, V, TINST, SLOT, STATIC, CYCLE, D, SPREV, S) :- U =< V, A is U * CYCLE, B is A + STATIC, C is TINST + D, max(A, TINST, INF), min(B, C, SUP), SUP < INF, DELTA is 0, NR is fix(floor(DELTA / SLOT)), SPREV1 is SPREV + NR, U1 is U + 1, sumSlots(U1, V, TINST, SLOT, STATIC, CYCLE, D, SPREV1, S). sumSlots(U, V, _, _, _, _, _, SPREV, S) :- U > V, S is SPREV. pSingleUpperBounds(O, T, D, N, SLOT, STATIC, CYCLE, PKH) :- pSingleUpperBounds(O, T, D, N, SLOT, STATIC, CYCLE, 1, 100000, PKH). pSingleUpperBounds(O, T, D, N, SLOT, STATIC, CYCLE, J, SPREV, PKH) :- J =< N, TINST is O + (J - 1) * T, U is fix(floor(TINST / CYCLE)), V is fix(floor((TINST + D) / CYCLE)), sumSlots(U, V, TINST, SLOT, STATIC, CYCLE, D, S), min(S, SPREV, SPREV1), J1 is J + 1, pSingleUpperBounds(O, T, D, N, SLOT, STATIC, CYCLE, J1, SPREV1, PKH). pSingleUpperBounds(_, _, _, N, _, _, _, J, SPREV, PKH) :- J > N, PKH is SPREV. pUpperBounds([], [], [], [], _, _, _, []). pUpperBounds([OH | OT], [TH | TT], [DH | DT], [NH | NT], SLOT, STATIC, CYCLE, PKH) :- pSingleUpperBounds(OH, TH, DH, NH, SLOT, STATIC, CYCLE, PKHTMP), PKHTMP1 is PKHTMP - 1, pUpperBounds(OT, TT, DT, NT, SLOT, STATIC, CYCLE, PKH1), PKH = [PKHTMP1 | PKH1]. sumLow(NA, KL, SL) :- sumLow(NA, KL, 0, SL). sumLow([], [], S, S). sumLow([NAH | NAT], [KLH | KLT], SLPREV, SL) :- S is NAH * (KLH + 1), SLPREV1 is SLPREV + S, sumLow(NAT, KLT, SLPREV1, SL). oUpperBounds(NA, TOTALNROFSLOTS, KL, OKH) :- sumLow(NA, KL, SL), oUpperBounds(NA, KL, TOTALNROFSLOTS, SL, OKH). oUpperBounds([], [], _, _, []). oUpperBounds([NAH | NAT], [KLH | KLT], TOTALNROFSLOTS, SL, OKH) :- S is NAH * (KLH + 1), SL1 is SL - S, T is TOTALNROFSLOTS - SL1, OKHTMP is fix(floor(T / NAH)) - 1, oUpperBounds(NAT, KLT, TOTALNROFSLOTS, SL, OKH1), OKH = [OKHTMP | OKH1]. rUpperBounds([], [], []). rUpperBounds([PKHH | PKHT], [OKHH | OKHT], KH) :- min(PKHH, OKHH, KHTMP), rUpperBounds(PKHT, OKHT, KH1), KH = [KHTMP | KH1]. upperBounds(O, T, D, N, SLOT, STATIC, CYCLE, NA, TOTALNROFSLOTS, KL, KH) :- pUpperBounds(O, T, D, N, SLOT, STATIC, CYCLE, PKH), write("pUpperBounds: "), writeln(PKH), oUpperBounds(NA, TOTALNROFSLOTS, KL, OKH), write("oUpperBounds: "), writeln(OKH), rUpperBounds(PKH, OKH, KH).