コード例 #1
0
ファイル: solution.py プロジェクト: fnrg-nfv/flexchain
def greedy_dc(model: Model) -> (float, int, float, float):
    """
    Greedy thought:
        Sort sfcs by its computing resources consumption in the increasing
        order. For every sfc, sort each available configuration by its
        latency in the increasing order. Find the first path whose resources
        can fulfill the requirement of sfc. If no available path is found,
        reject the sfc!
    """
    print(">>> Greedy Start <<<")

    topo = copy.deepcopy(model.topo)
    sfcs = model.sfc_list[:]
    sfcs.sort(key=lambda x: x.computing_resources_sum)

    with Timer(verbose_msg=f'[Greedy] Elapsed time: {{}}'), PixelBar(
            "SFC placement") as bar:
        bar.max = len(sfcs)
        for sfc in sfcs:
            configuration = generate_configuration_greedy_dfs(topo, sfc)
            if configuration and is_configuration_valid(
                    topo, sfc, configuration):
                sfc.accepted_configuration = configuration
            bar.next()

    obj_val = objective_value(model)
    accept_sfc_number = len(model.get_accepted_sfc_list())
    latency = average_latency(model)
    print("Objective Value: {} ({}, {}, {})".format(obj_val, evaluate(model),
                                                    accept_sfc_number,
                                                    latency))
    return obj_val, accept_sfc_number, latency, model.compute_resource_utilization(
    )
コード例 #2
0
def test_sat_composition_performance(PurchaseComposition):
    t = Timer()
    print("SAT (composition): ")
    print('Protocol, Property, Min, Mean, Max, Times')
    properties = {
        "Liveness": lambda P: P.is_live(),
        "Safety": lambda P: P.is_safe()
    }
    perf_test([PurchaseComposition.protocols['Refined-Commerce']], properties)
コード例 #3
0
ファイル: solution.py プロジェクト: fnrg-nfv/flexchain
def PARC(model: Model):
    """
        1. Sort SFCs by its computing resources in the ascending order.
        2. For every sfc, compute its merged chain.
        3. Find the first path whose resources can fulfill the requirement of sfc.
        4. If so, accept the configuration
        5. Otherwise, try to find the path for the origin sfc
        6. If so, accept the configuration
        7. Otherwise, refuse the sfc
    """
    print(">>> Para Greedy Start <<<")

    topo = copy.deepcopy(model.topo)
    sfcs = model.sfc_list[:]
    sfcs.sort(key=lambda sfc: sfc.computing_resources_sum)

    with Timer(verbose_msg=f'[ParaGreedy] Elapsed time: {{}}'), PixelBar(
            "SFC placement") as bar:
        bar.max = len(sfcs)
        for sfc in sfcs:
            optimal_sfc = SFC(sfc.pa.opt_vnf_list[:], sfc.latency,
                              sfc.throughput, sfc.s, sfc.d, sfc.idx)

            optimal_config = generate_configuration_greedy_dfs(
                topo, optimal_sfc)
            if optimal_config:  # generate origin "place" from the merged "place"
                merged_vnf_index = 0
                place = [optimal_config.place[0]]
                for para in sfc.pa.opt_strategy:
                    if para == 0:
                        merged_vnf_index += 1
                    place.append(optimal_config.place[merged_vnf_index])

                configuration = Configuration(sfc, optimal_config.route, place,
                                              optimal_config.route_latency,
                                              optimal_config.idx)
                if is_configuration_valid(topo, sfc, configuration):
                    sfc.accepted_configuration = configuration

            if not sfc.accepted_configuration:
                configuration = generate_configuration_greedy_dfs(topo, sfc)
                if configuration and is_configuration_valid(
                        topo, sfc, configuration):
                    sfc.accepted_configuration = configuration
            # else reject

            bar.next()

    obj_val = objective_value(model)
    accept_sfc_number = len(model.get_accepted_sfc_list())
    latency = average_latency(model)
    print("Objective Value: {} ({}, {}, {}, {})".format(
        obj_val, evaluate(model), accept_sfc_number, latency,
        model.compute_resource_utilization()))
    return obj_val, accept_sfc_number, latency, model.compute_resource_utilization(
    )
コード例 #4
0
def test_single_sub_performance(PurchaseComposition):
    t = Timer()
    print("SAT (single sub): ")
    print('Protocol, Property, Min, Mean, Max, Times')

    specs = [
        'sub-buyer-starts.bspl', 'sub-pay-first.bspl', 'sub-single-lookup.bspl'
    ]

    for s in specs:
        P = load_file('samples/bspl/performance/' +
                      s).protocols['Refined-Commerce']
        properties = {"Liveness": P.is_live, "Safety": P.is_safe}
        for name, fn in properties.items():
            times = []
            for x in range(10 + 1):
                t.tic()
                fn()
                t.toc()
                if x > 0:  # burn in once
                    times.append(t.elapsed * 1000)  # use milliseconds
            mean = sum(times) / len(times)
            print(
                f"{s}, {name}, {int(min(times))}, {int(mean)}, {int(max(times))}, {times}"
            )
コード例 #5
0
def test_sat_subprotocol_performance(PurchaseComposition):
    t = Timer()
    print("SAT (components): ")
    print('Protocol, Property, Min, Mean, Max')

    for P in PurchaseComposition.protocols.values():
        if 'Commerce' in P.name:
            continue
        properties = {
            "Enactability": P.is_enactable,
            "Liveness": P.is_live,
            "Safety": P.is_safe
        }
        for name, fn in properties.items():
            times = []
            for x in range(10):
                t.tic()
                fn()
                t.toc()
                print(t.elapsed)
                times.append(t.elapsed * 1000)  # use milliseconds
            mean = sum(times) / len(times)
            print(
                f"{P.name}, {name}, {int(min(times))}, {int(mean)}, {int(max(times))}"
            )
コード例 #6
0
def consistent(*statements, exhaustive=False):
    options = arg_parser.parse_known_args()[0]  # apparently returns a tuple
    stats["statements"] += logic.count(statements)
    statements = [logic.compile(s) for s in statements]

    clauses = statements
    cons = []
    t = Timer()
    t.tic()
    if options.exhaustive or exhaustive:
        cons += exhaustive_consistency(statements)
        result = solve(clauses + cons, options, depth="exhaustive")
    else:
        depth = int(options.depth)
        for d in range(depth):
            cons = consistency(clauses + cons)
        result = solve(clauses + cons, options, depth)
        while result and cycle(result):
            depth += 1
            cons = consistency(clauses + cons)
            result = solve(clauses + cons, options, depth)
    t.toc()
    stats["time"] += t.elapsed

    return result
コード例 #7
0
    def test_clear_timers(self):
        """Test clear timers"""
        t = Timer(matlab_like=False)
        for i in range(10):
            t.start(i)

        t.clear_timers()
        assert len(t._timers_start) == 0, "Timers not restarting"
コード例 #8
0
def perf_test(objects, properties):
    t = Timer()
    for obj in objects:
        for name, fn in properties.items():
            times = []
            for x in range(10 + 1):
                t.tic()
                fn(obj)
                t.toc()
                if x > 0:  # burn in once
                    times.append(t.elapsed * 1000)  # use milliseconds
            mean = sum(times) / len(times)
            print(
                f"{obj.name}, {name}, {int(min(times))}, {int(mean)}, {int(max(times))}, {times}"
            )
コード例 #9
0
def test_refinement_performance(PurchaseComposition):
    t = Timer()
    print("Refinement: ")
    print("Protocol, Min, Avg, Max")
    Ps = ['Either-Starts', 'Lookup-Prices', 'Flexible-Payment']
    Qs = ['Buyer-Starts', 'Single-Lookup', 'Pay-First']
    for i, name in enumerate(Ps):
        P = PurchaseComposition.protocols[Ps[i]]
        Q = PurchaseComposition.protocols[Qs[i]]
        times = []
        for x in range(10):
            t.tic()
            refines(UoD(), P.public_parameters, Q, P)
            t.toc()
            times.append(t.elapsed * 1000)
        avg = sum(times) / len(times)
        print(
            f"{P.name}, {int(min(times))}, {int(avg)}, {int(max(times))}, {times}"
        )
コード例 #10
0
    def test_error_not_initialized_non_matlab_like_key(self):
        """Test the error when timer has been not initialized"""
        t = Timer(matlab_like=False)

        with pytest.raises(TimerError):
            assert t.stop("init")
コード例 #11
0
    def test_error_not_initialized(self):
        """Test the error when timer has been not initialized"""
        t = Timer(matlab_like=True)

        with pytest.raises(TimerError):
            assert t.stop()
コード例 #12
0
ファイル: runme.py プロジェクト: hector-sab/ttictoc
time.sleep(1)
elapsed = toc()
print("Elapsed time:", elapsed)

print("\nNested Tic Toc")
tic()
for i in range(2):
    tic()
    time.sleep(1)
    elapsed = toc()
    print("[IN LOOP] Elapsed time:", elapsed)
print("[OUT LOOP] Elapsed time:", toc())

print("\n>>>Using Timer class")
print("\nSimple")
t = Timer()
t.start()
time.sleep(1)
elapsed = t.stop()
print("Elapsed time:", elapsed)

print("\nNested")
t.start()
for i in range(2):
    t.start()
    time.sleep(1)
    elapsed = t.stop()
    print("[IN LOOP] Elapsed time:", elapsed)
print("[OUT LOOP] Elapsed time:", t.stop())

print(">>> Tic Toc, v2 (non matlab-like)")
コード例 #13
0
ファイル: solution.py プロジェクト: fnrg-nfv/flexchain
def linear_programming(model: Model) -> (float, int, float, float):
    print(">>> Start LP <<<")
    problem = LpProblem("VNF Placement", LpMaximize)

    with Timer(verbose_msg=f'[GenC] Elapsed time: {{}}'), PixelBar(
            "Generating configuration sets") as bar:
        bar.max = len(model.sfc_list)
        for sfc in model.sfc_list:
            sfc.configurations = generate_configurations(model.topo, sfc)

            for configuration in sfc.configurations:
                configuration.var = LpVariable(configuration.name, 0, 1,
                                               LpContinuous)

            bar.next()

    # total number of valid sfc
    config_num = sum(len(sfc.configurations) for sfc in model.sfc_list)
    valid_sfc_num = sum(len(sfc.configurations) > 0 for sfc in model.sfc_list)
    print("Number of LP Variables: {}\tValid SFC: {}".format(
        config_num, valid_sfc_num))

    with Timer(verbose_msg=f'[LP Solving] Elapsed time: {{}}'):
        # Objective function
        problem += lpSum(
            (configuration.var for configuration in sfc.configurations)
            for sfc in model.sfc_list), "Total number of accepted requests"

        # Constraints
        # basic constraints
        for sfc in model.sfc_list:
            problem += lpSum(configuration.var for configuration in
                             sfc.configurations) <= 1.0, "Basic_{}".format(
                                 sfc.idx)

        # computing resource constraints
        for index, info in model.topo.nodes.data():
            problem += lpSum(
                configuration.var * configuration.computing_resource[index]
                for sfc in model.sfc_list
                for configuration in sfc.configurations
                if index in configuration.computing_resource
            ) <= info['computing_resource'], "CR_{}".format(index)

        # throughput constraints
        for start, end, info in model.topo.edges.data():
            problem += lpSum(
                configuration.var * sfc.throughput *
                configuration.edges[(start, end)] for sfc in model.sfc_list
                for configuration in sfc.configurations if (start, end) in
                configuration.edges) <= info['bandwidth'], "TP_{}_{}".format(
                    start, end)

        problem.solve()

    config.K = max(config.K / 3 * 2, config.K_MIN)

    obj_val = value(problem.objective)
    accept_sfc_number = sum(
        len(sfc.configurations) > 0 for sfc in model.sfc_list)
    latency = 0
    if accept_sfc_number is not 0:
        latency = sum(
            configuration.get_latency() * configuration.var.varValue
            for sfc in model.sfc_list
            for configuration in sfc.configurations) / accept_sfc_number
    print("Objective Value: {}({}, {}ms)".format(obj_val, accept_sfc_number,
                                                 latency))

    return obj_val, accept_sfc_number, latency, model.compute_resource_utilization(
    )