1/* Copyright (c) 2012 Massachusetts Institute of Technology 2 * 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: 9 * 10 * The above copyright notice and this permission notice shall be included in 11 * all copies or substantial portions of the Software. 12 * 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 19 * THE SOFTWARE. 20 */ 21 22#include "model/optical/OpticalLinkBackendRx.h" 23 24#include "util/Constants.h" 25#include "model/PortInfo.h" 26#include "model/TransitionInfo.h" 27#include "model/EventInfo.h" 28#include "model/electrical/DemuxTreeDeserializer.h" 29#include "model/electrical/BarrelShifter.h" 30#include "model/electrical/Multiplexer.h" 31#include <cmath> 32 33namespace DSENT 34{ 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. Also, there is 37 // redundant code between this one and the tx one... 38 39 OpticalLinkBackendRx::OpticalLinkBackendRx(const String& instance_name_, const TechModel* tech_model_) 40 : ElectricalModel(instance_name_, tech_model_) 41 { 42 initParameters(); 43 initProperties(); 44 } 45 46 OpticalLinkBackendRx::~OpticalLinkBackendRx() 47 {} 48 49 void OpticalLinkBackendRx::initParameters() 50 { 51 addParameterName("OutBits"); 52 addParameterName("CoreDataRate"); 53 addParameterName("LinkDataRate"); 54 addParameterName("RingTuningMethod"); 55 addParameterName("BitDuplicate"); 56 return; 57 } 58 59 void OpticalLinkBackendRx::initProperties() 60 { 61 return; 62 } 63 64 void OpticalLinkBackendRx::constructModel() 65 { 66 unsigned int out_bits = getParameter("OutBits"); 67 double core_data_rate = getParameter("CoreDataRate"); 68 double link_data_rate = getParameter("LinkDataRate"); 69 const String& tuning_method = getParameter("RingTuningMethod"); 70 bool bit_duplicate = getParameter("BitDuplicate"); 71 72 // Calculate deserialization ratio 73 unsigned int deserialization_ratio = (unsigned int) floor(link_data_rate / core_data_rate); 74 ASSERT(deserialization_ratio == link_data_rate / core_data_rate, 75 "[Error] " + getInstanceName() + " -> Cannot have non-integer deserialization ratios!"); 76 ASSERT((deserialization_ratio & (deserialization_ratio - 1)) == 0, 77 "[Error] " + getInstanceName() + " -> Deserialization ratio must be a power of 2"); 78 79 // Calculate output width 80 unsigned int in_bits = out_bits / deserialization_ratio; 81 ASSERT(out_bits >= deserialization_ratio, "[Error] " + getInstanceName() + 82 " -> Output width must be >= deserialization ratio!"); 83 ASSERT(floor((double) out_bits / deserialization_ratio) == in_bits, 84 "[Error] " + getInstanceName() + " -> Output width must be a multiple of the serialization ratio!"); 85 86 getGenProperties()->set("DeserializationRatio", deserialization_ratio); 87 getGenProperties()->set("InBits", in_bits); 88 89 // Create ports 90 createInputPort("In", makeNetIndex(0, in_bits-1)); 91 createInputPort("LinkCK"); 92 createOutputPort("Out", makeNetIndex(0, out_bits-1)); 93 94 //Create energy, power, and area results 95 createElectricalResults(); 96 // Create ring heating power cost 97 addNddPowerResult(new AtomicResult("RingTuning")); 98 // Create process bits event 99 createElectricalEventResult("ProcessBits"); 100 getEventInfo("ProcessBits")->setTransitionInfo("LinkCK", TransitionInfo(0.0, (double) deserialization_ratio / 2.0, 0.0)); 101 // Set conditions during idle state 102 getEventInfo("Idle")->setStaticTransitionInfos(); 103 getEventInfo("Idle")->setTransitionInfo("LinkCK", TransitionInfo(0.0, (double) deserialization_ratio / 2.0, 0.0)); 104 105 // Create deserializer 106 const String& deserializer_name = "Deserializer"; 107 DemuxTreeDeserializer* deserializer = new DemuxTreeDeserializer(deserializer_name, getTechModel()); 108 deserializer->setParameter("OutBits", out_bits); 109 deserializer->setParameter("InDataRate", link_data_rate); 110 deserializer->setParameter("OutDataRate", core_data_rate); 111 deserializer->setParameter("BitDuplicate", bit_duplicate); 112 deserializer->construct(); 113 114 addSubInstances(deserializer, 1.0); 115 addElectricalSubResults(deserializer, 1.0); 116 getEventResult("ProcessBits")->addSubResult(deserializer->getEventResult("Deserialize"), deserializer_name, 1.0); 117 118 if ((tuning_method == "ThermalWithBitReshuffle") || (tuning_method == "ElectricalAssistWithBitReshuffle")) 119 { 120 // If a bit reshuffling backend is present, create the reshuffling backend 121 unsigned int reorder_degree = getBitReorderDegree(); 122 123 // Create intermediate nets 124 createNet("ReorderIn", makeNetIndex(0, in_bits+reorder_degree-1)); 125 assign("ReorderIn", makeNetIndex(0, in_bits-1), "In"); 126 assign("ReorderIn", makeNetIndex(in_bits, in_bits+reorder_degree-1), "ReorderIn", makeNetIndex(0, reorder_degree-1)); 127 createNet("DeserializerIn", makeNetIndex(0, in_bits-1)); 128 createNet("BarrelShiftIn", makeNetIndex(0, out_bits-1)); 129 130 // Create bit reorder muxes 131 const String& reorder_mux_name = "ReorderMux"; 132 Multiplexer* reorder_mux = new Multiplexer(reorder_mux_name, getTechModel()); 133 reorder_mux->setParameter("NumberBits", in_bits); 134 reorder_mux->setParameter("NumberInputs", reorder_degree); 135 reorder_mux->setParameter("BitDuplicate", bit_duplicate); 136 reorder_mux->construct(); 137 138 // Create barrelshifter 139 unsigned int shift_index_min = (unsigned int)ceil(log2(deserialization_ratio)); 140 unsigned int shift_index_max = std::max(shift_index_min, (unsigned int) ceil(log2(out_bits)) - 1); 141 142 // Remember some things 143 getGenProperties()->set("ReorderDegree", reorder_degree); 144 getGenProperties()->set("ShiftIndexMin", shift_index_min); 145 getGenProperties()->set("ShiftIndexMax", shift_index_max); 146 147 const String& barrel_shift_name = "BarrelShifter"; 148 BarrelShifter* barrel_shift = new BarrelShifter(barrel_shift_name, getTechModel()); 149 barrel_shift->setParameter("NumberBits", out_bits); 150 barrel_shift->setParameter("ShiftIndexMax", shift_index_max); 151 barrel_shift->setParameter("ShiftIndexMin", shift_index_min); 152 barrel_shift->setParameter("BitDuplicate", bit_duplicate); 153 barrel_shift->construct(); 154 155 // Connect serializer 156 portConnect(deserializer, "In", "DeserializerIn"); 157 portConnect(deserializer, "Out", "BarrelShiftIn"); 158 portConnect(deserializer, "InCK", "LinkCK"); 159 160 // Connect barrelshifter 161 // TODO: Connect barrelshift shifts! 162 portConnect(barrel_shift, "In", "BarrelShiftIn"); 163 portConnect(barrel_shift, "Out", "Out"); 164 165 // Connect bit reorder muxes 166 // TODO: Connect re-order multiplex select signals! 167 for (unsigned int i = 0; i < reorder_degree; i++) 168 portConnect(reorder_mux, "In" + (String) i, "ReorderIn", makeNetIndex(i, i+in_bits-1)); 169 portConnect(reorder_mux, "Out", "DeserializerIn"); 170 171 addSubInstances(barrel_shift, 1.0); 172 addSubInstances(reorder_mux, 1.0); 173 addElectricalSubResults(barrel_shift, 1.0); 174 addElectricalSubResults(reorder_mux, 1.0); 175 getEventResult("ProcessBits")->addSubResult(barrel_shift->getEventResult("BarrelShift"), barrel_shift_name, 1.0); 176 getEventResult("ProcessBits")->addSubResult(reorder_mux->getEventResult("Mux"), reorder_mux_name, 1.0); 177 } 178 else if ((tuning_method == "FullThermal") || (tuning_method == "AthermalWithTrim")) 179 { 180 // If no bit reshuffling backend is present, then just connect deserializer up 181 portConnect(deserializer, "In", "In"); 182 portConnect(deserializer, "Out", "Out"); 183 portConnect(deserializer, "InCK", "LinkCK"); 184 } 185 else 186 { 187 ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown ring tuning method '" + tuning_method + "'!"); 188 } 189 190 return; 191 } 192 193 void OpticalLinkBackendRx::updateModel() 194 { 195 // Update everyone 196 Model::updateModel(); 197 // Update ring tuning power 198 getNddPowerResult("RingTuning")->setValue(getRingTuningPower()); 199 return; 200 } 201 202 void OpticalLinkBackendRx::propagateTransitionInfo() 203 { 204 // Get parameters 205 const String& tuning_method = getParameter("RingTuningMethod");; 206 207 // Get properties 208 209 // Update the deserializer 210 if ((tuning_method == "ThermalWithBitReshuffle") || (tuning_method == "ElectricalAssistWithBitReshuffle")) 211 { 212 // Get generated properties 213 unsigned int reorder_degree = getGenProperties()->get("ReorderDegree"); 214 unsigned int shift_index_min = getGenProperties()->get("ShiftIndexMin"); 215 unsigned int shift_index_max = getGenProperties()->get("ShiftIndexMax"); 216 217 // Reorder mux shift select bits 218 unsigned int reorder_sel_bits = (unsigned int)ceil(log2(reorder_degree)); 219 220 // Create bit reorder muxes 221 const String& reorder_mux_name = "ReorderMux"; 222 ElectricalModel* reorder_mux = (ElectricalModel*) getSubInstance(reorder_mux_name); 223 for (unsigned int i = 0; i < reorder_degree; ++i) 224 propagatePortTransitionInfo(reorder_mux, "In" + (String) i, "In"); 225 // Set select transitions to be 0, since these are statically configured 226 for (unsigned int i = 0; i < reorder_sel_bits; ++i) 227 reorder_mux->getInputPort("Sel" + (String) i)->setTransitionInfo(TransitionInfo(0.5, 0.0, 0.5)); 228 reorder_mux->use(); 229 230 // Update the deserializer 231 ElectricalModel* deserializer = (ElectricalModel*) getSubInstance("Deserializer"); 232 propagatePortTransitionInfo(deserializer, "In", reorder_mux, "Out"); 233 propagatePortTransitionInfo(deserializer, "InCK", "LinkCK"); 234 deserializer->use(); 235 236 // Update barrel shifter 237 const String& barrel_shift_name = "BarrelShifter"; 238 ElectricalModel* barrel_shift = (ElectricalModel*) getSubInstance(barrel_shift_name); 239 propagatePortTransitionInfo(barrel_shift, "In", deserializer, "Out"); 240 // Set shift transitions to be very low (since it is affected by slow temperature time constants) 241 for (unsigned int i = shift_index_min; i <= shift_index_max; ++i) 242 barrel_shift->getInputPort("Shift" + (String) i)->setTransitionInfo(TransitionInfo(0.499, 0.001, 0.499)); 243 barrel_shift->use(); 244 245 // Set output transition info 246 propagatePortTransitionInfo("Out", barrel_shift, "Out"); 247 } 248 else if ((tuning_method == "FullThermal") || (tuning_method == "AthermalWithTrim")) 249 { 250 // Update the deserializer 251 ElectricalModel* deserializer = (ElectricalModel*) getSubInstance("Deserializer"); 252 propagatePortTransitionInfo(deserializer, "In", "In"); 253 propagatePortTransitionInfo(deserializer, "InCK", "LinkCK"); 254 deserializer->use(); 255 256 // Set output transition info 257 propagatePortTransitionInfo("Out", deserializer, "Out"); 258 } 259 else 260 { 261 ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown ring tuning method '" + tuning_method + "'!"); 262 } 263 264 return; 265 } 266 267 double OpticalLinkBackendRx::getRingTuningPower() 268 { 269 // Get properties 270 const String& tuning_method = getParameter("RingTuningMethod");; 271 unsigned int number_rings = getGenProperties()->get("InBits"); 272 273 // Get tech model parameters 274 double R = getTechModel()->get("Ring->Radius"); 275 double n_g = getTechModel()->get("Ring->GroupIndex"); 276 double heating_efficiency = getTechModel()->get("Ring->HeatingEfficiency"); 277 // This can actually be derived if we know thermo-optic coefficient (delta n / delta T) 278 double tuning_efficiency = getTechModel()->get("Ring->TuningEfficiency"); 279 double sigma_r_local = getTechModel()->get("Ring->LocalVariationSigma"); 280 double sigma_r_systematic = getTechModel()->get("Ring->SystematicVariationSigma"); 281 double T_max = getTechModel()->get("Ring->TemperatureMax"); 282 double T_min = getTechModel()->get("Ring->TemperatureMin"); 283 double T = getTechModel()->get("Temperature"); 284 285 // Get constants 286 double c = Constants::c; 287 double pi = Constants::pi; 288 289 double tuning_power = 0.0; 290 291 if (tuning_method == "ThermalWithBitReshuffle") 292 { 293 // When an electrical backend is present, rings only have to tune to the nearest channel 294 // This can be approximated as each ring tuning to something exactly 1 channel away 295 296 // Setup calculations 297 double L = 2 * pi * R; // Optical length 298 double FSR = c / (n_g * L); // Free spectral range 299 double freq_sep = FSR / number_rings; // Channel separation 300 301 // Calculate tuning power 302 tuning_power = number_rings * freq_sep / (tuning_efficiency * heating_efficiency); 303 } 304 else if (tuning_method == "ElectricalAssistWithBitReshuffle") 305 { 306 // Electrical assistance allows for a fraction of the tuning range to be 307 // covered electrically. This is most pronounced when the tuning range is small, 308 // such is the case when bit reshuffling is applied 309 310 // Get electrically tunable range 311 double max_assist = getTechModel()->get("Ring->MaxElectricallyTunableFreq"); 312 313 // Setup calculations 314 double L = 2 * pi * R; // Optical length 315 double FSR = c / (n_g * L); // Free spectral range 316 double freq_sep = FSR / number_rings; // Channel separation 317 double heating_range = std::max(0.0, freq_sep - max_assist); // The distance needed to bridge using heaters 318 319 // Calculate tuning power, which is really only the power spent on heating since 320 // distance tuned electrically is pretty much free 321 tuning_power = number_rings * heating_range / (tuning_efficiency * heating_efficiency); 322 } 323 else if (tuning_method == "FullThermal") 324 { 325 // If there is no bit reshuffling backend, each ring must tune to an 326 // absolute channel frequency. Since we can only heat rings (and not cool), 327 // we can only red-shift (decrease frequency). Thus, a fabrication bias 328 // must be applied such that under any process and temperature corner, the 329 // ring resonance remains above channel resonance 330 // I'll use 3 sigmas of sigma_r_local and sigma_r_systematic, and bias against 331 // the full temperature range 332 double fabrication_bias_freq = 3.0 * sqrt(pow(sigma_r_local, 2) + pow(sigma_r_systematic, 2)) + 333 (T_max - T_min) * tuning_efficiency; 334 335 // The local/systematic variations are 0 on average. Thus, the tuning distance can be calculated as 336 double tuning_distance = fabrication_bias_freq - (T - T_min) * tuning_efficiency; 337 338 // Tuning power needed is just the number of rings * tuning distance / (tuning and heating efficiencies) 339 tuning_power = number_rings * tuning_distance / (tuning_efficiency * heating_efficiency); 340 } 341 else if (tuning_method == "AthermalWithTrim") 342 { 343 // Athermal! 344 tuning_power = 0; 345 } 346 else 347 { 348 ASSERT(false, "[Error] " + getInstanceName() + " -> Unknown ring tuning method '" + tuning_method + "'!"); 349 } 350 351 return tuning_power; 352 } 353 354 unsigned int OpticalLinkBackendRx::getBitReorderDegree() 355 { 356 // Get properties 357 unsigned int number_rings = getGenProperties()->get("InBits"); 358 359 // Get tech model parameters 360 double R = getTechModel()->get("Ring->Radius"); 361 double n_g = getTechModel()->get("Ring->GroupIndex"); 362 // This can actually be derived if we know thermo-optic coefficient (delta n / delta T) 363 double sigma_r_local = getTechModel()->get("Ring->LocalVariationSigma"); 364 365 // Get constants 366 double c = Constants::c; 367 double pi = Constants::pi; 368 369 // Calculates the degree of bit re-order multiplexing needed for bit-reshuffling backend 370 // Bit reshuffling tuning is largely unaffected by sigma_r_systematic. However, sigma_r_local 371 // Can potentially throw each ring to a channel several channels away. This just calculates 372 // the degree of bit reorder muxing needed to realign bits in the correct order 373 374 // Setup calculations 375 double L = 2 * pi * R; // Optical length 376 double FSR = c / (n_g * L); // Free spectral range 377 double freq_sep = FSR / number_rings; // Channel separation 378 // Using 4 sigmas as the worst re-ordering case (must double to get both sides) 379 unsigned int worst_case_channels = (unsigned int)ceil(2.0 * 4.0 * sigma_r_local / freq_sep); 380 381 return worst_case_channels; 382 } 383 384} // namespace DSENT 385 386