def get_query_list(k, port_range):
    node_query_list = []
    path_query_list = []
    for index in xrange(50):
        node_query_where = {}
        node_query_return = {}
        for _ in xrange(index):
            node_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            node_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        node_query_list.append(
            NodeQuery(randint(0, port_range), randint(0, k), node_query_where,
                      randint(1, index + 1), node_query_return,
                      category[randint(0, 1)]))
        path_query_where = {}
        path_query_return = {}
        for _ in xrange(index):
            path_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            path_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        path_query_list.append(
            PathQuery(randint(0, port_range), randint(0, k),
                      randint(0, port_range), randint(0, k), path_query_where,
                      randint(1, index + 1), path_query_return,
                      category[randint(0, 1)]))
    query_list = node_query_list + path_query_list
    return query_list
예제 #2
0
def get_query_list_dict(port_range, router_range):
    query_list_dict = {100: [], 500: [], 1000: []}
    for index in xrange(250):
        node_query_where = {}
        node_query_return = {}
        for _ in xrange(index):
            node_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            node_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        node = randint(0, router_range)
        port = randint(0, port_range)
        cat = category[randint(0, 1)]
        query_list_dict[100].append(
            NodeQuery(node, port, node_query_where, 100, node_query_return,
                      cat))
        query_list_dict[500].append(
            NodeQuery(node, port, node_query_where, 500, node_query_return,
                      cat))
        query_list_dict[1000].append(
            NodeQuery(node, port, node_query_where, 1000, node_query_return,
                      cat))

        path_query_where = {}
        path_query_return = {}
        for _ in xrange(index):
            path_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            path_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        src_node = randint(0, router_range)
        src_port = randint(0, port_range)
        dst_node = randint(0, router_range)
        dst_port = randint(0, port_range)
        cat = category[randint(0, 1)]
        query_list_dict[100].append(
            PathQuery(src_node, src_port, dst_node, dst_port, path_query_where,
                      100, path_query_return, cat))
        query_list_dict[500].append(
            PathQuery(src_node, src_port, dst_node, dst_port, path_query_where,
                      500, path_query_return, cat))
        query_list_dict[1000].append(
            PathQuery(src_node, src_port, dst_node, dst_port, path_query_where,
                      1000, path_query_return, cat))

    return query_list_dict
예제 #3
0
    node_query_list = []
    path_query_list = []
    for query_cnt in xrange(10, 1010, 10):
        node_query_cnt = query_cnt / 2
        for index in xrange(node_query_cnt - 5, node_query_cnt):
            node_query_where = {}
            node_query_return = {}
            for _ in xrange(index):
                node_query_where[metadata_list[randint(0, index) %
                                               metadata_len]] = {}
                node_query_return[metadata_list[randint(0, index) %
                                                metadata_len]] = {}
            node_query_list.append(
                NodeQuery(index, randint(0, k), node_query_where,
                          randint(1, node_query_cnt), node_query_return,
                          category[randint(0, 1)]))

        path_query_cnt = query_cnt / 2
        for index in xrange(path_query_cnt - 5, path_query_cnt):
            path_query_where = {}
            path_query_return = {}
            for _ in xrange(index):
                path_query_where[metadata_list[randint(0, index) %
                                               metadata_len]] = {}
                path_query_return[metadata_list[randint(0, index) %
                                                metadata_len]] = {}
            path_query_list.append(
                PathQuery(index, randint(0, k), index + 1,
                          randint(0, k), path_query_where,
                          randint(1, path_query_cnt), path_query_return,
예제 #4
0
    category = ['performance', 'failure']
    f = open('testsdata/fig6a_query_update_time_least.txt', 'w')

    node_query_update_list = []
    path_query_update_list = []
    for query_update_cnt in xrange(10, 1010, 10):
        query_add_time = 0.0
        node_query_update_cnt = query_update_cnt / 2
        for index in xrange(node_query_update_cnt-5, node_query_update_cnt):
            node_query_where = {}
            node_query_return = {}
            for _ in xrange(index):
                node_query_where[metadata_list[randint(0, index) % metadata_len]] = {}
                node_query_return[metadata_list[randint(0, index) % metadata_len]] = {}
            node_query_update_list.append(NodeQuery(index, randint(0, k), node_query_where,
                                                    randint(1, node_query_update_cnt),
                                                    node_query_return, category[randint(0, 1)]))

        path_query_update_cnt = query_update_cnt / 2
        for index in xrange(path_query_update_cnt-5, path_query_update_cnt):
            path_query_where = {}
            path_query_return = {}
            for _ in xrange(index):
                path_query_where[metadata_list[randint(0, index) % metadata_len]] = {}
                path_query_return[metadata_list[randint(0, index) % metadata_len]] = {}
            path_query_update_list.append(PathQuery(index, randint(0, k), index + 1, randint(0, k),
                                                    path_query_where, randint(1, path_query_update_cnt),
                                                    path_query_return, category[randint(0, 1)]))
        add_query_list = node_query_update_list + path_query_update_list

        for _ in xrange(10):
def get_query_list_dict(k, port_range):
    query_list_dict = {100: [], 500: [], 1000: []}
    node_query_list = []
    path_query_list = []
    for index in xrange(50):
        node_query_where = {}
        node_query_return = {}
        for _ in xrange(index):
            node_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            node_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        node_query_list.append(
            NodeQuery(randint(0, port_range), randint(0, k), node_query_where,
                      randint(1, index + 1), node_query_return,
                      category[randint(0, 1)]))
        path_query_where = {}
        path_query_return = {}
        for _ in xrange(index):
            path_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            path_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        path_query_list.append(
            PathQuery(randint(0, port_range), randint(0, k),
                      randint(0, port_range), randint(0, k), path_query_where,
                      randint(1, index + 1), path_query_return,
                      category[randint(0, 1)]))
    query_list_dict[100] = node_query_list + path_query_list

    query_list_dict[500] = deepcopy(query_list_dict[100])
    for index in xrange(100, 300):
        node_query_where = {}
        node_query_return = {}
        for _ in xrange(index):
            node_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            node_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        query_list_dict[500].append(
            NodeQuery(randint(0, port_range), randint(0, k), node_query_where,
                      randint(1, index), node_query_return,
                      category[randint(0, 1)]))
        path_query_where = {}
        path_query_return = {}
        for _ in xrange(index):
            path_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            path_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        query_list_dict[500].append(
            PathQuery(randint(0, port_range), randint(0, k),
                      randint(0, port_range), randint(0, k), path_query_where,
                      randint(1, index), path_query_return,
                      category[randint(0, 1)]))

    query_list_dict[1000] = deepcopy(query_list_dict[500])
    for index in xrange(300, 550):
        node_query_where = {}
        node_query_return = {}
        for _ in xrange(index):
            node_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            node_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        query_list_dict[1000].append(
            NodeQuery(randint(0, port_range), randint(0, k), node_query_where,
                      randint(1, index), node_query_return,
                      category[randint(0, 1)]))
        path_query_where = {}
        path_query_return = {}
        for _ in xrange(index):
            path_query_where[metadata_list[randint(0, index) %
                                           metadata_len]] = {}
            path_query_return[metadata_list[randint(0, index) %
                                            metadata_len]] = {}
        query_list_dict[1000].append(
            PathQuery(randint(0, port_range), randint(0, k),
                      randint(0, port_range), randint(0, k), path_query_where,
                      randint(1, index), path_query_return,
                      category[randint(0, 1)]))

    return query_list_dict
# -*- coding: utf-8 -*-
from topology.fat_tree import FatTreeTopology
from optimize_algorithm.generate_probe import generate_probe_set
from query_primitives.query import PathQuery, NodeQuery
from utils.const import metadata_list
from random import randint

if __name__ == '__main__':
    fat_tree = FatTreeTopology()
    k_fwd = 100
    k_tele = 20
    metadata_len = len(metadata_list)
    for query_cnt in xrange(10, 210, 10):
        node_query_list = [
            NodeQuery(index, 2,
                      {metadata_list[randint(0, 1000) % metadata_len]: {}}, 1,
                      {metadata_list[randint(0, 1000) % metadata_len]: {}},
                      'failure') for index in xrange(query_cnt / 2)
        ]
        path_query_list = [
            PathQuery(index, 1, index + 10, 1,
                      {metadata_list[randint(0, 2000) % metadata_len]: {}},
                      0.5,
                      {metadata_list[randint(0, 2000) % metadata_len]: {}},
                      'failure') for index in xrange(query_cnt / 2)
        ]
        query_list = node_query_list + path_query_list
        probe_pkt_list = generate_probe_set(query_list, fat_tree, k_fwd,
                                            k_tele)
        probe_cnt = 0
        for category in ['performance', 'failure']:
            probe_set_dict = probe_pkt_list[category]