def main(trace=False):
    vm = QemuNG(disk_path=r"../vms/ubuntu-20.img",
                guest_ip="10.10.0.43",
                host_ip="10.10.0.44")
    vm.ethernet_dev = vm.QEMU_VIRTIO

    if trace:
        vm.exe = ORIG_QEMU_TRACE

    vm.setup()
    vm.run()

    input("Press any enter to close VM")
    vm.teardown()
Exemple #2
0
def create_vms():
    OLD_QEMU = r"../qemu/build/qemu-system-x86_64"
    OLD_KERNEL = r"/home/bdaviv/repos/e1000-improv/linux-3.13.0/arch/x86/boot/bzImage"
    OLD_INITRD = r"../vms/initrd.img"
    base_machine = QemuNG(disk_path=r"../vms/ubuntu-20.img",
                          guest_ip="10.10.0.43",
                          host_ip="10.10.0.44")
    base_machine.ethernet_dev = base_machine.QEMU_VIRTIO

    # e1000_QnGn_better = deepcopy(base_machine)
    # e1000_QnGn_better.name = "QnGn-newer"
    # e1000_QnGn_better.ethernet_dev = e1000_QnGn_better.QEMU_E1000_BETTER

    virtio_QnGn = deepcopy(base_machine)
    virtio_QnGn.name = "QnGn"

    virtio_QnGo = deepcopy(base_machine)
    virtio_QnGo.name = 'QnGo'
    virtio_QnGo.kernel = OLD_KERNEL
    virtio_QnGo.initrd = OLD_INITRD

    virtio_QoGn = deepcopy(base_machine)
    virtio_QoGn.name = 'QoGn'
    virtio_QoGn.bootwait = 30
    virtio_QoGn.exe = OLD_QEMU

    virtio_QoGo = deepcopy(base_machine)
    virtio_QoGo.name = 'QoGo'
    virtio_QoGo.bootwait = 30
    virtio_QoGo.exe = OLD_QEMU
    virtio_QoGo.kernel = OLD_KERNEL
    virtio_QoGo.initrd = OLD_INITRD

    return (
        # e1000_QnGn_better,
        virtio_QnGn,
        virtio_QnGo,
        virtio_QoGn,
        virtio_QoGo)
Exemple #3
0
    def get_vms(self):
        qemu_e1000e = Qemu(disk_path=r"../vms/ubuntu-20.img",
                           guest_ip="10.10.0.43",
                           host_ip="10.10.0.44")
        qemu_e1000e.ethernet_dev = "e1000e"

        qemu_virtio = Qemu(disk_path=r"../vms/ubuntu-20.img",
                           guest_ip="10.10.0.43",
                           host_ip="10.10.0.44")
        qemu_virtio.ethernet_dev = Qemu.QEMU_VIRTIO

        qemu_virtio_drop_packets = QemuNG(disk_path=r"../vms/ubuntu-20.img",
                                          guest_ip="10.10.0.43",
                                          host_ip="10.10.0.44")
        qemu_virtio_drop_packets.ethernet_dev = Qemu.QEMU_VIRTIO
        qemu_virtio_drop_packets.e1000_options["NG_drop_packet"] = "on"

        qemu_virtio_latency = Qemu(disk_path=r"../vms/ubuntu-20.img",
                                   guest_ip="10.10.0.43",
                                   host_ip="10.10.0.44")
        qemu_virtio_latency.ethernet_dev = Qemu.QEMU_VIRTIO
        qemu_virtio_latency.qemu_config["latency_itr"] = 2

        qemu_e1000_baseline = Qemu(disk_path=r"../vms/ubuntu-20.img",
                                   guest_ip="10.10.0.43",
                                   host_ip="10.10.0.44")
        qemu_e1000_baseline.ethernet_dev = Qemu.QEMU_E1000

        qemu_e1000_arthur = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
                                         guest_ip="10.10.0.43",
                                         host_ip="10.10.0.44")
        qemu_e1000_arthur.qemu_config["latency_itr"] = 0
        qemu_e1000_arthur_nice = QemuE1000Max(
            disk_path=r"../vms/ubuntu-20.img",
            guest_ip="10.10.0.43",
            host_ip="10.10.0.44")
        qemu_e1000_arthur_nice.qemu_config["latency_itr"] = 0
        qemu_e1000_arthur_nice.is_io_thread_nice = True

        qemu_smart_itr = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
                                      guest_ip="10.10.0.43",
                                      host_ip="10.10.0.44")
        qemu_smart_itr.qemu_config["latency_itr"] = 1
        qemu_smart_itr.qemu_config["tx_packets_per_batch"] = 0
        qemu_smart_itr.qemu_config["dynamic_latency_mode"] = 0

        qemu_smart_itr2 = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
                                       guest_ip="10.10.0.43",
                                       host_ip="10.10.0.44")
        qemu_smart_itr2.qemu_config["latency_itr"] = 1
        qemu_smart_itr2.ethernet_dev = 'e1000-82545em'
        qemu_smart_itr2.addiotional_guest_command = 'sudo ethtool -C eth0 rx-usecs 3000'

        qemu_smart_itr3 = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
                                       guest_ip="10.10.0.43",
                                       host_ip="10.10.0.44")
        qemu_smart_itr3.qemu_config["latency_itr"] = 2
        qemu_smart_itr3.ethernet_dev = 'e1000-82545em'
        qemu_smart_itr3.addiotional_guest_command = 'sudo ethtool -C eth0 rx-usecs 3000'

        qemu_e1000_io_thread = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
                                            guest_ip="10.10.0.43",
                                            host_ip="10.10.0.44")
        qemu_e1000_io_thread.nic_additionals = ",iothread=iothread0"
        # qemu_smart_itr3.ethernet_dev = 'e1000-82545em'
        # qemu_smart_itr3.addiotional_guest_command = 'sudo ethtool -C eth0 rx-usecs 3000'
        # qemu_smart_itr3.qemu_config["drop_packet_every"] = 0

        #
        # qemu_e1000_no_new_improv = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
        #                                      guest_ip="10.10.0.43",
        #                                      host_ip="10.10.0.44")
        # qemu_e1000_no_new_improv.qemu_config["smart_interrupt_mitigation"] = 0
        # qemu_e1000_no_new_improv.qemu_config["drop_packet_every"] = 0
        #
        # qemu_virtio_drop = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
        #                                      guest_ip="10.10.0.43",
        #                                      host_ip="10.10.0.44")
        # qemu_virtio_drop.qemu_config["smart_interrupt_mitigation"] = 0
        # qemu_virtio_drop.qemu_config["drop_packet_every"] = 0
        # qemu_virtio_drop.ethernet_dev = Qemu.QEMU_VIRTIO
        #
        qemu_large_queue = QemuLargeRing(disk_path=r"../vms/ubuntu-20.img",
                                         guest_ip="10.10.0.43",
                                         host_ip="10.10.0.44")
        qemu_large_queue.is_io_thread_nice = True
        qemu_large_queue.qemu_config["drop_packet_every"] = 0

        qemu_large_queue_itr6 = QemuLargeRing(
            disk_path=r"../vms/ubuntu-20.img",
            guest_ip="10.10.0.43",
            host_ip="10.10.0.44")
        qemu_large_queue_itr6.is_io_thread_nice = True
        qemu_large_queue_itr6.qemu_config[
            "interrupt_mitigation_multiplier"] = 6
        qemu_large_queue_itr6.qemu_config["drop_packet_every"] = 0

        qemu_large_queue_batch_itr = QemuLargeRing(
            disk_path=r"../vms/ubuntu-20.img",
            guest_ip="10.10.0.43",
            host_ip="10.10.0.44")
        qemu_large_queue_batch_itr.is_io_thread_nice = True
        qemu_large_queue_batch_itr.io_nice = 4
        qemu_large_queue_batch_itr.qemu_config["interrupt_mode"] = 1
        qemu_large_queue_batch_itr.qemu_config["drop_packet_every"] = 0
        qemu_large_queue_batch_itr.qemu_config[
            "interrupt_mitigation_multiplier"] = 1000

        # qemu_e1000_best_itr = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
        #                                guest_ip="10.10.0.43",
        #                                host_ip="10.10.0.44")
        # qemu_e1000_best_itr.exe = r"/homes/bdaviv/repos/e1000-improv/qemu-2.2.0/build/x86_64-softmmu/qemu-system-x86_64"

        # self.qemu_virtio_1g = Qemu(disk_path=r"../vms/ubuntu-20.img",
        #                            guest_ip="10.10.0.43",
        #                            host_ip="10.10.0.44")
        # self.qemu_virtio_1g.ethernet_dev = Qemu.QEMU_VIRTIO
        # self.qemu_virtio_1g.mem=1024
        #
        # self.qemu_e1000_1g = Qemu(disk_path=r"../vms/ubuntu-20.img",
        #                           guest_ip="10.10.0.43",
        #                           host_ip="10.10.0.44")
        # self.qemu_e1000_1g.ethernet_dev = Qemu.QEMU_E1000
        # self.qemu_e1000_1g.mem=

        qemu_arthur_arthur = QemuE1000Max(disk_path=r"../vms/ubuntu-20.img",
                                          guest_ip="10.10.0.43",
                                          host_ip="10.10.0.44")
        qemu_arthur_arthur.ethernet_dev = qemu_arthur_arthur.QEMU_E1000
        qemu_arthur_arthur.qemu_additionals = "-enable-e1000-pcix"
        qemu_arthur_arthur.exe = "/home/bdaviv/repos/e1000-improv/qemu-arthur/build/x86_64-softmmu/qemu-system-x86_64"
        qemu_arthur_arthur.qemu_config = {
            "no_tso_loop_on": 1,
            "no_tcp_csum_on": 1,
            "tdt_handle_on_iothread": 1,
            "interrupt_mitigation_multiplier": 10,
            "drop_packet_every": 8000,
            "drop_packet_every_avg_packet_size_min": 25000,
            "drop_packet_every_avg_packet_size_max": 60000,
            "zero_copy_on": 1,
        }

        qemu_ng_max = QemuE1000NG(disk_path=r"../vms/ubuntu-20.img",
                                  guest_ip="10.10.0.43",
                                  host_ip="10.10.0.44")

        qemu_large_ring_ng = QemuLargeRingNG(disk_path=r"../vms/ubuntu-20.img",
                                             guest_ip="10.10.0.43",
                                             host_ip="10.10.0.44")

        qemu_ng_max_nocsum = QemuE1000NG(disk_path=r"../vms/ubuntu-20.img",
                                         guest_ip="10.10.0.43",
                                         host_ip="10.10.0.44")
        qemu_ng_max_nocsum.e1000_options["NG_no_checksum"] = "off"

        qemu_large_ring_ng_nocsum = QemuLargeRingNG(
            disk_path=r"../vms/ubuntu-20.img",
            guest_ip="10.10.0.43",
            host_ip="10.10.0.44")
        qemu_large_ring_ng_nocsum.e1000_options["NG_no_checksum"] = "off"
        qemu_virtio_nice = Qemu(disk_path=r"../vms/ubuntu-20.img",
                                guest_ip="10.10.0.43",
                                host_ip="10.10.0.44")
        qemu_virtio_nice.ethernet_dev = Qemu.QEMU_VIRTIO
        qemu_virtio_nice.is_io_thread_nice = True
        qemu_virtio_nice.io_nice = 5

        qemu_large_ring_ng_tso_offload = QemuLargeRingNG(
            disk_path=r"../vms/ubuntu-20.img",
            guest_ip="10.10.0.43",
            host_ip="10.10.0.44")
        qemu_large_ring_ng_tso_offload.e1000_options[
            "NG_tso_offloading"] = "on"

        return [
            # (qemu_virtio, "virtio-net_baseline"),
            (qemu_virtio_drop_packets, "qemu_virtio_drop_packets"),
            # (qemu_e1000e, "qemu_e1000e"),
            # (qemu_virtio_latency, "virito-net_smart_latency"), # working?
            # (qemu_virtio_nice, "qemu_virtio_nice"),

            # (qemu_e1000_no_new_improv, "qemu_e1000_no_new_improv"),

            # (qemu_e1000_baseline, "e1000_baseline"),
            # (qemu_e1000_newest, "qemu_e1000_newest"),

            # (qemu_e1000_arthur, "e1000_10x_arthur"),
            # (qemu_arthur_arthur, "e1000_arthur_version"),
            #     (qemu_e1000_arthur_nice, "qemu_e1000_arthur_nice"),
            # (qemu_smart_itr, "qemu_smart_latency1"),
            # (qemu_smart_itr2, "qemu_smart_latency2"),
            # (qemu_smart_itr3, "e1000_smart_latency"),  # working?
            # (qemu_e1000_io_thread, "qemu_io_thread"),

            # (qemu_e1000_no_new_improv, "qemu_e1000_no_new_improv")
            # (qemu_large_queue, "qemu_large_ring_nice"),
            # (qemu_large_queue_itr6, "qemu_large_ring_nice_itr6"),
            # (qemu_large_queue_batch_itr, "qemu_large_queue_batch_itr"),

            # (qemu_e1000_best_itr, "qemu_e1000_best_itr"),
            # (self.qemu_virtio_1g, "qemu_virtio_1G"),
            # (self.qemu_e1000_1g, "qemu_e1000_1G"),
            # (qemu_ng_max, "qemu_ng_max"),
            (qemu_large_ring_ng, "qemu_large_ring_ng"),
            # (qemu_ng_max_nocsum, "qemu_ng_max_nocsum"),
            # (qemu_large_ring_ng_nocsum, "qemu_large_ring_ng_nocsum"),
            # (qemu_large_ring_ng_tso_offload, "qemu_large_ring_ng_tso_offload"),
        ]
def main(directory=None, netperf_msg_size=None):
    trace_dir = get_dir(directory)

    if netperf_msg_size is None:
        netperf_msg_size = MSG_SIZE

    if ORIG_QEMU != TMP_QEMU:
        shutil.copyfile(ORIG_QEMU, TMP_QEMU)
    os.makedirs(trace_dir, exist_ok=True)

    netserver_start()
    logger.info("msg size = %s", netperf_msg_size)

    vm = QemuNG(disk_path=r"../vms/ubuntu-20.img",
                guest_ip="10.10.0.43",
                host_ip="10.10.0.44")
    vm.ethernet_dev = Qemu.QEMU_VIRTIO
    # vm.qemu_config["latency_itr"] = 0
    vm.e1000_options["NG_notify_batch"] = "on"
    vm.BOOTUP_WAIT = 15
    # vm.addiotional_guest_command = 'sudo ethtool -C eth0 rx-usecs 3000'

    local_trace = Trace(localRoot, os.path.join(trace_dir, "trace_host"))
    local_trace.setup()
    local_trace.set_buffer_size(100000)

    local_trace.enable_event("kvm/kvm_write_tsc_offset")
    # local_trace.enable_event("kvm/kvm_set_irq")
    # local_trace.enable_event("kvm/kvm_msi_set_irq")
    # local_trace.enable_event("kvm/kvm_inj_virq")
    # local_trace.enable_event("kvm/kvm_ioapic_set_irq")
    # local_trace.enable_event("kvm/kvm_exit")
    # local_trace.enable_event("kvm/kvm_entry")
    # local_trace.enable_event("kvm/kvm_userspace_exit")

    local_trace.set_event_filter(
        "sched/sched_switch", r'prev_comm ~ "*qemu*" || next_comm ~ "*qemu*"')
    # local_trace.enable_event("sched/sched_switch")

    local_trace.set_event_filter("sched/sched_wakeup", '\"comm~*qemu*\"')
    # local_trace.enable_event("sched/sched_wakeup")

    local_trace.set_event_filter("sched/sched_waking", '\"comm~*qemu*\"')
    # local_trace.enable_event("sched/sched_waking")

    # objdump -tT /tmp/qemu-system-x86_64 |grep .text|grep virtio_queue_notify_vq
    ## local_trace.uprobe_add("p:virtio_queue_notify_vq /tmp/qemu-system-x86_64:0x1bfba6")
    # local_trace.uprobe_add_event("p", "virtio_queue_notify_vq", TMP_QEMU, "virtio_queue_notify_vq")
    # objdump -tT /tmp/qemu-system-x86_64 |grep .text|grep kvm_vcpu_ioctl
    ## local_trace.uprobe_add("p:kvm_vcpu_ioctl /tmp/qemu-system-x86_64:0x16a886 cmd=%si")
    # local_trace.uprobe_add_event("p", "kvm_vcpu_ioctl", TMP_QEMU, "kvm_vcpu_ioctl", "cmd=%si")

    # local_trace.uprobe_add_event("p", "tap_write_packet", TMP_QEMU, "tap_write_packet")
    # local_trace.uprobe_add_event("p", "tap_recv_packets", TMP_QEMU, "tap_send")
    # local_trace.uprobe_add_event("r", "tap_recv_packets_end", TMP_QEMU, "tap_send")
    # local_trace.uprobe_add_event("p", "virtio_irq", TMP_QEMU, "virtio_irq")

    # local_trace.uprobe_add_event("p", "virtio_queue_notify_vq", TMP_QEMU, "virtio_queue_notify_vq")
    # local_trace.uprobe_add_event("p", "e1000_set_kick", TMP_QEMU, "e1000_set_kick")
    # local_trace.uprobe_add_event("p", "e1000_receive_batch_finished", TMP_QEMU, "e1000_receive_batch_finished")
    local_trace.uprobe_enable()

    local_trace.empty_trace()
    local_trace.trace_on()
    # local_trace.trace_to_local_file()

    vm.setup()
    vm.run()

    remote_trace = Trace(vm.root, os.path.join(trace_dir, "trace_guest"))
    remote_trace.setup()
    remote_trace.set_buffer_size(100000)
    # remote_trace.enable_event("tcp")
    # remote_trace.enable_event("net")
    # remote_trace.enable_event("irq")
    # remote_trace.enable_event("irq_vectors")
    # remote_trace.enable_event("napi")
    # remote_trace.enable_event("power/cpu_idle")
    # remote_trace.enable_event("syscalls/sys_enter_sendto")
    # remote_trace.enable_event("syscalls/sys_enter_recvfrom")
    remote_trace.enable_event("net/net_dev_xmit")

    # remote_trace.enable_event("irq/irq_handler_entry")
    # remote_trace.enable_event("e1000/e1000_pre_mem_op")
    # remote_trace.enable_event("e1000/e1000_post_mem_op")
    # remote_trace.enable_event("e1000/e1000_set_tdt")
    # remote_trace.enable_event("e1000/e1000_post_set_tdt")

    # remote_trace.kprobe_add("p:notify_begin virtqueue_kick")
    # remote_trace.kprobe_add("r:notify_end virtqueue_kick")

    # remote_trace.kprobe_enable()
    remote_trace.trace_on()

    netperf = NetPerfTCP(None, runtime=2)
    run_command_async("tcpdump -i tap0 -s 100 -w {} -W 1 -G 7".format(
        os.path.join(trace_dir, "virtio.cap")))
    remote_trace.trace_marker(TRACE_BEGIN_MSG)
    netperf_perf = netperf.run_netperf(vm, msg_size=netperf_msg_size)
    remote_trace.trace_marker(TRACE_END_MSG)
    print("Netperf performance: %s" % (netperf_perf, ))
    logger.info("Netperf performance: %s", netperf_perf)

    remote_trace.trace_off()
    remote_trace.disable_all_events()
    local_trace.trace_off()
    local_trace.disable_all_events()

    netperf_perf = netperf.run_netperf(vm, msg_size=netperf_msg_size)
    print("Base Netperf performance: %s" % (netperf_perf, ))
    logger.info("Base Netperf performance: %s", netperf_perf)

    local_trace.read_trace_once(to_file=True)
    remote_trace.read_trace_once(to_file=True)
    # local_trace.trace_to_local_file_stop()

    local_trace.disable_all_events()

    # input("Press Enter to exit")
    vm.teardown()
    netserver_stop()