Changeset 231

Show
Ignore:
Timestamp:
04/07/09 00:42:38 (15 years ago)
Author:
bhilburn
Message:

Style fixes for the most part. Perhaps one or two memory leaks. Added a
bunch of TODOs.

Location:
vtcross/trunk/src
Files:
6 modified

Legend:

Unmodified
Added
Removed
  • vtcross/trunk/src/cognitive_engines/CognitiveEngine.cpp

    r230 r231  
    2222#include "vtcross/cbr.h" 
    2323 
     24// TODO this is really bad; need to move to a proper cbr.h 
    2425#include "cbr.c" 
    2526 
     
    2829 
    2930 
    30  
    3131static cbr myCBR; 
     32 
    3233 
    3334CognitiveEngine::CognitiveEngine() 
     
    4142CognitiveEngine::~CognitiveEngine() 
    4243{ 
    43         cbr_free(myCBR); 
     44    cbr_free(myCBR); 
    4445    delete [] pList; 
    4546    delete [] oList; 
     
    4950 
    5051 
    51 CognitiveEngine::CognitiveEngine(const char* serverName, const char* serverPort, \ 
     52CognitiveEngine::CognitiveEngine(const char *serverName, const char *serverPort, \ 
    5253        const bool SML) 
    5354{ 
     
    7273 
    7374void 
    74 CognitiveEngine::ConnectToRemoteComponent(const char* serverName, \ 
    75         const char* serverPort, const bool SML) 
     75CognitiveEngine::ConnectToRemoteComponent(const char *serverName, \ 
     76        const char *serverPort, const bool SML) 
    7677{ 
    7778    commandSocketFD = ClientSocket(serverName, serverPort); 
     
    9899{  
    99100   LOG("Cognitive Engine:: Receiving feedback.\n"); 
    100          
    101         uint32_t numberColumns =  
    102                 radioInfo->numParameters + 
    103                 radioInfo->numUtilities; 
    104  
    105         uint32_t obsColumns = radioInfo->numObservables + 1; 
    106  
    107         float valList[numberColumns]; 
    108         float obsVals[numberColumns]; 
     101     
     102    uint32_t numberColumns =  
     103        radioInfo->numParameters + 
     104        radioInfo->numUtilities; 
     105 
     106    uint32_t obsColumns = radioInfo->numObservables + 1; 
     107 
     108    float valList[numberColumns]; 
     109    float obsVals[numberColumns]; 
    109110    char *nameList[numberColumns]; 
    110111    char *obsList[obsColumns]; 
     
    112113    size_t columnObsIndex = 0; 
    113114    for (size_t i = 0; i < radioInfo->numObservables; i++){ 
    114                 obsList[columnObsIndex] = (char*)observables[i].name.c_str(); 
     115        obsList[columnObsIndex] = (char*)observables[i].name.c_str(); 
    115116        columnObsIndex++; 
    116117    }   
     
    119120    size_t columnIndex = 0; 
    120121    for (size_t i = 0; i < radioInfo->numParameters; i++){ 
    121                 nameList[columnIndex] = (char*)parameters[i].name.c_str(); 
     122        nameList[columnIndex] = (char*)parameters[i].name.c_str(); 
    122123        columnIndex++; 
    123124    }    
    124125    for (size_t i = 0; i < radioInfo->numUtilities; i++){ 
    125                 nameList[columnIndex] = (char*)uList[i].name.c_str(); 
     126        nameList[columnIndex] = (char*)uList[i].name.c_str(); 
    126127        columnIndex++; 
    127128    }    
    128129 
    129         size_t obsValueIndex = 0; 
     130    size_t obsValueIndex = 0; 
    130131    for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    131                 obsVals[obsValueIndex] = observables[i].value; 
    132                 obsValueIndex++; 
    133         } 
    134         // Calculate Utility 
    135         float newUtilityValue = 0; 
     132        obsVals[obsValueIndex] = observables[i].value; 
     133        obsValueIndex++; 
     134    } 
     135 
     136    /* Calculate Utility */ 
     137    float newUtilityValue = 0; 
    136138 
    137139    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    138                 newUtilityValue = newUtilityValue + (uList[i].target - observables[i].value); 
    139         } 
    140         obsVals[obsValueIndex] = newUtilityValue; 
    141  
    142         size_t returnValueIndex = 0; 
     140        newUtilityValue = newUtilityValue + (uList[i].target - observables[i].value); 
     141    } 
     142    obsVals[obsValueIndex] = newUtilityValue; 
     143 
     144    size_t returnValueIndex = 0; 
    143145    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    144                 valList[returnValueIndex] = parameters[i].value; 
    145                 returnValueIndex++; 
    146         } 
     146        valList[returnValueIndex] = parameters[i].value; 
     147        returnValueIndex++; 
     148    } 
    147149    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    148                 valList[returnValueIndex] = uList[i].target; 
    149                 returnValueIndex++; 
    150         } 
    151  
    152  
    153         cbr_update(myCBR, nameList, obsList, valList, obsVals,  
    154                         numberColumns, obsColumns); 
     150        valList[returnValueIndex] = uList[i].target; 
     151        returnValueIndex++; 
     152    } 
     153 
     154    cbr_update(myCBR, nameList, obsList, valList, obsVals,  
     155            numberColumns, obsColumns); 
    155156} 
    156157 
     
    177178            /* Receive Set of current Parameters */ 
    178179            memset(buffer, 0, 256); 
    179             ReadMessage(commandSocketFD,buffer); 
     180            ReadMessage(commandSocketFD, buffer); 
    180181            uint32_t numParameters = atoi(buffer); 
    181182    
     
    193194 
    194195            /* Receive Set of Observables */ 
     196            memset(buffer, 0, 256); 
     197            ReadMessage(commandSocketFD, buffer); 
     198            uint32_t numObservables = atoi(buffer); 
     199    
     200            Observable *o = new Observable[numObservables]; 
     201  
     202            for(size_t i = 0; i < numObservables; i++) { 
     203                memset(buffer, 0, 256); 
     204                ReadMessage(commandSocketFD, buffer); 
     205                o[i].name = std::string(buffer); 
     206     
     207                memset(buffer, 0, 256); 
     208                ReadMessage(commandSocketFD, buffer); 
     209                o[i].value = atof(buffer); 
     210            }   
     211 
     212            ReceiveFeedback(o,p); 
     213 
     214            delete [] o; 
     215            delete [] p; 
     216        }  
     217        else if(strcmp(buffer, "request_optimization") == 0) { 
     218             
     219            /* Receive Set of Observables */ 
     220            LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); 
     221 
    195222            memset(buffer, 0, 256); 
    196223            ReadMessage(commandSocketFD,buffer); 
     
    209236            }   
    210237 
    211                         ReceiveFeedback(o,p); 
    212  
    213             delete [] o; 
    214             delete [] p; 
    215                 }  
    216                 else if(strcmp(buffer, "request_optimization") == 0) { 
    217              
    218             /* Receive Set of Observables */ 
    219                         LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); 
     238            /* Receive Set of current Parameters */ 
     239            LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); 
    220240 
    221241            memset(buffer, 0, 256); 
    222             ReadMessage(commandSocketFD,buffer); 
    223             uint32_t numObservables = atoi(buffer); 
    224     
    225             Observable *o = new Observable[numObservables]; 
    226   
    227             for(size_t i = 0; i < numObservables; i++) { 
    228                 memset(buffer, 0, 256); 
    229                 ReadMessage(commandSocketFD, buffer); 
    230                 o[i].name = std::string(buffer); 
    231      
    232                 memset(buffer, 0, 256); 
    233                 ReadMessage(commandSocketFD, buffer); 
    234                 o[i].value = atof(buffer); 
    235             }   
    236  
    237             /* Receive Set of current Parameters */ 
    238                         LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); 
    239  
    240             memset(buffer, 0, 256); 
    241             ReadMessage(commandSocketFD,buffer); 
     242            ReadMessage(commandSocketFD, buffer); 
    242243            uint32_t numCurrentParameters = atoi(buffer); 
    243244    
     
    253254                cp[i].value = atof(buffer); 
    254255            }   
    255                         LOG("Cognitive Engine:: Processing parameters....\n"); 
     256            LOG("Cognitive Engine:: Processing parameters....\n"); 
    256257 
    257258            Parameter *solutionSet; 
    258                          
    259                         solutionSet = GetSolution(o,cp); 
     259             
     260            solutionSet = GetSolution(o,cp); 
    260261 
    261262            // TODO need to actually do something with the observables here 
    262263            
    263                         LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); 
    264                         char numParametersChar[10]; 
    265                         char solutionValue[50]; 
    266                         sprintf(numParametersChar,"%i",radioInfo->numParameters); 
    267                         SendMessage(commandSocketFD,numParametersChar); 
     264            LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); 
     265            char numParametersChar[10]; 
     266            char solutionValue[50]; 
     267            sprintf(numParametersChar, "%i", radioInfo->numParameters); 
     268            SendMessage(commandSocketFD, numParametersChar); 
    268269            for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    269                 SendMessage(commandSocketFD,solutionSet[i].name.c_str()); 
     270                SendMessage(commandSocketFD, solutionSet[i].name.c_str()); 
    270271                memset(solutionValue, 0, 50); 
    271                             sprintf(solutionValue,"%f",solutionSet[i].value); 
    272                 SendMessage(commandSocketFD,solutionValue); 
    273                         } 
     272                sprintf(solutionValue, "%f", solutionSet[i].value); 
     273                SendMessage(commandSocketFD, solutionValue); 
     274            } 
    274275 
    275276            delete [] o; 
     
    430431    /* Receive Set of Utilities */ 
    431432    memset(buffer, 0, 256); 
    432     ReadMessage(commandSocketFD,buffer); 
     433    ReadMessage(commandSocketFD, buffer); 
    433434    radioInfo->numUtilities = atoi(buffer); 
    434435     
    435436    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    436437        memset(buffer, 0, 256); 
    437         ReadMessage(commandSocketFD,buffer); 
     438        ReadMessage(commandSocketFD, buffer); 
    438439        uList[i].name = std::string(buffer); 
    439440    
    440441        memset(buffer, 0, 256); 
    441         ReadMessage(commandSocketFD,buffer); 
     442        ReadMessage(commandSocketFD, buffer); 
    442443        uList[i].units = std::string(buffer); 
    443444 
    444445        memset(buffer, 0, 256); 
    445         ReadMessage(commandSocketFD,buffer); 
     446        ReadMessage(commandSocketFD, buffer); 
    446447        uList[i].goal = std::string(buffer); 
    447448     
    448449        memset(buffer, 0, 256); 
    449         ReadMessage(commandSocketFD,buffer); 
     450        ReadMessage(commandSocketFD, buffer); 
    450451        uList[i].target = atof(buffer); 
    451452    } 
     
    484485            memset(buffer, 0, 256); 
    485486            ReadMessage(commandSocketFD,buffer); 
     487            // TODO for + if{break} = while? 
    486488            for(size_t k = 0; k < radioInfo->numUtilities; k++) { 
    487                 if(uList[k].name == std::string(buffer)){     
     489                if(uList[k].name == std::string(buffer)) {     
    488490                    pList[i].affection_list[j].u = &uList[k];    
    489491                    break; 
     
    492494 
    493495            memset(buffer, 0, 256); 
    494             ReadMessage(commandSocketFD,buffer); 
     496            ReadMessage(commandSocketFD, buffer); 
    495497            pList[i].affection_list[j].relation = std::string(buffer);    
    496498        } 
     
    499501    /* Receive Set of Observables */ 
    500502    memset(buffer, 0, 256); 
    501     ReadMessage(commandSocketFD,buffer); 
     503    ReadMessage(commandSocketFD, buffer); 
    502504    radioInfo->numObservables = atoi(buffer); 
    503505     
    504506    for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    505507        memset(buffer, 0, 256); 
    506         ReadMessage(commandSocketFD,buffer); 
     508        ReadMessage(commandSocketFD, buffer); 
    507509        oList[i].name = std::string(buffer); 
    508510     
    509511        memset(buffer, 0, 256); 
    510         ReadMessage(commandSocketFD,buffer); 
     512        ReadMessage(commandSocketFD, buffer); 
    511513        oList[i].numAffects = atoi(buffer); 
    512514     
    513515        for(size_t j = 0; j < oList[i].numAffects; j++) { 
    514516            memset(buffer, 0, 256); 
    515             ReadMessage(commandSocketFD,buffer); 
     517            ReadMessage(commandSocketFD, buffer); 
     518            // TODO for + if{break} = while? 
    516519            for(size_t k = 0; k < radioInfo->numUtilities; k++) { 
    517                 if(uList[k].name == std::string(buffer)){     
     520                if(uList[k].name == std::string(buffer)){     
    518521                    oList[i].affection_list[j].u = &uList[k];    
    519522                    break; 
     
    522525  
    523526            memset(buffer, 0, 256); 
    524             ReadMessage(commandSocketFD,buffer); 
     527            ReadMessage(commandSocketFD, buffer); 
    525528            oList[i].affection_list[j].relation = std::string(buffer);    
    526529        } 
     
    529532    SendMessage(commandSocketFD, "receive_config_ack"); 
    530533 
    531         BuildCognitiveEngine(); 
     534    BuildCognitiveEngine(); 
    532535} 
    533536 
     
    541544    /* Receive number of experience entries */ 
    542545    memset(buffer, 0, 256); 
    543     ReadMessage(commandSocketFD,buffer); 
     546    ReadMessage(commandSocketFD, buffer); 
    544547    numberExp = atoi(buffer); 
    545548 
    546     LOG("Cognitive Engine:: Waiting for %i number of entries.\n",numberExp); 
     549    LOG("Cognitive Engine:: Waiting for %i number of entries.\n", numberExp); 
    547550  
    548551    SendMessage(commandSocketFD, "receive_exp_ack"); 
     
    558561    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    559562        searchNames[i] = (char*)observables[i].name.c_str(); 
    560         } 
     563    } 
    561564 
    562565    float searchVals[radioInfo->numUtilities]; 
    563566 
    564         for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    565                 searchVals[i] = uList[i].target; 
     567    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
     568        searchVals[i] = uList[i].target; 
    566569    } 
    567570 
    568571    uint32_t numberColumns =  
    569                 radioInfo->numUtilities + 
    570                 radioInfo->numParameters + 
    571                 radioInfo->numObservables + 1; 
    572          
    573         float returnValues[numberColumns]; 
    574          
    575         int searchOps[radioInfo->numUtilities]; 
     572        radioInfo->numUtilities + 
     573        radioInfo->numParameters + 
     574        radioInfo->numObservables + 1; 
     575     
     576    float returnValues[numberColumns]; 
     577     
     578    int searchOps[radioInfo->numUtilities]; 
    576579    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    577580 
    578581        /* If the goal is to maximum, set the search operation to 
    579                  * return values greater than the target. 
    580                  * 
    581                  * If the goal is to minimize, set the search operation to 
    582                  * return values less than the target. 
    583                  */ 
    584  
    585                 if(strcmp(uList[i].goal.c_str(),"max") == 0) { 
    586                     searchOps[i] = GT; 
    587                 } else if(strcmp(uList[i].goal.c_str(),"min") == 0) { 
    588                         searchOps[i] = LT; 
    589                 } 
    590         } 
    591  
    592         /* CBR specific call */ 
    593         uint32_t rc = cbr_search(myCBR, searchNames, searchOps, searchVals, 
    594                         radioInfo->numUtilities, returnValues); 
    595  
    596         if(rc == 0){ 
     582         * return values greater than the target. 
     583         * 
     584         * If the goal is to minimize, set the search operation to 
     585         * return values less than the target. 
     586         */ 
     587        if(strcmp(uList[i].goal.c_str(), "max") == 0) { 
     588            searchOps[i] = GT; 
     589        } else if(strcmp(uList[i].goal.c_str(), "min") == 0) { 
     590            searchOps[i] = LT; 
     591        } 
     592    } 
     593 
     594    /* CBR specific call */ 
     595    uint32_t rc = cbr_search(myCBR, searchNames, searchOps, searchVals, 
     596            radioInfo->numUtilities, returnValues); 
     597 
     598    if(rc == 0){ 
    597599        /* Adapt the returned parameters to meet the objective */ 
    598              
    599600        WARNING("Cognitive Engine:: Found\n"); 
    600601 
    601                 // Should do a random adaptation..  
    602                 if(returnValues[numberColumns-1] < 0) { 
    603                         returnValues[2] = returnValues[2] - 15; 
    604                         returnValues[3] = returnValues[3] - 2; 
     602        /* Should do a random adaptation.. */ 
     603        if(returnValues[numberColumns-1] < 0) { 
     604            returnValues[2] = returnValues[2] - 15; 
     605            returnValues[3] = returnValues[3] - 2; 
    605606        } else { 
    606                         returnValues[2] = returnValues[2] + 15; 
    607                         returnValues[3] = returnValues[3] + 2; 
    608                 } 
    609     } else if(rc == 31337){ 
     607            returnValues[2] = returnValues[2] + 15; 
     608            returnValues[3] = returnValues[3] + 2; 
     609        } 
     610    } else if(rc == 31337) { 
    610611        WARNING("Cognitive Engine:: Not Found.\n"); 
    611                 /* No rows in the CBR, pick default parameters */ 
    612                 // Currently this is hard coded and implementation specific! 
    613             returnValues[2] = currentParameters[0].value + 5; 
    614             returnValues[3] = currentParameters[1].value + 10; 
     612        /* No rows in the CBR, pick default parameters */ 
     613        /* Currently this is hard coded and implementation specific! */ 
     614        returnValues[2] = currentParameters[0].value + 5; 
     615        returnValues[3] = currentParameters[1].value + 10; 
    615616         
    616         } else { 
     617    } else { 
    617618        WARNING("Cognitive Engine:: Search return an invalid value.\n"); 
    618         } 
    619  
    620         size_t returnValueIndex = 0; 
     619    } 
     620 
     621    size_t returnValueIndex = 0; 
    621622    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    622                 uList[i].value = returnValues[returnValueIndex]; 
    623                 returnValueIndex++; 
    624         } 
     623        uList[i].value = returnValues[returnValueIndex]; 
     624        returnValueIndex++; 
     625    } 
    625626    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    626                 pList[i].value = returnValues[returnValueIndex]; 
    627                 returnValueIndex++; 
    628         } 
     627        pList[i].value = returnValues[returnValueIndex]; 
     628        returnValueIndex++; 
     629    } 
    629630    for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    630                 oList[i].value = returnValues[returnValueIndex]; 
    631                 returnValueIndex++; 
    632         } 
     631        oList[i].value = returnValues[returnValueIndex]; 
     632        returnValueIndex++; 
     633    } 
    633634    returnValues[returnValueIndex] = 0; 
    634635 
    635636    char *allNames[numberColumns]; 
    636         size_t allNameIndex = 0; 
     637    size_t allNameIndex = 0; 
    637638    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    638639        allNames[allNameIndex] = (char*)uList[i].name.c_str(); 
    639                 returnValues[allNameIndex] = uList[i].target; 
    640                 allNameIndex++; 
    641         } 
     640        returnValues[allNameIndex] = uList[i].target; 
     641        allNameIndex++; 
     642    } 
    642643    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    643644        allNames[allNameIndex] = (char*)pList[i].name.c_str(); 
    644                 allNameIndex++; 
    645         } 
     645        allNameIndex++; 
     646    } 
    646647    for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    647648        allNames[allNameIndex] = (char*)oList[i].name.c_str(); 
    648                 returnValues[allNameIndex] = 0; 
    649                 allNameIndex++; 
    650         } 
     649        returnValues[allNameIndex] = 0; 
     650        allNameIndex++; 
     651    } 
    651652    allNames[allNameIndex] = "utility"; 
    652653 
    653         // Add row to CBR.  
    654         cbr_add_row(myCBR, allNames, returnValues, returnValueIndex+1); 
    655  
    656         return pList; 
    657  
     654    // Add row to CBR.  
     655    cbr_add_row(myCBR, allNames, returnValues, returnValueIndex+1); 
     656 
     657    return pList; 
    658658} 
    659659 
    660660 
    661661Parameter*  
    662 CognitiveEngine::GetSolution(Observable *observables, Parameter *currentParameters, std::string service) 
    663 { 
    664     LOG("Cognitive Engine:: Generating solution for %s service.\n",service.c_str()); 
     662CognitiveEngine::GetSolution(Observable *observables, \ 
     663        Parameter *currentParameters, std::string service) 
     664{ 
     665    LOG("Cognitive Engine:: Generating solution for %s service.\n", service.c_str()); 
    665666 
    666667    return pList; 
     
    679680CognitiveEngine::BuildCognitiveEngine() 
    680681{ 
    681         char filename[] = {"ex1"}; 
    682         char tablename[] = {"data"}; 
     682    char filename[] = {"ex1"}; 
     683    char tablename[] = {"data"}; 
    683684 
    684685    uint32_t numberColumns =  
    685                 radioInfo->numUtilities + 
    686                 radioInfo->numParameters + 
    687                 radioInfo->numObservables + 1; 
     686        radioInfo->numUtilities + 
     687        radioInfo->numParameters + 
     688        radioInfo->numObservables + 1; 
    688689 
    689690    char *cols[numberColumns]; 
     
    691692    size_t columnIndex = 0; 
    692693    for (size_t i = 0; i < radioInfo->numUtilities; i++){ 
    693                 cols[columnIndex] = (char*)uList[i].name.c_str(); 
     694        cols[columnIndex] = (char*)uList[i].name.c_str(); 
    694695        columnIndex++; 
    695696    }    
    696697    for (size_t i = 0; i < radioInfo->numParameters; i++){ 
    697                 cols[columnIndex] = (char*)pList[i].name.c_str(); 
     698        cols[columnIndex] = (char*)pList[i].name.c_str(); 
    698699        columnIndex++; 
    699700    }    
    700701    for (size_t i = 0; i < radioInfo->numObservables; i++){ 
    701                 cols[columnIndex] = (char*)oList[i].name.c_str(); 
     702        cols[columnIndex] = (char*)oList[i].name.c_str(); 
    702703        columnIndex++; 
    703704    }    
  • vtcross/trunk/src/include/vtcross/components.h

    r230 r231  
    293293        int32_t commandSocketFD; 
    294294         
    295         Utility * uList; 
    296         Parameter * pList; 
    297         Observable * oList; 
    298         struct Radio_Info * radioInfo; 
     295        // TODO Need a description for these fields.  Are these radio utilites, 
     296        // parameters, and observables global to the whole system? 
     297        Utility *uList; 
     298        Parameter *pList; 
     299        Observable *oList; 
     300        struct Radio_Info *radioInfo; 
    299301}; 
    300302 
  • vtcross/trunk/src/include/vtcross/socketcomm.h

    r216 r231  
    1818/* TODO 
    1919 */ 
    20 void ReadMessage(int32_t socketFD, char* msgBuffer); 
     20void ReadMessage(int32_t socketFD, char *msgBuffer); 
    2121 
    2222/* TODO 
    2323 */ 
    24 //int32_t SendMessage(int32_t socketFD, char* message); 
    25 int32_t SendMessage(int32_t socketFD, const char* message) ; 
     24int32_t SendMessage(int32_t socketFD, const char *message) ; 
    2625 
    2726/* TODO 
     
    3837 * to do. 
    3938 */ 
    40 int32_t ClientSocket(const char* serverName, const char* portNumber); 
     39int32_t ClientSocket(const char  *serverName, const char *portNumber); 
    4140 
    4241/* TODO 
  • vtcross/trunk/src/libvtcross/libvtcross.cpp

    r230 r231  
    2121ConnectToRemoteComponent() 
    2222{ 
    23         uint32_t socket;  
    24     socket = ClientSocket("localhost", "40000"); 
    25      
    26     return socket; 
     23    // TODO why is this hardcoded like this?? 
     24        return ClientSocket("localhost", "40000"); 
    2725} 
    2826 
     27// TODO the following three functions all do exactly the same thing.  Why not 
     28// simply combine them? 
    2929uint32_t 
    3030GetNumObservables() 
    3131{ 
    32         uint32_t socketfd, numObservables; 
    3332    char buffer[256]; 
    3433 
    35     socketfd = ConnectToRemoteComponent(); 
    36     SendMessage(socketfd,"get_number_observables"); 
     34    uint32_t socketfd = ConnectToRemoteComponent(); 
     35    SendMessage(socketfd, "get_number_observables"); 
    3736     
    3837    memset(buffer, 0, 256); 
    3938    ReadMessage(socketfd, buffer); 
    40     numObservables = atoi(buffer); 
     39    uint32_t numObservables = atoi(buffer); 
    4140         
    4241        return numObservables;  
     
    4645GetNumUtilities() 
    4746{ 
    48         uint32_t socketfd, numUtilities; 
    4947    char buffer[256]; 
    5048 
    51     socketfd = ConnectToRemoteComponent(); 
    52     SendMessage(socketfd,"get_number_utilities"); 
     49    uint32_t socketfd = ConnectToRemoteComponent(); 
     50    SendMessage(socketfd, "get_number_utilities"); 
    5351     
    5452    memset(buffer, 0, 256); 
    5553    ReadMessage(socketfd, buffer); 
    56     numUtilities = atoi(buffer); 
     54    uint32_t numUtilities = atoi(buffer); 
    5755         
    5856        return numUtilities;  
     
    6260GetNumParameters() 
    6361{ 
    64         uint32_t socketfd, numParameters; 
    6562    char buffer[256]; 
    6663 
    67     socketfd = ConnectToRemoteComponent(); 
    68     SendMessage(socketfd,"get_number_parameters"); 
     64    uint32_t socketfd = ConnectToRemoteComponent(); 
     65    SendMessage(socketfd, "get_number_parameters"); 
    6966     
    7067    memset(buffer, 0, 256); 
    7168    ReadMessage(socketfd, buffer); 
    72     numParameters = atoi(buffer); 
     69    uint32_t numParameters = atoi(buffer); 
    7370         
    7471        return numParameters;  
    7572} 
     73// end previous TODO 
    7674 
    7775/* Given a certain set of observables, ask the radio to find the optimum radio 
     
    8583 * memory when it is done using it. 
    8684 */ 
    87 Parameter* GetOptimalParameters(Observable *radioObservables, uint32_t numObservables, 
    88                 Parameter *currentParameters, uint32_t numCurrentParameters) { 
    89     uint32_t i,socketfd,numParameters; 
     85Parameter*  
     86GetOptimalParameters(Observable *radioObservables, uint32_t numObservables, 
     87                Parameter *currentParameters, uint32_t numCurrentParameters) 
     88{ 
    9089    char var[50]; 
    9190    char counter[55]; 
     
    9998     */ 
    10099 
    101     // Send Observables 
     100    /* Send Observables */ 
    102101    sprintf(counter, "%i", numObservables); 
    103102    SendMessage(socketFD, counter); 
     
    108107    } 
    109108 
    110     // Send Parameters  
     109    /* Send Parameters */ 
    111110    memset(counter, 0, 55); 
    112111    sprintf(counter, "%i", numCurrentParameters); 
    113112    SendMessage(socketFD, counter); 
    114          
    115         for(i = 0; i < numCurrentParameters; i++) { 
     113        for(size_t i = 0; i < numCurrentParameters; i++) { 
    116114        SendMessage(socketFD,currentParameters[i].name.c_str()); 
    117115        sprintf(var,"%f",currentParameters[i].value); 
     
    122120    memset(buffer, 0, 256); 
    123121    ReadMessage(socketFD, buffer); 
    124     numParameters = atoi(buffer); 
     122    uint32_t numParameters = atoi(buffer); 
    125123    Parameter *pList = new Parameter[numParameters]; 
    126124     
     
    154152         
    155153        for(size_t i = 0; i < numParameters; i++) { 
    156         SendMessage(socketFD,p[i].name.c_str()); 
    157         sprintf(var,"%f",p[i].value); 
    158         SendMessage(socketFD,var);       
     154        SendMessage(socketFD, p[i].name.c_str()); 
     155        sprintf(var, "%f", p[i].value); 
     156        SendMessage(socketFD, var);      
    159157    } 
    160158     
  • vtcross/trunk/src/libvtcross/libvtcross_demo.cpp

    r230 r231  
    2323main(int32_t argc, char *argv[]) 
    2424{ 
     25        for(size_t i = 0; i < 10; i++) { 
     26        Observable *o = new Observable[2]; 
     27        Parameter *currentParameters = new Parameter[2]; 
     28        Parameter *p; 
    2529 
    26         for(size_t i = 0; i < 10; i++) { 
    27     Observable *o = new Observable[2]; 
    28     Parameter *currentParameters = new Parameter[2]; 
    29     Parameter * p; 
     30        uint32_t numParameters; 
     31        uint32_t numObservables; 
     32        uint32_t numUtilities; 
    3033 
    31         uint32_t numParameters; 
    32         uint32_t numObservables; 
    33         uint32_t numUtilities; 
     34        o[0].name = "throughput"; 
     35        o[0].value = 150.00; 
     36        o[1].name = "PER"; 
     37        o[1].value = 12.00; 
    3438 
    35     o[0].name = "throughput"; 
    36         o[0].value = 150.00; 
    37     o[1].name = "PER"; 
    38         o[1].value = 12.00; 
     39        if(i == 0) { 
     40            currentParameters[0].name = "bandwidth"; 
     41            currentParameters[0].value = 300.0; 
     42            currentParameters[1].name = "tx_power"; 
     43            currentParameters[1].value = 10.0; 
     44        } else { 
     45            currentParameters[0].value = p[0].value; 
     46            currentParameters[1].value = p[1].value; 
     47        } 
    3948 
    40         if(i == 0) { 
    41     currentParameters[0].name = "bandwidth"; 
    42     currentParameters[0].value = 300.0; 
    43     currentParameters[1].name = "tx_power"; 
    44     currentParameters[1].value = 10.0; 
     49        p = GetOptimalParameters(o,2,currentParameters,2); 
     50        numParameters = GetNumParameters(); 
     51        numObservables = GetNumObservables(); 
     52        numUtilities = GetNumUtilities(); 
    4553 
    46         } else { 
    47     currentParameters[0].value = p[0].value; 
    48     currentParameters[1].value = p[1].value; 
    49         } 
    50     p = GetOptimalParameters(o,2,currentParameters,2); 
    51     numParameters = GetNumParameters(); 
    52     numObservables = GetNumObservables(); 
    53     numUtilities = GetNumUtilities(); 
     54        LOG("Application:: Received the following parameters.\n"); 
     55         
     56        for(size_t i = 0; i < numParameters; i++) { 
     57            LOG("%s:: %f\n", p[i].name.c_str(), p[i].value); 
     58        } 
    5459 
    55         printf("Application:: Received the following parameters.\n"); 
    56          
    57         for(size_t i = 0; i < numParameters; i++) { 
    58                 printf("%s:: %f\n",p[i].name.c_str(),p[i].value); 
     60        /* Try them out! Do they work? */ 
     61        o[0].value = 0.5*p[0].value + .1*p[1].value; 
     62        o[1].value = 15-p[1].value; 
     63 
     64        UpdateParameterPerformance(p, numParameters, o, numObservables);         
     65         
     66        delete [] p;  
     67        delete [] o;  
    5968        } 
    6069 
    61         // Try them out! Do they work? 
    62      
    63     o[0].value = 0.5*p[0].value + .1*p[1].value; 
    64     o[1].value = 15-p[1].value; 
    65  
    66         UpdateParameterPerformance(p,numParameters,o,numObservables);    
    67          
    68          
    69         delete [] p;  
    70     delete [] o;  
    71         } 
    7270        return 0; 
    7371} 
  • vtcross/trunk/src/shell/CognitiveRadioShell.cpp

    r230 r231  
    111111 
    112112 
     113// TODO what is the point of always returning a 1? 
    113114bool 
    114 CognitiveRadioShell::SendRadioConfiguration(int32_t socketfd) 
     115CognitiveRadioShell::SendRadioConfiguration(int32_t socketFD) 
    115116{ 
    116117    LOG("Cognitive Radio Shell:: Sending radio configuration to Cognitive Engine.\n"); 
    117     uint32_t i,j; 
     118 
    118119    char counter[55]; 
    119120    char var[50]; 
    120121 
    121     // utilities 
    122     // Send number of utilities 
    123     sprintf(counter,"%d",radio_info->numUtilities); 
    124     SendMessage(socketfd,counter); 
    125     // send utility      
    126     for(i = 0; i < radio_info->numUtilities; i++) { 
    127         SendMessage(socketfd, utils[i].name.c_str()); 
    128         SendMessage(socketfd, utils[i].units.c_str()); 
    129         SendMessage(socketfd, utils[i].goal.c_str()); 
     122    /* Send utilities */ 
     123    sprintf(counter, "%d", radio_info->numUtilities); 
     124    SendMessage(socketFD, counter); 
     125    for(size_t i = 0; i < radio_info->numUtilities; i++) { 
     126        SendMessage(socketFD, utils[i].name.c_str()); 
     127        SendMessage(socketFD, utils[i].units.c_str()); 
     128        SendMessage(socketFD, utils[i].goal.c_str()); 
    130129        sprintf(var,"%f", utils[i].target); 
    131         SendMessage(socketfd, var); 
    132     } 
    133  
    134     // parameters 
     130        SendMessage(socketFD, var); 
     131    } 
     132 
     133    /* Send parameters */ 
    135134    sprintf(counter,"%i",radio_info->numParameters); 
    136     SendMessage(socketfd,counter); 
    137     for(i = 0; i < radio_info->numParameters; i++) { 
    138         SendMessage(socketfd, params[i].name.c_str()); 
    139         SendMessage(socketfd, params[i].units.c_str()); 
     135    SendMessage(socketFD,counter); 
     136    for(size_t i = 0; i < radio_info->numParameters; i++) { 
     137        SendMessage(socketFD, params[i].name.c_str()); 
     138        SendMessage(socketFD, params[i].units.c_str()); 
    140139        sprintf(var, "%f", params[i].min); 
    141         SendMessage(socketfd,var); 
     140        SendMessage(socketFD,var); 
    142141        sprintf(var, "%f", params[i].max); 
    143         SendMessage(socketfd, var); 
     142        SendMessage(socketFD, var); 
    144143        sprintf(var, "%f", params[i].step); 
    145         SendMessage(socketfd, var); 
     144        SendMessage(socketFD, var); 
    146145 
    147146        sprintf(counter, "%i", params[i].numAffects);  
    148         SendMessage(socketfd, counter); 
    149         for(j = 0; j < params[i].numAffects; j++) { 
    150             SendMessage(socketfd, params[i].affection_list[j].u->name.c_str()); 
    151             SendMessage(socketfd, params[i].affection_list[j].relation.c_str()); 
     147        SendMessage(socketFD, counter); 
     148        for(size_t j = 0; j < params[i].numAffects; j++) { 
     149            SendMessage(socketFD, params[i].affection_list[j].u->name.c_str()); 
     150            SendMessage(socketFD, params[i].affection_list[j].relation.c_str()); 
    152151        } 
    153152    } 
    154153 
    155     // observables 
     154    /* Send observables */ 
    156155    sprintf(counter,"%i",radio_info->numObservables); 
    157     SendMessage(socketfd, counter); 
    158     for(i = 0; i < radio_info->numObservables; i++) { 
    159         SendMessage(socketfd, observables[i].name.c_str()); 
     156    SendMessage(socketFD, counter); 
     157    for(size_t i = 0; i < radio_info->numObservables; i++) { 
     158        SendMessage(socketFD, observables[i].name.c_str()); 
    160159                 
    161160        sprintf(counter, "%i", observables[i].numAffects);  
    162         SendMessage(socketfd, counter); 
    163         for(j = 0; j < observables[i].numAffects; j++) { 
    164             SendMessage(socketfd, observables[i].affection_list[j].u->name.c_str()); 
    165             SendMessage(socketfd, observables[i].affection_list[j].relation.c_str()); 
     161        SendMessage(socketFD, counter); 
     162        for(size_t j = 0; j < observables[i].numAffects; j++) { 
     163            SendMessage(socketFD, observables[i].affection_list[j].u->name.c_str()); 
     164            SendMessage(socketFD, observables[i].affection_list[j].relation.c_str()); 
    166165        } 
    167166    } 
    168167         
    169     // Receive ACK for utils 
     168    /* Receive ACK for radio configuration */ 
    170169    char buffer[256]; 
    171170    memset(buffer, 0, 256);  
    172     ReadMessage(socketfd, buffer); 
     171    ReadMessage(socketFD, buffer); 
    173172 
    174173    if(strcmp(buffer, "receive_config_ack") != 0) { 
     
    178177 
    179178    return 1; 
    180  
    181179} 
    182180 
     
    189187        char numberExpString[50]; 
    190188 
    191     sprintf(numberExpString,"%i",numberExp); 
     189    sprintf(numberExpString, "%i", numberExp); 
    192190    SendMessage(socketFD, numberExpString);  
    193191 
     
    196194    ReadMessage(socketFD, buffer); 
    197195    if(strcmp(buffer, "receive_exp_ack") != 0) { 
    198         LOG("Cognitive Radio Shell:: Unexpected response: %s\n",buffer); 
     196        // TODO perhaps this should be a WARNING instead of a LOG? 
     197        LOG("Cognitive Radio Shell:: Unexpected response: %s\n", buffer); 
    199198        return 0; 
    200199    } 
     200 
    201201    return 1; 
    202202} 
     
    446446 
    447447    return 1; 
    448  
    449448} 
    450449 
     
    454453{ 
    455454    char buffer[256]; 
    456     uint32_t numObservables,numParameters,numCurrentParameters; 
    457455    char counter[55]; 
    458456    char var[50]; 
     
    462460    memset(buffer, 0, 256); 
    463461    ReadMessage(commandSocketFD, buffer); 
    464     numObservables = atoi(buffer); 
     462    uint32_t numObservables = atoi(buffer); 
    465463   
    466464        LOG("Cognitive Radio Shell:: Attempting to get %i observables.\n", numObservables); 
     
    476474        o[i].value = atof(buffer); 
    477475    } 
     476 
    478477        /* Receive Set of Current Parameters */ 
    479478    memset(buffer, 0, 256); 
    480479    ReadMessage(commandSocketFD,buffer); 
    481     numCurrentParameters = atoi(buffer); 
     480    uint32_t numCurrentParameters = atoi(buffer); 
    482481   
    483482        LOG("Cognitive Radio Shell:: Attempting to get %i parameters.\n",numCurrentParameters); 
     
    492491        cp[i].value = atof(buffer); 
    493492    } 
     493 
    494494    /* Send to Cognitive Engine  
    495495         * TODO: With multiple CEs we need to make a decision about where 
    496496         * to send this information 
    497497         */ 
    498  
    499498        if(!SML_present) {  
    500499            LOG("Cognitive Radio Shell:: Passing on observables to Cognitive Engine\n"); 
     
    522521    memset(buffer, 0, 256); 
    523522    ReadMessage(ceSocketFD, buffer); 
    524     numParameters = atoi(buffer); 
     523    uint32_t numParameters = atoi(buffer); 
    525524    
    526525    Parameter *p = new Parameter[numParameters]; 
     
    552551} 
    553552 
     553// TODO point of always returning 1? 
    554554bool 
    555555CognitiveRadioShell::UpdateParameterPerformance(int32_t socketFD) 
    556556{ 
    557557    char counter[55]; 
    558     uint32_t numObservables,numParameters; 
    559558    char var[50]; 
    560559    char buffer[256]; 
     
    563562    memset(buffer, 0, 256); 
    564563    ReadMessage(commandSocketFD,buffer); 
    565     numParameters = atoi(buffer); 
     564    uint32_t numParameters = atoi(buffer); 
    566565   
    567566    Parameter *p = new Parameter[numParameters]; 
     
    579578    memset(buffer, 0, 256); 
    580579    ReadMessage(commandSocketFD, buffer); 
    581     numObservables = atoi(buffer); 
     580    uint32_t numObservables = atoi(buffer); 
    582581   
    583582    Observable *o = new Observable[numObservables]; 
     
    593592    } 
    594593 
    595  
    596594    SendMessage(ceSocketFD, "update_performance"); 
    597595    
    598     // Send Parameters  
     596    /* Send Parameters */ 
    599597    memset(counter, 0, 55); 
    600598    sprintf(counter, "%i", numParameters); 
     
    607605    }    
    608606     
    609     // Send Observables 
     607    /* Send Observables */ 
    610608    sprintf(counter, "%i", numObservables); 
    611609    SendMessage(ceSocketFD, counter); 
     
    615613        SendMessage(ceSocketFD, var);  
    616614    }    
     615 
     616    delete [] p; 
     617    delet [] o; 
    617618     
    618619    return 1; 
    619620} 
     621 
     622 
    620623void 
    621624CognitiveRadioShell::HandleMessage(int32_t socketFD) 
     
    625628    ReadMessage(socketFD, buffer); 
    626629 
     630    // TODO trying to read this code lock makes my eyes bleed 
    627631    if(strcmp(buffer, "register_engine_cognitive") == 0) {  
    628632        RegisterCognitiveEngine(socketFD); 
     
    639643    } else if(strcmp(buffer, "update_performance") == 0) { 
    640644        UpdateParameterPerformance(socketFD); 
    641     } else if(strcmp(buffer,"get_number_utilities") == 0) { 
     645    } else if(strcmp(buffer, "get_number_utilities") == 0) { 
    642646                char numUtilities[20]; 
    643                 sprintf(numUtilities,"%i",radio_info->numUtilities); 
    644         SendMessage(commandSocketFD,numUtilities); 
    645     } else if(strcmp(buffer,"get_number_observables") == 0) { 
     647                sprintf(numUtilities, "%i", radio_info->numUtilities); 
     648        SendMessage(commandSocketFD, numUtilities); 
     649    } else if(strcmp(buffer, "get_number_observables") == 0) { 
    646650                char numObservables[20]; 
    647                 sprintf(numObservables,"%i",radio_info->numObservables); 
    648         SendMessage(commandSocketFD,numObservables); 
    649     } else if(strcmp(buffer,"get_number_parameters") == 0) { 
     651                sprintf(numObservables, "%i", radio_info->numObservables); 
     652        SendMessage(commandSocketFD, numObservables); 
     653    } else if(strcmp(buffer, "get_number_parameters") == 0) { 
    650654                char numParameters[20]; 
    651                 sprintf(numParameters,"%i",radio_info->numParameters); 
    652         SendMessage(commandSocketFD,numParameters); 
    653     } else if(strcmp(buffer,"request_optimization") == 0) { 
     655                sprintf(numParameters, "%i", radio_info->numParameters); 
     656        SendMessage(commandSocketFD, numParameters); 
     657    } else if(strcmp(buffer, "request_optimization") == 0) { 
    654658        /* Receive optimization request and current environment */ 
    655659        GetOptimalParameters(socketFD);   
    656     } else if(strcmp(buffer,"request_optimization_service") == 0) { 
     660    } else if(strcmp(buffer, "request_optimization_service") == 0) { 
    657661        /* Receive optimization request and current environment */ 
    658662        //GetOptimalParametersService(socketFD);