1 /* Copyright (c) 2012 Massachusetts Institute of Technology
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
4 * of this software and associated documentation files (the "Software"), to deal
5 * in the Software without restriction, including without limitation the rights
6 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7 * copies of the Software, and to permit persons to whom the Software is
8 * furnished to do so, subject to the following conditions:
10 * The above copyright notice and this permission notice shall be included in
11 * all copies or substantial portions of the Software.
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 #include "model/optical/OpticalLinkBackendTx.h"
24 #include "util/Constants.h"
25 #include "model/PortInfo.h"
26 #include "model/TransitionInfo.h"
27 #include "model/EventInfo.h"
28 #include "model/electrical/MuxTreeSerializer.h"
29 #include "model/electrical/BarrelShifter.h"
30 #include "model/electrical/Multiplexer.h"
35 // TODO: Kind of don't like the way thermal tuning is written here. Maybe will switch
36 // to curve fitting the CICC paper, which uses results from a monte-carlo sim
38 OpticalLinkBackendTx::OpticalLinkBackendTx(const String
& instance_name_
, const TechModel
* tech_model_
)
39 : ElectricalModel(instance_name_
, tech_model_
)
45 OpticalLinkBackendTx::~OpticalLinkBackendTx()
48 void OpticalLinkBackendTx::initParameters()
50 addParameterName("InBits");
51 addParameterName("CoreDataRate");
52 addParameterName("LinkDataRate");
53 addParameterName("RingTuningMethod");
54 addParameterName("BitDuplicate");
58 void OpticalLinkBackendTx::initProperties()
63 void OpticalLinkBackendTx::constructModel()
65 unsigned int in_bits
= getParameter("InBits");
66 double core_data_rate
= getParameter("CoreDataRate");
67 double link_data_rate
= getParameter("LinkDataRate");
68 const String
& tuning_method
= getParameter("RingTuningMethod");;
69 bool bit_duplicate
= getParameter("BitDuplicate");
71 // Calculate serialization ratio
72 unsigned int serialization_ratio
= (unsigned int) floor(link_data_rate
/ core_data_rate
);
73 ASSERT(serialization_ratio
== link_data_rate
/ core_data_rate
,
74 "[Error] " + getInstanceName() + " -> Cannot have non-integer serialization ratios " +
75 "(" + (String
) (core_data_rate
/ link_data_rate
) + ")!");
77 // Calculate output width
78 ASSERT(floor((double) in_bits
/ serialization_ratio
) == (double) in_bits
/ serialization_ratio
,
79 "[Error] " + getInstanceName() + " -> Input width (" + (String
) in_bits
+ ") " +
80 "must be a multiple of the serialization ratio (" + (String
) serialization_ratio
+ ")!");
81 unsigned int out_bits
= in_bits
/ serialization_ratio
;
83 getGenProperties()->set("SerializationRatio", serialization_ratio
);
84 getGenProperties()->set("OutBits", out_bits
);
87 createInputPort("In", makeNetIndex(0, in_bits
-1));
88 createInputPort("LinkCK");
89 createOutputPort("Out", makeNetIndex(0, out_bits
-1));
91 //Create energy, power, and area results
92 createElectricalResults();
93 // Create ring heating power cost
94 addNddPowerResult(new AtomicResult("RingTuning"));
95 // Create process bits event
96 createElectricalEventResult("ProcessBits");
97 getEventInfo("ProcessBits")->setTransitionInfo("LinkCK", TransitionInfo(0.0, (double) serialization_ratio
/ 2.0, 0.0));
98 // Set conditions during idle state
99 getEventInfo("Idle")->setStaticTransitionInfos();
100 getEventInfo("Idle")->setTransitionInfo("LinkCK", TransitionInfo(0.0, (double) serialization_ratio
/ 2.0, 0.0));
103 const String
& serializer_name
= "Serializer";
104 MuxTreeSerializer
* serializer
= new MuxTreeSerializer(serializer_name
, getTechModel());
105 serializer
->setParameter("InBits", in_bits
);
106 serializer
->setParameter("InDataRate", core_data_rate
);
107 serializer
->setParameter("OutDataRate", link_data_rate
);
108 serializer
->setParameter("BitDuplicate", bit_duplicate
);
109 serializer
->construct();
111 addSubInstances(serializer
, 1.0);
112 addElectricalSubResults(serializer
, 1.0);
113 getEventResult("ProcessBits")->addSubResult(serializer
->getEventResult("Serialize"), serializer_name
, 1.0);
115 if ((tuning_method
== "ThermalWithBitReshuffle") || (tuning_method
== "ElectricalAssistWithBitReshuffle"))
117 // If a bit reshuffling backend is present, create the reshuffling backend
118 unsigned int reorder_degree
= getBitReorderDegree();
120 // Create intermediate nets
121 createNet("SerializerIn", makeNetIndex(0, in_bits
-1));
122 createNet("ReorderIn", makeNetIndex(0, out_bits
+reorder_degree
-1));
123 assign("ReorderIn", makeNetIndex(out_bits
, out_bits
+reorder_degree
-1), "ReorderIn", makeNetIndex(0, reorder_degree
-1));
125 // Create barrelshifter
126 unsigned int shift_index_min
= (unsigned int)ceil(log2(serialization_ratio
));
127 unsigned int shift_index_max
= std::max(shift_index_min
, (unsigned int) ceil(log2(in_bits
)) - 1);
129 // Remember some things
130 getGenProperties()->set("ReorderDegree", reorder_degree
);
131 getGenProperties()->set("ShiftIndexMin", shift_index_min
);
132 getGenProperties()->set("ShiftIndexMax", shift_index_max
);
134 const String
& barrel_shift_name
= "BarrelShifter";
135 BarrelShifter
* barrel_shift
= new BarrelShifter(barrel_shift_name
, getTechModel());
136 barrel_shift
->setParameter("NumberBits", in_bits
);
137 barrel_shift
->setParameter("ShiftIndexMax", shift_index_max
);
138 barrel_shift
->setParameter("ShiftIndexMin", shift_index_min
);
139 barrel_shift
->setParameter("BitDuplicate", bit_duplicate
);
140 barrel_shift
->construct();
142 // Create bit reorder muxes
143 const String
& reorder_mux_name
= "ReorderMux";
144 Multiplexer
* reorder_mux
= new Multiplexer(reorder_mux_name
, getTechModel());
145 reorder_mux
->setParameter("NumberBits", out_bits
);
146 reorder_mux
->setParameter("NumberInputs", reorder_degree
);
147 reorder_mux
->setParameter("BitDuplicate", bit_duplicate
);
148 reorder_mux
->construct();
150 // Connect barrelshifter
151 // TODO: Connect barrelshift shifts!
152 portConnect(barrel_shift
, "In", "In");
153 portConnect(barrel_shift
, "Out", "SerializerIn");
155 // Connect serializer
156 portConnect(serializer
, "In", "SerializerIn");
157 portConnect(serializer
, "Out", "ReorderIn", makeNetIndex(0, out_bits
-1));
158 portConnect(serializer
, "OutCK", "LinkCK");
160 // Connect bit reorder muxes
161 // TODO: Connect re-order multiplex select signals!
162 for (unsigned int i
= 0; i
< reorder_degree
; i
++)
163 portConnect(reorder_mux
, "In" + (String
) i
, "ReorderIn", makeNetIndex(i
, i
+out_bits
-1));
164 portConnect(reorder_mux
, "Out", "Out");
166 addSubInstances(barrel_shift
, 1.0);
167 addSubInstances(reorder_mux
, 1.0);
168 addElectricalSubResults(barrel_shift
, 1.0);
169 addElectricalSubResults(reorder_mux
, 1.0);
170 getEventResult("ProcessBits")->addSubResult(barrel_shift
->getEventResult("BarrelShift"), barrel_shift_name
, 1.0);
171 getEventResult("ProcessBits")->addSubResult(reorder_mux
->getEventResult("Mux"), reorder_mux_name
, 1.0); // This happens multiple times
173 else if ((tuning_method
== "FullThermal") || (tuning_method
== "AthermalWithTrim"))
175 // If no bit reshuffling backend is present, then just connect serializer up
176 portConnect(serializer
, "In", "In");
177 portConnect(serializer
, "Out", "Out");
178 portConnect(serializer
, "OutCK", "LinkCK");
182 ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown ring tuning method '" + tuning_method
+ "'!");
188 void OpticalLinkBackendTx::updateModel()
191 Model::updateModel();
192 // Update ring tuning power
193 getNddPowerResult("RingTuning")->setValue(getRingTuningPower());
197 void OpticalLinkBackendTx::propagateTransitionInfo()
200 const String
& tuning_method
= getParameter("RingTuningMethod");
202 // Update the serializer
203 if ((tuning_method
== "ThermalWithBitReshuffle") || (tuning_method
== "ElectricalAssistWithBitReshuffle"))
205 // Get generated properties
206 unsigned int reorder_degree
= getGenProperties()->get("ReorderDegree").toUInt();
207 unsigned int shift_index_min
= getGenProperties()->get("ShiftIndexMin").toUInt();
208 unsigned int shift_index_max
= getGenProperties()->get("ShiftIndexMax").toUInt();
210 // Update barrel shifter
211 const String
& barrel_shift_name
= "BarrelShifter";
212 ElectricalModel
* barrel_shift
= (ElectricalModel
*) getSubInstance(barrel_shift_name
);
213 propagatePortTransitionInfo(barrel_shift
, "In", "In");
214 // Set shift transitions to be very low (since it is affected by slow temperature time constants)
215 for (unsigned int i
= shift_index_min
; i
<= shift_index_max
; ++i
)
216 barrel_shift
->getInputPort("Shift" + (String
) i
)->setTransitionInfo(TransitionInfo(0.499, 0.001, 0.499));
219 // Set serializer transition info
220 ElectricalModel
* serializer
= (ElectricalModel
*) getSubInstance("Serializer");
221 propagatePortTransitionInfo(serializer
, "In", barrel_shift
, "Out");
222 propagatePortTransitionInfo(serializer
, "OutCK", "LinkCK");
225 // Reorder mux shift select bits
226 unsigned int reorder_sel_bits
= (unsigned int)ceil(log2(reorder_degree
));
228 // Reorder mux probabilities
229 const String
& reorder_mux_name
= "ReorderMux";
230 ElectricalModel
* reorder_mux
= (ElectricalModel
*) getSubInstance(reorder_mux_name
);
231 for (unsigned int i
= 0; i
< reorder_degree
; ++i
)
232 propagatePortTransitionInfo(reorder_mux
, "In" + (String
) i
, serializer
, "Out");
233 // Set select transitions to be 0, since these are statically configured
234 for (unsigned int i
= 0; i
< reorder_sel_bits
; ++i
)
235 reorder_mux
->getInputPort("Sel" + (String
) i
)->setTransitionInfo(TransitionInfo(0.5, 0.0, 0.5));
238 // Set output transition info
239 propagatePortTransitionInfo("Out", reorder_mux
, "Out");
241 else if ((tuning_method
== "FullThermal") || (tuning_method
== "AthermalWithTrim"))
243 // Set serializer transition info
244 ElectricalModel
* serializer
= (ElectricalModel
*) getSubInstance("Serializer");
245 propagatePortTransitionInfo(serializer
, "In", "In");
246 propagatePortTransitionInfo(serializer
, "OutCK", "LinkCK");
249 // Set output transition info
250 propagatePortTransitionInfo("Out", serializer
, "Out");
256 double OpticalLinkBackendTx::getRingTuningPower()
259 const String
& tuning_method
= getParameter("RingTuningMethod");;
260 unsigned int number_rings
= getGenProperties()->get("OutBits");
262 // Get tech model parameters
263 double R
= getTechModel()->get("Ring->Radius");
264 double n_g
= getTechModel()->get("Ring->GroupIndex");
265 double heating_efficiency
= getTechModel()->get("Ring->HeatingEfficiency");
266 // This can actually be derived if we know thermo-optic coefficient (delta n / delta T)
267 double tuning_efficiency
= getTechModel()->get("Ring->TuningEfficiency");
268 double sigma_r_local
= getTechModel()->get("Ring->LocalVariationSigma");
269 double sigma_r_systematic
= getTechModel()->get("Ring->SystematicVariationSigma");
270 double T_max
= getTechModel()->get("Ring->TemperatureMax");
271 double T_min
= getTechModel()->get("Ring->TemperatureMin");
272 double T
= getTechModel()->get("Temperature");
275 double c
= Constants::c
;
276 double pi
= Constants::pi
;
278 double tuning_power
= 0.0;
280 if (tuning_method
== "ThermalWithBitReshuffle")
282 // When an electrical backend is present, rings only have to tune to the nearest channel
283 // This can be approximated as each ring tuning to something exactly 1 channel away
285 // Setup calculations
286 double L
= 2 * pi
* R
; // Optical length
287 double FSR
= c
/ (n_g
* L
); // Free spectral range
288 double freq_sep
= FSR
/ number_rings
; // Channel separation
290 // Calculate tuning power
291 tuning_power
= number_rings
* freq_sep
/ (tuning_efficiency
* heating_efficiency
);
293 else if (tuning_method
== "ElectricalAssistWithBitReshuffle")
295 // Electrical assistance allows for a fraction of the tuning range to be
296 // covered electrically. This is most pronounced when the tuning range is small,
297 // such is the case when bit reshuffling is applied. The electrically
298 // assisted part of it pretty much comes for free...
300 // Get electrically tunable range
301 double max_assist
= getTechModel()->get("Ring->MaxElectricallyTunableFreq");
303 // Setup calculations
304 double L
= 2 * pi
* R
; // Optical length
305 double FSR
= c
/ (n_g
* L
); // Free spectral range
306 double freq_sep
= FSR
/ number_rings
; // Channel separation
307 double heating_range
= std::max(0.0, freq_sep
- max_assist
); // The distance needed to bridge using heaters
309 // Calculate tuning power, which is really only the power spent on heating since
310 // distance tuned electrically is pretty much free
311 tuning_power
= number_rings
* heating_range
/ (tuning_efficiency
* heating_efficiency
);
313 else if (tuning_method
== "FullThermal")
315 // If there is no bit reshuffling backend, each ring must tune to an
316 // absolute channel frequency. Since we can only heat rings (and not cool),
317 // we can only red-shift (decrease frequency). Thus, a fabrication bias
318 // must be applied such that under any process and temperature corner, the
319 // ring resonance remains above channel resonance
320 // I'll use 3 sigmas of sigma_r_local and sigma_r_systematic, and bias against
321 // the full temperature range
322 double fabrication_bias_freq
= 3.0 * sqrt(pow(sigma_r_local
, 2) + pow(sigma_r_systematic
, 2)) +
323 (T_max
- T_min
) * tuning_efficiency
;
325 // The local/systematic variations are 0 on average. Thus, the tuning distance can be calculated as
326 double tuning_distance
= fabrication_bias_freq
- (T
- T_min
) * tuning_efficiency
;
328 // Tuning power needed is just the number of rings * tuning distance / (tuning and heating efficiencies)
329 tuning_power
= number_rings
* tuning_distance
/ (tuning_efficiency
* heating_efficiency
);
331 else if (tuning_method
== "AthermalWithTrim")
333 // Athermal! Each ring's process variations are trimmed! Everything is free!
334 // Basically an ideal scenario
339 ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown ring tuning method '" + tuning_method
+ "'!");
345 unsigned int OpticalLinkBackendTx::getBitReorderDegree()
348 unsigned int number_rings
= getGenProperties()->get("OutBits");
350 // Get tech model parameters
351 double R
= getTechModel()->get("Ring->Radius");
352 double n_g
= getTechModel()->get("Ring->GroupIndex");
353 // This can actually be derived if we know thermo-optic coefficient (delta n / delta T)
354 double sigma_r_local
= getTechModel()->get("Ring->LocalVariationSigma");
357 double c
= Constants::c
;
358 double pi
= Constants::pi
;
360 // Calculates the degree of bit re-order multiplexing needed for bit-reshuffling backend
361 // Bit reshuffling tuning is largely unaffected by sigma_r_systematic. However, sigma_r_local
362 // Can potentially throw each ring to a channel several channels away. This just calculates
363 // the degree of bit reorder muxing needed to realign bits in the correct order
365 // Setup calculations
366 double L
= 2 * pi
* R
; // Optical length
367 double FSR
= c
/ (n_g
* L
); // Free spectral range
368 double freq_sep
= FSR
/ number_rings
; // Channel separation
369 // Using 4 sigmas as the worst re-ordering case (must double to get both sides)
370 unsigned int worst_case_channels
= (unsigned int)ceil(2.0 * 4.0 * sigma_r_local
/ freq_sep
);
372 return worst_case_channels
;