void childProcess( Process* proc ) {
closeUnusedPipes( proc );
// STARTED
proc -> started += 1;
incLamportTime();
Message startedMsg;
fillMessage( &startedMsg, proc, STARTED );
makeIPCLog( startedMsg.s_payload );
send_multicast( proc, &startedMsg );
// Receive STARTED
while( proc -> started != proc -> total ) {
defaultCSExtendedCycle( proc );
}
sprintf( LogBuf, log_received_all_started_fmt, get_lamport_time(), proc -> localId );
makeIPCLog( LogBuf );
// Payload
int totalIterations = proc -> localId * 5;
for( int i = 1; i <= totalIterations; i ++ ) {
sprintf( LogBuf, log_loop_operation_fmt, proc -> localId, i, totalIterations );
if( proc -> isMutex ) request_cs( proc );
print( LogBuf );
if( proc -> isMutex ) release_cs( proc );
}
// DONE
proc -> done += 1;
incLamportTime();
Message doneMsg;
fillMessage( &doneMsg, proc, DONE );
makeIPCLog( doneMsg.s_payload );
send_multicast( proc, &doneMsg );
// Receive DONE
while( proc -> done != proc -> total ) {
defaultCSExtendedCycle( proc );
}
sprintf( LogBuf, log_received_all_done_fmt, get_lamport_time(), proc -> localId );
makeIPCLog( LogBuf );
closeTheOtherPipes( proc );
}
/* Creates and sends message.*/
void twitClient::createAndSendMessage(char command[],const std::string& other)
{
char* msg = new char[PACKAGE_SIZE];
resetMessage(msg);
fillMessage(msg,command,other);
sendMessage(msg);
delete[] (msg);
}
int release_cs( const void* self ) {
const Process* proc = self;
pop( proc -> list );
// CS_RELEASE
incLamportTime();
Message releaseMsg;
fillMessage( &releaseMsg, proc, CS_RELEASE );
send_multicast( ( void* ) proc, &releaseMsg );
return 0;
}
int request_cs( const void* self ) {
Process* proc = ( Process* ) self;
// CS_REQUEST
incLamportTime();
Message requestMsg;
fillMessage( &requestMsg, proc, CS_REQUEST );
send_multicast( ( void* ) proc, &requestMsg );
Request request = { get_lamport_time(), proc -> localId };
insert( proc -> list, request );
proc -> replied = 1;
while( proc -> replied != proc -> total || !isFirst( proc -> list, proc -> localId ) ) {
defaultCSExtendedCycle( proc );
}
return 0;
}
void SinaParserXml::parserDM(QDomElement &messageElement, Status &status)
{
QDomNodeList messageNodes = messageElement.childNodes();
for( uint j=0; j<messageNodes.length(); j++)
{
QDomNode node = messageNodes.at(j);
QDomElement element = node.toElement();
if(element.tagName()=="sender")
{
QDomNodeList senderNodes = element.childNodes();
for( uint i=0; i<senderNodes.length(); i++)
{
QDomElement senderElement = senderNodes.at(i).toElement();
fillSender(status, senderElement.tagName(), senderElement.text());
}
}
else
fillMessage(status, element.tagName(), element.text());
}
}
void defaultCSExtendedCycle( Process* proc ) {
Message msg;
receive_any( proc, &msg );
setMaxLamportTime( msg.s_header.s_local_time );
incLamportTime();
switch( msg.s_header.s_type ) {
case STARTED: {
proc -> started += 1;
break;
}
case CS_REQUEST: {
Request request = { msg.s_header.s_local_time, proc -> msgAuthor };
insert( proc -> list, request );
// CS_REPLY
incLamportTime();
Message replyMsg;
fillMessage( &replyMsg, proc, CS_REPLY );
send( ( void* ) proc, proc -> msgAuthor, &replyMsg );
break;
}
case CS_REPLY: {
proc -> replied += 1;
break;
}
case CS_RELEASE: {
pop( proc -> list );
break;
}
case DONE: {
proc -> done += 1;
break;
}
}
}
Exception::Exception(const std::string& iFile, int iLine, std::ostringstream& iStreamMessage) throw ()
:std::exception(),_message(),_file(iFile), _line(0) {
fillMessage(iFile, iLine, iStreamMessage);
}
Exception::Exception(const std::string& iFile, int iLine, const std::string& iMessage) throw ()
:std::exception(),_message(),_file(iFile), _line(0) {
std::ostringstream aStream;
aStream << iMessage;
fillMessage(iFile, iLine, aStream);
}
void GameConnect::handle(portals::OutPortal<messages::GameState>& out,
portals::InPortal<messages::GCResponse>& in,
int player)
{
char packet[sizeof(struct RoboCupGameControlData)];
int result;
struct sockaddr from;
int addrlen = sizeof(from);
struct RoboCupGameControlData control;
do
{
portals::Message<messages::GameState> gameMessage(0);
memset(&packet[0], 0, sizeof(struct RoboCupGameControlData));
result = _socket->receiveFrom(&packet[0], sizeof(packet),
&from, &addrlen);
if (_timer->timestamp() - _gcTimestamp > TEAMMATE_DEAD_THRESHOLD) {
_haveRemoteGC = false;
fillMessage(gameMessage.get(), control);
out.setMessage(gameMessage);
}
if (result <= 0)
break;
if (!verify(&packet[0]))
continue; // Bad Packet.
_haveRemoteGC = true;
_gcTimestamp = _timer->timestamp();
memcpy(&control, &packet[0], sizeof(RoboCupGameControlData));
fillMessage(gameMessage.get(), control);
#ifdef DEBUG_COMM
std::cout << "Received Game Controller message:\n\n"
<< gameMessage.get()->DebugString()
<< std::endl;
#endif
out.setMessage(gameMessage);
// Reset the target to the GC that we are getting data from.
char destination[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &((struct sockaddr_in*)&from)->sin_addr,
&destination[0], INET_ADDRSTRLEN);
_socket->setTarget(&destination[0], GAMECONTROLLER_PORT);
_socket->setBroadcast(false);
in.latch();
if (player)
respond(player, in.message().status());
else
{
//@TODO: Currently can't respond with correct status,
//need InPortals for other players... Too much overhead?
// for (int i = 1; i <= NUM_PLAYERS_PER_TEAM; ++i)
// respond(i);
}
} while (true);
}
