added prose description of the ILP model implemented in Gurobi.

src/pipedream/ilp/the-ilp-model.txt

+///#############################################################################
+///##### INPUT
+
+///### CPU LAYOUT
+
+/// number of instructions (each is identified by an opaque int)
+int num_insts     = ...;
+
+/// number of muops (each is identified by an opaque int)
+int num_muops     = ...;
+
+/// number of ports (each is identified by an opaque int)
+int num_ports     = ...;
+
+
+///### KERNELS
+
+/// number of kernels that where run
+int num_kernels   = ...;
+
+/// Instruction per Cycle (IPC), i.e. throughput, measured for kernel *k*
+float IPC[k in num_kernels] = ...;
+
+/// how many times instruction *i* appears in kernel *k*
+int occurences[k in num_kernels][i in num_insts] = ...;
+
+
+///#############################################################################
+///##### OUTPUT
+
+/// bipartite graph between instructions and muops
+dvar int graph_im[num_muops][num_ports] in 0..1;
+
+/// bipartite graph between muops and ports
+dvar int graph_mp[num_muops][num_ports] in 0..1;
+
+
+///#############################################################################
+///##### HELPERS
+
+/// throughput per edge (inst, muop) in kernel k
+dvar float throughput_im[num_kernels][num_insts][num_muops];
+
+/// throughput per edge (muop, port) in kernel k
+dvar float throughput_mp[num_kernels][num_insts][num_muops];
+
+/// throughput for muop type i in kernel s
+dexpr float muop_throughput[k in num_kernels][m in num_muops] = sum(p in num_ports) throughput[k][m][p];
+
+/// mean throughput for a given muop type in a kernel
+dexpr float mean[k in num_kernels][m in num_muops] = (1 / num_ports) * sum(p in num_ports) throughput[k][m][p];
+
+/// variance of throughput for a given muop type in a kernel
+dexpr float variance[k in num_kernels][m in num_muops] = (1 / num_ports) *
+  sum(p in num_ports) pow(throughput[k][m][p], 2) - pow(mean[k][m], 2);
+
+
+dexpr int num_im_edges = sum(k in num_kernels) sum(i in num_insts) sum(m in num_muops) delta_mp[k][i][m]
+
+dexpr int num_mp_edges = sum(k in num_kernels) sum(m in num_muops) sum(p in num_ports) delta_mp[k][m][p]
+
+
+//##############################################################################
+//##### OBJECTIVE FUNCTION
+
+dexpr float all_throughputs = sum(k in num_kernels) total_throughput[k];
+
+/// number of edges present in the machine
+dexpr float num_edges = sum(i in Src, p in num_ports) delta_mp[m][p];
+
+dexpr float all_variances = sum(k in num_kernels, i in Src) variance[k][m];
+
+maximize(num_mp_edges - num_im_edges);
+
+
+//##############################################################################
+//##### CONSTRAINTS
+
+subject to {
+  forall(k in num_kernels, i in Src, p in num_ports) {
+    throughput_bounds:
+      0 <= throughput[k][m][p];
+  }
+  forall(k in num_kernels, i in Src, p in num_ports) {
+    throughputs_limited_by_delta_mp:
+      throughput[k][m][p] <= delta_mp[m][p];
+  }
+
+  forall(k in num_kernels, p in num_ports) {
+    port_bandwidth:
+      sum(i in Src) throughput[k][m][p] <= 1;
+  }
+
+  forall(k in num_kernels) {
+    total_throughput_limited_by_ports:
+      total_throughput[k] <= num_ports;
+  }
+
+  forall(k in num_kernels) {
+    total_throughput_is_sum_of_throughputss:
+      total_throughput[k] == sum(i in Src) muop_throughput[k][m];
+  }
+
+#// prints constraints set with OPL label iff constraint text is not empty
+#% macro constraint_set(name)
+#%   set X = caller().strip()
+#%   if X and not X.isspace()
+  {{ name }}:
+    {{ X }}
+#%   endif
+#% endmacro
+
+#// print delta_mp
+#% call constraint_set('port_layout')
+#%   for i, j in model.delta_mp | sort_by_index
+#%     set edge = model.delta_mp[i, j]
+#%     if edge.is_specified
+    delta_mp[{{ i | tuple }}][{{ j | tuple }}] == {{ edge }};
+#%     endif
+#%   endfor
+#% endcall
+
+#// print total throughput per kernel
+#% call constraint_set('observed_total_throughput')
+#%   for seq in model.total_throughput | sort_by_index
+#%     set total_throughput = model.total_throughput[seq]
+#%     if total_throughput.is_specified
+    total_throughput[{{ seq[0] | tuple }}] == {{ total_throughput }};
+#%     endif
+#%   endfor
+#% endcall
+
+#// print throughput per muop/port pair
+#% call constraint_set('observed_throughputs')
+#%   for s, i, j in model.throughput | sort_by_index
+#%     set throughput = model.throughput[s, i, j]
+#%     if throughput.is_specified
+    throughput[{{ s | tuple }}][{{ i | tuple }}][{{ j | tuple }}] == {{ throughput }};
+#%     endif
+#%   endfor
+#% endcall
+
+#// print instruction ratios in kernels
+#% call constraint_set('inst_mix')
+#%   set mix = model.instruction_mix
+#%   for s, i in mix
+#%     set ratio = mix[s, i]
+#%     if ratio == 0
+         #// can't use muop_throughput here because that would use tuple patterns
+         #// and we already use non-pattern constraints elsewhere
+    sum(p in num_ports) throughput[{{ s | tuple }}][{{ i | tuple }}][p] == 0;
+#%     endif
+#%   endfor
+#%   for s in model.kernels
+#%     for i1, i2 in model.muops | combinations(2)
+#%       set r1 = mix[s, i1]
+#%       set r2 = mix[s, i2]
+#%       if r1 and r2
+    {{ r1 }} * sum(p in num_ports) throughput[{{ s | tuple }}][{{ i1 | tuple }}][p] == {{ r2 }} * sum(p in num_ports) throughput[{{ s | tuple }}][{{ i2 | tuple }}][p];
+#%       endif
+#%     endfor
+#%   endfor
+#% endcall
+}