| /* |
| * Copyright (c) 1999-2008 Mark D. Hill and David A. Wood |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer; |
| * redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution; |
| * neither the name of the copyright holders nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| /* |
| * VCallocator_d.cc |
| * |
| * Niket Agarwal, Princeton University |
| * |
| * */ |
| |
| #include "mem/ruby/network/garnet-flexible-pipeline/NetworkConfig.hh" |
| #include "mem/ruby/network/garnet-fixed-pipeline/VCallocator_d.hh" |
| #include "mem/ruby/network/garnet-fixed-pipeline/Router_d.hh" |
| #include "mem/ruby/network/garnet-fixed-pipeline/InputUnit_d.hh" |
| #include "mem/ruby/network/garnet-fixed-pipeline/OutputUnit_d.hh" |
| #include "mem/ruby/network/garnet-fixed-pipeline/GarnetNetwork_d.hh" |
| |
| VCallocator_d::VCallocator_d(Router_d *router) |
| { |
| m_router = router; |
| m_num_vcs = m_router->get_num_vcs(); |
| m_vc_per_vnet = m_router->get_vc_per_vnet(); |
| m_local_arbiter_activity = 0; |
| m_global_arbiter_activity = 0; |
| } |
| |
| void VCallocator_d::init() |
| { |
| m_input_unit = m_router->get_inputUnit_ref(); |
| m_output_unit = m_router->get_outputUnit_ref(); |
| |
| m_num_inports = m_router->get_num_inports(); |
| m_num_outports = m_router->get_num_outports(); |
| m_round_robin_invc.setSize(m_num_inports); |
| m_round_robin_outvc.setSize(m_num_outports); |
| m_outvc_req.setSize(m_num_outports); |
| m_outvc_is_req.setSize(m_num_outports); |
| |
| for(int i = 0; i < m_num_inports; i++) |
| { |
| m_round_robin_invc[i].setSize(m_num_vcs); |
| |
| for(int j = 0; j < m_num_vcs; j++) |
| { |
| m_round_robin_invc[i][j] = 0; |
| } |
| } |
| |
| for(int i = 0; i < m_num_outports; i++) |
| { |
| m_round_robin_outvc[i].setSize(m_num_vcs); |
| m_outvc_req[i].setSize(m_num_vcs); |
| m_outvc_is_req[i].setSize(m_num_vcs); |
| |
| for(int j = 0; j < m_num_vcs; j++) |
| { |
| m_round_robin_outvc[i][j].first = 0; |
| m_round_robin_outvc[i][j].second = 0; |
| m_outvc_is_req[i][j] = false; |
| |
| m_outvc_req[i][j].setSize(m_num_inports); |
| |
| for(int k = 0; k < m_num_inports; k++) |
| { |
| m_outvc_req[i][j][k].setSize(m_num_vcs); |
| for(int l = 0; l < m_num_vcs; l++) |
| { |
| m_outvc_req[i][j][k][l] = false; |
| } |
| } |
| } |
| } |
| } |
| |
| void VCallocator_d::clear_request_vector() |
| { |
| for(int i = 0; i < m_num_outports; i++) |
| { |
| for(int j = 0; j < m_num_vcs; j++) |
| { |
| if(!m_outvc_is_req[i][j]) |
| continue; |
| m_outvc_is_req[i][j] = false; |
| for(int k = 0; k < m_num_inports; k++) |
| { |
| for(int l = 0; l < m_num_vcs; l++) |
| { |
| m_outvc_req[i][j][k][l] = false; |
| } |
| } |
| } |
| } |
| } |
| |
| void VCallocator_d::wakeup() |
| { |
| arbitrate_invcs(); // First stage of allocation |
| arbitrate_outvcs(); // Second stage of allocation |
| |
| clear_request_vector(); |
| check_for_wakeup(); |
| } |
| |
| bool VCallocator_d::is_invc_candidate(int inport_iter, int invc_iter) |
| { |
| int outport = m_input_unit[inport_iter]->get_route(invc_iter); |
| int vnet = get_vnet(invc_iter); |
| int t_enqueue_time = m_input_unit[inport_iter]->get_enqueue_time(invc_iter); |
| |
| int invc_base = vnet*m_vc_per_vnet; |
| |
| if((m_router->get_net_ptr())->isVNetOrdered(vnet)) |
| { |
| for(int vc_offset = 0; vc_offset < m_vc_per_vnet; vc_offset++) |
| { |
| int temp_vc = invc_base + vc_offset; |
| if(m_input_unit[inport_iter]->need_stage(temp_vc, VC_AB_, VA_) && (m_input_unit[inport_iter]->get_route(temp_vc) == outport) && (m_input_unit[inport_iter]->get_enqueue_time(temp_vc) < t_enqueue_time)) |
| { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| void VCallocator_d::select_outvc(int inport_iter, int invc_iter) |
| { |
| int outport = m_input_unit[inport_iter]->get_route(invc_iter); |
| int vnet = get_vnet(invc_iter); |
| int outvc_base = vnet*m_vc_per_vnet; |
| int num_vcs_per_vnet = m_vc_per_vnet; |
| |
| int outvc_offset = m_round_robin_invc[inport_iter][invc_iter]; |
| m_round_robin_invc[inport_iter][invc_iter]++; |
| |
| if(m_round_robin_invc[inport_iter][invc_iter] >= num_vcs_per_vnet) |
| m_round_robin_invc[inport_iter][invc_iter] = 0; |
| |
| for(int outvc_offset_iter = 0; outvc_offset_iter < num_vcs_per_vnet; outvc_offset_iter++) |
| { |
| outvc_offset++; |
| if(outvc_offset >= num_vcs_per_vnet) |
| outvc_offset = 0; |
| int outvc = outvc_base + outvc_offset; |
| if(m_output_unit[outport]->is_vc_idle(outvc)) |
| { |
| m_local_arbiter_activity++; |
| m_outvc_req[outport][outvc][inport_iter][invc_iter] = true; |
| if(!m_outvc_is_req[outport][outvc]) |
| m_outvc_is_req[outport][outvc] = true; |
| return; // out vc acquired |
| } |
| } |
| } |
| |
| void VCallocator_d::arbitrate_invcs() |
| { |
| for(int inport_iter = 0; inport_iter < m_num_inports; inport_iter++) |
| { |
| for(int invc_iter = 0; invc_iter < m_num_vcs; invc_iter++) |
| { |
| if(m_input_unit[inport_iter]->need_stage(invc_iter, VC_AB_, VA_)) |
| { |
| if(!is_invc_candidate(inport_iter, invc_iter)) |
| continue; |
| |
| select_outvc(inport_iter, invc_iter); |
| } |
| } |
| } |
| } |
| |
| void VCallocator_d::arbitrate_outvcs() |
| { |
| for(int outport_iter = 0; outport_iter < m_num_outports; outport_iter++) |
| { |
| for(int outvc_iter = 0; outvc_iter < m_num_vcs; outvc_iter++) |
| { |
| if(!m_outvc_is_req[outport_iter][outvc_iter]) // No requests for this outvc in this cycle |
| continue; |
| |
| int inport = m_round_robin_outvc[outport_iter][outvc_iter].first; |
| int invc_offset = m_round_robin_outvc[outport_iter][outvc_iter].second; |
| int vnet = get_vnet(outvc_iter); |
| int invc_base = vnet*m_vc_per_vnet; |
| int num_vcs_per_vnet = m_vc_per_vnet; |
| |
| m_round_robin_outvc[outport_iter][outvc_iter].second++; |
| if(m_round_robin_outvc[outport_iter][outvc_iter].second >= num_vcs_per_vnet) |
| { |
| m_round_robin_outvc[outport_iter][outvc_iter].second = 0; |
| m_round_robin_outvc[outport_iter][outvc_iter].first++; |
| if(m_round_robin_outvc[outport_iter][outvc_iter].first >= m_num_inports) |
| m_round_robin_outvc[outport_iter][outvc_iter].first = 0; |
| } |
| for(int in_iter = 0; in_iter < m_num_inports*num_vcs_per_vnet; in_iter++) |
| { |
| invc_offset++; |
| if(invc_offset >= num_vcs_per_vnet) |
| { |
| invc_offset = 0; |
| inport++; |
| if(inport >= m_num_inports) |
| inport = 0; |
| } |
| int invc = invc_base + invc_offset; |
| if(m_outvc_req[outport_iter][outvc_iter][inport][invc]) |
| { |
| m_global_arbiter_activity++; |
| m_input_unit[inport]->grant_vc(invc, outvc_iter); |
| m_output_unit[outport_iter]->update_vc(outvc_iter, inport, invc); |
| m_router->swarb_req(); |
| break; |
| } |
| } |
| } |
| } |
| } |
| |
| int VCallocator_d::get_vnet(int invc) |
| { |
| for(int i = 0; i < RubySystem::getNetwork()->getNumberOfVirtualNetworks(); i++) |
| { |
| if(invc >= (i*m_vc_per_vnet) && invc < ((i+1)*m_vc_per_vnet)) |
| { |
| return i; |
| } |
| } |
| ERROR_MSG("Could not determine vc"); |
| return -1; |
| } |
| |
| void VCallocator_d::check_for_wakeup() |
| { |
| for(int i = 0; i < m_num_inports; i++) |
| { |
| for(int j = 0; j < m_num_vcs; j++) |
| { |
| if(m_input_unit[i]->need_stage_nextcycle(j, VC_AB_, VA_)) |
| { |
| g_eventQueue_ptr->scheduleEvent(this, 1); |
| return; |
| } |
| } |
| } |
| } |
