def get_config(tp):
chip = tp.get_child_str('chip')
config = js.import_config({'includes': ["defaults.json"]})
config.merge(Config(config=system_gen.get_config(tp)).get_js_config())
config.merge(
js.import_config({'includes2': ["chips/%s/defaults.json" % (chip)]}))
return config
def get_config(tp):
chip = tp.get_child_str('chip')
config = js.import_config({'@includes@': ["defaults.json"]},
interpret=True)
config.merge(
Config(config=system_gen.get_config(tp)).get_js_config(expand=True))
config.merge(
js.import_config({'@includes2@': ["chips/%s/defaults.json" % (chip)]},
interpret=True))
return config
def gen_config(args, config):
full_config = js.import_config(config.get_dict(), interpret=True, gen=True)
gvsoc_config = full_config.get('gvsoc')
debug_mode = gvsoc_config.get_bool('debug-mode') or \
gvsoc_config.get_bool('traces/enabled') or \
gvsoc_config.get_bool('events/enabled') or \
len(gvsoc_config.get('traces/include_regex')) != 0 or \
len(gvsoc_config.get('events/include_regex')) != 0
gvsoc_config.set("debug-mode", debug_mode)
if debug_mode:
debug_binaries = []
if args.binary is not None:
debug_binaries.append(args.binary)
rom_binary = full_config.get_str('**/soc/rom/config/binary')
if rom_binary is not None:
if os.path.exists(rom_binary):
debug_binaries.append(rom_binary)
for binary in debug_binaries:
full_config.set('**/debug_binaries', binary + '.debugInfo')
full_config.set('**/binaries', binary)
gvsoc_config_path = os.path.join(config.get_str('gapy/work_dir'),
'gvsoc_config.json')
return full_config, gvsoc_config_path
def __init__(self,
name=None,
config_path=None,
config_string=None,
config=None,
args=None):
self.name = name
if config_path is not None:
with open(config_path, 'r') as fd:
config = json.load(fd, object_pairs_hook=OrderedDict)
if config_string is not None:
config = json.loads(config_string, object_pairs_hook=OrderedDict)
try:
if args is not None:
for arg in args.split(':'):
key, value = arg.split('=')
config2 = js.import_config(config)
config2.set(key, value)
config = config2.get_dict()
except:
pass
self.top = Top_template(config=config)
def __init__(self,
name=None,
config_path=None,
config_string=None,
config=None,
props=None,
args=None):
self.name = name
self.config_args = []
if config_path is not None:
with open(config_path, 'r') as fd:
config = json.load(fd, object_pairs_hook=OrderedDict)
if config_string is not None:
config = json.loads(config_string, object_pairs_hook=OrderedDict)
args_objects = []
arg_list = {}
try:
js_config = js.import_config(config)
if args is not None:
for name2 in args.split(':'):
for name in name2.split(' '):
arg = Arg(name)
arg_list[arg.name] = arg
extra_args = []
for arg in arg_list.values():
extra_args += self.preprocess_arg(js_config, arg, arg_list)
for extra_arg in extra_args:
arg = Arg(extra_arg)
arg_list[arg.name] = arg
for arg in arg_list.values():
args_objects += self.handle_arg(js_config, arg, arg_list)
if props is not None:
for arg in props.split(':'):
key, value = arg.split('=')
js_config.set(key, value)
config = js_config.get_dict()
except:
pass
if args_objects is not None:
for arg_object in args_objects:
self.config_args += arg_object.process(js_config, arg_list)
self.top = Top_template(config=config)
def importConfig(parser):
argsCli = sys.argv[1:]
if '-h' in argsCli:
argsCli.remove('-h')
parser.parse_known_args(argsCli)
args, _ = parser.parse_known_args(argsCli)
if args.py_target is not None:
class_name, module_name = args.py_target.split('@')
module = importlib.import_module(module_name)
if not callable(getattr(module, class_name, None)):
raise RuntimeError(
'Unable to find target class (method: %s, filepath: %s)' %
(class_name, module_name))
runner = Runner(None,
'top',
options=args.config_items,
target_class=getattr(module, class_name, None))
return (js.import_config(runner.get_config()), runner)
elif args.target is not None:
jsonPath = os.path.join(targetsDir, args.target + '.json')
ini_configs = args.ini_configs
if os.environ.get('GAPY_CONFIGS_INI') is not None:
ini_configs += os.environ.get('GAPY_CONFIGS_INI').split()
return (js.import_config_from_file(jsonPath,
find=True,
interpret=True,
paths=gapyJsonPath,
ini_configs=ini_configs,
config_items=args.config_items),
None)
else:
return (None, None)
def __init__(self, args, config):
super(Runner, self).__init__(args, config)
self.__process_args()
try:
gv.gvsoc.process_args(args, config)
except:
pass
self.areas = []
self.cmd_args = self.config.get('rtl/args').get_dict()
self.plt_args = []
self.env = {}
self.platform_path = None
self.platform_tool = self.config.get_str('rtl/simulator')
if os.environ.get('GAPY_RTL_SIMULATOR') is not None:
self.platform_tool = os.environ.get('GAPY_RTL_SIMULATOR')
self.plt_config = self.config.get('rtl/' + self.platform_tool)
self.plt_profile_config = self.plt_config.get('profiles/rtl')
if self.config.get('**/runner/peripherals') is not None:
self.set_arg('-gCONFIG_FILE=rtl_config.json')
if os.environ.get('INSTALL_DIR') is not None:
dpi_path = '%s/lib/libpulpdpi' % (
os.environ.get('INSTALL_DIR'))
if not os.path.exists(dpi_path + '.so'):
raise FatalError('Did no find DPI models: ' + dpi_path +
'.so')
self.set_arg('-sv_lib %s' % dpi_path)
#
# Co-simulation with GVSOC
#
if self.config.get_bool('**/runner/gvsoc_dpi/enabled'):
dpi_path = '%s/lib/libgvsocdpi' % (os.environ.get('INSTALL_DIR'))
if not os.path.exists(dpi_path + '.so'):
raise FatalError('Did no find DPI models: ' + dpi_path + '.so')
if self.platform_tool == 'vsim':
self.set_arg('-sv_lib %s' % dpi_path)
else:
self.set_cmd_arg('-sv_lib %s' % dpi_path)
full_config, gvsoc_config_path = gv.gvsoc.gen_config(
args, self.config)
gv.gvsoc.prepare_exec(self.config, full_config)
gv.gvsoc.dump_config(full_config, gvsoc_config_path)
if self.platform_tool == 'vsim':
self.set_arg('+DPI_CONFIG_FILE=%s' % gvsoc_config_path)
else:
self.set_cmd_arg('+DPI_CONFIG_FILE=%s' % gvsoc_config_path)
else:
if os.environ.get('TARGET_CHIP') == 'GAP9_V2':
dpi_path = os.path.join(self.__get_platform_path(),
'ips_inputs/dpi/libchipwrapper')
if self.platform_tool == 'vsim':
self.set_arg('-sv_lib %s' % dpi_path)
else:
self.set_cmd_arg('-sv_lib %s' % dpi_path)
if self.args.cov or os.environ.get('GAPY_RTL_COVERAGE') is not None:
test_name = os.environ.get('PLPTEST_NAME')
if test_name is None:
test_name = 'test'
test_name = test_name.replace(':', '.').replace('/', '.')
self.set_cmd_arg(
'-covoverwrite -covworkdir %s/cov_work -covtest %s' %
(os.environ.get('XCSIM_PATH'), test_name))
self.full_config = js.import_config(self.config.get_dict(),
interpret=True,
gen=True)
def get_js_config(self, configs=None, expand=False):
result = js.import_config(self.gen(), interpret=expand)
return result
def get_config_from_string(name, config_string, interpret=False, **kwargs):
return create_config(name,
js.import_config(config_string),
interpret=interpret)
def get_config(file,
name="",
config_name=None,
ini_configs=[],
ini_configs_dict={},
config_opts=[],
properties=[],
interpret=False,
**kwargs):
template_properties = []
config_properties = config_opts
for prop in properties:
if prop.find('config/') == 0:
config_properties.append(prop.split('config/')[1])
else:
template_properties.append(prop)
if file is not None and file.find('@') != -1:
name, file = file.split('@')
if file is not None and file.find('config_file') != -1:
dummy, file = file.split('=', 1)
opts = []
if file.find(':'):
opts = file.split(':')[1:]
file = file.split(':')[0]
config = js.import_config_from_file(file, find=True, interpret=interpret)
for ini_config in ini_configs:
parser = configparser.SafeConfigParser(
ini_configs_dict, dict_type=collections.OrderedDict)
parser.optionxform = str
paths = parser.read(ini_config)
if len(paths) == 0:
raise Exception("Didn't manage to open file: %s" % (ini_config))
user_config = collections.OrderedDict()
for section in parser.sections():
for item in parser.items(section):
path = ('%s.%s' % (section, item[0])).split('.')
config.set_from_list(path, item[1])
for prop in template_properties:
for key, value in prop.split('='):
config.user_set(key, value)
config = js.import_config(config.get_dict(), interpret=interpret)
result = create_config(name,
config,
interpret=interpret,
config_name=config_name,
**kwargs)
for config_opt in config_opts + opts:
key, value = config_opt.split('=', 1)
result.user_set(key, value)
return result
def get_json_config(self, config):
return js.import_config(config.get_dict())
def __init__(self, args, config):
super(Runner, self).__init__(args, config)
self.__process_args()
try:
gv.gvsoc.process_args(args, config)
except:
pass
self.cmd_args = []
self.plt_args = []
self.env = {}
self.platform_path = None
self.platform_tool = self.config.get_str('rtl/simulator')
if os.environ.get('GAPY_RTL_SIMULATOR') is not None:
self.platform_tool = os.environ.get('GAPY_RTL_SIMULATOR')
self.plt_config = self.config.get('rtl/' + self.platform_tool)
self.plt_profile_config = self.plt_config.get('profiles/rtl')
if self.config.get('**/runner/peripherals') is not None:
self.set_arg('-gCONFIG_FILE=rtl_config.json')
if os.environ.get('INSTALL_DIR') is not None:
dpi_path = '%s/lib/libpulpdpi' % (
os.environ.get('INSTALL_DIR'))
if not os.path.exists(dpi_path + '.so'):
raise FatalError('Did no find DPI models: ' + dpi_path +
'.so')
self.set_arg('-sv_lib %s' % dpi_path)
#
# Co-simulation with GVSOC
#
if self.config.get_bool('**/runner/gvsoc_dpi/enabled'):
dpi_path = '%s/lib/libgvsocdpi' % (os.environ.get('INSTALL_DIR'))
if not os.path.exists(dpi_path + '.so'):
raise FatalError('Did no find DPI models: ' + dpi_path + '.so')
if self.platform_tool == 'vsim':
self.set_arg('-sv_lib %s' % dpi_path)
else:
self.set_cmd_arg('-sv_lib %s' % dpi_path)
full_config, gvsoc_config_path = gv.gvsoc.gen_config(
args, self.config)
gv.gvsoc.prepare_exec(self.config, full_config)
gv.gvsoc.dump_config(full_config, gvsoc_config_path)
if self.platform_tool == 'vsim':
self.set_arg('+DPI_CONFIG_FILE=%s' % gvsoc_config_path)
else:
self.set_cmd_arg('+DPI_CONFIG_FILE=%s' % gvsoc_config_path)
else:
if self.platform_tool == 'vsim':
self.set_arg('-sv_lib %s/%s' %
(self.__get_platform_path(),
'ips_inputs/dpi/libchipwrapper'))
else:
self.set_cmd_arg('-sv_lib %s/%s' %
(self.__get_platform_path(),
'ips_inputs/dpi/libchipwrapper'))
self.full_config = js.import_config(self.config.get_dict(),
interpret=True,
gen=True)
def gen_stimuli(self, work_dir):
runner = gap9_v2.Runner(None, js.import_config(self.get_config()),
None)
runner.gen_efuse_stim(self.__get_efuse_path(work_dir))
