/* Send the task spec to the agent */
void agent_init(const char * theTaskSpec) {
int agentState = kAgentInit;
unsigned int theTaskSpecLength = 0;
unsigned int offset = 0;
if (theTaskSpec != NULL)
theTaskSpecLength = strlen(theTaskSpec);
if (theBuffer.capacity == 0)
rlBufferCreate(&theBuffer, 65536);
/* send across agent_init specific data */
rlBufferClear(&theBuffer);
offset = 0;
/* Strings are always preceeded by their length, and do not include their null terminating character */
offset = rlBufferWrite(&theBuffer, offset, &theTaskSpecLength, 1, sizeof(int));
if (theTaskSpecLength > 0) {
offset = rlBufferWrite(&theBuffer, offset, theTaskSpec, theTaskSpecLength, sizeof(char));
}
rlSendBufferData(rlGetAgentConnection(), &theBuffer, agentState);
/* Receive the receipt from the Client, to ensure that AgentInit has been completed */
rlBufferClear(&theBuffer);
rlRecvBufferData(rlGetAgentConnection(), &theBuffer, &agentState);
assert(agentState == kAgentInit);
}
const char* RL_env_message(const char *message) {
int experimentState = kRLEnvMessage;
unsigned int messageLength = 0;
unsigned int offset = 0;
if (message != 0){
messageLength = strlen(message);
}
forceConnection();
rlBufferClear(&clientexp_rlbuffer);
offset = 0;
offset = rlBufferWrite(&clientexp_rlbuffer, offset, &messageLength, 1, sizeof(int));
if (messageLength > 0) {
offset = rlBufferWrite(&clientexp_rlbuffer, offset, message, messageLength, sizeof(char));
}
rlSendBufferData(theExperimentConnection, &clientexp_rlbuffer, experimentState);
rlBufferClear(&clientexp_rlbuffer);
rlRecvBufferData(theExperimentConnection, &clientexp_rlbuffer, &experimentState);
assert(experimentState == kRLEnvMessage);
offset = 0;
offset = rlBufferRead(&clientexp_rlbuffer, offset, &messageLength, 1, sizeof(int));
/* Sept 12 2008 made this >= instead of > so that we'd at least have size 1 */
if (messageLength >= clientexp_messagecapacity) {
if(clientexp_message!=0){
free(clientexp_message);
clientexp_message=0;
}
clientexp_message = (char*)calloc(messageLength+1, sizeof(char));
clientexp_messagecapacity = messageLength;
}
if (messageLength > 0) {
offset = rlBufferRead(&clientexp_rlbuffer, offset, clientexp_message, messageLength, sizeof(char));
}
/* Sept 12 2008 moved this out of the if statement so we actually null terminate at the right place if we get a "" message */
clientexp_message[messageLength] = '\0';
return clientexp_message;
}
const char* env_message(const char* inMessage) {
int envState = kEnvMessage;
unsigned int theInMessageLength = 0;
unsigned int theOutMessageLength = 0;
unsigned int offset = 0;
if (inMessage != NULL) {
theInMessageLength = strlen(inMessage);
}
if (theBuffer.capacity == 0)
rlBufferCreate(&theBuffer, 65356);
rlBufferClear(&theBuffer);
offset = 0;
offset = rlBufferWrite(&theBuffer, offset, &theInMessageLength, 1, sizeof(int));
if (theInMessageLength > 0) {
offset = rlBufferWrite(&theBuffer, offset, inMessage, theInMessageLength, sizeof(char));
}
rlSendBufferData(rlGetEnvironmentConnection(), &theBuffer, envState);
rlBufferClear(&theBuffer);
rlRecvBufferData(rlGetEnvironmentConnection(), &theBuffer, &envState);
assert(envState == kEnvMessage);
offset = 0;
offset = rlBufferRead(&theBuffer, offset, &theOutMessageLength, 1, sizeof(int));
/*Free and point the old message to null */
if (theOutMessage != 0) {
free(theOutMessage);
theOutMessage = 0;
}
/* Allocated memory for the new message, maybe just 1 byte for the terminator */
theOutMessage = (char*)calloc(theOutMessageLength+1, sizeof(char));
/* Fill up the string from the buffer */
if (theOutMessageLength > 0) {
offset = rlBufferRead(&theBuffer, offset, theOutMessage, theOutMessageLength, sizeof(char));
}
/* Set the terminator */
theOutMessage[theOutMessageLength] = '\0';
return theOutMessage;
}
static void onAgentMessage(int theConnection) {
unsigned int inMessageLength = 0;
unsigned int outMessageLength = 0;
char* inMessage = 0;
const char* outMessage = 0;
unsigned int offset = 0;
/* Read the data in the buffer (data from server) */
offset = 0;
offset = rlBufferRead(&theBuffer, offset, &inMessageLength, 1, sizeof(int));
if (inMessageLength >= clientagent_inmessagecapacity) {
inMessage = (char*)calloc(inMessageLength+1, sizeof(char));
free(clientagent_inmessage);
clientagent_inmessage = inMessage;
clientagent_inmessagecapacity = inMessageLength;
}
if (inMessageLength > 0) {
offset = rlBufferRead(&theBuffer, offset, clientagent_inmessage, inMessageLength, sizeof(char));
}
/*Make sure to null terminate the string */
clientagent_inmessage[inMessageLength]='\0';
/* Call RL method on the recv'd data */
outMessage = agent_message(clientagent_inmessage);
if (outMessage != NULL) {
outMessageLength = strlen(outMessage);
}
/* Prepare the buffer for sending data back to the server */
/* we want to start sending, so we're going to reset the offset to 0 so we write to the beginning of the buffer */
rlBufferClear(&theBuffer);
offset = 0;
offset = rlBufferWrite(&theBuffer, offset, &outMessageLength, 1, sizeof(int));
if (outMessageLength > 0) {
offset = rlBufferWrite(&theBuffer, offset, outMessage, outMessageLength, sizeof(char));
}
}
/* Send the final reward to the agent */
void agent_end(const double theReward) {
int agentState = kAgentEnd;
unsigned int offset = 0;
rlBufferClear(&theBuffer);
/*offset = rlBufferWrite(&theBuffer, offset, &agentState, 1, sizeof(int));*/ /* Removed, shouldn't have been sent. */
offset = rlBufferWrite(&theBuffer, offset, &theReward, 1, sizeof(double));
rlSendBufferData(rlGetAgentConnection(), &theBuffer, agentState);
rlBufferClear(&theBuffer);
rlRecvBufferData(rlGetAgentConnection(), &theBuffer, &agentState);
assert(agentState == kAgentEnd);
}
int RL_episode(unsigned int numSteps) {
int terminal=0;
unsigned int offset = 0;
int experimentState = kRLEpisode;
assert(theExperimentConnection != 0);
rlBufferClear(&clientexp_rlbuffer);
offset = 0;
offset = rlBufferWrite(&clientexp_rlbuffer, offset, &numSteps, 1, sizeof(int));
rlSendBufferData(theExperimentConnection, &clientexp_rlbuffer, experimentState);
rlBufferClear(&clientexp_rlbuffer);
/*Brian Sept 8 2008 :: Not really sure if I should be resetting offset to 0 here. Seems to work as is*/
offset=0;
rlRecvBufferData(theExperimentConnection, &clientexp_rlbuffer, &experimentState);
offset = rlBufferRead(&clientexp_rlbuffer, offset, &terminal, 1, sizeof(int));
assert(experimentState == kRLEpisode);
return terminal;
}
/* Send the reward and the observation to the agent, receive the action and return it */
const action_t *agent_step(const double theReward, const observation_t *theObservation) {
int agentState = kAgentStep;
unsigned int offset = 0;
rlBufferClear(&theBuffer);
offset = 0;
offset = rlBufferWrite(&theBuffer, offset, &theReward, 1, sizeof(double));
offset = rlCopyADTToBuffer(theObservation, &theBuffer, offset);
rlSendBufferData(rlGetAgentConnection(), &theBuffer, agentState);
rlBufferClear(&theBuffer);
rlRecvBufferData(rlGetAgentConnection(), &theBuffer, &agentState);
assert(agentState == kAgentStep);
offset = 0;
if(globalAction==0)globalAction=allocateRLStructPointer(0,0,0);
offset = rlCopyBufferToADT(&theBuffer, offset, globalAction);
return globalAction;
}
