def restore(self):
#load state
data = State.get_data(self.version, self.StateID)
for inputsize in data:
try:
algdata = inputsize["Methodology"]
except:
inputsize = {
"Input": self.newinput,
"BenchmarkInput": self.benchmark_input,
"Methodology": {},
}
State.checkpoint(self.version, self.StateID, data)
continue
if not (algdata in [None, {}, []]):
self.benchmark_input = inputsize["BenchmarkInput"]
self.benchmark_solutions = None
for sol in self.profiling_solutions:
if sol["Input"] == self.benchmark_input:
self.benchmark_solutions = sol["Configurations"]
if not self.benchmark_solutions:
#the benchmark input from the save file doesn't have any solution explored
self.benchmark_input = self.profiling_solutions[-1][
"Input"]
self.benchmark_solutions = self.profiling_solutions[-1][
"Configurations"]
self.strategy.update_state(algdata)
#if profiling with the input size was finished go to the next one
if not self.strategy.stop_condition():
break
return data
def restore(self):
print "Restoring Profile."
data = State.get_data(self.version, self.StateID)
q = False
for inputsize in data:
try:
algdata = inputsize["Algorithm"]
except:
inputsize = {
"ResourceVariables": self.variables,
"InputParameters": self.parameters,
"Algorithm": {}
}
State.checkpoint(self.version, self.StateID, data)
break
if algdata != None and algdata != []:
if inputsize["InputParameters"] == self.parameters:
q = True
self.strategy.update_state(algdata)
#if profiling with the input size was finished go to the next one
if not self.strategy.stop_condition():
break
if not q:
return []
return data
def recieve(self):
buff = b''
while True:
if len(buff) < 3:
buff += self.connection.recv(3)
# Package metadata: type and length
package_type, package_len = struct.unpack('<BH', buff[0:3])
buff = buff[3:]
# recieve until the package is complete.
while len(buff) < package_len:
buff += self.connection.recv(package_len)
try:
if package_type == PACKAGE_TYPE_STATUS:
self.main.update_state(State(bytes(buff)))
elif package_type == PACKAGE_TYPE_RESPONSE:
self.response_holder.set(bytes(buff))
self.recv_event.set()
else:
self.main.ui.print(
'Wrong package recieved: 0x{:02x}'.format(
package_type))
except Exception as e:
self.main.ui.print(repr(e))
# remove full packages from buffer:
buff = buff[package_len:]
def restore(self):
if self.Data == {}:
#load state
for v in self.versions:
version = ".".join(map(lambda s: str(s), v))
data = State.get_data(version, self.StateID)
if data in [None, {}, []]:
continue
self.Data[version] = data[0]
def save_state(self):
print "Save state to file."
data = State.get_data(self.version, self.StateID)
algdata = self.strategy.get_state()
info = {
"Input": self.newinput,
"BenchmarkInput": self.benchmark_input,
"Methodology": algdata
}
q = False
for inputsize in data:
if inputsize["Input"] == self.newinput:
inputsize.update(info)
q = True
if not q:
data.append(info)
State.checkpoint(self.version, self.StateID, data)
def save_state(self):
print "Save state to file."
data = State.get_data(self.version, self.StateID)
algdata = self.strategy.get_state()
info = {
"ResourceVariables": self.variables,
"InputParameters": self.parameters,
"Algorithm": algdata
}
q = False
for inputsize in data:
if inputsize["InputParameters"] == self.parameters:
inputsize.update(info)
q = True
if not q:
data.append(info)
State.checkpoint(self.version, self.StateID, data)
def get_explored_solutions(self):
data = State.get_data(self.version, self.StateID)
if data in [None, []]:
return self.variables, None
solutions = []
for info in data:
solutions.append({
"Input": info["InputParameters"],
"Configurations": info["Algorithm"]["solutions"]
})
return self.variables, solutions
def query_initial_status(self, connection):
""" Sends an initial status update to retrieve the current state. """
command_bytes = self.command_manager.get_command(
'adc update state').get_command_bytes('')
connection.send(command_bytes)
# Metadata: type and length
package_descriptor = connection.recv(3)
package_type, package_len = struct.unpack('<BH', package_descriptor)
# Get content of the package.
buff = b''
while len(buff) < package_len:
buff += connection.recv(package_len - len(buff))
if package_type == PACKAGE_TYPE_RESPONSE:
status, = struct.unpack('<B', buff[0:1])
if status != 0:
self.ui.print("Couldn't get a first status update")
else:
self.update_state(State(buff[1:]))
else:
self.ui.print("Couldn't get a first status update")
def model_version(v):
version = ".".join(map(lambda s: str(s), v))
#LOOK FOR PROFILE DATA
profile_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), "../profiles"))
data_file = "%s/%s-%s.pf" % (profile_dir, Controller.application.Name,
version)
State.load(version, data_file)
current_state = State.get_current_state(version)
if current_state == 0:
print "Profiling state."
#profiling with static input phase
#get the first small input size to profile with
parameters = VariableMapper(
Controller.application.getParameterVariableMap(
)).lower_bound_values()
#start profiler to create a model
Profiler.StateID = current_state
profiler = Profiler(Controller.application,
version,
parameters=parameters)
try:
profiler.run()
except:
traceback.print_exc()
print 'Profiler interrupted. Exiting'
return False, None
State.change_state(version)
current_state = State.get_current_state(version)
State.checkpoint(version, current_state)
#get the input size from the SLO for which to make prediction
input_size = Controller.application.getExecutionParameters(
Controller.slo.ExecutionArguments)
modeller = None
if current_state >= 1:
print "Modelling state."
#profiling variable input
#modelling state - use function to predict
Extrapolator.StateID = current_state
variables, solutions_identified_in_profiling = Profiler(
Controller.application, version).get_explored_solutions()
print len(solutions_identified_in_profiling)
modeller = Extrapolator(Controller.application, version, variables,
solutions_identified_in_profiling,
input_size)
try:
modeller.run()
except:
traceback.print_exc()
print 'Modeller interrupted. Exiting'
return False, None
State.change_state(version)
current_state = State.get_current_state(version)
print "Current state", current_state
State.save(version)
#retrieve the model - tuple (function,constraints)
model = modeller.get_model()
return True, model