scripts/compare-machine-types.py - qemu - Git at Google

 #!/usr/bin/env python3
 #
 # Script to compare machine type compatible properties (include/hw/core/boards.h).
 # compat_props are applied to the driver during initialization to change
 # default values, for instance, to maintain compatibility.
 # This script constructs table with machines and values of their compat_props
 # to compare and to find places for improvements or places with bugs. If
 # during the comparison, some machine type doesn't have a property (it is in
 # the comparison table because another machine type has it), then the
 # appropriate method will be used to obtain the default value of this driver
 # property via qmp command (e.g. query-cpu-model-expansion for x86_64-cpu).
 # These methods are defined below in qemu_property_methods.
 #
 # Copyright (c) Yandex Technologies LLC, 2023
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation; either version 2 of the License, or
 # (at your option) any later version.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
 # along with this program; if not, see <http://www.gnu.org/licenses/>.

 import sys
 from argparse import ArgumentParser, RawTextHelpFormatter, Namespace
 import pandas as pd
 from contextlib import ExitStack
 from typing import Optional, List, Dict, Generator, Tuple, Union, Any, Set

 try:
     from qemu.machine import QEMUMachine
 except ModuleNotFoundError as exc:
     print(f"Module '{exc.name}' not found.", file=sys.stderr)
     print(f"Try $builddir/run {' '.join(sys.argv)}", file=sys.stderr)
     sys.exit(1)


 default_qemu_args = '-enable-kvm -machine none'
 default_qemu_binary = 'build/qemu-system-x86_64'


 # Methods for gettig the right values of drivers properties
 #
 # Use these methods as a 'whitelist' and add entries only if necessary. It's
 # important to be stable and predictable in analysis and tests.
 # Be careful:
 # * Class must be inherited from 'QEMUObject' and used in new_driver()
 # * Class has to implement get_prop method in order to get values
 # * Specialization always wins (with the given classes for 'device' and
 #   'x86_64-cpu', method of 'x86_64-cpu' will be used for '486-x86_64-cpu')

 class Driver():
     def __init__(self, vm: QEMUMachine, name: str, abstract: bool) -> None:
         self.vm = vm
         self.name = name
         self.abstract = abstract
         self.parent: Optional[Driver] = None
         self.property_getter: Optional[Driver] = None

     def get_prop(self, driver: str, prop: str) -> str:
         if self.property_getter:
             return self.property_getter.get_prop(driver, prop)
         else:
             return 'Unavailable method'

     def is_child_of(self, parent: 'Driver') -> bool:
         """Checks whether self is (recursive) child of @parent"""
         cur_parent = self.parent
         while cur_parent:
             if cur_parent is parent:
                 return True
             cur_parent = cur_parent.parent

         return False

     def set_implementations(self, implementations: List['Driver']) -> None:
         self.implementations = implementations


 class QEMUObject(Driver):
     def __init__(self, vm: QEMUMachine, name: str) -> None:
         super().__init__(vm, name, True)

     def set_implementations(self, implementations: List[Driver]) -> None:
         self.implementations = implementations

         # each implementation of the abstract driver has to use property getter
         # of this abstract driver unless it has specialization. (e.g. having
         # 'device' and 'x86_64-cpu', property getter of 'x86_64-cpu' will be
         # used for '486-x86_64-cpu')
         for impl in implementations:
             if not impl.property_getter or\
                     self.is_child_of(impl.property_getter):
                 impl.property_getter = self


 class QEMUDevice(QEMUObject):
     def __init__(self, vm: QEMUMachine) -> None:
         super().__init__(vm, 'device')
         self.cached: Dict[str, List[Dict[str, Any]]] = {}

     def get_prop(self, driver: str, prop_name: str) -> str:
         if driver not in self.cached:
             self.cached[driver] = self.vm.cmd('device-list-properties',
                                               typename=driver)
         for prop in self.cached[driver]:
             if prop['name'] == prop_name:
                 return str(prop.get('default-value', 'No default value'))

         return 'Unknown property'


 class QEMUx86CPU(QEMUObject):
     def __init__(self, vm: QEMUMachine) -> None:
         super().__init__(vm, 'x86_64-cpu')
         self.cached: Dict[str, Dict[str, Any]] = {}

     def get_prop(self, driver: str, prop_name: str) -> str:
         if not driver.endswith('-x86_64-cpu'):
             return 'Wrong x86_64-cpu name'

         # crop last 11 chars '-x86_64-cpu'
         name = driver[:-11]
         if name not in self.cached:
             self.cached[name] = self.vm.cmd(
                 'query-cpu-model-expansion', type='full',
                 model={'name': name})['model']['props']
         return str(self.cached[name].get(prop_name, 'Unknown property'))


 # Now it's stub, because all memory_backend types don't have default values
 # but this behaviour can be changed
 class QEMUMemoryBackend(QEMUObject):
     def __init__(self, vm: QEMUMachine) -> None:
         super().__init__(vm, 'memory-backend')
         self.cached: Dict[str, List[Dict[str, Any]]] = {}

     def get_prop(self, driver: str, prop_name: str) -> str:
         if driver not in self.cached:
             self.cached[driver] = self.vm.cmd('qom-list-properties',
                                               typename=driver)
         for prop in self.cached[driver]:
             if prop['name'] == prop_name:
                 return str(prop.get('default-value', 'No default value'))

         return 'Unknown property'


 def new_driver(vm: QEMUMachine, name: str, is_abstr: bool) -> Driver:
     if name == 'object':
         return QEMUObject(vm, 'object')
     elif name == 'device':
         return QEMUDevice(vm)
     elif name == 'x86_64-cpu':
         return QEMUx86CPU(vm)
     elif name == 'memory-backend':
         return QEMUMemoryBackend(vm)
     else:
         return Driver(vm, name, is_abstr)
 # End of methods definition


 class VMPropertyGetter:
     """It implements the relationship between drivers and how to get their
     properties"""
     def __init__(self, vm: QEMUMachine) -> None:
         self.drivers: Dict[str, Driver] = {}

         qom_all_types = vm.cmd('qom-list-types', abstract=True)
         self.drivers = {t['name']: new_driver(vm, t['name'],
                                               t.get('abstract', False))
                         for t in qom_all_types}

         for t in qom_all_types:
             drv = self.drivers[t['name']]
             if 'parent' in t:
                 drv.parent = self.drivers[t['parent']]

         for drv in self.drivers.values():
             imps = vm.cmd('qom-list-types', implements=drv.name)
             # only implementations inherit property getter
             drv.set_implementations([self.drivers[imp['name']]
                                      for imp in imps])

     def get_prop(self, driver: str, prop: str) -> str:
         # wrong driver name or disabled in config driver
         try:
             drv = self.drivers[driver]
         except KeyError:
             return 'Unavailable driver'

         assert not drv.abstract

         return drv.get_prop(driver, prop)

     def get_implementations(self, driver: str) -> List[str]:
         return [impl.name for impl in self.drivers[driver].implementations]


 class Machine:
     """A short QEMU machine type description. It contains only processed
     compat_props (properties of abstract classes are applied to its
     implementations)
     """
     # raw_mt_dict - dict produced by `query-machines`
     def __init__(self, raw_mt_dict: Dict[str, Any],
                  qemu_drivers: VMPropertyGetter) -> None:
         self.name = raw_mt_dict['name']
         self.compat_props: Dict[str, Any] = {}
         # properties are applied sequentially and can rewrite values like in
         # QEMU. Also it has to resolve class relationships to apply appropriate
         # values from abstract class to all implementations
         for prop in raw_mt_dict['compat-props']:
             driver = prop['qom-type']
             try:
                 # implementation adds only itself, abstract class adds
                 #  lementation (abstract classes are uninterestiong)
                 impls = qemu_drivers.get_implementations(driver)
                 for impl in impls:
                     if impl not in self.compat_props:
                         self.compat_props[impl] = {}
                     self.compat_props[impl][prop['property']] = prop['value']
             except KeyError:
                 # QEMU doesn't know this driver thus it has to be saved
                 if driver not in self.compat_props:
                     self.compat_props[driver] = {}
                 self.compat_props[driver][prop['property']] = prop['value']


 class Configuration():
     """Class contains all necessary components to generate table and is used
     to compare different binaries"""
     def __init__(self, vm: QEMUMachine,
                  req_mt: List[str], all_mt: bool) -> None:
         self._vm = vm
         self._binary = vm.binary
         self._qemu_args = args.qemu_args.split(' ')

         self._qemu_drivers = VMPropertyGetter(vm)
         self.req_mt = get_req_mt(self._qemu_drivers, vm, req_mt, all_mt)

     def get_implementations(self, driver_name: str) -> List[str]:
         return self._qemu_drivers.get_implementations(driver_name)

     def get_table(self, req_props: List[Tuple[str, str]]) -> pd.DataFrame:
         table: List[pd.DataFrame] = []
         for mt in self.req_mt:
             name = f'{self._binary}\n{mt.name}'
             column = []
             for driver, prop in req_props:
                 try:
                     # values from QEMU machine type definitions
                     column.append(mt.compat_props[driver][prop])
                 except KeyError:
                     # values from QEMU type definitions
                     column.append(self._qemu_drivers.get_prop(driver, prop))
             table.append(pd.DataFrame({name: column}))

         return pd.concat(table, axis=1)


 script_desc = """Script to compare machine types (their compat_props).

 Examples:
 * save info about all machines:  ./scripts/compare-machine-types.py --all \
 --format csv --raw > table.csv
 * compare machines: ./scripts/compare-machine-types.py --mt pc-q35-2.12 \
 pc-q35-3.0
 * compare binaries and machines: ./scripts/compare-machine-types.py \
 --mt pc-q35-6.2 pc-q35-7.0 --qemu-binary build/qemu-system-x86_64 \
 build/qemu-exp
   ╒════════════╤══════════════════════════╤════════════════════════════\
 ╤════════════════════════════╤══════════════════╤══════════════════╕
   │   Driver   │         Property         │  build/qemu-system-x86_64  \
 │  build/qemu-system-x86_64  │  build/qemu-exp  │  build/qemu-exp  │
   │            │                          │         pc-q35-6.2         \
 │         pc-q35-7.0         │    pc-q35-6.2    │    pc-q35-7.0    │
   ╞════════════╪══════════════════════════╪════════════════════════════\
 ╪════════════════════════════╪══════════════════╪══════════════════╡
   │  PIIX4_PM  │ x-not-migrate-acpi-index │            True            \
 │           False            │      False       │      False       │
   ├────────────┼──────────────────────────┼────────────────────────────\
 ┼────────────────────────────┼──────────────────┼──────────────────┤
   │ virtio-mem │  unplugged-inaccessible  │           False            \
 │            auto            │      False       │       auto       │
   ╘════════════╧══════════════════════════╧════════════════════════════\
 ╧════════════════════════════╧══════════════════╧══════════════════╛

 If a property from QEMU machine defintion applies to an abstract class (e.g. \
 x86_64-cpu) this script will compare all implementations of this class.

 "Unavailable method" - means that this script doesn't know how to get \
 default values of the driver. To add method use the construction described \
 at the top of the script.
 "Unavailable driver" - means that this script doesn't know this driver. \
 For instance, this can happen if you configure QEMU without this device or \
 if machine type definition has error.
 "No default value" - means that the appropriate method can't get the default \
 value and most likely that this property doesn't have it.
 "Unknown property" - means that the appropriate method can't find property \
 with this name."""


 def parse_args() -> Namespace:
     parser = ArgumentParser(formatter_class=RawTextHelpFormatter,
                             description=script_desc)
     parser.add_argument('--format', choices=['human-readable', 'json', 'csv'],
                         default='human-readable',
                         help='returns table in json format')
     parser.add_argument('--raw', action='store_true',
                         help='prints ALL defined properties without value '
                              'transformation. By default, only rows '
                              'with different values will be printed and '
                              'values will be transformed(e.g. "on" -> True)')
     parser.add_argument('--qemu-args', default=default_qemu_args,
                         help='command line to start qemu. '
                              f'Default: "{default_qemu_args}"')
     parser.add_argument('--qemu-binary', nargs="*", type=str,
                         default=[default_qemu_binary],
                         help='list of qemu binaries that will be compared. '
                              f'Deafult: {default_qemu_binary}')

     mt_args_group = parser.add_mutually_exclusive_group()
     mt_args_group.add_argument('--all', action='store_true',
                                help='prints all available machine types (list '
                                     'of machine types will be ignored)')
     mt_args_group.add_argument('--mt', nargs="*", type=str,
                                help='list of Machine Types '
                                     'that will be compared')

     return parser.parse_args()


 def mt_comp(mt: Machine) -> Tuple[str, int, int, int]:
     """Function to compare and sort machine by names.
     It returns socket_name, major version, minor version, revision"""
     # none, microvm, x-remote and etc.
     if '-' not in mt.name or '.' not in mt.name:
         return mt.name, 0, 0, 0

     socket, ver = mt.name.rsplit('-', 1)
     ver_list = list(map(int, ver.split('.', 2)))
     ver_list += [0] * (3 - len(ver_list))
     return socket, ver_list[0], ver_list[1], ver_list[2]


 def get_mt_definitions(qemu_drivers: VMPropertyGetter,
                        vm: QEMUMachine) -> List[Machine]:
     """Constructs list of machine definitions (primarily compat_props) via
     info from QEMU"""
     raw_mt_defs = vm.cmd('query-machines', compat_props=True)
     mt_defs = []
     for raw_mt in raw_mt_defs:
         mt_defs.append(Machine(raw_mt, qemu_drivers))

     mt_defs.sort(key=mt_comp)
     return mt_defs


 def get_req_mt(qemu_drivers: VMPropertyGetter, vm: QEMUMachine,
                req_mt: Optional[List[str]], all_mt: bool) -> List[Machine]:
     """Returns list of requested by user machines"""
     mt_defs = get_mt_definitions(qemu_drivers, vm)
     if all_mt:
         return mt_defs

     if req_mt is None:
         print('Enter machine types for comparision')
         exit(0)

     matched_mt = []
     for mt in mt_defs:
         if mt.name in req_mt:
             matched_mt.append(mt)

     return matched_mt


 def get_affected_props(configs: List[Configuration]) -> Generator[Tuple[str,
                                                                         str],
                                                                   None, None]:
     """Helps to go through all affected in machine definitions drivers
     and properties"""
     driver_props: Dict[str, Set[Any]] = {}
     for config in configs:
         for mt in config.req_mt:
             compat_props = mt.compat_props
             for driver, prop in compat_props.items():
                 if driver not in driver_props:
                     driver_props[driver] = set()
                 driver_props[driver].update(prop.keys())

     for driver, props in sorted(driver_props.items()):
         for prop in sorted(props):
             yield driver, prop


 def transform_value(value: str) -> Union[str, bool]:
     true_list = ['true', 'on']
     false_list = ['false', 'off']

     out = value.lower()

     if out in true_list:
         return True

     if out in false_list:
         return False

     return value


 def simplify_table(table: pd.DataFrame) -> pd.DataFrame:
     """transforms values to make it easier to compare it and drops rows
     with the same values for all columns"""

     table = table.map(transform_value)

     return table[~table.iloc[:, 3:].eq(table.iloc[:, 2], axis=0).all(axis=1)]


 # constructs table in the format:
 #
 # Driver  | Property  | binary1  | binary1  | ...
 #         |           | machine1 | machine2 | ...
 # ------------------------------------------------------ ...
 # driver1 | property1 |  value1  |  value2  | ...
 # driver1 | property2 |  value3  |  value4  | ...
 # driver2 | property3 |  value5  |  value6  | ...
 #   ...   |    ...    |   ...    |   ...    | ...
 #
 def fill_prop_table(configs: List[Configuration],
                     is_raw: bool) -> pd.DataFrame:
     req_props = list(get_affected_props(configs))
     if not req_props:
         print('No drivers to compare. Check machine names')
         exit(0)

     driver_col, prop_col = tuple(zip(*req_props))
     table = [pd.DataFrame({'Driver': driver_col}),
              pd.DataFrame({'Property': prop_col})]

     table.extend([config.get_table(req_props) for config in configs])

     df_table = pd.concat(table, axis=1)

     if is_raw:
         return df_table

     return simplify_table(df_table)


 def print_table(table: pd.DataFrame, table_format: str) -> None:
     if table_format == 'json':
         print(comp_table.to_json())
     elif table_format == 'csv':
         print(comp_table.to_csv())
     else:
         print(comp_table.to_markdown(index=False, stralign='center',
                                      colalign=('center',), headers='keys',
                                      tablefmt='fancy_grid',
                                      disable_numparse=True))


 if __name__ == '__main__':
     args = parse_args()
     with ExitStack() as stack:
         vms = [stack.enter_context(QEMUMachine(binary=binary, qmp_timer=15,
                args=args.qemu_args.split(' '))) for binary in args.qemu_binary]

         configurations = []
         for vm in vms:
             vm.launch()
             configurations.append(Configuration(vm, args.mt, args.all))

         comp_table = fill_prop_table(configurations, args.raw)
         if not comp_table.empty:
             print_table(comp_table, args.format)
	#!/usr/bin/env python3
	#
	# Script to compare machine type compatible properties (include/hw/core/boards.h).
	# compat_props are applied to the driver during initialization to change
	# default values, for instance, to maintain compatibility.
	# This script constructs table with machines and values of their compat_props
	# to compare and to find places for improvements or places with bugs. If
	# during the comparison, some machine type doesn't have a property (it is in
	# the comparison table because another machine type has it), then the
	# appropriate method will be used to obtain the default value of this driver
	# property via qmp command (e.g. query-cpu-model-expansion for x86_64-cpu).
	# These methods are defined below in qemu_property_methods.
	#
	# Copyright (c) Yandex Technologies LLC, 2023
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 2 of the License, or
	# (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program; if not, see <http://www.gnu.org/licenses/>.

	import sys
	from argparse import ArgumentParser, RawTextHelpFormatter, Namespace
	import pandas as pd
	from contextlib import ExitStack
	from typing import Optional, List, Dict, Generator, Tuple, Union, Any, Set

	try:
	from qemu.machine import QEMUMachine
	except ModuleNotFoundError as exc:
	print(f"Module '{exc.name}' not found.", file=sys.stderr)
	print(f"Try $builddir/run {' '.join(sys.argv)}", file=sys.stderr)
	sys.exit(1)


	default_qemu_args = '-enable-kvm -machine none'
	default_qemu_binary = 'build/qemu-system-x86_64'


	# Methods for gettig the right values of drivers properties
	#
	# Use these methods as a 'whitelist' and add entries only if necessary. It's
	# important to be stable and predictable in analysis and tests.
	# Be careful:
	# * Class must be inherited from 'QEMUObject' and used in new_driver()
	# * Class has to implement get_prop method in order to get values
	# * Specialization always wins (with the given classes for 'device' and
	# 'x86_64-cpu', method of 'x86_64-cpu' will be used for '486-x86_64-cpu')

	class Driver():
	def __init__(self, vm: QEMUMachine, name: str, abstract: bool) -> None:
	self.vm = vm
	self.name = name
	self.abstract = abstract
	self.parent: Optional[Driver] = None
	self.property_getter: Optional[Driver] = None

	def get_prop(self, driver: str, prop: str) -> str:
	if self.property_getter:
	return self.property_getter.get_prop(driver, prop)
	else:
	return 'Unavailable method'

	def is_child_of(self, parent: 'Driver') -> bool:
	"""Checks whether self is (recursive) child of @parent"""
	cur_parent = self.parent
	while cur_parent:
	if cur_parent is parent:
	return True
	cur_parent = cur_parent.parent

	return False

	def set_implementations(self, implementations: List['Driver']) -> None:
	self.implementations = implementations


	class QEMUObject(Driver):
	def __init__(self, vm: QEMUMachine, name: str) -> None:
	super().__init__(vm, name, True)

	def set_implementations(self, implementations: List[Driver]) -> None:
	self.implementations = implementations

	# each implementation of the abstract driver has to use property getter
	# of this abstract driver unless it has specialization. (e.g. having
	# 'device' and 'x86_64-cpu', property getter of 'x86_64-cpu' will be
	# used for '486-x86_64-cpu')
	for impl in implementations:
	if not impl.property_getter or\
	self.is_child_of(impl.property_getter):
	impl.property_getter = self


	class QEMUDevice(QEMUObject):
	def __init__(self, vm: QEMUMachine) -> None:
	super().__init__(vm, 'device')
	self.cached: Dict[str, List[Dict[str, Any]]] = {}

	def get_prop(self, driver: str, prop_name: str) -> str:
	if driver not in self.cached:
	self.cached[driver] = self.vm.cmd('device-list-properties',
	typename=driver)
	for prop in self.cached[driver]:
	if prop['name'] == prop_name:
	return str(prop.get('default-value', 'No default value'))

	return 'Unknown property'


	class QEMUx86CPU(QEMUObject):
	def __init__(self, vm: QEMUMachine) -> None:
	super().__init__(vm, 'x86_64-cpu')
	self.cached: Dict[str, Dict[str, Any]] = {}

	def get_prop(self, driver: str, prop_name: str) -> str:
	if not driver.endswith('-x86_64-cpu'):
	return 'Wrong x86_64-cpu name'

	# crop last 11 chars '-x86_64-cpu'
	name = driver[:-11]
	if name not in self.cached:
	self.cached[name] = self.vm.cmd(
	'query-cpu-model-expansion', type='full',
	model={'name': name})['model']['props']
	return str(self.cached[name].get(prop_name, 'Unknown property'))


	# Now it's stub, because all memory_backend types don't have default values
	# but this behaviour can be changed
	class QEMUMemoryBackend(QEMUObject):
	def __init__(self, vm: QEMUMachine) -> None:
	super().__init__(vm, 'memory-backend')
	self.cached: Dict[str, List[Dict[str, Any]]] = {}

	def get_prop(self, driver: str, prop_name: str) -> str:
	if driver not in self.cached:
	self.cached[driver] = self.vm.cmd('qom-list-properties',
	typename=driver)
	for prop in self.cached[driver]:
	if prop['name'] == prop_name:
	return str(prop.get('default-value', 'No default value'))

	return 'Unknown property'


	def new_driver(vm: QEMUMachine, name: str, is_abstr: bool) -> Driver:
	if name == 'object':
	return QEMUObject(vm, 'object')
	elif name == 'device':
	return QEMUDevice(vm)
	elif name == 'x86_64-cpu':
	return QEMUx86CPU(vm)
	elif name == 'memory-backend':
	return QEMUMemoryBackend(vm)
	else:
	return Driver(vm, name, is_abstr)
	# End of methods definition


	class VMPropertyGetter:
	"""It implements the relationship between drivers and how to get their
	properties"""
	def __init__(self, vm: QEMUMachine) -> None:
	self.drivers: Dict[str, Driver] = {}

	qom_all_types = vm.cmd('qom-list-types', abstract=True)
	self.drivers = {t['name']: new_driver(vm, t['name'],
	t.get('abstract', False))
	for t in qom_all_types}

	for t in qom_all_types:
	drv = self.drivers[t['name']]
	if 'parent' in t:
	drv.parent = self.drivers[t['parent']]

	for drv in self.drivers.values():
	imps = vm.cmd('qom-list-types', implements=drv.name)
	# only implementations inherit property getter
	drv.set_implementations([self.drivers[imp['name']]
	for imp in imps])

	def get_prop(self, driver: str, prop: str) -> str:
	# wrong driver name or disabled in config driver
	try:
	drv = self.drivers[driver]
	except KeyError:
	return 'Unavailable driver'

	assert not drv.abstract

	return drv.get_prop(driver, prop)

	def get_implementations(self, driver: str) -> List[str]:
	return [impl.name for impl in self.drivers[driver].implementations]


	class Machine:
	"""A short QEMU machine type description. It contains only processed
	compat_props (properties of abstract classes are applied to its
	implementations)
	"""
	# raw_mt_dict - dict produced by `query-machines`
	def __init__(self, raw_mt_dict: Dict[str, Any],
	qemu_drivers: VMPropertyGetter) -> None:
	self.name = raw_mt_dict['name']
	self.compat_props: Dict[str, Any] = {}
	# properties are applied sequentially and can rewrite values like in
	# QEMU. Also it has to resolve class relationships to apply appropriate
	# values from abstract class to all implementations
	for prop in raw_mt_dict['compat-props']:
	driver = prop['qom-type']
	try:
	# implementation adds only itself, abstract class adds
	# lementation (abstract classes are uninterestiong)
	impls = qemu_drivers.get_implementations(driver)
	for impl in impls:
	if impl not in self.compat_props:
	self.compat_props[impl] = {}
	self.compat_props[impl][prop['property']] = prop['value']
	except KeyError:
	# QEMU doesn't know this driver thus it has to be saved
	if driver not in self.compat_props:
	self.compat_props[driver] = {}
	self.compat_props[driver][prop['property']] = prop['value']


	class Configuration():
	"""Class contains all necessary components to generate table and is used
	to compare different binaries"""
	def __init__(self, vm: QEMUMachine,
	req_mt: List[str], all_mt: bool) -> None:
	self._vm = vm
	self._binary = vm.binary
	self._qemu_args = args.qemu_args.split(' ')

	self._qemu_drivers = VMPropertyGetter(vm)
	self.req_mt = get_req_mt(self._qemu_drivers, vm, req_mt, all_mt)

	def get_implementations(self, driver_name: str) -> List[str]:
	return self._qemu_drivers.get_implementations(driver_name)

	def get_table(self, req_props: List[Tuple[str, str]]) -> pd.DataFrame:
	table: List[pd.DataFrame] = []
	for mt in self.req_mt:
	name = f'{self._binary}\n{mt.name}'
	column = []
	for driver, prop in req_props:
	try:
	# values from QEMU machine type definitions
	column.append(mt.compat_props[driver][prop])
	except KeyError:
	# values from QEMU type definitions
	column.append(self._qemu_drivers.get_prop(driver, prop))
	table.append(pd.DataFrame({name: column}))

	return pd.concat(table, axis=1)


	script_desc = """Script to compare machine types (their compat_props).

	Examples:
	* save info about all machines: ./scripts/compare-machine-types.py --all \
	--format csv --raw > table.csv
	* compare machines: ./scripts/compare-machine-types.py --mt pc-q35-2.12 \
	pc-q35-3.0
	* compare binaries and machines: ./scripts/compare-machine-types.py \
	--mt pc-q35-6.2 pc-q35-7.0 --qemu-binary build/qemu-system-x86_64 \
	build/qemu-exp
	╒════════════╤══════════════════════════╤════════════════════════════\
	╤════════════════════════════╤══════════════════╤══════════════════╕
	│ Driver │ Property │ build/qemu-system-x86_64 \
	│ build/qemu-system-x86_64 │ build/qemu-exp │ build/qemu-exp │
	│ │ │ pc-q35-6.2 \
	│ pc-q35-7.0 │ pc-q35-6.2 │ pc-q35-7.0 │
	╞════════════╪══════════════════════════╪════════════════════════════\
	╪════════════════════════════╪══════════════════╪══════════════════╡
	│ PIIX4_PM │ x-not-migrate-acpi-index │ True \
	│ False │ False │ False │
	├────────────┼──────────────────────────┼────────────────────────────\
	┼────────────────────────────┼──────────────────┼──────────────────┤
	│ virtio-mem │ unplugged-inaccessible │ False \
	│ auto │ False │ auto │
	╘════════════╧══════════════════════════╧════════════════════════════\
	╧════════════════════════════╧══════════════════╧══════════════════╛

	If a property from QEMU machine defintion applies to an abstract class (e.g. \
	x86_64-cpu) this script will compare all implementations of this class.

	"Unavailable method" - means that this script doesn't know how to get \
	default values of the driver. To add method use the construction described \
	at the top of the script.
	"Unavailable driver" - means that this script doesn't know this driver. \
	For instance, this can happen if you configure QEMU without this device or \
	if machine type definition has error.
	"No default value" - means that the appropriate method can't get the default \
	value and most likely that this property doesn't have it.
	"Unknown property" - means that the appropriate method can't find property \
	with this name."""


	def parse_args() -> Namespace:
	parser = ArgumentParser(formatter_class=RawTextHelpFormatter,
	description=script_desc)
	parser.add_argument('--format', choices=['human-readable', 'json', 'csv'],
	default='human-readable',
	help='returns table in json format')
	parser.add_argument('--raw', action='store_true',
	help='prints ALL defined properties without value '
	'transformation. By default, only rows '
	'with different values will be printed and '
	'values will be transformed(e.g. "on" -> True)')
	parser.add_argument('--qemu-args', default=default_qemu_args,
	help='command line to start qemu. '
	f'Default: "{default_qemu_args}"')
	parser.add_argument('--qemu-binary', nargs="*", type=str,
	default=[default_qemu_binary],
	help='list of qemu binaries that will be compared. '
	f'Deafult: {default_qemu_binary}')

	mt_args_group = parser.add_mutually_exclusive_group()
	mt_args_group.add_argument('--all', action='store_true',
	help='prints all available machine types (list '
	'of machine types will be ignored)')
	mt_args_group.add_argument('--mt', nargs="*", type=str,
	help='list of Machine Types '
	'that will be compared')

	return parser.parse_args()


	def mt_comp(mt: Machine) -> Tuple[str, int, int, int]:
	"""Function to compare and sort machine by names.
	It returns socket_name, major version, minor version, revision"""
	# none, microvm, x-remote and etc.
	if '-' not in mt.name or '.' not in mt.name:
	return mt.name, 0, 0, 0

	socket, ver = mt.name.rsplit('-', 1)
	ver_list = list(map(int, ver.split('.', 2)))
	ver_list += [0] * (3 - len(ver_list))
	return socket, ver_list[0], ver_list[1], ver_list[2]


	def get_mt_definitions(qemu_drivers: VMPropertyGetter,
	vm: QEMUMachine) -> List[Machine]:
	"""Constructs list of machine definitions (primarily compat_props) via
	info from QEMU"""
	raw_mt_defs = vm.cmd('query-machines', compat_props=True)
	mt_defs = []
	for raw_mt in raw_mt_defs:
	mt_defs.append(Machine(raw_mt, qemu_drivers))

	mt_defs.sort(key=mt_comp)
	return mt_defs


	def get_req_mt(qemu_drivers: VMPropertyGetter, vm: QEMUMachine,
	req_mt: Optional[List[str]], all_mt: bool) -> List[Machine]:
	"""Returns list of requested by user machines"""
	mt_defs = get_mt_definitions(qemu_drivers, vm)
	if all_mt:
	return mt_defs

	if req_mt is None:
	print('Enter machine types for comparision')
	exit(0)

	matched_mt = []
	for mt in mt_defs:
	if mt.name in req_mt:
	matched_mt.append(mt)

	return matched_mt


	def get_affected_props(configs: List[Configuration]) -> Generator[Tuple[str,
	str],
	None, None]:
	"""Helps to go through all affected in machine definitions drivers
	and properties"""
	driver_props: Dict[str, Set[Any]] = {}
	for config in configs:
	for mt in config.req_mt:
	compat_props = mt.compat_props
	for driver, prop in compat_props.items():
	if driver not in driver_props:
	driver_props[driver] = set()
	driver_props[driver].update(prop.keys())

	for driver, props in sorted(driver_props.items()):
	for prop in sorted(props):
	yield driver, prop


	def transform_value(value: str) -> Union[str, bool]:
	true_list = ['true', 'on']
	false_list = ['false', 'off']

	out = value.lower()

	if out in true_list:
	return True

	if out in false_list:
	return False

	return value


	def simplify_table(table: pd.DataFrame) -> pd.DataFrame:
	"""transforms values to make it easier to compare it and drops rows
	with the same values for all columns"""

	table = table.map(transform_value)

	return table[~table.iloc[:, 3:].eq(table.iloc[:, 2], axis=0).all(axis=1)]


	# constructs table in the format:
	#
	# Driver \| Property \| binary1 \| binary1 \| ...
	# \| \| machine1 \| machine2 \| ...
	# ------------------------------------------------------ ...
	# driver1 \| property1 \| value1 \| value2 \| ...
	# driver1 \| property2 \| value3 \| value4 \| ...
	# driver2 \| property3 \| value5 \| value6 \| ...
	# ... \| ... \| ... \| ... \| ...
	#
	def fill_prop_table(configs: List[Configuration],
	is_raw: bool) -> pd.DataFrame:
	req_props = list(get_affected_props(configs))
	if not req_props:
	print('No drivers to compare. Check machine names')
	exit(0)

	driver_col, prop_col = tuple(zip(*req_props))
	table = [pd.DataFrame({'Driver': driver_col}),
	pd.DataFrame({'Property': prop_col})]

	table.extend([config.get_table(req_props) for config in configs])

	df_table = pd.concat(table, axis=1)

	if is_raw:
	return df_table

	return simplify_table(df_table)


	def print_table(table: pd.DataFrame, table_format: str) -> None:
	if table_format == 'json':
	print(comp_table.to_json())
	elif table_format == 'csv':
	print(comp_table.to_csv())
	else:
	print(comp_table.to_markdown(index=False, stralign='center',
	colalign=('center',), headers='keys',
	tablefmt='fancy_grid',
	disable_numparse=True))


	if __name__ == '__main__':
	args = parse_args()
	with ExitStack() as stack:
	vms = [stack.enter_context(QEMUMachine(binary=binary, qmp_timer=15,
	args=args.qemu_args.split(' '))) for binary in args.qemu_binary]

	configurations = []
	for vm in vms:
	vm.launch()
	configurations.append(Configuration(vm, args.mt, args.all))

	comp_table = fill_prop_table(configurations, args.raw)
	if not comp_table.empty:
	print_table(comp_table, args.format)