diff options
Diffstat (limited to 'src/intersim2/routers/event_router.cpp')
| -rw-r--r-- | src/intersim2/routers/event_router.cpp | 890 |
1 files changed, 890 insertions, 0 deletions
diff --git a/src/intersim2/routers/event_router.cpp b/src/intersim2/routers/event_router.cpp new file mode 100644 index 0000000..e3f9712 --- /dev/null +++ b/src/intersim2/routers/event_router.cpp @@ -0,0 +1,890 @@ +// $Id: event_router.cpp 5188 2012-08-30 00:31:31Z dub $ + +/* + Copyright (c) 2007-2012, Trustees of The Leland Stanford Junior University + 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. + + 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. +*/ + +#include <string> +#include <sstream> +#include <iostream> +#include <cstdlib> +#include <cassert> + +#include "event_router.hpp" +#include "stats.hpp" +#include "globals.hpp" + +EventRouter::EventRouter( const Configuration& config, + Module *parent, const string & name, int id, + int inputs, int outputs ) + : Router( config, + parent, name, + id, + inputs, outputs ) +{ + ostringstream module_name; + + _vcs = config.GetInt( "num_vcs" ); + + // Cut-through mode --- packets are not broken + // up and input buffers are assumed to be + // expressed in units of maximum size packets. + + _vct = config.GetInt( "vct" ); + + // Routing + + string rf = config.GetStr("routing_function") + "_" + config.GetStr("topology"); + map<string, tRoutingFunction>::iterator rf_iter = gRoutingFunctionMap.find(rf); + if(rf_iter == gRoutingFunctionMap.end()) { + Error("Invalid routing function: " + rf); + } + _rf = rf_iter->second; + + // Alloc VC's + + _buf.resize(_inputs); + _active.resize(_inputs); + + for ( int i = 0; i < _inputs; ++i ) { + module_name << "buf_" << i; + _buf[i] = new Buffer( config, _outputs, this, module_name.str( ) ); + module_name.seekp( 0, ios::beg ); + _active[i].resize(_vcs, false); + } + + // Alloc next VCs' state + + _output_state.resize(_outputs); + + for ( int o = 0; o < _outputs; ++o ) { + module_name << "output" << o << "_vc_state"; + _output_state[o] = new EventNextVCState(config, this, module_name.str()); + module_name.seekp( 0, ios::beg ); + } + + // Alloc arbiters + + _arrival_arbiter.resize(_outputs); + + for ( int o = 0; o < _outputs; ++o ) { + module_name << "arrival_arb_output" << o; + _arrival_arbiter[o] = + new PriorityArbiter( config, this, module_name.str( ), _inputs ); + module_name.seekp( 0, ios::beg ); + } + + _transport_arbiter.resize(_inputs); + + for ( int i = 0; i < _inputs; ++i ) { + module_name << "transport_arb_input" << i; + _transport_arbiter[i] = + new PriorityArbiter( config, this, module_name.str( ), _outputs ); + module_name.seekp( 0, ios::beg ); + } + + // Alloc pipelines (to simulate processing/transmission delays) + + _crossbar_pipe = + new PipelineFIFO<Flit>( this, "crossbar_pipeline", _outputs, + _crossbar_delay ); + + _credit_pipe = + new PipelineFIFO<Credit>( this, "credit_pipeline", _inputs, + _credit_delay ); + + _arrival_pipe = + new PipelineFIFO<tArrivalEvent>( this, "arrival_pipeline", _inputs, + 0 /* FIX THIS EVENTUALLY */); + + // Queues + + _input_buffer.resize(_inputs); + _output_buffer.resize(_outputs); + + _in_cred_buffer.resize(_inputs); + _out_cred_buffer.resize(_outputs); + + _arrival_queue.resize(_inputs); + _transport_queue.resize(_outputs); + + // Misc. + + _transport_free.resize(_inputs, true); + _transport_match.resize(_inputs, -1); +} + +EventRouter::~EventRouter( ) +{ + for ( int i = 0; i < _inputs; ++i ) { + delete _buf[i]; + } + + for ( int o = 0; o < _outputs; ++o ) { + delete _output_state[o]; + } + + for ( int o = 0; o < _outputs; ++o ) { + delete _arrival_arbiter[o]; + } + + for ( int i = 0; i < _inputs; ++i ) { + delete _transport_arbiter[i]; + } + + delete _crossbar_pipe; + delete _credit_pipe; + delete _arrival_pipe; +} + +void EventRouter::ReadInputs( ) +{ + _ReceiveFlits( ); + _ReceiveCredits( ); +} + +void EventRouter::_InternalStep( ) +{ + // Receive incoming flits + _IncomingFlits( ); + + // The input pipe simulates routing delay + _arrival_pipe->Advance( ); + + // Clear output requests + for ( int output = 0; output < _outputs; ++output ) { + _arrival_arbiter[output]->Clear( ); + } + + // Check input arrival queues and generate + // requests for the outputs + for ( int input = 0; input < _inputs; ++input ) { + _ArrivalRequests( input ); + } + + // Arbitrate between requests at outputs + for ( int output = 0; output < _outputs; ++output ) { + _ArrivalArb( output ); + } + + for ( int input = 0; input < _inputs; ++input ) { + _transport_arbiter[input]->Clear( ); + } + + _crossbar_pipe->WriteAll( 0 ); + _credit_pipe->WriteAll( 0 ); + + // Generate transport events and their + // requests for the inputs + for ( int output = 0; output < _outputs; ++output ) { + _TransportRequests( output ); + } + + // Arbitrate between requests at inputs + for ( int input = 0; input < _inputs; ++input ) { + _TransportArb( input ); + } + + _crossbar_pipe->Advance( ); + _credit_pipe->Advance( ); + + _OutputQueuing( ); +} + +void EventRouter::WriteOutputs( ) +{ + _SendFlits( ); + _SendCredits( ); +} + +void EventRouter::_ReceiveFlits( ) +{ + Flit *f; + + for ( int input = 0; input < _inputs; ++input ) { + f = _input_channels[input]->Receive(); + + if ( f ) { + _input_buffer[input].push( f ); + } + } +} + +void EventRouter::_ReceiveCredits( ) +{ + Credit *c; + + for ( int output = 0; output < _outputs; ++output ) { + c = _output_credits[output]->Receive(); + + if ( c ) { + _out_cred_buffer[output].push( c ); + } + } +} + +void EventRouter::_ProcessWaiting( int output, int out_vc ) +{ + // out_vc just sent the transport event for out_vc, + // check if any events are queued on that vc. if so, + // generate another transport event and set the + // owner of the vc, otherwise set the vc to idle. + + int credits; + + tTransportEvent *tevt; + + EventNextVCState::tWaiting *w; + + if ( _output_state[output]->IsWaiting( out_vc ) ) { + + // State remains as busy, but the waiting VC takes over + w = _output_state[output]->PopWaiting( out_vc ); + + _output_state[output]->SetState( out_vc, EventNextVCState::busy ); + _output_state[output]->SetInput( out_vc, w->input ); + _output_state[output]->SetInputVC( out_vc, w->vc ); + + if ( w->watch ) { + cout << "Dequeuing waiting arrival event at " << FullName() + << " for flit " << w->id << endl; + } + + credits = _output_state[output]->GetCredits( out_vc ); + + // Try to queue a transmit event for a waiting packet + if ( credits > 0 ) { + tevt = new tTransportEvent; + tevt->src_vc = w->vc; + tevt->dst_vc = out_vc; + tevt->input = w->input; + tevt->watch = w->watch; // just to have something here + tevt->id = w->id; + + _transport_queue[output].push( tevt ); + + if ( tevt->watch ) { + cout << "Injecting transport event at " << FullName() + << " for flit " << tevt->id << endl; + } + + credits--; + _output_state[output]->SetCredits( out_vc, credits ); + _output_state[output]->SetPresence( out_vc, w->pres - 1 ); + + } else { + // No credits available, just store presence + _output_state[output]->SetPresence( out_vc, w->pres ); + } + + delete w; + + } else { + // Tail sent, none waiting => VC is idle + _output_state[output]->SetState( out_vc, EventNextVCState::idle ); + } +} + +void EventRouter::_IncomingFlits( ) +{ + Flit *f; + Buffer *cur_buf; + + tArrivalEvent *aevt; + + _arrival_pipe->WriteAll( 0 ); + + for ( int input = 0; input < _inputs; ++input ) { + if ( !_input_buffer[input].empty( ) ) { + f = _input_buffer[input].front( ); + _input_buffer[input].pop( ); + + cur_buf = _buf[input]; + int vc = f->vc; + + cur_buf->AddFlit( vc, f ); + + // Head flit arriving at idle VC + if ( !_active[input][vc] ) { + + if ( !f->head ) { + cout << "Non-head flit:" << endl; + cout << *f; + Error( "Received non-head flit at idle VC" ); + } + + const OutputSet *route_set; + int out_vc, out_port; + + cur_buf->Route( vc, _rf, this, f, input ); + route_set = cur_buf->GetRouteSet( vc ); + + if ( !route_set->GetPortVC( &out_port, &out_vc ) ) { + Error( "The event-driven router requires routing functions with a single (port,vc) output" ); + } + + cur_buf->SetOutput( vc, out_port, out_vc ); + _active[input][vc] = true; + } else { + if ( f->head ) { + cout << *f; + Error( "Received head flit at non-idle VC." ); + } + } + + if ( f->watch ) { + *gWatchOut << GetSimTime() << " | " << FullName() << " | " + << "Received flit at " << FullName() << ". Output port = " + << cur_buf->GetOutputPort( vc ) << ", output VC = " + << cur_buf->GetOutputVC( vc ) << endl + << *f; + } + + // In cut-through mode, only head flits generate arrivals, + // otherwise all flits generate + + if ( ( !_vct ) || ( _vct && f->head ) ) { + // Add the arrival event to a delay pipeline to + // account for routing/decoding time + + aevt = new tArrivalEvent; + + aevt->input = input; + aevt->output = cur_buf->GetOutputPort( vc ); + aevt->src_vc = f->vc; + aevt->dst_vc = cur_buf->GetOutputVC( vc ); + aevt->head = f->head; + aevt->tail = f->tail; + + //if ( f->head && f->tail ) { + // Error( "Head/tail packets not supported." ); + //} + + aevt->watch = f->watch; + aevt->id = f->id; + + _arrival_pipe->Write( aevt, input ); + + if ( aevt->watch ) { + cout << "Injected arrival event at " << FullName() + << " for flit " << aevt->id << endl; + } + } + } + } +} + +void EventRouter::_ArrivalRequests( int input ) +{ + tArrivalEvent *aevt; + + aevt = _arrival_pipe->Read( input ); + if ( aevt ) { + _arrival_queue[input].push( aevt ); + } + + if ( !_arrival_queue[input].empty( ) ) { + aevt = _arrival_queue[input].front( ); + _arrival_arbiter[aevt->output]->AddRequest( input ); + } +} + +void EventRouter::_SendTransport( int input, int output, tArrivalEvent *aevt ) +{ + // Try to send a transport event + + tTransportEvent *tevt; + + int credits; + int pres; + + credits = _output_state[output]->GetCredits( aevt->dst_vc ); + + if ( credits > 0 ) { + // Take a credit and queue a transport event + credits--; + _output_state[output]->SetCredits( aevt->dst_vc, credits ); + + tevt = new tTransportEvent; + tevt->src_vc = aevt->src_vc; + tevt->dst_vc = aevt->dst_vc; + tevt->input = input; + tevt->watch = aevt->watch; + tevt->id = aevt->id; + + _transport_queue[output].push( tevt ); + + if ( tevt->watch ) { + cout << "Injecting transport event at " << FullName() + << " for flit " << tevt->id << endl; + } + } else { + if ( aevt->watch ) { + cout << "No credits available at " << FullName() + << " for flit " << aevt->id << " storing presence." << endl; + } + + // No credits available, just store presence + pres = _output_state[output]->GetPresence( aevt->dst_vc ); + _output_state[output]->SetPresence( aevt->dst_vc, pres + 1 ); + } +} + +void EventRouter::_ArrivalArb( int output ) +{ + tArrivalEvent *aevt; + tTransportEvent *tevt; + Credit *c; + + EventNextVCState::tWaiting *w; + + int input; + int credits; + int pres; + + // Incoming credits can produce or enable + // transport events --- process them first + + if ( !_out_cred_buffer[output].empty( ) ) { + c = _out_cred_buffer[output].front( ); + _out_cred_buffer[output].pop( ); + + assert( c->vc.size() == 1 ); + int vc = *c->vc.begin(); + + EventNextVCState::eNextVCState state = + _output_state[output]->GetState( vc ); + + credits = _output_state[output]->GetCredits( vc ); + pres = _output_state[output]->GetPresence( vc ); + + if ( _vct ) { + // In cut-through mode, only head credits indicate a change in + // channel state. + + if ( c->head ) { + credits++; + _output_state[output]->SetCredits( vc, credits ); + _ProcessWaiting( output, vc ); + } + } else { + credits++; + _output_state[output]->SetCredits( vc, credits ); + + if ( c->tail ) { // tail flit -- recycle VC + if ( state != EventNextVCState::busy ) { + Error( "Received tail credit at non-busy output VC" ); + } + + _ProcessWaiting( output, vc ); + } else if ( ( state == EventNextVCState::busy ) && ( pres > 0 ) ) { + // Flit is present => generate transport event + + tevt = new tTransportEvent; + tevt->input = _output_state[output]->GetInput( vc ); + tevt->src_vc = _output_state[output]->GetInputVC( vc ); + tevt->dst_vc = vc; + tevt->watch = false; + tevt->id = -1; + + _transport_queue[output].push( tevt ); + + pres--; + credits--; + _output_state[output]->SetPresence( vc, pres ); + _output_state[output]->SetCredits( vc, credits ); + } + } + + c->Free(); + } + + // Now process arrival events + + _arrival_arbiter[output]->Arbitrate( ); + input = _arrival_arbiter[output]->Match( ); + + if ( input != -1 ) { + // Winning arrival event gets access to output + + aevt = _arrival_queue[input].front( ); + _arrival_queue[input].pop( ); + + if ( aevt->watch ) { + cout << "Processing arrival event at " << FullName() + << " for flit " << aevt->id << endl; + } + + EventNextVCState::eNextVCState state = + _output_state[output]->GetState( aevt->dst_vc ); + + if ( aevt->head ) { // Head flits + if ( state == EventNextVCState::idle ) { + // Allocate the output VC and queue a transport event + _output_state[output]->SetState( aevt->dst_vc, EventNextVCState::busy ); + _output_state[output]->SetInput( aevt->dst_vc, input ); + _output_state[output]->SetInputVC( aevt->dst_vc, aevt->src_vc ); + + _SendTransport( input, output, aevt ); + } else { + // VC busy => queue a waiting event + + w = new EventNextVCState::tWaiting; + + w->input = input; + w->vc = aevt->src_vc; + w->id = aevt->id; + w->watch = aevt->watch; + w->pres = 1; + + _output_state[output]->PushWaiting( aevt->dst_vc, w ); + } + } else { + if ( _vct ) { + Error( "Received arrival event for non-head flit in cut-through mode" ); + } + + if ( state != EventNextVCState::busy ) { + cout << "flit id = " << aevt->id << endl; + Error( "Received a body flit at a non-busy output VC" ); + } + + if ( ( !_output_state[output]->IsInputWaiting( aevt->dst_vc, input, aevt->src_vc ) ) && + ( input == _output_state[output]->GetInput( aevt->dst_vc ) ) && + ( aevt->src_vc == _output_state[output]->GetInputVC( aevt->dst_vc ) ) ) { + // Body flit part of the current active VC => queue transport event + // (the weird IsInputWaiting call handles a body flit waiting in addition + // to a head flit) + + _SendTransport( input, output, aevt ); + } else { + + // VC busy with a differnet transaction => update waiting event + _output_state[output]->IncrWaiting( aevt->dst_vc, input, aevt->src_vc ); + } + } + + delete aevt; + } +} + +void EventRouter::_TransportRequests( int output ) +{ + tTransportEvent *tevt; + + if ( !_transport_queue[output].empty( ) ) { + tevt = _transport_queue[output].front( ); + _transport_arbiter[tevt->input]->AddRequest( output ); + } +} + +void EventRouter::_TransportArb( int input ) +{ + tTransportEvent *tevt; + + int output; + Buffer *cur_buf; + Flit *f; + Credit *c; + + if ( _transport_free[input] ) { + _transport_arbiter[input]->Arbitrate( ); + output = _transport_arbiter[input]->Match( ); + } else { + output = _transport_match[input]; + } + + if ( output != -1 ) { + // This completes the match from input to output => + // one flit can be transferred + + tevt = _transport_queue[output].front( ); + + if ( tevt->watch ) { + cout << "Processing transport event at " << FullName() + << " for flit " << tevt->id << endl; + } + + cur_buf = _buf[input]; + int vc = tevt->src_vc; + + // Some sanity checking first + + if ( !_active[input][vc] ) { + Error( "Non-active VC received grant." ); + } + + if ( cur_buf->Empty( vc ) ) { + return; //Error( "Empty VC received grant." ); + } + + if ( tevt->dst_vc != cur_buf->GetOutputVC( vc ) ) { + Error( "Transport event's VC does not match input's destination VC." ); + } + + f = cur_buf->RemoveFlit( vc ); + + if ( _vct ) { + if ( f->tail ) { + _transport_free[input] = true; + _transport_match[input] = -1; + + _transport_queue[output].pop( ); + delete tevt; + + _active[input][vc] = false; + } else { + _transport_free[input] = false; + _transport_match[input] = output; + } + } else { + _transport_free[input] = true; + _transport_match[input] = -1; + + _transport_queue[output].pop( ); + delete tevt; + + if ( f->tail ) { + _active[input][vc] = false; + } + } + + c = Credit::New( ); + c->vc.insert(f->vc); + c->head = f->head; + c->tail = f->tail; + c->id = f->id; + _credit_pipe->Write( c, input ); + + if ( f->watch && c->tail ) { + *gWatchOut << GetSimTime() << " | " << FullName() << " | " + << FullName() << " sending tail credit back for flit " << f->id << endl; + } + + // Update and forward the flit to the crossbar + + f->hops++; + f->vc = cur_buf->GetOutputVC( vc ); + _crossbar_pipe->Write( f, output ); + + if ( f->watch ) { + *gWatchOut << GetSimTime() << " | " << FullName() << " | " + << "Forwarding flit through crossbar at " << FullName() << ":" << endl + << *f; + } + } +} + +void EventRouter::_OutputQueuing( ) +{ + Flit *f; + Credit *c; + + for ( int output = 0; output < _outputs; ++output ) { + f = _crossbar_pipe->Read( output ); + + if ( f ) { + _output_buffer[output].push( f ); + } + } + + for ( int input = 0; input < _inputs; ++input ) { + c = _credit_pipe->Read( input ); + + if ( c ) { + _in_cred_buffer[input].push( c ); + } + } +} + +void EventRouter::_SendFlits( ) +{ + for ( int output = 0; output < _outputs; ++output ) { + if ( !_output_buffer[output].empty( ) ) { + Flit *f = _output_buffer[output].front( ); + _output_buffer[output].pop( ); + _output_channels[output]->Send( f ); + } + } +} + +void EventRouter::_SendCredits( ) +{ + for ( int input = 0; input < _inputs; ++input ) { + if ( !_in_cred_buffer[input].empty( ) ) { + Credit *c = _in_cred_buffer[input].front( ); + _in_cred_buffer[input].pop( ); + _input_credits[input]->Send( c ); + } + } +} + +void EventRouter::Display( ostream & os ) const +{ + for ( int input = 0; input < _inputs; ++input ) { + _buf[input]->Display( os ); + } +} + +EventNextVCState::EventNextVCState( const Configuration& config, + Module *parent, const string& name ) : + Module( parent, name ) +{ + _buf_size = config.GetInt( "vc_buf_size" ); + _vcs = config.GetInt( "num_vcs" ); + + _credits.resize(_vcs, _buf_size); + _presence.resize(_vcs, 0); + _input.resize(_vcs); + _inputVC.resize(_vcs); + _waiting.resize(_vcs); + _state.resize(_vcs, idle); +} + +EventNextVCState::eNextVCState EventNextVCState::GetState( int vc ) const +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + return _state[vc]; +} + +int EventNextVCState::GetPresence( int vc ) const +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + return _presence[vc]; +} + +int EventNextVCState::GetCredits( int vc ) const +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + return _credits[vc]; +} + +int EventNextVCState::GetInput( int vc ) const +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + return _input[vc]; +} + +int EventNextVCState::GetInputVC( int vc ) const +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + return _inputVC[vc]; +} + +bool EventNextVCState::IsWaiting( int vc ) const +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + return !_waiting[vc].empty( ); +} + +void EventNextVCState::PushWaiting( int vc, tWaiting *w ) +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + + if ( w->watch ) { + cout << FullName() << " pushing flit " << w->id + << " onto a waiting queue of length " << _waiting[vc].size( ) << endl; + } + + _waiting[vc].push_back( w ); +} + +void EventNextVCState::IncrWaiting( int vc, int w_input, int w_vc ) +{ + list<tWaiting *>::iterator match; + + // search for match + for ( match = _waiting[vc].begin( ); match != _waiting[vc].end( ); match++ ) { + if ( ( (*match)->input == w_input ) && + ( (*match)->vc == w_vc ) ) break; + } + + if ( match != _waiting[vc].end( ) ) { + (*match)->pres++; + } else { + Error( "Did not find match in IncrWaiting" ); + } +} + +bool EventNextVCState::IsInputWaiting( int vc, int w_input, int w_vc ) const +{ + list<tWaiting *>::const_iterator match; + bool r; + + // search for match + for ( match = _waiting[vc].begin( ); match != _waiting[vc].end( ); match++ ) { + if ( ( (*match)->input == w_input ) && + ( (*match)->vc == w_vc ) ) break; + } + + if ( match != _waiting[vc].end( ) ) { + r = true; + } else { + r = false; + } + + return r; +} + +EventNextVCState::tWaiting *EventNextVCState::PopWaiting( int vc ) +{ + tWaiting *w; + + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + + w = _waiting[vc].front( ); + _waiting[vc].pop_front( ); + + return w; +} + +void EventNextVCState::SetState( int vc, eNextVCState state ) +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + _state[vc] = state; +} + +void EventNextVCState::SetCredits( int vc, int value ) +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + _credits[vc] = value; +} + +void EventNextVCState::SetPresence( int vc, int value ) +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + _presence[vc] = value; +} + +void EventNextVCState::SetInput( int vc, int input ) +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + _input[vc] = input; +} + +void EventNextVCState::SetInputVC( int vc, int in_vc ) +{ + assert( ( vc >= 0 ) && ( vc < _vcs ) ); + _inputVC[vc] = in_vc; +} |