def calibrate(dev, runtime, block, inst, cfg):
assert (cfg.inst.block == block.name)
assert (cfg.inst.loc == inst)
new_adp = adplib.ADP()
new_adp.add_instance(block, inst)
config = new_adp.configs.get(block.name, \
inst)
config.set_config(cfg)
all_codes = calibrate(runtime,block,inst, \
new_adp, \
method=llenums.CalibrateObjective.MAXIMIZE_FIT)
print(all_codes)
def generate_adp(board, blk, loc, cfg):
adp_file = get_adp(board, blk, loc, cfg)
new_adp = adplib.ADP()
new_adp.add_instance(blk, loc)
blkcfg = new_adp.configs.get(blk.name, loc)
blkcfg.set_config(cfg)
with open(adp_file, 'w') as fh:
text = json.dumps(new_adp.to_json())
fh.write(text)
return adp_file
def profile_hidden_state(runtime, dev, planner, hidden, adp=None, quiet=False):
# make new config for profiling operation
if adp is None:
new_adp = adplib.ADP()
new_adp.add_instance(planner.block, planner.loc)
else:
new_adp = adp.copy(dev)
config = new_adp.configs.get(planner.block.name, \
planner.loc)
config.set_config(planner.config)
# set hidden state
for state_var, value in hidden.items():
stmt = config.get(state_var)
assert (isinstance(stmt, adplib.StateConfig))
stmt.value = value
planner.new_dynamic()
output = planner.output
method = planner.method
dynamic = planner.next_dynamic()
while not dynamic is None:
input_vals = {}
for name, value in dynamic.items():
if planner.block.data.has(name):
assert(isinstance(config[name], \
adplib.ConstDataConfig))
config[name].value = value
else:
st = planner.block.inputs[name]
input_vals[st.ll_identifier] = value
if not quiet:
print("-> input %s" % str(dynamic))
profile(runtime, \
dev, \
planner.block, \
planner.loc, \
new_adp, \
output.ll_identifier, \
method=method, \
inputs=input_vals, \
quiet=quiet)
dynamic = planner.next_dynamic()
def calibrate(runtime,dev,blk,loc,adp, \
calib_obj=llenums.CalibrateObjective.MAXIMIZE_FIT):
state_t = {blk.name: blk.state.concretize(adp, loc)}
# build set state command
loc_t, loc_d = make_block_loc_t(blk, loc)
set_state_data = {"inst": loc_d, "state": state_t}
cmd_t, cmd_data = make_circ_cmd(llenums.CircCmdType.SET_STATE,
set_state_data)
cmd = cmd_t.build(cmd_data, debug=True)
# execute set state command
print("-> setting state")
print(state_t)
runtime.execute(cmd)
resp = unpack_response(runtime.result())
cmd_t, cmd_data = make_circ_cmd(llenums.CircCmdType.GET_STATE,
set_state_data)
cmd = cmd_t.build(cmd_data, debug=True)
# execute set state command
calibrate_data = {"calib_obj": calib_obj.name, \
"inst": loc_d}
cmd_t, cmd_data = make_circ_cmd(llenums.CircCmdType.CALIBRATE,
calibrate_data)
print(cmd_data)
print("-> calibrating block")
cmd = cmd_t.build(cmd_data, debug=True)
runtime.execute(cmd)
resp = unpack_response(runtime.result())
state = resp[blk.name]
print("response: %s" % str(state))
new_adp = adplib.ADP()
new_adp.add_instance(blk, loc)
blk.state.lift(new_adp, loc, dict(state))
blkcfg = new_adp.configs.get(blk.name, loc)
return blkcfg
def to_adp(vadps):
adp = adplib.ADP()
for stmt in vadps:
if isinstance(stmt, VADPConfig):
block = stmt.target.block
loc = stmt.target.ident
adp.add_instance(block, loc)
cfg = adp.configs.get(block.name, loc)
cfg.modes = stmt.mode
for datafield, value in stmt.assigns.items():
if (isinstance(cfg[datafield], adplib.ExprDataConfig)):
cfg[datafield].expr = value
elif (isinstance(cfg[datafield], adplib.ConstDataConfig)):
cfg[datafield].value = value.compute()
else:
raise Exception("cannot set field <%s>" % datafield)
elif isinstance(stmt, VADPConn):
sb = stmt.source.block
sl = stmt.source.ident
sp = stmt.source.port
db = stmt.sink.block
dl = stmt.sink.ident
dp = stmt.sink.port
adp.add_conn(sb, sl, sp, db, dl, dp)
for stmt in vadps:
if isinstance(stmt, VADPSource):
block = stmt.target.block
loc = stmt.target.ident
port = stmt.target.port
dsexpr = stmt.dsexpr
adp.add_source(block, loc, port, dsexpr)
return adp
def characterize(runtime,board,block,_cfg,locs, \
grid_size=7, \
num_hidden_codes=200):
print("=> characterizing %s" % block.name)
for loc in locs:
adp = adplib.ADP()
cfg = _cfg.copy()
adp.add_instance(block,loc)
cfg.inst.loc = loc
adp.configs.get(block.name,loc).set_config(cfg)
new_adp = runtime_util.make_block_test_adp(board,adp,block,cfg)
new_cfg = new_adp.configs.get(block.name,loc)
print("=== %s.%s ===" % (block.name,loc))
print(new_cfg)
print("grid-size: %d / num-codes: %d / num-locs: %d" % (grid_size, \
num_hidden_codes, \
len(locs)))
if not has_hidden_codes(block,loc,new_cfg):
return
random_hidden_codes = list(planlib.RandomCodeIterator(block,loc,new_cfg, \
num_hidden_codes))
for hidden_code in random_hidden_codes:
for output in block.outputs:
for method,n,m,reps in runtime_util.get_profiling_steps(output,new_cfg,grid_size):
planner = planlib.SingleTargetedPointPlanner(block, \
loc, \
output, \
new_cfg, \
method,
n=n,
m=m,
reps=reps,
hidden_codes=hidden_code)
proflib.profile_all_hidden_states(runtime, board, planner, adp=new_adp, quiet=True)
def profile(runtime,dev, \
blk,loc,adp,output_port, \
inputs, \
method=llenums.ProfileOpType.INPUT_OUTPUT,quiet=False):
state_t = {blk.name: blk.state.concretize(adp, loc)}
# build profiling command
loc_t, loc_d = llutil.make_block_loc_t(blk, loc)
values = [0.0] * 2
for input_ident, input_val in inputs.items():
values[input_ident.code()] = input_val
if not quiet:
print("profile-inputs: %s" % values)
profile_data = {"method": method.name, \
"inst": loc_d,
"in_vals": values, \
"state":state_t,
"output":output_port.name}
cmd_t, cmd_data = llutil.make_circ_cmd(llenums.CircCmdType.PROFILE,
profile_data)
cmd = cmd_t.build(cmd_data, debug=True)
# execute profiling command
runtime.execute(cmd)
resp = llutil.unpack_response(runtime.result(quiet=quiet))
# reconstruct analog device program
new_adp = adplib.ADP()
blk, loc = llutil.from_block_loc_t(dev, resp['spec']['inst'])
new_adp.add_instance(blk, loc)
state = resp['spec']['state'][blk.name]
blk.state.lift(new_adp, loc, dict(state))
blkcfg = new_adp.configs.get(blk.name, loc)
# retrieve parameters for new result
inputs = {}
port = llutil.get_by_ll_identifier(blk.inputs, llenums.PortType.IN0)
if not port is None:
inputs[port.name] = resp['spec']['in_vals'][
llenums.PortType.IN0.code()]
if not quiet:
print("in %s = %f" % (port.name, inputs[port.name]))
port = llutil.get_by_ll_identifier(blk.inputs, llenums.PortType.IN1)
if not port is None:
inputs[port.name] = resp['spec']['in_vals'][
llenums.PortType.IN1.code()]
new_out = llutil.get_by_ll_identifier(blk.outputs, \
llenums.PortType \
.from_code(int(resp['spec']['output'])))
new_method = llenums.ProfileOpType.from_code(int(resp['spec']['method']))
out_mean = resp['mean']
out_std = resp['stdev']
out_status = llenums.ProfileStatus.from_code(int(resp['status']))
if not quiet:
print("datum inputs=%s out=%f std=%f status=%s" %
(inputs, out_mean, out_std, out_status.value))
print(blkcfg)
# insert into database
if out_status == llenums.ProfileStatus.SUCCESS:
dataset = exp_profile_lib.load(dev, blk, loc, new_out, blkcfg, method)
if dataset is None:
dataset = exp_profile_lib.ExpProfileDataset(blk, \
loc, \
new_out, \
blkcfg, \
new_method)
dataset.add(config=blkcfg, \
inputs=inputs, \
mean=out_mean, \
std=out_std)
exp_profile_lib.update(dev, dataset)
return blkcfg