non_renewables = [0 for j in range(NB_NON_RENEWABLE)]
for m in MODES:
dren = m['demandRenewable']
dnren = m['demandNonRenewable']
for j in range(NB_RENEWABLE):
dem = m['demandRenewable'][j]
if dem > 0:
renewables[j] += mdl.pulse(modes[m['id']], dem)
for j in range(NB_NON_RENEWABLE):
dem = m['demandNonRenewable'][j]
if dem > 0:
non_renewables[j] += dem * mdl.presence_of(modes[m['id']])
# Constrain renewable resources capacity
for j in range(NB_RENEWABLE):
mdl.add(mdl.always_in(renewables[j], (INTERVAL_MIN, INTERVAL_MAX), 0, CAPACITIES_RENEWABLE[j]))
# Constrain non-renewable resources capacity
for j in range(NB_NON_RENEWABLE):
mdl.add(non_renewables[j] <= CAPACITIES_NON_RENEWABLE[j])
# Minimize overall schedule end date
mdl.add(mdl.minimize(mdl.max([mdl.end_of(t) for t in tasks.values()])))
#-----------------------------------------------------------------------------
# Solve the model and display the result
#-----------------------------------------------------------------------------
# Solve model
print("Solving model....")
# Create model
mdl = CpoModel()
# Create array of variables for subsquares
vx = [mdl.interval_var(size=SIZE_SUBSQUARE[i], name="X" + str(i), end=(0, SIZE_SQUARE)) for i in range(NB_SUBSQUARE)]
vy = [mdl.interval_var(size=SIZE_SUBSQUARE[i], name="Y" + str(i), end=(0, SIZE_SQUARE)) for i in range(NB_SUBSQUARE)]
# Create dependencies between variables
for i in range(len(SIZE_SUBSQUARE)):
for j in range(i):
mdl.add( (mdl.end_of(vx[i]) <= mdl.start_of(vx[j])) | (mdl.end_of(vx[j]) <= mdl.start_of(vx[i]))
| (mdl.end_of(vy[i]) <= mdl.start_of(vy[j])) | (mdl.end_of(vy[j]) <= mdl.start_of(vy[i])))
# To speed-up the search, create cumulative expressions on each dimension
rx = mdl.sum([mdl.pulse(vx[i], SIZE_SUBSQUARE[i]) for i in range(NB_SUBSQUARE)])
mdl.add(mdl.always_in(rx, (0, SIZE_SQUARE), SIZE_SQUARE, SIZE_SQUARE))
ry = mdl.sum([mdl.pulse(vy[i], SIZE_SUBSQUARE[i]) for i in range(NB_SUBSQUARE)])
mdl.add(mdl.always_in(ry, (0, SIZE_SQUARE), SIZE_SQUARE, SIZE_SQUARE))
# Define search phases, also to speed-up the search
mdl.set_search_phases([mdl.search_phase(vx), mdl.search_phase(vy)])
#-----------------------------------------------------------------------------
# Solve the model and display the result
#-----------------------------------------------------------------------------
# Solve model
print("Solving model....")
msol = mdl.solve(TimeLimit=20, LogPeriod=50000)
def floorPlanner(CONFIG, SCHEDULER, RATE, printFlag=0, figFlag=0):
HEIGHT_REC = 4
WIDTH_REC = 4
NUM_RESOURCES = 16
# Sizes of the hardware resources
SIZE_HARDWARE = [1 for _ in range(NUM_RESOURCES)]
RESOUCE_dict = {
0: 'A72',
1: 'A53-0',
2: 'A53-1',
3: 'FFT',
4: 'DAP-0',
5: 'DAP-1',
6: 'Memory',
7: 'Cache-1',
8: 'Cache-2',
9: 'Cache-3',
10: 'Cache-4'
}
# read from rpt file
df = pd.read_fwf("inputs/" + CONFIG + "/trace_" + SCHEDULER + "_" + RATE +
"/matrix_traffic_" + SCHEDULER + "_" + RATE +
".rpt") # read file --- MODIFY HERE
df = df.drop(df.columns[df.columns.str.contains('unnamed', case=False)],
axis=1) # drop unnamed
df = df.drop(range(10)) # drop the first 10 lines
vol = df.values.tolist()
vol_commu = [list(map(int, i)) for i in vol]
extend_factor = NUM_RESOURCES - len(vol_commu)
for i in range(extend_factor):
RESOUCE_dict[len(vol_commu) + i] = 'empty'
for _ in range(extend_factor):
for row in range(len(vol_commu)):
vol_commu[row].extend([0])
for _ in range(extend_factor):
vol_commu.append([0 for _ in range(len(vol_commu[0]))])
#-----------------------------------------------------------------------------
# Build the model
#-----------------------------------------------------------------------------
# Create model
mdl = CpoModel()
# Create array of variables for subsquares
vx = [
mdl.interval_var(size=SIZE_HARDWARE[i],
name="X" + str(i),
end=(0, WIDTH_REC)) for i in range(NUM_RESOURCES)
]
vy = [
mdl.interval_var(size=SIZE_HARDWARE[i],
name="Y" + str(i),
end=(0, HEIGHT_REC)) for i in range(NUM_RESOURCES)
]
# Create dependencies between variables
for i in range(len(SIZE_HARDWARE)):
for j in range(i):
mdl.add((mdl.end_of(vx[i]) <= mdl.start_of(vx[j]))
| (mdl.end_of(vx[j]) <= mdl.start_of(vx[i]))
| (mdl.end_of(vy[i]) <= mdl.start_of(vy[j]))
| (mdl.end_of(vy[j]) <= mdl.start_of(vy[i])))
# Set up the objective
"""
obj = mdl.minimize( mdl.sum( vol_commu[i][j] * ( mdl.max( [mdl.end_of(vx[i]) - mdl.end_of(vx[j]), mdl.end_of(vx[j]) - mdl.end_of(vx[i])] )\
+ mdl.max( [mdl.start_of(vy[i]) - mdl.end_of(vy[j]), mdl.start_of(vy[j]) - mdl.end_of(vy[i])] ) ) \
for i in range(NUM_RESOURCES) for j in range(NUM_RESOURCES) if vol_commu[i][j]) )
"""
obj = mdl.minimize( mdl.sum( vol_commu[i][j] * ( mdl.max( [mdl.end_of(vx[i]) - mdl.end_of(vx[j]), mdl.end_of(vx[j]) - mdl.end_of(vx[i])] )\
+ mdl.min([mdl.min([mdl.max( [mdl.start_of(vy[i]) - mdl.end_of(vy[j]), 0] ), mdl.max( [mdl.start_of(vy[j]) - mdl.end_of(vy[i]), 0] )]), 1]) ) \
for i in range(NUM_RESOURCES) for j in range(NUM_RESOURCES) if vol_commu[i][j]) )
mdl.add(obj)
# To speed-up the search, create cumulative expressions on each dimension
rx = mdl.sum(
[mdl.pulse(vx[i], SIZE_HARDWARE[i]) for i in range(NUM_RESOURCES)])
mdl.add(mdl.always_in(rx, (0, WIDTH_REC), WIDTH_REC, WIDTH_REC))
ry = mdl.sum(
[mdl.pulse(vy[i], SIZE_HARDWARE[i]) for i in range(NUM_RESOURCES)])
mdl.add(mdl.always_in(ry, (0, HEIGHT_REC), HEIGHT_REC, HEIGHT_REC))
# Define search phases, also to speed-up the search
mdl.set_search_phases([mdl.search_phase(vx), mdl.search_phase(vy)])
#-----------------------------------------------------------------------------
# Solve the model and display the result
#-----------------------------------------------------------------------------
# Solve model
print("Solving model....")
msol = mdl.solve(TimeLimit=20, LogPeriod=50000)
if printFlag:
print("Solution: ")
msol.print_solution()
if msol and visu.is_visu_enabled():
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from matplotlib.patches import Polygon
import matplotlib.ticker as ticker
# Plot external square
if figFlag:
plt.show()
print("Plotting squares....")
fig, ax = plt.subplots()
plt.plot((0, 0), (0, HEIGHT_REC), (WIDTH_REC, HEIGHT_REC),
(WIDTH_REC, 0))
plt.xlim((0, WIDTH_REC))
plt.ylim((0, HEIGHT_REC // 2))
for i in range(len(SIZE_HARDWARE)):
# Display square i
sx, sy = msol.get_var_solution(vx[i]), msol.get_var_solution(vy[i])
(sx_st, sx_ed, sy_st, sy_ed) = (sx.get_start(), sx.get_end(),
sy.get_start(), sy.get_end())
# transform
#sx1, sx2, sy1, sy2 = sx_st, sx_ed, sy_st, sy_ed
sx1 = sx_st + 0.5 if sy_st % 2 else sx_st
sy1 = sy_st / 2
sx2, sy2 = sx1 + 0.5, sy1 + 0.5
poly = Polygon([(sx1, sy1), (sx1, sy2), (sx2, sy2), (sx2, sy1)],
fc=cm.Set2(float(i) / len(SIZE_HARDWARE)))
ax.add_patch(poly)
# Display identifier of square i at its center
ax.text(float(sx1 + sx2) / 2,
float(sy1 + sy2) / 2,
RESOUCE_dict[i],
ha='center',
va='center')
ax.xaxis.set_major_locator(ticker.MultipleLocator(0.5))
ax.yaxis.set_major_locator(ticker.MultipleLocator(0.5))
plt.margins(0)
fig.savefig("outputs/MESH/" + CONFIG + "_" + SCHEDULER + "_" + RATE +
".png")
if figFlag:
plt.show()
name='task_{}'.format(task['id']))
# Optional task intervals that belong to each machine
task_machine_intervals = model.interval_var_list(NUM_MACHINES,
name='task_{}_on_'.format(
task['id']),
optional=True)
for i in range(NUM_MACHINES):
m_id = data['machines'][i]['id']
# Bind with machine switched on intervals
model.add(
model.always_equal(tasks_running_on_machines[m_id],
task_machine_intervals[i], 1))
model.add(
model.always_in(machine_on_off[m_id], task_machine_intervals[i], 1,
1))
# Add resource usage by task
for j in range(NUM_RESOURCES):
machine_resources[m_id][j] += model.pulse(
task_machine_intervals[i], task['resource_usage'][j])
# For visualization
task_intervals_on_machines[m_id].append(
(task, task_machine_intervals[i]))
# Only one interval will be effective
model.add(model.alternative(task_interval, task_machine_intervals))
task_intervals.append((task, task_interval))
all_state_functions.append(house_state)
# Allocate tasks to workers
for t in ALL_TASKS:
desc[tasks[t.id]] = t
house[tasks[t.id]] = loc
workers_usage += mdl.pulse(tasks[t.id], 1)
# Make houses
for i, sd in enumerate(HOUSES):
make_house(i, sd)
# Number of workers should not be greater than the limit
mdl.add(
mdl.always_in(workers_usage, (INTERVAL_MIN, INTERVAL_MAX), 0, NB_WORKERS))
# Minimize overall completion date
mdl.add(mdl.minimize(mdl.max([mdl.end_of(task) for task in all_tasks])))
#-----------------------------------------------------------------------------
# Solve the model and display the result
#-----------------------------------------------------------------------------
def compact(name):
# Example: H3-garden -> G3
# ^ ^
loc, task = name[1:].split('-', 1)
return task[0].upper() + loc
