void ChaosRouter::_OutputAdvance( )
{
Flit *f, *f2;
Credit *c;
bool advanced;
int mq;
_crossbar_pipe->WriteAll( 0 );
for ( int i = 0; i < _inputs; ++i ) {
if ( ( ( _input_output_match[i] != -1 ) ||
( _input_mq_match[i] != -1 ) ) &&
( !_input_frame[i].empty( ) ) ) {
advanced = false;
f = _input_frame[i].front( );
/*if ( ! ) {
} else {
cout << "Input = " << i
<< ", input_output_match = " << _input_output_match[i]
<< ", input_mq_match = " << _input_mq_match[i] << endl;
Error( "Input queue empty, but matched!" );
}*/
if ( _input_output_match[i] != -1 ) {
if ( f->tail ) {
_output_matched[_input_output_match[i]] = false;
}
_crossbar_pipe->Write( f, _input_output_match[i] );
if ( f->watch ) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "Flit traversing crossbar from input queue "
<< i << " at "
<< FullName() << endl
<< *f;
}
advanced = true;
} else if ( !_MultiQueueFull( _input_mq_match[i] ) ) {
mq = _input_mq_match[i];
if ( f->head ) {
_rf( this, f, i, _mq_route[mq], false );
_mq_age[mq] = 0;
if ( _multi_state[mq] == empty ) {
_multi_state[mq] = filling;
} else if ( _multi_state[mq] == leaving ) {
_multi_state[mq] = shared;
} else {
Error( "Multi-queue received head while not empty or leaving!" );
}
}
if ( f->tail ) {
_mq_matched[mq] = false;
if ( _multi_state[mq] == filling ) {
_multi_state[mq] = full;
} else if ( _multi_state[mq] == cut_through ) {
_multi_state[mq] = leaving;
} else {
Error( "Multi-queue received tail while not filling or cutting-through!" );
}
}
_multi_queue[mq].push( f );
if ( f->watch ) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "Flit stored in multiqueue at "
<< FullName() << endl
<< "State = " << _multi_state[mq] << endl
<< *f;
}
advanced = true;
}
if ( advanced ) {
_input_frame[i].pop( );
if ( f->tail ) { // last in packet, update state
if ( _input_state[i] == leaving ) {
_input_state[i] = empty;
} else if ( _input_state[i] == shared ) {
_input_state[i] = filling;
f2 = _input_frame[i].front( );
// update routes
_rf( this, f2, i, _input_route[i], false );
}
_input_output_match[i] = -1;
_input_mq_match[i] = -1;
}
c = Credit::New( );
c->vc.insert(0);
_credit_queue[i].push( c );
}
}
}
for ( int m = 0; m < _multi_queue_size; ++m ) {
if ( _multi_match[m] != -1 ) {
if ( !_multi_queue[m].empty( ) ) {
f = _multi_queue[m].front( );
_multi_queue[m].pop( );
} else {
cout << "State = " << _multi_state[m] << endl;
Error( "Multi queue empty, but matched!" );
}
_crossbar_pipe->Write( f, _multi_match[m] );
if ( f->watch ) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "Flit traversing crossbar from multiqueue slot "
<< m << " at "
<< FullName() << endl
<< *f;
}
if ( f->head ) {
if ( _multi_state[m] == filling ) {
_multi_state[m] = cut_through;
} else if ( _multi_state[m] == full ) {
_multi_state[m] = leaving;
} else {
Error( "Multi-queue sent head while not filling or full!" );
}
}
if ( f->tail ) {
_output_matched[_multi_match[m]] = false;
_multi_match[m] = -1;
if ( _multi_state[m] == shared ) {
_multi_state[m] = filling;
} else if ( _multi_state[m] == leaving ) {
_multi_state[m] = empty;
} else {
cout << "State = " << _multi_state[m] << endl;
cout << *f;
Error( "Multi-queue sent tail while not leaving or shared!" );
}
}
}
_mq_age[m]++;
}
}
void ChaosRouter::ReadInputs( )
{
Flit *f;
Credit *c;
for ( int input = 0; input < _inputs; ++input ) {
f = _input_channels[input]->Receive();
if ( f ) {
_input_frame[input].push( f );
if ( f->watch ) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "Flit arriving at " << FullName()
<< " on channel " << input << endl
<< *f;
}
switch( _input_state[input] ) {
case empty:
if ( f->head ) {
if ( f->tail ) {
_input_state[input] = full;
} else {
_input_state[input] = filling;
}
_rf( this, f, input, _input_route[input], false );
} else {
cout << *f;
Error( "Empty buffer received non-head flit!" );
}
break;
case filling:
if ( f->tail ) {
_input_state[input] = full;
} else if ( f->head ) {
Error( "Input buffer received another head before previous tail!" );
}
break;
case full:
Error( "Received flit while full!" );
break;
case leaving:
if ( f->head ) {
_input_state[input] = shared;
if ( f->tail ) {
Error( "Received single-flit packet in leaving state!" );
}
} else {
cout << *f;
Error( "Received non-head flit while packet leaving!" );
}
break;
case cut_through:
if ( f->tail ) {
_input_state[input] = leaving;
}
if ( f->head ) {
cout << *f;
Error( "Received head flit in cut through buffer!" );
}
break;
case shared:
if ( f->head ) {
Error( "Shared buffer received another head!" );
} else if ( f->tail ) {
cout << "Input " << input << endl;
cout << *f;
Error( "Shared buffer received another tail!" );
}
break;
}
}
}
// Process incoming credits
for ( int output = 0; output < _outputs; ++output ) {
c = _output_credits[output]->Receive();
if ( c ) {
_next_queue_cnt[output]--;
if ( _next_queue_cnt[output] < 0 ) {
Error( "Next queue count fell below zero!" );
}
c->Free();
}
}
}
EGLBoolean egl_display_t::initialize(EGLint *major, EGLint *minor) {
{
Mutex::Autolock _rf(refLock);
refs++;
if (refs > 1) {
if (major != NULL)
*major = VERSION_MAJOR;
if (minor != NULL)
*minor = VERSION_MINOR;
while(!eglIsInitialized) refCond.wait(refLock);
return EGL_TRUE;
}
while(eglIsInitialized) refCond.wait(refLock);
}
{
Mutex::Autolock _l(lock);
#if EGL_TRACE
// Called both at early_init time and at this time. (Early_init is pre-zygote, so
// the information from that call may be stale.)
initEglTraceLevel();
initEglDebugLevel();
#endif
setGLHooksThreadSpecific(&gHooksNoContext);
// initialize each EGL and
// build our own extension string first, based on the extension we know
// and the extension supported by our client implementation
egl_connection_t* const cnx = &gEGLImpl;
cnx->major = -1;
cnx->minor = -1;
if (cnx->dso) {
EGLDisplay idpy = disp.dpy;
if (cnx->egl.eglInitialize(idpy, &cnx->major, &cnx->minor)) {
//ALOGD("initialized dpy=%p, ver=%d.%d, cnx=%p",
// idpy, cnx->major, cnx->minor, cnx);
// display is now initialized
disp.state = egl_display_t::INITIALIZED;
// get the query-strings for this display for each implementation
disp.queryString.vendor = cnx->egl.eglQueryString(idpy,
EGL_VENDOR);
disp.queryString.version = cnx->egl.eglQueryString(idpy,
EGL_VERSION);
disp.queryString.extensions = cnx->egl.eglQueryString(idpy,
EGL_EXTENSIONS);
disp.queryString.clientApi = cnx->egl.eglQueryString(idpy,
EGL_CLIENT_APIS);
} else {
ALOGW("eglInitialize(%p) failed (%s)", idpy,
egl_tls_t::egl_strerror(cnx->egl.eglGetError()));
}
}
// the query strings are per-display
mVendorString.setTo(sVendorString);
mVersionString.setTo(sVersionString);
mClientApiString.setTo(sClientApiString);
mExtensionString.setTo(gBuiltinExtensionString);
char const* start = gExtensionString;
char const* end;
do {
// find the space separating this extension for the next one
end = strchr(start, ' ');
if (end) {
// length of the extension string
const size_t len = end - start;
if (len) {
// NOTE: we could avoid the copy if we had strnstr.
const String8 ext(start, len);
if (findExtension(disp.queryString.extensions, ext.string(),
len)) {
mExtensionString.append(start, len+1);
}
}
// process the next extension string, and skip the space.
start = end + 1;
}
} while (end);
egl_cache_t::get()->initialize(this);
char value[PROPERTY_VALUE_MAX];
property_get("debug.egl.finish", value, "0");
if (atoi(value)) {
finishOnSwap = true;
}
property_get("debug.egl.traceGpuCompletion", value, "0");
if (atoi(value)) {
traceGpuCompletion = true;
}
if (major != NULL)
*major = VERSION_MAJOR;
if (minor != NULL)
*minor = VERSION_MINOR;
mHibernation.setDisplayValid(true);
}
{
Mutex::Autolock _rf(refLock);
eglIsInitialized = true;
refCond.broadcast();
}
return EGL_TRUE;
}
void GPUTrafficManager::_Step()
{
bool flits_in_flight = false;
for(int c = 0; c < _classes; ++c) {
flits_in_flight |= !_total_in_flight_flits[c].empty();
}
if(flits_in_flight && (_deadlock_timer++ >= _deadlock_warn_timeout)){
_deadlock_timer = 0;
cout << "WARNING: Possible network deadlock.\n";
}
vector<map<int, Flit *> > flits(_subnets);
for ( int subnet = 0; subnet < _subnets; ++subnet ) {
for ( int n = 0; n < _nodes; ++n ) {
Flit * const f = _net[subnet]->ReadFlit( n );
if ( f ) {
if(f->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Ejecting flit " << f->id
<< " (packet " << f->pid << ")"
<< " from VC " << f->vc
<< "." << endl;
}
if(g_hpcl_comp_config.hpcl_comp_en == 0) {
g_icnt_interface->WriteOutBuffer(subnet, n, f);
//added by kh(030816)
g_hpcl_network_anal->add_sample(hpcl_network_anal::NORMAL_FLIT_NO, 1);
///
} else {
//added by kh (030816)
//(2.1.a) all reply flits (even write reply) are injected to decompressor for maintaining the order of flits.
//coming from the same vc
//Decompression: WRITE_REPLY should go through decomp, although no data is compressed.
//READ_REPLY = {f1,f2,f3,f4,f5}, WRITE_REPLY = {f6}
//Problematic case queue: f1,f2,f6,f3,f4,f5.
if(f->type == Flit::READ_REPLY || f->type == Flit::WRITE_REPLY) { //only sm receives
assert(g_hpcl_global_decomp_pl_2B[n]);
//inject a flit to decompressor
hpcl_comp_pl_data* pl_data = new hpcl_comp_pl_data;
pl_data->add_comp_pl_data(f);
g_hpcl_global_decomp_pl_2B[n]->set_input_data(pl_data);
//added by kh (030316)
//set vc info to compressed flits.
for(int i = 0; i < f->compressed_other_flits.size(); i++) {
Flit* cf = f->compressed_other_flits[i];
assert(cf);
cf->vc = f->vc;
}
///
//delete pl_data;
//added by kh (030816)
g_hpcl_network_anal->add_sample(hpcl_network_anal::NORMAL_FLIT_NO, 1);
if(f->compressed_other_flits.size() > 0) {
g_hpcl_network_anal->add_sample(hpcl_network_anal::READ_REPLY_COMP_FLIT_NO, f->compressed_other_flits.size()+1);
} else {
g_hpcl_network_anal->add_sample(hpcl_network_anal::READ_REPLY_UNCOMP_FLIT_NO, 1);
}
///
} else if(f->type == Flit::CTRL_MSG) { //(2.2.a) all ctrl flits are injected to decompressor
//std::cout << "f->id " << f->id << " f->src " << f->src << " f->dest " << f->dest << " node " << n << std::endl;
hpcl_comp_pl_data* pl_data = new hpcl_comp_pl_data;
pl_data->add_comp_pl_data(f);
g_hpcl_global_decomp_pl_2B[n]->set_input_data(pl_data);
//added by kh (030816)
g_hpcl_network_anal->add_sample(hpcl_network_anal::CTRL_FLIT_NO,1);
///
} else {
g_icnt_interface->WriteOutBuffer(subnet, n, f);
//added by kh (030816)
g_hpcl_network_anal->add_sample(hpcl_network_anal::NORMAL_FLIT_NO, 1);
///
}
///
}
}
g_icnt_interface->Transfer2BoundaryBuffer(subnet, n);
Flit* const ejected_flit = g_icnt_interface->GetEjectedFlit(subnet, n);
if (ejected_flit) {
if(ejected_flit->head)
assert(ejected_flit->dest == n);
if(ejected_flit->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Ejected flit " << ejected_flit->id
<< " (packet " << ejected_flit->pid
<< " VC " << ejected_flit->vc << ")"
<< "from ejection buffer." << endl;
}
flits[subnet].insert(make_pair(n, ejected_flit));
if((_sim_state == warming_up) || (_sim_state == running)) {
++_accepted_flits[ejected_flit->cl][n];
if(ejected_flit->tail) {
++_accepted_packets[ejected_flit->cl][n];
}
}
}
// Processing the credit From the network
Credit * const c = _net[subnet]->ReadCredit( n );
if ( c ) {
#ifdef TRACK_FLOWS
for(set<int>::const_iterator iter = c->vc.begin(); iter != c->vc.end(); ++iter) {
int const vc = *iter;
assert(!_outstanding_classes[n][subnet][vc].empty());
int cl = _outstanding_classes[n][subnet][vc].front();
_outstanding_classes[n][subnet][vc].pop();
assert(_outstanding_credits[cl][subnet][n] > 0);
--_outstanding_credits[cl][subnet][n];
}
#endif
_buf_states[n][subnet]->ProcessCredit(c);
c->Free();
}
}
_net[subnet]->ReadInputs( );
}
if(g_hpcl_comp_config.hpcl_comp_en == 1)
{
//added by kh (030816)
//(2.3) Decompressor
for(int i = 0; i < g_hpcl_global_decomp_pl_2B.size(); i++)
{
if(!g_hpcl_global_decomp_pl_2B[i]) continue;
g_hpcl_global_decomp_pl_2B[i]->run(getTime()+getTotalTime());
hpcl_comp_pl_data* comp_pl_data = g_hpcl_global_decomp_pl_2B[i]->get_output_data();
Flit* flit = comp_pl_data->get_flit_ptr();
if(flit) {
int subnet = 0;
assert(flit->const_dest == i);
//std::cout << "Flit " << flit->id << " type " << flit->type << " is out from decomp" << std::endl;
/*
std::cout << GetSimTime() << "| MYEJECT | node " << i << " Flit " << flit->id << " type " << flit->type << " tail " << flit->tail << " vc " << flit->vc;
if(flit->type == Flit::ANY_TYPE) std::cout << " ctrl " << std::endl;
else std::cout << " mf " << ((mem_fetch*)flit->data)->get_request_uid() << std::endl;
*/
//std::cout << "Flit " << flit->id << " enc_status " << flit->m_enc_status;
#ifdef CORRECTNESS_CHECK
if(flit->m_enc_status == 1) {
std::cout << "dec_status " << flit->check_correctness() << std::endl;
if(flit->check_correctness() == false) {
printf("flit %d has incorrect decoding!\n", flit->id);
printf("\traw_data = ");
for(int k = flit->raw_data.size()-1; k >=0; k--) {
printf("%02x", flit->raw_data[k]);
}
printf("\n");
printf("\tdec_data = ");
for(int k = flit->decomp_data.size()-1; k >=0; k--) {
printf("%02x", flit->decomp_data[k]);
}
printf("\n");
}
}
#endif
g_icnt_interface->WriteOutBuffer(subnet, i, flit);
}
//reset output data
g_hpcl_global_decomp_pl_2B[i]->reset_output_data();
}
///
//added by kh (030816)
//(1.2.c) generate/inject ctrl flit is injected to NI injection buffer
for(int i = 0; i < g_hpcl_global_comp_pl_2B.size(); i++)
{
if(!g_hpcl_global_comp_pl_2B[i]) continue;
if(g_hpcl_global_comp_pl_2B[i]->has_out_dict_ctrl_msg() == false) continue;
if(g_hpcl_global_comp_pl_2B[i]->get_state() == hpcl_comp_pl<unsigned short>::HPCL_COMP_RUN) continue;
hpcl_dict_ctrl_msg<unsigned short>* ctrl_msg = g_hpcl_global_comp_pl_2B[i]->front_out_dict_ctrl_msg();
int packet_size = 1; //1 flit
Flit::FlitType packet_type = Flit::CTRL_MSG;
void* data = NULL;
assert(ctrl_msg->get_dest_node()>=0);
int subnet = 0;
int response_size = 32; //32bytes
//send ctrl from MC
int sender_device_id = -1;
if(g_mc_placement_config.is_mc_node(i)) {
sender_device_id = g_mc_placement_config.get_mc_node_index(i) + 56; //56 SMs and 8 MCs
}
assert(sender_device_id >= 0);
int sender_node_id = i;
int receiver_node_id = ctrl_msg->get_dest_node();
int receiver_device_id = g_mc_placement_config.get_sm_node_index(receiver_node_id);
assert(sender_node_id>=0);
assert(receiver_node_id>=0);
if(g_icnt_interface->HasBuffer(sender_device_id, response_size)) {
//std::cout << getTime()+getTotalTime() << " | " << " PUSH2 | " << " input " << sender_device_id << " output " << receiver_device_id << " ctrl_msg " << ctrl_msg->get_id();
//std::cout << std::endl;
_GeneratePacket(sender_node_id, -1, 0, getTime(), subnet, packet_size, packet_type, ctrl_msg, receiver_node_id);
g_hpcl_global_comp_pl_2B[i]->pop_out_dict_ctrl_msg();
// std::cout << "ctrl_msg | id " << ctrl_msg->get_id();
// std::cout << " | src_node " << ctrl_msg->get_src_node();
// std::cout << " | dest_node " << ctrl_msg->get_dest_node();
// std::cout << " | word_index " << ctrl_msg->get_word_index();
// std::cout << " | word " << ctrl_msg->get_new_word() << std::endl;;
//
// g_hpcl_global_comp_pl_2B[i]->validate_word(ctrl_msg->get_dest_node(), ctrl_msg->get_word_index(), ctrl_msg->get_new_word());
}
}
///
}
// GPGPUSim will generate/inject packets from interconnection interface
#if 0
if ( !_empty_network ) {
_Inject();
}
#endif
for(int subnet = 0; subnet < _subnets; ++subnet) {
for(int n = 0; n < _nodes; ++n) {
Flit * f = NULL;
BufferState * const dest_buf = _buf_states[n][subnet];
int const last_class = _last_class[n][subnet];
int class_limit = _classes;
if(_hold_switch_for_packet) {
list<Flit *> const & pp = _input_queue[subnet][n][last_class];
if(!pp.empty() && !pp.front()->head &&
!dest_buf->IsFullFor(pp.front()->vc)) {
f = pp.front();
assert(f->vc == _last_vc[n][subnet][last_class]);
// if we're holding the connection, we don't need to check that class
// again in the for loop
--class_limit;
}
}
for(int i = 1; i <= class_limit; ++i) {
int const c = (last_class + i) % _classes;
list<Flit *> const & pp = _input_queue[subnet][n][c];
if(pp.empty()) {
continue;
}
Flit * const cf = pp.front();
assert(cf);
assert(cf->cl == c);
assert(cf->subnetwork == subnet);
if(g_hpcl_comp_config.hpcl_comp_en == 1) {
//added by kh (030816)
//If compressor is busy with compressing flits of a packet,
//don't inject a head flit of a new packet to the busy compressor
//compressor is only for read reply, but write reply goes through the compressor to avoid intermixed flits from different packets
//Thus, the following filtering is not restricted to read reply, thus we have no flit type checking to read reply.
if(g_mc_placement_config.is_mc_node(n) == true && cf->head == true) {
if(g_hpcl_global_comp_pl_2B[n] && g_hpcl_global_comp_pl_2B[n]->get_state() == hpcl_comp_pl<unsigned short>::HPCL_COMP_RUN) {
f = NULL;
break;
}
}
///
}
if(f && (f->pri >= cf->pri)) {
continue;
}
//KH: routing output port is decided here.
if(cf->head && cf->vc == -1) { // Find first available VC
//std::cout << "_Step is called!!!!" << std::endl;
//assert(1 == 0);
OutputSet route_set;
_rf(NULL, cf, -1, &route_set, true);
set<OutputSet::sSetElement> const & os = route_set.GetSet();
assert(os.size() == 1);
OutputSet::sSetElement const & se = *os.begin();
assert(se.output_port == -1);
int vc_start = se.vc_start;
int vc_end = se.vc_end;
int vc_count = vc_end - vc_start + 1;
if(_noq) {
assert(_lookahead_routing);
const FlitChannel * inject = _net[subnet]->GetInject(n);
const Router * router = inject->GetSink();
assert(router);
int in_channel = inject->GetSinkPort();
// NOTE: Because the lookahead is not for injection, but for the
// first hop, we have to temporarily set cf's VC to be non-negative
// in order to avoid seting of an assertion in the routing function.
cf->vc = vc_start;
_rf(router, cf, in_channel, &cf->la_route_set, false);
cf->vc = -1;
if(cf->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Generating lookahead routing info for flit " << cf->id
<< " (NOQ)." << endl;
}
set<OutputSet::sSetElement> const sl = cf->la_route_set.GetSet();
assert(sl.size() == 1);
int next_output = sl.begin()->output_port;
vc_count /= router->NumOutputs();
vc_start += next_output * vc_count;
vc_end = vc_start + vc_count - 1;
assert(vc_start >= se.vc_start && vc_start <= se.vc_end);
assert(vc_end >= se.vc_start && vc_end <= se.vc_end);
assert(vc_start <= vc_end);
}
if(cf->watch) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "Finding output VC for flit " << cf->id
<< ":" << endl;
}
for(int i = 1; i <= vc_count; ++i) {
int const lvc = _last_vc[n][subnet][c];
int const vc =
(lvc < vc_start || lvc > vc_end) ?
vc_start :
(vc_start + (lvc - vc_start + i) % vc_count);
assert((vc >= vc_start) && (vc <= vc_end));
if(!dest_buf->IsAvailableFor(vc)) {
if(cf->watch) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< " Output VC " << vc << " is busy." << endl;
}
} else {
if(dest_buf->IsFullFor(vc)) {
if(cf->watch) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< " Output VC " << vc << " is full." << endl;
}
} else {
if(cf->watch) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< " Selected output VC " << vc << "." << endl;
}
cf->vc = vc;
break;
}
}
}
}
if(cf->vc == -1) {
if(cf->watch) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "No output VC found for flit " << cf->id
<< "." << endl;
}
} else {
if(dest_buf->IsFullFor(cf->vc)) {
if(cf->watch) {
*gWatchOut << GetSimTime() << " | " << FullName() << " | "
<< "Selected output VC " << cf->vc
<< " is full for flit " << cf->id
<< "." << endl;
}
} else {
f = cf;
}
}
}
if(f) {
assert(f->subnetwork == subnet);
int const c = f->cl;
if(f->head) {
if (_lookahead_routing) {
if(!_noq) {
const FlitChannel * inject = _net[subnet]->GetInject(n);
const Router * router = inject->GetSink();
assert(router);
int in_channel = inject->GetSinkPort();
_rf(router, f, in_channel, &f->la_route_set, false);
if(f->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Generating lookahead routing info for flit " << f->id
<< "." << endl;
}
} else if(f->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Already generated lookahead routing info for flit " << f->id
<< " (NOQ)." << endl;
}
} else {
f->la_route_set.Clear();
}
dest_buf->TakeBuffer(f->vc);
_last_vc[n][subnet][c] = f->vc;
}
_last_class[n][subnet] = c;
_input_queue[subnet][n][c].pop_front();
#ifdef TRACK_FLOWS
++_outstanding_credits[c][subnet][n];
_outstanding_classes[n][subnet][f->vc].push(c);
#endif
if(g_hpcl_comp_config.hpcl_comp_en == 0) {
dest_buf->SendingFlit(f);
} else {
//added by kh(030816)
//(1.1.a) send a head flit first: update buffer state
if(g_mc_placement_config.is_mc_node(n) == true && f->type == Flit::READ_REPLY) {
if(f->head) dest_buf->SendingFlit(f);
//skip for other flits
} else {
dest_buf->SendingFlit(f);
}
///
}
if(_pri_type == network_age_based) {
f->pri = numeric_limits<int>::max() - _time;
assert(f->pri >= 0);
}
if(f->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Injecting flit " << f->id
<< " into subnet " << subnet
<< " at time " << _time
<< " with priority " << f->pri
<< "." << endl;
}
f->itime = _time;
// Pass VC "back"
if(!_input_queue[subnet][n][c].empty() && !f->tail) {
Flit * const nf = _input_queue[subnet][n][c].front();
nf->vc = f->vc;
}
if((_sim_state == warming_up) || (_sim_state == running)) {
++_sent_flits[c][n];
//added by kh(070215)
++_sent_flits_net[subnet][n];
if(f->head) {
++_sent_packets[c][n];
//added by kh(030816)
if(f->type < Flit::ANY_TYPE) {
//added by kh(121715)
if(g_mc_placement_config.is_sm_node(n)) {
((mem_fetch*)f->data)->set_status(HEAD_FLIT_INJECTED_TO_INJECT_BUF_IN_SM, _time);
//added by kh(122815)
double req_queuing_lat_in_sm = _time - ((mem_fetch*)f->data)->get_timestamp(HEAD_FLIT_INJECTED_TO_NI_INPUT_BUF_IN_SM);
g_hpcl_network_anal->add_sample(hpcl_network_anal::REQ_QUEUING_LAT_IN_SM, req_queuing_lat_in_sm);
///
} else if(g_mc_placement_config.is_mc_node(n)) {
((mem_fetch*)f->data)->set_status(HEAD_FLIT_INJECTED_TO_INJECT_BUF_IN_MEM, _time);
//added by kh(122815)
double rep_queuing_lat_in_mc = _time - ((mem_fetch*)f->data)->get_timestamp(HEAD_FLIT_INJECTED_TO_NI_INPUT_BUF_IN_MEM);
g_hpcl_network_anal->add_sample(hpcl_network_anal::REP_QUEUING_LAT_IN_MC, rep_queuing_lat_in_mc);
///
}
///
}
}
}
#ifdef TRACK_FLOWS
++_injected_flits[c][n];
#endif
if(g_hpcl_comp_config.hpcl_comp_en == 0) {
_net[subnet]->WriteFlit(f, n);
} else {
//added by kh (021416)
//Compression
//(1.1.b) flits but a head flit are injected to the compressor
if(g_mc_placement_config.is_mc_node(n) == true && f->type == Flit::READ_REPLY) {
hpcl_comp_pl_data* pl_data = NULL;
//A head flit is found. It means other flits are in _input_queue now.
//flits move from _input_queue to compressor by force.
//Those flits are sent to network in different paths such that we set info for
//flit navigation here.
if(f->head == true) {
assert(!_input_queue[subnet][n][c].empty());
Flit * body_flit = _input_queue[subnet][n][c].front();
_input_queue[subnet][n][c].pop_front();
if(_pri_type == network_age_based) {
body_flit->pri = numeric_limits<int>::max() - _time;
assert(body_flit->pri >= 0);
}
body_flit->itime = _time;
// Pass VC "back" for next flit
if(!_input_queue[subnet][n][c].empty() && !body_flit->tail) {
Flit * const nf = _input_queue[subnet][n][c].front();
nf->vc = body_flit->vc;
}
++_sent_flits[c][n];
++_sent_flits_net[subnet][n];
pl_data = new hpcl_comp_pl_data;
pl_data->add_comp_pl_data(body_flit);
g_hpcl_global_comp_pl_2B[n]->set_input_data(pl_data);
//delete pl_data;
//(1.1.a) send a head flit first
_net[subnet]->WriteFlit(f, n);
} else {
pl_data = new hpcl_comp_pl_data;
pl_data->add_comp_pl_data(f);
g_hpcl_global_comp_pl_2B[n]->set_input_data(pl_data);
//delete pl_data;
}
//(1.2.a) words in a flit are pushed to a queue in a compressor
if(pl_data) {
Flit* flit = pl_data->get_flit_ptr();
assert(flit);
//Use receiver's id as global dict index
int global_dict_index = flit->const_dest;
//Push words to be updated to word_queue (this is done at zero-time)
vector<unsigned short> word_list;
g_hpcl_global_comp_pl_2B[n]->decompose(flit->raw_data, word_list);
for(int i = 0; i < word_list.size(); i++)
g_hpcl_global_comp_pl_2B[n]->push_word_to_queue(word_list[i], global_dict_index);
delete pl_data;
}
} else if (g_mc_placement_config.is_mc_node(n) == true && f->type == Flit::CTRL_MSG) {
hpcl_dict_ctrl_msg<unsigned short>* ctrl_msg = (hpcl_dict_ctrl_msg<unsigned short>*)f->data;
/*
std::cout << "ctrl_msg | id " << ctrl_msg->get_id();
std::cout << " | src_node " << ctrl_msg->get_src_node();
std::cout << " | dest_node " << ctrl_msg->get_dest_node();
std::cout << " | word_index " << ctrl_msg->get_word_index();
std::cout << " | word " << ctrl_msg->get_new_word();
std::cout << " | n " << n;
std::cout << std::endl;;
*/
g_hpcl_global_comp_pl_2B[n]->release_word(ctrl_msg->get_dest_node(), ctrl_msg->get_word_index(), ctrl_msg->get_new_word());
g_hpcl_global_comp_pl_2B[n]->validate_word(ctrl_msg->get_dest_node(), ctrl_msg->get_word_index(), ctrl_msg->get_new_word());
_net[subnet]->WriteFlit(f, n);
} else {
_net[subnet]->WriteFlit(f, n);
}
///
}
}
}
}
if(g_hpcl_comp_config.hpcl_comp_en == 1) {
//added by kh(030816)
//(1.3) Compression: Pipelined Compression
for(int i = 0; i < g_hpcl_global_comp_pl_2B.size(); i++)
{
if(!g_hpcl_global_comp_pl_2B[i]) continue;
//(1.2.b) words in the queue are updated to dictionary, when idle state
//(1.2.d) ctrl msgs for words with frequency (>= threshold) are generated in compressor's run function, when idle state
g_hpcl_global_comp_pl_2B[i]->run(getTime()+getTotalTime());
hpcl_comp_pl_data* comp_pl_rsl = g_hpcl_global_comp_pl_2B[i]->get_output_data();
Flit* flit = comp_pl_rsl->get_flit_ptr();
if(flit) {
//std::cout << "node " << i << " flit->id " << flit->id << std::endl;
//(1.1.c) flits are injected from the compressor to an input buffer
if(HasBufferSpace(i, flit)) {
SendFlitToBuffer(i, flit); //for credit management.
SendFlitToNetwork(i, flit);
//std::cout << "\t" << " send flit " << flit->id << std::endl;
if(g_hpcl_global_comp_pl_2B[i]->get_comp_done() == true)
{
assert(g_hpcl_global_comp_pl_2B[i]->get_state() == hpcl_comp_pl<unsigned short>::HPCL_COMP_RUN);
g_hpcl_global_comp_pl_2B[i]->set_state(hpcl_comp_pl<unsigned short>::HPCL_COMP_IDLE);
g_hpcl_global_comp_pl_2B[i]->reset_comp_done();
}
//reset output data
g_hpcl_global_comp_pl_2B[i]->reset_output_data();
} else {
//std::cout << "\t" << " cannot send flit " << flit->id << " due to no space!!!!!!!!!!" << std::endl;
}
}
}
///
}
//Send the credit To the network
for(int subnet = 0; subnet < _subnets; ++subnet) {
for(int n = 0; n < _nodes; ++n) {
map<int, Flit *>::const_iterator iter = flits[subnet].find(n);
if(iter != flits[subnet].end()) {
Flit * const f = iter->second;
f->atime = _time;
//added by kh(070715)
if(f->tail) {
//added by kh(030816)
if(f->type < Flit::ANY_TYPE) {
//added by kh(121715)
if(g_mc_placement_config.is_sm_node(n)) {
//std::cout << "mf's id: " << ((mem_fetch*)f->data)->get_request_uid() << ", time: " << _time << std::endl;
((mem_fetch*)f->data)->set_status(TAIL_FLIT_EJECTED_FROM_EJECT_BUF_IN_SM, _time);
//added by kh(122815)
double rep_net_lat = _time - ((mem_fetch*)f->data)->get_timestamp(HEAD_FLIT_INJECTED_TO_INJECT_BUF_IN_MEM);
g_hpcl_network_anal->add_sample(hpcl_network_anal::REP_NET_LAT, rep_net_lat);
///
} else if(g_mc_placement_config.is_mc_node(n)) {
((mem_fetch*)f->data)->set_status(TAIL_FLIT_EJECTED_FROM_EJECT_BUF_IN_MEM, _time);
//added by kh(122815)
double req_net_lat = _time - ((mem_fetch*)f->data)->get_timestamp(HEAD_FLIT_INJECTED_TO_INJECT_BUF_IN_SM);
g_hpcl_network_anal->add_sample(hpcl_network_anal::REQ_NET_LAT, req_net_lat);
///
}
}
}
///
if(f->watch) {
*gWatchOut << GetSimTime() << " | "
<< "node" << n << " | "
<< "Injecting credit for VC " << f->vc
<< " into subnet " << subnet
<< "." << endl;
}
if(g_hpcl_comp_config.hpcl_comp_en == 0) {
Credit * const c = Credit::New();
c->vc.insert(f->vc);
_net[subnet]->WriteCredit(c, n);
} else {
//added by kh(030816)
if(f->type == Flit::READ_REPLY) {
if(f->tail == false && f->m_enc_status == 1) {
} else {
Credit * const c = Credit::New();
c->vc.insert(f->vc);
_net[subnet]->WriteCredit(c, n);
//std::cout << "\tf->vc " << f->vc << " f->id " << f->id << std::endl;
}
} else {
Credit * const c = Credit::New();
c->vc.insert(f->vc);
_net[subnet]->WriteCredit(c, n);
}
///
}
#ifdef TRACK_FLOWS
++_ejected_flits[f->cl][n];
#endif
_RetireFlit(f, n);
}
}
flits[subnet].clear();
// _InteralStep here
_net[subnet]->Evaluate( ); //run router's pipeline
_net[subnet]->WriteOutputs( ); //send flits..
}
++_time;
assert(_time);
if(gTrace){
cout<<"TIME "<<_time<<endl;
}
}
EGLBoolean egl_display_t::initialize(EGLint *major, EGLint *minor) {
{
Mutex::Autolock _rf(refLock);
refs++;
if (refs > 1) {
if (major != NULL)
*major = VERSION_MAJOR;
if (minor != NULL)
*minor = VERSION_MINOR;
while(!eglIsInitialized) refCond.wait(refLock);
return EGL_TRUE;
}
while(eglIsInitialized) refCond.wait(refLock);
}
{
Mutex::Autolock _l(lock);
setGLHooksThreadSpecific(&gHooksNoContext);
// initialize each EGL and
// build our own extension string first, based on the extension we know
// and the extension supported by our client implementation
egl_connection_t* const cnx = &gEGLImpl;
cnx->major = -1;
cnx->minor = -1;
if (cnx->dso) {
EGLDisplay idpy = disp.dpy;
if (cnx->egl.eglInitialize(idpy, &cnx->major, &cnx->minor)) {
//ALOGD("initialized dpy=%p, ver=%d.%d, cnx=%p",
// idpy, cnx->major, cnx->minor, cnx);
// display is now initialized
disp.state = egl_display_t::INITIALIZED;
// get the query-strings for this display for each implementation
disp.queryString.vendor = cnx->egl.eglQueryString(idpy,
EGL_VENDOR);
disp.queryString.version = cnx->egl.eglQueryString(idpy,
EGL_VERSION);
disp.queryString.extensions = cnx->egl.eglQueryString(idpy,
EGL_EXTENSIONS);
disp.queryString.clientApi = cnx->egl.eglQueryString(idpy,
EGL_CLIENT_APIS);
} else {
ALOGW("eglInitialize(%p) failed (%s)", idpy,
egl_tls_t::egl_strerror(cnx->egl.eglGetError()));
}
}
// the query strings are per-display
mVendorString.setTo(sVendorString);
mVersionString.setTo(sVersionString);
mClientApiString.setTo(sClientApiString);
mExtensionString.setTo(gBuiltinExtensionString);
char const* start = gExtensionString;
do {
// length of the extension name
size_t len = strcspn(start, " ");
if (len) {
// NOTE: we could avoid the copy if we had strnstr.
const String8 ext(start, len);
if (findExtension(disp.queryString.extensions, ext.string(),
len)) {
mExtensionString.append(ext + " ");
}
// advance to the next extension name, skipping the space.
start += len;
start += (*start == ' ') ? 1 : 0;
}
} while (*start != '\0');
egl_cache_t::get()->initialize(this);
char value[PROPERTY_VALUE_MAX];
property_get("debug.egl.finish", value, "0");
if (atoi(value)) {
finishOnSwap = true;
}
property_get("debug.egl.traceGpuCompletion", value, "0");
if (atoi(value)) {
traceGpuCompletion = true;
}
if (major != NULL)
*major = VERSION_MAJOR;
if (minor != NULL)
*minor = VERSION_MINOR;
}
{
Mutex::Autolock _rf(refLock);
eglIsInitialized = true;
refCond.broadcast();
}
return EGL_TRUE;
}
