root/vtcross/branches/trnewman/CR_shell/src/main_cognitive_radio.cpp @ 90

#include <iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include "tinyxml.h"
#include "tinystr.h"
#include "socket/ServerSocket.h"
#include "socket/SocketException.h"

using namespace std;

#define SERVER_PORT 30000

struct CE_Info {
        int numUtilities;
        int numParameters;
        int numObservables;
};

struct Utility {
        string name;
        string units;
        string goal;
        float target;
    float value;
};
struct Affect {
        Utility * u;
        string relation;
};
struct Parameter {
        string name;
        string units;
        float min;
        int numAffects;
        Affect affection_list[10];
        float max;
        float step;
    float value;
};

struct Observable {
        string name;
        Affect affection_list[10];
        int numAffects;
    float value;
};

void print_current_config(Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info) {
        int i = 0;
        int j = 0;

        for(i = 0; i < ce_info->numUtilities ; i++) {
                cout << "Utility:  " << uList[i]->name << endl;
                cout << "     Units:  " << uList[i]->units << endl;
                cout << "     Goal:   " << uList[i]->goal << endl;
                cout << "     Target: " << uList[i]->target << endl;
        }

        for(i = 0; i < ce_info->numParameters; i++) {
                cout << "Parameter:  " << pList[i]->name << endl;
                cout << "       Units:   " << pList[i]->units << endl;
                cout << "       Min:     " << pList[i]->min << endl;
                cout << "       Max:     " << pList[i]->max << endl;
                cout << "       Step:    " << pList[i]->step << endl;
                for(j = 0; j < pList[i]->numAffects; j++) {
                        cout << "       Affect: " << pList[i]->affection_list[j].u->name << " -> " << pList[i]->affection_list[j].relation << endl;
                }
        }
        
    for(i = 0; i < ce_info->numObservables; i++) {
                cout << "Observable:  " << oList[i]->name << endl;
                for(j = 0; j < oList[i]->numAffects; j++) {
                        cout << "       Affect: " << oList[i]->affection_list[j].u->name << " -> " << oList[i]->affection_list[j].relation << endl;
                }
        }
}


int parse_ce_config( TiXmlDocument * doc , Utility * u[], Parameter * p[], Observable * o[], CE_Info * ce_info) {

        TiXmlElement* pElem;    //!current element
        TiXmlElement* pChild;   //!current child of pElem
        TiXmlElement* pChild1;  //!current child of pElem
        TiXmlElement* pSecondChild;     //!current child of pElem
        TiXmlHandle hDoc(doc);  //!handle to xml document
        TiXmlHandle hRoot(0); //! handle to root element 

        int count = 0;
        int i = 0;
        int j = 0;
        int k = 0;
        int match_found = 0;

        pElem = hDoc.FirstChildElement().Element();
        if(!pElem) { cout << "no valid root! quit-ing function!" << endl; return 0; }
        hRoot = TiXmlHandle(pElem);

        // Pull utility information from XML file.

        pElem = hRoot.FirstChild("utilities").Element();
        pChild1 = hRoot.Child("utilities",count).Element();


        for(pChild = pChild1->FirstChildElement("utility"); pChild; pChild = pChild->NextSiblingElement())
        {
                u[i] = new Utility;
                const char *uName = pChild->Attribute("name");
                if(uName) u[i]->name = uName;   
                const char *uUnits = pChild->Attribute("units");
                if(uUnits) u[i]->units = uUnits;
                const char *uGoal = pChild->Attribute("goal");
                if(uGoal) u[i]->goal = uGoal;
                if(pChild->QueryFloatAttribute("target",&u[i]->target) != TIXML_SUCCESS) u[i]->target = -1;
                i++;
        }
        ce_info->numUtilities = i;      
        cout << "Parsed " << ce_info->numUtilities << " utilities." << endl;

        // Pull observable information from XML file.
        i = 0;
        pElem = hRoot.FirstChild("observables").Element();
        pChild1 = hRoot.Child("observables",count).Element();
        
        for(pChild = pChild1->FirstChildElement("observable"); pChild; pChild = pChild->NextSiblingElement())
        {

                const char *oName = pChild->Attribute("name");
                o[i] = new Observable;

                if(oName) o[i]->name = oName;
                
                j = 0;
                for(pSecondChild = pChild->FirstChildElement("affect"); pSecondChild; pSecondChild = pSecondChild->NextSiblingElement())
                {
                        const char *oUtilName = pSecondChild->Attribute("utility");

                        // If a utility affects this parameter find the utility object and assign it
                        if(oUtilName) {
                                // Search for correct utility
                                for( k=0 ; u[k]!=NULL ; k++ ){
                                        if(u[k]->name == oUtilName) {
                                                o[i]->affection_list[j].u = u[k];
                                                // Set relationship
                                                const char *oRelate = pSecondChild->Attribute("relationship");
                                                if(oRelate) o[i]->affection_list[j].relation = oRelate;
                                                j++;
                                                match_found = 1;
                                                break;
                                        }
                                }
                        }
                        if(!match_found) cout << "Error: " << o[i]->name << ": " << oUtilName << " not a valid utility: Affect not added." << endl;     
                        match_found = 0;        
                }
                o[i]->numAffects = j; 
                i++;
        }
        ce_info->numObservables = i;    
        cout << "Parsed " << ce_info->numObservables << " observables." << endl;
        

        // Pull parameter information from XML file.
        pElem = hRoot.FirstChild("parameters").Element();
        pChild1 = hRoot.Child("parameters",count).Element();
        
        i = 0;
        for(pChild = pChild1->FirstChildElement("parameter"); pChild; pChild = pChild->NextSiblingElement())
        {
                p[i] = new Parameter;

                const char *pName = pChild->Attribute("name");
                if(pName) p[i]->name = pName;   
                const char *pUnits = pChild->Attribute("units");
                if(pUnits) p[i]->units = pUnits;

                if(pChild->QueryFloatAttribute("min",&p[i]->min) != TIXML_SUCCESS) p[i]->min = -1;
                if(pChild->QueryFloatAttribute("max",&p[i]->max) != TIXML_SUCCESS) p[i]->max = -1;
                if(pChild->QueryFloatAttribute("step",&p[i]->step) != TIXML_SUCCESS) p[i]->step = -1;
                
                j = 0;
                for(pSecondChild = pChild->FirstChildElement("affect"); pSecondChild; pSecondChild = pSecondChild->NextSiblingElement())
                {
                        const char *pUtilName = pSecondChild->Attribute("utility");
                        
                        // If a utility affects this parameter find the utility object and assign it
                        if(pUtilName) {
                                // Search for correct utility
                                for( k=0 ; u[k]!=NULL ; k++ ){
                                        if(u[k]->name == pUtilName) {
                                                // If match found, assign it to this index
                                                p[i]->affection_list[j].u = u[k];       
                                                const char *pRelate = pSecondChild->Attribute("relationship");
                                                if(pRelate) {
                                                        p[i]->affection_list[j].relation = pRelate;
                                                } else {
                                                        cout << "Error: No relation found." << endl;
                                                }
                                                match_found = 1;
                                                j++;
                                                break;
                                        }
                                }
                        }
                        if(!match_found) cout << "Error: " << p[i]->name << ": " << pUtilName << " not a valid utility: Affect not added." << endl;     
                        match_found = 0;        
                }
                p[i]->numAffects = j; 
                i++;

        }
        ce_info->numParameters = i;     
        cout << "Parsed " << ce_info->numParameters << " parameters." << endl;
        return 1;
}


void error(char *msg)
{
    perror(msg);
    exit(1);
}


int ReceiveMessage(int socket,char * buffer) 
{
    int i,n;
    
    n = recv(socket,buffer,256,MSG_PEEK);
    for(i=0;i<256;i++){
        if(strcmp(&buffer[i],"\0") == 0) break;
    }
    n = recv(socket,buffer,i+1,0);
    if (n < 0)
        error("ERROR reading from socket");
    //    printf("ReadMessage:%s %d\n",buffer,n);

    return n;
}


int SendMessage(int socketfd, string message) {
        int n;

        message.append("\0");   
        // Write message back to client
    n = write(socketfd,message.c_str(),(message.size()+1));
    if (n<0)
        error("Error sending to client\n");
    if(n == 0)
        printf("Client closed the socket.\n");

        //printf("SendMessage:%s %d\n",message.c_str(),n);      
    return n;
}

void GetEnvironment() {

}

void Policy_ValidateSettings() {

}


void LoadCEConfiguration(int socketfd,Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info){
        int n,i,j;
        char counter[55];
        char var[50];
        //int total_bytes;   

        printf("Sending configuration to CE.\n");
 
        // utilities
        // Send number of utilities
        sprintf(counter,"%d",ce_info->numUtilities);
        SendMessage(socketfd,counter);
        // send utility 
    for(i = 0; i < ce_info->numUtilities; i++) {
                SendMessage(socketfd,uList[i]->name);
                SendMessage(socketfd,uList[i]->units);
                SendMessage(socketfd,uList[i]->goal);
                sprintf(var,"%f",uList[i]->target);
                SendMessage(socketfd,var);
        }

        // parameters
    sprintf(counter,"%i",ce_info->numParameters);
        SendMessage(socketfd,counter);
        for(i = 0; i < ce_info->numParameters; i++) {
                SendMessage(socketfd,pList[i]->name);
                SendMessage(socketfd,pList[i]->units);
                sprintf(var,"%f",pList[i]->min);
                SendMessage(socketfd,var);
                sprintf(var,"%f",pList[i]->max);
                SendMessage(socketfd,var);
                sprintf(var,"%f",pList[i]->step);
                SendMessage(socketfd,var);
                
                sprintf(counter,"%i",pList[i]->numAffects); 
                SendMessage(socketfd,counter);
                for(j = 0; j < pList[i]->numAffects; j++) {
                        SendMessage(socketfd,pList[i]->affection_list[j].u->name);
                        SendMessage(socketfd,pList[i]->affection_list[j].relation);
                }
        }

    // observables
        sprintf(counter,"%i",ce_info->numObservables);
        SendMessage(socketfd,counter);
        for(i = 0; i < ce_info->numObservables; i++) {
                SendMessage(socketfd,oList[i]->name);
                
                sprintf(counter,"%i",oList[i]->numAffects); 
                SendMessage(socketfd,counter);
                for(j = 0; j < oList[i]->numAffects; j++) {
                        SendMessage(socketfd,oList[i]->affection_list[j].u->name);
                        SendMessage(socketfd,oList[i]->affection_list[j].relation);
                }
        }
        
        printf("Configuration sent, waiting for ACK...\n");
        // Receive ACK for utils
    char buffer[256];
        string message;
        n = ReceiveMessage(socketfd, buffer);
    printf("%s\n", buffer);
        //cout << message << endl;
        printf("ACK received.\n");

}

void UpdateCEConfiguration() {

}

void ResetCEConfiguration(){

}

void UpdateCEExperience(int socketfd, int num_rows, int num_cols, 
        float * past_exp[]) 
{
    char buffer[256];
    int i, j;
        char counter[55];
        char var[50];

    for (i = 0; i < num_rows; i++){
        for (j = 0; j< num_cols; j++){
                sprintf(var,"%f",past_exp[i][j]);
        //printf("%f, \n", past_exp[i][j]);
        //printf("%s, \n", var);
        }
    }
    
    // send the number of rows to the ce first
        sprintf(counter,"%d",num_rows);
        SendMessage(socketfd,counter);
    // send the number of columns to the ce
        sprintf(counter,"%d",num_cols);
        SendMessage(socketfd,counter);
    // update ce with experience
    for (i = 0; i < num_rows; i++){
        for (j = 0; j< num_cols; j++){
                sprintf(var,"%f",past_exp[i][j]);
                SendMessage(socketfd,var);
        }
    }

    printf("experience sent\n");
}

void ResetCEExperience() {

}

// Update operating settings
// This function will interact with the hardware "drivers"
void UpdateRadioSettings() 
{
}

int RequestCEOptimization(int sockfd, Utility *uList[], 
        Parameter *pList[], Observable *oList[],
        CE_Info *ce_info)
{
    char buffer[256];
    int i;
    float var;

    /*// utility
    for (i = 0; i < ce_info->numUtilities; i++){
        bzero(buffer,256);
        ReceiveMessage(sockfd,buffer);
        var = atof(buffer);
        uList[i]->value = var;
        printf("utility %s, value %f\n"
                , uList[i]->name.c_str(), uList[i]->value);
    }*/
    
    // paramter
    for (i = 0; i < ce_info->numParameters; i++){
        bzero(buffer,256);
        ReceiveMessage(sockfd,buffer);
        var = atof(buffer);
        pList[i]->value = var;
        printf("parameter %s, value %f\n"
                , pList[i]->name.c_str(), pList[i]->value);
    }

    /*// observable
    for (i = 0; i < ce_info->numObservables; i++){
        bzero(buffer,256);
        ReceiveMessage(sockfd,buffer);
        var = atof(buffer);
        oList[i]->value = var;
        printf("observable %s, value %f\n"
                , oList[i]->name.c_str(), oList[i]->value);
    }*/

    return 1;
}

void RunSimulator(int socketfd, Utility * uList[], 
        Parameter * pList[], Observable * oList[], 
        CE_Info * ce_info) {
        
        float **past_exp;
    int num_rows, num_cols;

        // Set fake current environment params = current environment
        RequestCEOptimization(socketfd, uList, pList, oList, ce_info);

        // Act like we are updating the hardware tranmission settings
        UpdateRadioSettings();

        // Send back fake utility values
    // need to initialize
        //UpdateCEExperience(socketfd, num_rows, num_cols, past_exp);   
}

void StartMessaging(int socketfd, Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info) 
{
        LoadCEConfiguration(socketfd, uList, pList, oList, ce_info);
        
    // cr experience
    float **past_exp;
        int num_cols;
    // get number of columns
    num_cols = ce_info->numUtilities + ce_info->numParameters;
    num_cols = num_cols + ce_info->numObservables;
    num_cols = num_cols + 1;    // overall utility
    int num_rows = 2;
    past_exp = (float **)malloc(sizeof(float)*num_rows);
    int i;
    for (i=0; i<num_rows; i++){
        past_exp[i] = (float*)malloc(sizeof(float)*num_cols);
    }
    // sample experience #1
    past_exp[0][0] = 1e3f;  // throughput
    past_exp[0][1] = 1;     // spectral_efficiency
    past_exp[0][2] = -3.5;  // log10_ber
    past_exp[0][3] = 1;     // mod_scheme
    past_exp[0][4] = -10;   // tx_power
    past_exp[0][5] = 10.0;  // SNR
    past_exp[0][6] = 0.762; // overall utility*/
    // sample experience #2
    past_exp[1][0] = 1e2f;  // throughput
    past_exp[1][1] = 1;     // spectral_efficiency
    past_exp[1][2] = -3.5;  // log10_ber
    past_exp[1][3] = 1;     // mod_scheme
    past_exp[1][4] = -14;   // tx_power
    past_exp[1][5] = 3.0;   // SNR
    past_exp[1][6] = 0.462; // overall utility


        // update ce with experience
    UpdateCEExperience(socketfd, num_rows, num_cols, past_exp); 

        RunSimulator(socketfd, uList, pList, oList, ce_info);
}

int StartShell(int port,Utility * uList[], Parameter * pList[], Observable * oList[], CE_Info * ce_info) {
        // Start socket server
        int sockfd, newsockfd, clilen;
        struct sockaddr_in serv_addr, cli_addr;

        // Setup server socket connection
        sockfd = socket(AF_INET, SOCK_STREAM, 0);
        if (sockfd < 0) 
                error("ERROR opening socket");
        bzero((char *) &serv_addr, sizeof(serv_addr));
        serv_addr.sin_family = AF_INET;
        serv_addr.sin_port = htons(port);
        serv_addr.sin_addr.s_addr = INADDR_ANY;
        if (bind(sockfd, (struct sockaddr *) &serv_addr,
                sizeof(serv_addr)) < 0) 
                error("ERROR on binding");
        listen(sockfd,5);
        clilen = sizeof(cli_addr);

        //while(1) {
                newsockfd = accept(sockfd, 
                        (struct sockaddr *) &cli_addr, 
                        (socklen_t*)&clilen);
                if (newsockfd < 0) 
                        error("ERROR on accept");

                // Begin parsing the messages
                StartMessaging(newsockfd, uList, pList, oList, ce_info);
        //}
        return 0;
}

int main(int argc, char* argv[]) {


        // CognitiveEngine CE;
        // CognitiveEngineShell Shell;
        string pFilename; 
        int pid;

        Utility * uList[10];
        Parameter * pList[10];
        Observable * oList[10];
        CE_Info ce_info;

        if(argc < 2) { 
                cout << "Warning no XML file specific using default: example.xml" << endl;
                pFilename = "example.xml";
        } else {  
                pFilename = argv[1];
        }

        TiXmlDocument doc( pFilename.c_str() );
        bool loadOkay = doc.LoadFile();
        if (!loadOkay)
        {
                cout << "Loading " << pFilename << " failed." << endl;
                return 0;
        }

        cout << "Attemping to parse " << pFilename << "." << endl;
        parse_ce_config( &doc , uList, pList, oList, &ce_info);
        cout << "Configuration file parsing completed." << endl;

    //print_current_config(uList, pList, oList, &ce_info);
        
    pid = fork();
        if(pid == 0) {
                // In child process - open policy engine port.
        //      StartShell(30000,uList, pList, oList, &ce_info);
        } else {
                // In parent process - open cognitive engine port.
                StartShell(30001,uList, pList, oList, &ce_info);
        } 
        

   return 1;
}