Changeset 533

Show
Ignore:
Timestamp:
01/04/10 15:14:18 (14 years ago)
Author:
bhilburn
Message:

Converted the DSA_CE to use the new class tree.

Location:
vtcross/trunk/src/cognitive_engines
Files:
4 modified

Legend:

Unmodified
Added
Removed

  • vtcross/trunk/src/cognitive_engines/DSA_CE/DSA_CognitiveEngine.cpp

    r529 r533  
    4444#define UTILITY 4 
    4545 
    46  
    47 static CBR *myCBR; 
    48  
    49  
    50 CognitiveEngine::CognitiveEngine() 
     46class DSA_CE : public CognitiveEngine 
     47{ 
     48    public: 
     49        /*! Default constructor. */ 
     50        DSA_CE(); 
     51 
     52        /*! Default destructor. */ 
     53        ~DSA_CE(); 
     54 
     55        /*! \brief Preferred constructor. 
     56         * 
     57         * Overloaded constructor that creates a cognitive engine object and 
     58         * connects it to either the shell or an SML, depening on the SML bool. 
     59         * 
     60         * The 'numFields' parameter sets how large the parameter, observable, 
     61         * and utility arrays should be upon instantiation. 
     62         */ 
     63        DSA_CE(const char* serverName, const char* serverPort, \ 
     64                const int32_t numFields, const bool SML); 
     65 
     66        void RegisterServices(); 
     67        void DeregisterServices(); 
     68 
     69        /*! \brief Request that the CE optimize a set of parameters.  
     70         * 
     71         * Find the most optimal set of transmission parameters given certain 
     72         * observables and possibly a service if the SML component is present 
     73         * and active. */ 
     74        Parameter *GetSolution(Observable *observables, \ 
     75                Parameter *currentParameters); 
     76        Parameter *GetSolution(Observable *observables, \ 
     77                Parameter *currentParameters, std::string service); 
     78 
     79        /*! \brief Receive feedback from the radio  
     80         * 
     81         * Receive a feedback from the radio regarding the performance of a 
     82         * certain set of parameters, possibly associated with a service. 
     83         * 
     84         * Feedback is a single set of performance statistics that is achieved 
     85         * corresponding to a specific set of transmission parameters.  Feedback 
     86         * helps a Cognitive Engine make better future decisions based upon  
     87         * more accurate performance statistics.  
     88         */ 
     89        void ReceiveFeedback(Observable *observables,Parameter *parameters); 
     90        void ReceiveFeedback(Observable *observables, Parameter *parameters, \ 
     91                std::string service); 
     92 
     93 
     94        /*! \brief Initialize the CE and prepare it for operation.  
     95         * 
     96         * BuildCognitiveEngine performs the CE implementation specific work 
     97         * that defines the internals of a CE.  For example, a CBR CE engine 
     98         * would build the case-base reasoner or create the database, a neural 
     99         * network based CE may perform the initial training, a GA based CE 
     100         * may build the chromosome structure. 
     101         */ 
     102        void BuildCognitiveEngine(); 
     103 
     104        /*! \brief Each of these functions responds to a specific command. 
     105         * 
     106         * These functions are left principally un-implemented. It is the duty 
     107         * of child classes to implement these functions, as they define the 
     108         * cognitive engine's functionality. 
     109         */ 
     110        void PerformUpdatePerformance(); 
     111        void PerformRequestOptimizationService(); 
     112        void PerformRequestOptimization(); 
     113        void PerformQueryComponentType(); 
     114        void PerformConnectSML(); 
     115        void PerformDisconnectSML(); 
     116        void PerformResetEngineCognitive(); 
     117        void PerformShutdownEngineCognitive(); 
     118 
     119        CBR *myCBR; 
     120}; 
     121 
     122DSA_CE::DSA_CE() 
    51123{ 
    52124    LOG("Creating Cognitive Engine.\n"); 
    … …  
    57129 
    58130 
    59 CognitiveEngine::~CognitiveEngine() 
     131DSA_CE::~DSA_CE() 
    60132{ 
    61133    delete myCBR; 
    … …  
    68140 
    69141 
    70 CognitiveEngine::CognitiveEngine(const char *serverName, const char *serverPort, \ 
    71         const bool SML) 
     142DSA_CE::DSA_CE(const char* serverName, const char* serverPort, \ 
     143                const int32_t numFields, const bool SML) \ 
     144        : CognitiveEngine(serverName, serverPort, numFields, SML) 
    72145{ 
    73146    LOG("Creating Cognitive Engine.\n"); 
    74  
    75     pList = new Parameter[10]; 
    76     oList = new Observable[10]; 
    77     uList = new Utility[10]; 
    78     radioInfo = new Radio_Info; 
    79  
    80     ConnectToRemoteComponent(serverName, serverPort, SML); 
    81 } 
    82  
    83  
    84 void 
    85 CognitiveEngine::SendComponentType() 
    86 { 
    87     SendMessage(commandSocketFD, "response_engine_cognitive"); 
    88     LOG("Cognitive Engine responded to GetRemoteComponentType query.\n"); 
    89 } 
    90  
    91  
    92 void 
    93 CognitiveEngine::ConnectToRemoteComponent(const char *serverName, \ 
    94         const char *serverPort, const bool SML) 
    95 { 
    96     commandSocketFD = ClientSocket(serverName, serverPort); 
    97  
    98     SML_present = SML; 
    99  
    100     if(SML) { 
     147    srand ( time(NULL) ); 
     148} 
     149 
     150 
     151void  
     152DSA_CE::RegisterServices() 
     153{ 
     154    LOG("Cognitive Engine:: Registering services.\n"); 
     155 
     156    SendMessage(commandSocketFD, "register_service"); 
     157    SendMessage(commandSocketFD, "test_srv"); 
     158 
     159    SendMessage(commandSocketFD, "register_service"); 
     160    SendMessage(commandSocketFD, "test_srv1"); 
     161 
     162    SendMessage(commandSocketFD, "register_service"); 
     163    SendMessage(commandSocketFD, "test_srv2"); 
     164 
     165    SendMessage(commandSocketFD, "register_service"); 
     166    SendMessage(commandSocketFD, "test_srv3"); 
     167 
     168} 
     169 
     170//Combined with deregister component since those two things must happen togeather 
     171void  
     172DSA_CE::DeregisterServices() 
     173{ 
     174    LOG("Cognitive Engine:: Deregistering services.\n"); 
     175 
     176    SendMessage(commandSocketFD, "deregister_service"); 
     177    SendMessage(commandSocketFD, "test_srv"); 
     178 
     179    SendMessage(commandSocketFD, "deregister_service"); 
     180    SendMessage(commandSocketFD, "test_srv1"); 
     181 
     182    SendMessage(commandSocketFD, "deregister_service"); 
     183    SendMessage(commandSocketFD, "test_srv2"); 
     184 
     185    SendMessage(commandSocketFD, "deregister_service"); 
     186    SendMessage(commandSocketFD, "test_srv3"); 
     187 
     188} 
     189 
     190/* The core of the CE is this function */ 
     191Parameter*  
     192DSA_CE::GetSolution(Observable *observables, Parameter *currentParameters) 
     193{ 
     194    LOG("Cognitive Engine:: Generating solution.\n"); 
     195 
     196    /* Put together the CBR search array */ 
     197 
     198    uint32_t channel = 0; 
     199    string searchNames[1]; 
     200    string sumSearchName; 
     201    float searchVals[1]; 
     202    float utilArray[(int)pList[0].max]; 
     203    int searchOps[1]; 
     204    uint32_t numberColumns = radioInfo->numUtilities + radioInfo->numParameters + \ 
     205                             radioInfo->numObservables + 1; 
     206 
     207    float returnValues[numberColumns]; 
     208    float sumRetVals[numberColumns]; 
     209    
     210    // Total sum of utilities in sumRetVals[0] 
     211 
     212    string channel_name = "channel"; 
     213    string utility_name = "utility"; 
     214 
     215    for(int32_t i = 0 ; i < pList[0].max ; i++ ) { 
     216        searchNames[0] = pList[0].name; 
     217        searchOps[0] = 0; 
     218        searchVals[0] = i+1;  
     219     
     220        uint32_t rc = myCBR->Search(searchNames, searchOps, searchVals, 
     221            1, returnValues); 
     222 
     223    if(rc == 31337) { 
     224        // No entry - must add 
    101225         
    102         RegisterComponent(); 
    103         LOG("Cognitive Engine connected to SML at %s.\n", serverName); 
    104         ReceiveRadioConfiguration(); 
    105         ReceiveExperience(); 
     226            string rowNames[numberColumns]; 
     227            size_t rowIndex = 0; 
     228            for(size_t j = 0; j < radioInfo->numUtilities; j++) { 
     229                rowNames[rowIndex] = uList[j].name; 
     230                rowIndex++; 
     231            } 
     232            for(size_t j = 0; j < radioInfo->numParameters; j++) { 
     233                rowNames[rowIndex] = pList[j].name; 
     234            if(pList[j].name == "channel") 
     235                returnValues[rowIndex] = i+1; 
     236                rowIndex++; 
     237            } 
     238            for(size_t j = 0; j < radioInfo->numObservables; j++) { 
     239                rowNames[rowIndex] = oList[j].name; 
     240                rowIndex++; 
     241            } 
     242    
     243            rowNames[rowIndex] = utility_name; 
     244        returnValues[rowIndex] = 500; 
     245 
     246                /* Add the new optimized set to the CBR database */ 
     247 
     248            myCBR->AddRow(rowNames, returnValues, numberColumns); 
     249    } 
     250 
     251    utilArray[i] = returnValues[UTILITY];  
     252    } 
     253 
     254    printf("Current Channel Utility Scores\n"); 
     255    printf("1: %f\t7: %f\t8: %f\t14: %f\n",utilArray[0],utilArray[1],utilArray[2],utilArray[3]);     
     256    // Get sum of all the channel utilities. 
     257    sumSearchName = utility_name; 
     258    uint32_t rc = myCBR->SearchSum(sumSearchName, sumRetVals); 
     259 
     260    // Psuedo random channel selection based upon utility. 
     261    int k = rand() % (int)sumRetVals[0]; 
     262    int cdf_total(0); 
     263 
     264    for ( int i = 0; i < pList[0].max; i++ ) { 
     265        cdf_total += utilArray[i]; 
     266        if(k < cdf_total) { 
     267        channel = i + 1; 
     268        break; 
     269    } 
     270    } 
    106271         
    107         RegisterServices(); 
    108     } 
    109     else { 
    110         RegisterComponent(); 
    111         LOG("Cognitive Engine connected to shell at %s.\n", serverName); 
    112         ReceiveRadioConfiguration(); 
    113         ReceiveExperience(); 
    114     } 
    115 } 
     272    searchNames[0] = pList[0].name; 
     273    searchOps[0] = 0; 
     274    searchVals[0] = channel;  
     275   
     276    rc = myCBR->Search(searchNames, searchOps, searchVals, 
     277        1, returnValues); 
     278 
     279 
     280    //returnValues[CHANNEL] = rand() % (int)pList[0].max + (int)pList[0].min;  
     281    returnValues[CHANNEL] = channel; 
     282 
     283    printf("Cognitive Engine:: ..---===***### Channel %i has been selected ###***===---..\n",channel);  
     284    /* Package up the new set of parameters in order to add 
     285       the new entry into the CBR database.  */ 
     286 
     287    size_t returnValueIndex = 0; 
     288    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
     289        uList[i].value = returnValues[returnValueIndex]; 
     290        returnValueIndex++; 
     291    } 
     292    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
     293        pList[i].value = returnValues[returnValueIndex]; 
     294        returnValueIndex++; 
     295    } 
     296    for(size_t i = 0; i < radioInfo->numObservables; i++) { 
     297        oList[i].value = returnValues[returnValueIndex]; 
     298        returnValueIndex++; 
     299    } 
     300    //returnValues[returnValueIndex] = 0; 
     301 
     302    string allNames[numberColumns]; 
     303    size_t allNameIndex = 0; 
     304    for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
     305        allNames[allNameIndex] = uList[i].name; 
     306        returnValues[allNameIndex] = uList[i].target; 
     307        allNameIndex++; 
     308    } 
     309    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
     310        allNames[allNameIndex] = pList[i].name; 
     311        allNameIndex++; 
     312    } 
     313    for(size_t i = 0; i < radioInfo->numObservables; i++) { 
     314        allNames[allNameIndex] = oList[i].name; 
     315    //    returnValues[allNameIndex] = 0; 
     316        allNameIndex++; 
     317    } 
     318    
     319    allNames[allNameIndex] = utility_name; 
     320 
     321    /* Add the new optimized set to the CBR database */ 
     322    //myCBR->AddRow(allNames, returnValues, returnValueIndex+1); 
     323 
     324 
     325    /* Return the set of new parameter values.  */ 
     326    return pList; 
     327} 
     328 
     329 
     330Parameter*  
     331DSA_CE::GetSolution(Observable *observables, \ 
     332        Parameter *currentParameters, std::string service) 
     333{ 
     334    LOG("Cognitive Engine:: Generating solution for %s service.\n", service.c_str()); 
     335 
     336    return pList; 
     337} 
     338 
    116339 
    117340void  
    118 CognitiveEngine::ReceiveFeedback(Observable *observables, Parameter *parameters) 
     341DSA_CE::ReceiveFeedback(Observable *observables, Parameter *parameters) 
    119342{  
    120343   LOG("Cognitive Engine:: Receiving feedback.\n"); 
    … …  
    125348    uint32_t obsColumns = radioInfo->numObservables + 1; 
    126349    uint32_t numberTotalColumns = radioInfo->numUtilities + 
    127                                 radioInfo->numParameters + 
    128                                 radioInfo->numObservables + 1; 
     350                    radioInfo->numParameters + 
     351                    radioInfo->numObservables + 1; 
    129352 
    130353    float valList[numberColumns]; 
    … …  
    189412 
    190413    if((observables[COMMUNICATION_TIME].value != 0) || (observables[ENERGY].value > Detection_Threshold)) {  
    191         printf("Cognitive Engine:: Possible PU Detection - Decrementing Utility. %f %f",observables[COMMUNICATION_TIME].value,observables[ENERGY].value); 
    192         newUtilityValue = newUtilityValue + punishment; 
     414    printf("Cognitive Engine:: Possible PU Detection - Decrementing Utility. %f %f",observables[COMMUNICATION_TIME].value,observables[ENERGY].value); 
     415    newUtilityValue = newUtilityValue + punishment; 
    193416    } else { 
    194         printf("Cognitive Engine:: Scan Mode:: No PU detected - Incrementing Utility."); 
    195         newUtilityValue = newUtilityValue + reward; 
     417    printf("Cognitive Engine:: Scan Mode:: No PU detected - Incrementing Utility."); 
     418    newUtilityValue = newUtilityValue + reward; 
    196419    } 
    197420 
    198421    if(newUtilityValue <= 100) 
    199         newUtilityValue = 100; 
     422    newUtilityValue = 100; 
    200423 
    201424    // Put limit on utility score to prevent a positive feedback loop  
    202425    if(newUtilityValue >= 800) 
    203         newUtilityValue = 800; 
     426    newUtilityValue = 800; 
    204427 
    205428    obsVals[obsValueIndex] = newUtilityValue; 
    … …  
    224447 
    225448void  
    226 CognitiveEngine::WaitForSignal() 
    227 { 
    228     char buffer[256]; 
    229  
    230     while(true) { 
    231         memset(buffer, 0, 256); 
    232         
    233         ReadMessage(commandSocketFD, buffer); 
    234  
    235         // TODO this is ugly... is there a better way? Doesn't strcmp compare the 
    236         // whole string?  We only need to compare until we find a single different 
    237         // byte... 
    238         // 
    239         // If we send integer op codes rather than strings, this process will be 
    240         // MUCH faster since instead of donig string compares we can simply 
    241         // switch on the integer value... 
    242         if(strcmp(buffer, "update_performance") == 0) { 
    243              
    244             /* Receive Set of current Parameters */ 
    245             memset(buffer, 0, 256); 
    246             ReadMessage(commandSocketFD, buffer); 
    247             uint32_t numParameters = atoi(buffer); 
    248     
    249             Parameter *p = new Parameter[numParameters]; 
    250   
    251             for(size_t i = 0; i < numParameters; i++) { 
    252                 memset(buffer, 0, 256); 
    253                 ReadMessage(commandSocketFD, buffer); 
    254                 p[i].name = std::string(buffer); 
    255      
    256                 memset(buffer, 0, 256); 
    257                 ReadMessage(commandSocketFD, buffer); 
    258                 p[i].value = atof(buffer); 
    259             }  
    260  
    261             /* Receive Set of Observables */ 
    262             memset(buffer, 0, 256); 
    263             ReadMessage(commandSocketFD, buffer); 
    264             uint32_t numObservables = atoi(buffer); 
    265     
    266             Observable *o = new Observable[numObservables]; 
    267   
    268             for(size_t i = 0; i < numObservables; i++) { 
    269                 memset(buffer, 0, 256); 
    270                 ReadMessage(commandSocketFD, buffer); 
    271                 o[i].name = std::string(buffer); 
    272      
    273                 memset(buffer, 0, 256); 
    274                 ReadMessage(commandSocketFD, buffer); 
    275                 o[i].value = atof(buffer); 
    276             }   
    277  
    278             ReceiveFeedback(o,p); 
    279  
    280             delete [] o; 
    281             delete [] p; 
    282         }  
    283         else if(strcmp(buffer, "request_optimization_service") == 0) { 
    284             // THIS IS CURRENTLY IN DEMO MODE             
    285  
    286  
    287             /* Receive Set of Observables */ 
    288             LOG("\nCognitive Engine:: Receiving service name\n"); 
    289  
    290             memset(buffer, 0, 256); 
    291             ReadMessage(commandSocketFD,buffer); 
    292             LOG("\nCognitive Engine:: Got service name, %s\n", buffer); 
    293  
    294             /* Receive Set of Observables */ 
    295             LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); 
    296  
    297             memset(buffer, 0, 256); 
    298             ReadMessage(commandSocketFD,buffer); 
    299             uint32_t numObservables = atoi(buffer); 
    300     
    301             Observable *o = new Observable[numObservables]; 
    302   
    303             for(size_t i = 0; i < numObservables; i++) { 
    304                 memset(buffer, 0, 256); 
    305                 ReadMessage(commandSocketFD, buffer); 
    306                 o[i].name = std::string(buffer); 
    307      
    308                 memset(buffer, 0, 256); 
    309                 ReadMessage(commandSocketFD, buffer); 
    310                 o[i].value = atof(buffer); 
    311             }   
    312  
    313             /* Receive Set of current Parameters */ 
    314             LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); 
    315  
    316             memset(buffer, 0, 256); 
    317             ReadMessage(commandSocketFD, buffer); 
    318             uint32_t numCurrentParameters = atoi(buffer); 
    319     
    320             Parameter *cp = new Parameter[numCurrentParameters]; 
    321   
    322             for(size_t i = 0; i < numCurrentParameters; i++) { 
    323                 memset(buffer, 0, 256); 
    324                 ReadMessage(commandSocketFD, buffer); 
    325                 cp[i].name = std::string(buffer); 
    326      
    327                 memset(buffer, 0, 256); 
    328                 ReadMessage(commandSocketFD, buffer); 
    329                 cp[i].value = atof(buffer); 
    330             }   
    331             LOG("Cognitive Engine:: Processing parameters....\n"); 
    332  
    333             // TODO need to actually do something with the observables here 
    334             
    335             LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); 
    336             char numParametersChar[10]; 
    337             sprintf(numParametersChar, "%i", radioInfo->numParameters); 
    338             SendMessage(commandSocketFD, numParametersChar); 
    339             for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    340                 SendMessage(commandSocketFD, "test"); 
    341                 SendMessage(commandSocketFD, "00"); 
    342             } 
    343  
    344             delete [] o; 
    345             delete [] cp; 
    346         } 
    347         else if(strcmp(buffer, "request_optimization") == 0) { 
    348              
    349             /* Receive Set of Observables */ 
    350             LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); 
    351  
    352             memset(buffer, 0, 256); 
    353             ReadMessage(commandSocketFD,buffer); 
    354             uint32_t numObservables = atoi(buffer); 
    355     
    356             Observable *o = new Observable[numObservables]; 
    357   
    358             for(size_t i = 0; i < numObservables; i++) { 
    359                 memset(buffer, 0, 256); 
    360                 ReadMessage(commandSocketFD, buffer); 
    361                 o[i].name = std::string(buffer); 
    362      
    363                 memset(buffer, 0, 256); 
    364                 ReadMessage(commandSocketFD, buffer); 
    365                 o[i].value = atof(buffer); 
    366             }   
    367  
    368             /* Receive Set of current Parameters */ 
    369             LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); 
    370  
    371             memset(buffer, 0, 256); 
    372             ReadMessage(commandSocketFD, buffer); 
    373             uint32_t numCurrentParameters = atoi(buffer); 
    374     
    375             Parameter *cp = new Parameter[numCurrentParameters]; 
    376   
    377             for(size_t i = 0; i < numCurrentParameters; i++) { 
    378                 memset(buffer, 0, 256); 
    379                 ReadMessage(commandSocketFD, buffer); 
    380                 cp[i].name = std::string(buffer); 
    381      
    382                 memset(buffer, 0, 256); 
    383                 ReadMessage(commandSocketFD, buffer); 
    384                 cp[i].value = atof(buffer); 
    385             }   
    386             LOG("Cognitive Engine:: Processing parameters....\n"); 
    387  
    388             Parameter *solutionSet; 
    389              
    390             solutionSet = GetSolution(o,cp); 
    391  
    392             // TODO need to actually do something with the observables here 
    393             
    394             LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); 
    395             char numParametersChar[10]; 
    396             char solutionValue[50]; 
    397             sprintf(numParametersChar, "%i", radioInfo->numParameters); 
    398             SendMessage(commandSocketFD, numParametersChar); 
    399             for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    400                 SendMessage(commandSocketFD, solutionSet[i].name.c_str()); 
    401                 memset(solutionValue, 0, 50); 
    402                 sprintf(solutionValue, "%f", solutionSet[i].value); 
    403                 SendMessage(commandSocketFD, solutionValue); 
    404             } 
    405  
    406             delete [] o; 
    407             delete [] cp; 
    408         } 
    409         else if(strcmp(buffer, "query_component_type") == 0) { 
    410             SendComponentType(); 
    411         } 
    412         else if(strcmp(buffer, "connect_sml") == 0) { 
    413             /* This command implies that we are disconnecting from the shell and 
    414              * connecting to a SML component. */ 
    415             char serverName[256]; 
    416             char serverPort[256]; 
    417             // TODO is this going to end up being too slow? 
    418             memset(serverName, 0, 256); 
    419             memset(serverPort, 0, 256); 
    420  
    421             ReadMessage(commandSocketFD, serverName); 
    422             ReadMessage(commandSocketFD, serverPort); 
    423  
    424             /* Only continue if we are currently connected to a shell. */ 
    425             if(!SML_present) { 
    426                 DeregisterComponent(); 
    427  
    428                 shutdown(commandSocketFD, 2); 
    429                 close(commandSocketFD); 
    430  
    431                 ConnectToRemoteComponent(serverName, serverPort, true); 
    432             } 
    433         } 
    434         else if(strcmp(buffer, "disconnect_sml") == 0) { 
    435             /* This command implies that we are disconnecting from the SML and 
    436              * connecting to a shell component. */ 
    437             char serverName[256]; 
    438             char serverPort[256]; 
    439             // TODO is this going to end up being too slow? 
    440             memset(serverName, 0, 256); 
    441             memset(serverPort, 0, 256); 
    442  
    443             ReadMessage(commandSocketFD, serverName); 
    444             ReadMessage(commandSocketFD, serverPort); 
    445  
    446             /* We only want to do this if we are actually connected to an SML 
    447              * currently. */ 
    448             if(SML_present) { 
    449                 DeregisterServices(); 
    450  
    451                 shutdown(commandSocketFD, 2); 
    452                 close(commandSocketFD); 
    453  
    454                 ConnectToRemoteComponent(serverName, serverPort, false); 
    455             } 
    456         } 
    457         else if(strcmp(buffer, "reset_engine_cognitive") == 0) { 
    458             Reset(); 
    459         } 
    460         else if(strcmp(buffer, "shutdown_engine_cognitive") == 0) { 
    461             Shutdown(); 
    462         } 
    463     } 
    464 } 
    465  
    466  
    467 void  
    468 CognitiveEngine::Shutdown() 
    469 { 
    470     if(SML_present) { 
    471         //DeregisterServices(); 
    472         DeregisterComponent(); 
    473     }  
    474     else { 
    475         DeregisterComponent(); 
    476     } 
    477     // TODO should something else be happening here? 
     449DSA_CE::ReceiveFeedback(Observable *observables, Parameter *parameters, \ 
     450    std::string service) 
     451{ 
     452    LOG("Cognitive Engine:: Receiving feedback.\n"); 
    478453} 
    479454 
    480455 
    481456void 
    482 CognitiveEngine::Reset() 
    483 { 
    484     LOG("Resetting Cognitive Engine.\n"); 
    485  
    486     if(SML_present) { 
    487         DeregisterServices(); 
    488         DeregisterComponent(); 
    489     }  
    490     else { 
    491         DeregisterComponent(); 
    492     } 
    493 } 
    494  
    495  
    496 void 
    497 CognitiveEngine::RegisterComponent() 
    498 { 
    499     char buffer[256]; 
    500     SendMessage(commandSocketFD, "register_engine_cognitive"); 
    501     LOG("Cognitive Engine:: Registration message sent to shell.\n"); 
    502  
    503     memset(buffer, 0, 256); 
    504     ReadMessage(commandSocketFD, buffer); 
    505 } 
    506  
    507 void  
    508 CognitiveEngine::DeregisterComponent() 
    509 { 
    510     SendMessage(commandSocketFD, "deregister_engine_cognitive"); 
    511     LOG("Cognitive Engine:: Deregistration message sent.\n"); 
    512  
    513     shutdown(commandSocketFD, 2); 
    514     close(commandSocketFD); 
    515     commandSocketFD = -1; 
    516     LOG("Cognitive Engine:: Shell socket closed.\n"); 
    517 } 
    518  
    519  
    520 void  
    521 CognitiveEngine::RegisterServices() 
    522 { 
    523     LOG("Cognitive Engine:: Registering services.\n"); 
    524  
    525     SendMessage(commandSocketFD, "register_service"); 
    526     SendMessage(commandSocketFD, "test_srv"); 
    527  
    528     SendMessage(commandSocketFD, "register_service"); 
    529     SendMessage(commandSocketFD, "test_srv1"); 
    530  
    531     SendMessage(commandSocketFD, "register_service"); 
    532     SendMessage(commandSocketFD, "test_srv2"); 
    533  
    534     SendMessage(commandSocketFD, "register_service"); 
    535     SendMessage(commandSocketFD, "test_srv3"); 
    536  
    537 } 
    538  
    539 //Combined with deregister component since those two things must happen togeather 
    540 void  
    541 CognitiveEngine::DeregisterServices() 
    542 { 
    543     LOG("Cognitive Engine:: Deregistering services.\n"); 
    544  
    545     SendMessage(commandSocketFD, "deregister_service"); 
    546     SendMessage(commandSocketFD, "test_srv"); 
    547  
    548     SendMessage(commandSocketFD, "deregister_service"); 
    549     SendMessage(commandSocketFD, "test_srv1"); 
    550  
    551     SendMessage(commandSocketFD, "deregister_service"); 
    552     SendMessage(commandSocketFD, "test_srv2"); 
    553  
    554     SendMessage(commandSocketFD, "deregister_service"); 
    555     SendMessage(commandSocketFD, "test_srv3"); 
    556  
    557 } 
    558  
    559 void  
    560 CognitiveEngine::ReceiveRadioConfiguration() 
    561 { 
    562     LOG("Cognitive Engine:: Receiving Radio Configuration.\n"); 
    563      
    564     char buffer[256]; 
    565   
    566     /* Receive Set of Utilities */ 
    567     memset(buffer, 0, 256); 
    568     ReadMessage(commandSocketFD, buffer); 
    569     radioInfo->numUtilities = atoi(buffer); 
    570  
    571     for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    572         memset(buffer, 0, 256); 
    573         ReadMessage(commandSocketFD, buffer); 
    574         uList[i].name = std::string(buffer); 
    575     
    576         memset(buffer, 0, 256); 
    577         ReadMessage(commandSocketFD, buffer); 
    578         uList[i].units = std::string(buffer); 
    579  
    580         memset(buffer, 0, 256); 
    581         ReadMessage(commandSocketFD, buffer); 
    582         uList[i].goal = std::string(buffer); 
    583      
    584         memset(buffer, 0, 256); 
    585         ReadMessage(commandSocketFD, buffer); 
    586         uList[i].target = atof(buffer); 
    587     } 
    588  
    589     /* Receive Set of Parameters */ 
    590     memset(buffer, 0, 256); 
    591     ReadMessage(commandSocketFD, buffer); 
    592     radioInfo->numParameters = atoi(buffer); 
    593      
    594     for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    595         memset(buffer, 0, 256); 
    596         ReadMessage(commandSocketFD, buffer); 
    597         pList[i].name = std::string(buffer); 
    598      
    599         memset(buffer, 0, 256); 
    600         ReadMessage(commandSocketFD, buffer); 
    601         pList[i].units = std::string(buffer); 
    602  
    603         memset(buffer, 0, 256); 
    604         ReadMessage(commandSocketFD, buffer); 
    605         pList[i].min = atof(buffer); 
    606      
    607         memset(buffer, 0, 256); 
    608         ReadMessage(commandSocketFD, buffer); 
    609         pList[i].max = atof(buffer); 
    610      
    611         memset(buffer, 0, 256); 
    612         ReadMessage(commandSocketFD, buffer); 
    613         pList[i].step = atof(buffer); 
    614      
    615         memset(buffer, 0, 256); 
    616         ReadMessage(commandSocketFD,buffer); 
    617         pList[i].numAffects = atoi(buffer); 
    618      
    619         for(size_t j = 0; j < pList[i].numAffects; j++) { 
    620             memset(buffer, 0, 256); 
    621             ReadMessage(commandSocketFD,buffer); 
    622             // TODO for + if{break} = while? 
    623             for(size_t k = 0; k < radioInfo->numUtilities; k++) { 
    624                 if(uList[k].name == std::string(buffer)) {     
    625                     pList[i].affection_list[j].u = &uList[k];    
    626                     break; 
    627                 } 
    628             } 
    629  
    630             memset(buffer, 0, 256); 
    631             ReadMessage(commandSocketFD, buffer); 
    632             pList[i].affection_list[j].relation = std::string(buffer);    
    633         } 
    634     }    
    635  
    636     /* Receive Set of Observables */ 
    637     memset(buffer, 0, 256); 
    638     ReadMessage(commandSocketFD, buffer); 
    639     radioInfo->numObservables = atoi(buffer); 
    640      
    641     for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    642         memset(buffer, 0, 256); 
    643         ReadMessage(commandSocketFD, buffer); 
    644         oList[i].name = std::string(buffer); 
    645      
    646         memset(buffer, 0, 256); 
    647         ReadMessage(commandSocketFD, buffer); 
    648         oList[i].numAffects = atoi(buffer); 
    649      
    650         for(size_t j = 0; j < oList[i].numAffects; j++) { 
    651             memset(buffer, 0, 256); 
    652             ReadMessage(commandSocketFD, buffer); 
    653             // TODO for + if{break} = while? 
    654             for(size_t k = 0; k < radioInfo->numUtilities; k++) { 
    655                 if(uList[k].name == std::string(buffer)){     
    656                     oList[i].affection_list[j].u = &uList[k];    
    657                     break; 
    658                 } 
    659             } 
    660   
    661             memset(buffer, 0, 256); 
    662             ReadMessage(commandSocketFD, buffer); 
    663             oList[i].affection_list[j].relation = std::string(buffer);    
    664         } 
    665     } 
    666  
    667     SendMessage(commandSocketFD, "receive_config_ack"); 
    668  
    669     BuildCognitiveEngine(); 
    670 } 
    671  
    672 void  
    673 CognitiveEngine::ReceiveExperience() 
    674 { 
    675     LOG("Cognitive Engine:: Receiving Experience Report.\n"); 
    676     char buffer[256]; 
    677     uint32_t numberExp; 
    678      
    679     /* Receive number of experience entries */ 
    680     memset(buffer, 0, 256); 
    681     ReadMessage(commandSocketFD, buffer); 
    682     numberExp = atoi(buffer); 
    683  
    684     LOG("Cognitive Engine:: Waiting for %i number of entries.\n", numberExp); 
    685   
    686     SendMessage(commandSocketFD, "receive_exp_ack"); 
    687 } 
    688  
    689  
    690 /* The core of the CE is this function */ 
    691  
    692 Parameter*  
    693 CognitiveEngine::GetSolution(Observable *observables, Parameter *currentParameters) 
    694 { 
    695     LOG("Cognitive Engine:: Generating solution.\n"); 
    696  
    697     /* Put together the CBR search array */ 
    698  
    699     uint32_t channel = 0; 
    700     string searchNames[1]; 
    701     string sumSearchName; 
    702     float searchVals[1]; 
    703     float utilArray[(int)pList[0].max]; 
    704     int searchOps[1]; 
    705     uint32_t numberColumns = radioInfo->numUtilities + radioInfo->numParameters + \ 
    706                              radioInfo->numObservables + 1; 
    707  
    708     float returnValues[numberColumns]; 
    709     float sumRetVals[numberColumns]; 
    710     
    711     // Total sum of utilities in sumRetVals[0] 
    712  
    713     string channel_name = "channel"; 
    714     string utility_name = "utility"; 
    715  
    716     for(int32_t i = 0 ; i < pList[0].max ; i++ ) { 
    717         searchNames[0] = pList[0].name; 
    718         searchOps[0] = 0; 
    719         searchVals[0] = i+1;  
    720      
    721         uint32_t rc = myCBR->Search(searchNames, searchOps, searchVals, 
    722             1, returnValues); 
    723  
    724         if(rc == 31337) { 
    725                 // No entry - must add 
    726                  
    727                 string rowNames[numberColumns]; 
    728                 size_t rowIndex = 0; 
    729                 for(size_t j = 0; j < radioInfo->numUtilities; j++) { 
    730                         rowNames[rowIndex] = uList[j].name; 
    731                         rowIndex++; 
    732                 } 
    733                 for(size_t j = 0; j < radioInfo->numParameters; j++) { 
    734                         rowNames[rowIndex] = pList[j].name; 
    735                         if(pList[j].name == "channel") 
    736                                 returnValues[rowIndex] = i+1; 
    737                         rowIndex++; 
    738                 } 
    739                 for(size_t j = 0; j < radioInfo->numObservables; j++) { 
    740                         rowNames[rowIndex] = oList[j].name; 
    741                         rowIndex++; 
    742                 } 
    743     
    744                 rowNames[rowIndex] = utility_name; 
    745                 returnValues[rowIndex] = 500; 
    746  
    747                 /* Add the new optimized set to the CBR database */ 
    748  
    749                 myCBR->AddRow(rowNames, returnValues, numberColumns); 
    750         } 
    751  
    752         utilArray[i] = returnValues[UTILITY];  
    753     } 
    754  
    755     printf("Current Channel Utility Scores\n"); 
    756     printf("1: %f\t7: %f\t8: %f\t14: %f\n",utilArray[0],utilArray[1],utilArray[2],utilArray[3]);     
    757     // Get sum of all the channel utilities. 
    758     sumSearchName = utility_name; 
    759     uint32_t rc = myCBR->SearchSum(sumSearchName, sumRetVals); 
    760  
    761     // Psuedo random channel selection based upon utility. 
    762     int k = rand() % (int)sumRetVals[0]; 
    763     int cdf_total(0); 
    764  
    765     for ( int i = 0; i < pList[0].max; i++ ) { 
    766         cdf_total += utilArray[i]; 
    767         if(k < cdf_total) { 
    768                 channel = i + 1; 
    769                 break; 
    770         } 
    771     } 
    772          
    773     searchNames[0] = pList[0].name; 
    774     searchOps[0] = 0; 
    775     searchVals[0] = channel;  
    776    
    777     rc = myCBR->Search(searchNames, searchOps, searchVals, 
    778         1, returnValues); 
    779  
    780  
    781     //returnValues[CHANNEL] = rand() % (int)pList[0].max + (int)pList[0].min;  
    782     returnValues[CHANNEL] = channel; 
    783  
    784     printf("Cognitive Engine:: ..---===***### Channel %i has been selected ###***===---..\n",channel);  
    785     /* Package up the new set of parameters in order to add 
    786        the new entry into the CBR database.  */ 
    787  
    788     size_t returnValueIndex = 0; 
    789     for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    790         uList[i].value = returnValues[returnValueIndex]; 
    791         returnValueIndex++; 
    792     } 
    793     for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    794         pList[i].value = returnValues[returnValueIndex]; 
    795         returnValueIndex++; 
    796     } 
    797     for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    798         oList[i].value = returnValues[returnValueIndex]; 
    799         returnValueIndex++; 
    800     } 
    801     //returnValues[returnValueIndex] = 0; 
    802  
    803     string allNames[numberColumns]; 
    804     size_t allNameIndex = 0; 
    805     for(size_t i = 0; i < radioInfo->numUtilities; i++) { 
    806         allNames[allNameIndex] = uList[i].name; 
    807         returnValues[allNameIndex] = uList[i].target; 
    808         allNameIndex++; 
    809     } 
    810     for(size_t i = 0; i < radioInfo->numParameters; i++) { 
    811         allNames[allNameIndex] = pList[i].name; 
    812         allNameIndex++; 
    813     } 
    814     for(size_t i = 0; i < radioInfo->numObservables; i++) { 
    815         allNames[allNameIndex] = oList[i].name; 
    816     //    returnValues[allNameIndex] = 0; 
    817         allNameIndex++; 
    818     } 
    819     
    820     allNames[allNameIndex] = utility_name; 
    821  
    822     /* Add the new optimized set to the CBR database */ 
    823     //myCBR->AddRow(allNames, returnValues, returnValueIndex+1); 
    824  
    825  
    826     /* Return the set of new parameter values.  */ 
    827     return pList; 
    828 } 
    829  
    830  
    831 Parameter*  
    832 CognitiveEngine::GetSolution(Observable *observables, \ 
    833         Parameter *currentParameters, std::string service) 
    834 { 
    835     LOG("Cognitive Engine:: Generating solution for %s service.\n", service.c_str()); 
    836  
    837     return pList; 
    838 } 
    839  
    840  
    841 void  
    842 CognitiveEngine::ReceiveFeedback(Observable *observables, Parameter *parameters, \ 
    843     std::string service) 
    844 { 
    845     LOG("Cognitive Engine:: Receiving feedback.\n"); 
    846 } 
    847  
    848  
    849 void 
    850 CognitiveEngine::BuildCognitiveEngine() 
     457DSA_CE::BuildCognitiveEngine() 
    851458{ 
    852459    string filename = "ex1"; 
    … …  
    885492} 
    886493 
     494 
     495void  
     496DSA_CE::PerformUpdatePerformance() 
     497{ 
     498    /* Receive Set of current Parameters */ 
     499    char buffer[256]; 
     500    memset(buffer, 0, 256); 
     501    ReadMessage(commandSocketFD, buffer); 
     502    uint32_t numParameters = atoi(buffer); 
     503 
     504    Parameter *p = new Parameter[numParameters]; 
     505 
     506    for(size_t i = 0; i < numParameters; i++) { 
     507        memset(buffer, 0, 256); 
     508        ReadMessage(commandSocketFD, buffer); 
     509        p[i].name = std::string(buffer); 
     510 
     511        memset(buffer, 0, 256); 
     512        ReadMessage(commandSocketFD, buffer); 
     513        p[i].value = atof(buffer); 
     514    }  
     515 
     516    /* Receive Set of Observables */ 
     517    memset(buffer, 0, 256); 
     518    ReadMessage(commandSocketFD, buffer); 
     519    uint32_t numObservables = atoi(buffer); 
     520 
     521    Observable *o = new Observable[numObservables]; 
     522 
     523    for(size_t i = 0; i < numObservables; i++) { 
     524        memset(buffer, 0, 256); 
     525        ReadMessage(commandSocketFD, buffer); 
     526        o[i].name = std::string(buffer); 
     527 
     528        memset(buffer, 0, 256); 
     529        ReadMessage(commandSocketFD, buffer); 
     530        o[i].value = atof(buffer); 
     531    }   
     532 
     533    ReceiveFeedback(o,p); 
     534 
     535    delete [] o; 
     536    delete [] p; 
     537} 
     538 
     539 
     540void 
     541DSA_CE::PerformRequestOptimizationService() 
     542{ 
     543    // THIS IS CURRENTLY IN DEMO MODE             
     544 
     545 
     546    /* Receive Set of Observables */ 
     547    LOG("\nCognitive Engine:: Receiving service name\n"); 
     548 
     549    char buffer[256]; 
     550    memset(buffer, 0, 256); 
     551    ReadMessage(commandSocketFD,buffer); 
     552    LOG("\nCognitive Engine:: Got service name, %s\n", buffer); 
     553 
     554    /* Receive Set of Observables */ 
     555    LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); 
     556 
     557    memset(buffer, 0, 256); 
     558    ReadMessage(commandSocketFD,buffer); 
     559    uint32_t numObservables = atoi(buffer); 
     560 
     561    Observable *o = new Observable[numObservables]; 
     562 
     563    for(size_t i = 0; i < numObservables; i++) { 
     564        memset(buffer, 0, 256); 
     565        ReadMessage(commandSocketFD, buffer); 
     566        o[i].name = std::string(buffer); 
     567 
     568        memset(buffer, 0, 256); 
     569        ReadMessage(commandSocketFD, buffer); 
     570        o[i].value = atof(buffer); 
     571    }   
     572 
     573    /* Receive Set of current Parameters */ 
     574    LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); 
     575 
     576    memset(buffer, 0, 256); 
     577    ReadMessage(commandSocketFD, buffer); 
     578    uint32_t numCurrentParameters = atoi(buffer); 
     579 
     580    Parameter *cp = new Parameter[numCurrentParameters]; 
     581 
     582    for(size_t i = 0; i < numCurrentParameters; i++) { 
     583        memset(buffer, 0, 256); 
     584        ReadMessage(commandSocketFD, buffer); 
     585        cp[i].name = std::string(buffer); 
     586 
     587        memset(buffer, 0, 256); 
     588        ReadMessage(commandSocketFD, buffer); 
     589        cp[i].value = atof(buffer); 
     590    }   
     591    LOG("Cognitive Engine:: Processing parameters....\n"); 
     592 
     593    // TODO need to actually do something with the observables here 
     594    
     595    LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); 
     596    char numParametersChar[10]; 
     597    sprintf(numParametersChar, "%i", radioInfo->numParameters); 
     598    SendMessage(commandSocketFD, numParametersChar); 
     599    for(size_t i = 0; i < radioInfo->numParameters; i++) { 
     600        SendMessage(commandSocketFD, "test"); 
     601        SendMessage(commandSocketFD, "00"); 
     602    } 
     603 
     604    delete [] o; 
     605    delete [] cp; 
     606} 
     607 
     608 
     609void 
     610DSA_CE::PerformRequestOptimization() 
     611{ 
     612        /* Receive Set of Observables */ 
     613        LOG("\nCognitive Engine:: Receiving Observable Parameters\n"); 
     614 
     615    char buffer[256]; 
     616        memset(buffer, 0, 256); 
     617        ReadMessage(commandSocketFD,buffer); 
     618        uint32_t numObservables = atoi(buffer); 
     619 
     620        Observable *o = new Observable[numObservables]; 
     621 
     622        for(size_t i = 0; i < numObservables; i++) { 
     623                memset(buffer, 0, 256); 
     624                ReadMessage(commandSocketFD, buffer); 
     625                o[i].name = std::string(buffer); 
     626 
     627                memset(buffer, 0, 256); 
     628                ReadMessage(commandSocketFD, buffer); 
     629                o[i].value = atof(buffer); 
     630        }   
     631 
     632        /* Receive Set of current Parameters */ 
     633        LOG("Cognitive Engine:: Receiving Current Transmission Parameters\n"); 
     634 
     635        memset(buffer, 0, 256); 
     636        ReadMessage(commandSocketFD, buffer); 
     637        uint32_t numCurrentParameters = atoi(buffer); 
     638 
     639        Parameter *cp = new Parameter[numCurrentParameters]; 
     640 
     641        for(size_t i = 0; i < numCurrentParameters; i++) { 
     642                memset(buffer, 0, 256); 
     643                ReadMessage(commandSocketFD, buffer); 
     644                cp[i].name = std::string(buffer); 
     645 
     646                memset(buffer, 0, 256); 
     647                ReadMessage(commandSocketFD, buffer); 
     648                cp[i].value = atof(buffer); 
     649        }   
     650        LOG("Cognitive Engine:: Processing parameters....\n"); 
     651 
     652        Parameter *solutionSet; 
     653         
     654        solutionSet = GetSolution(o,cp); 
     655 
     656        // TODO need to actually do something with the observables here 
     657    
     658        LOG("Cognitive Engine:: Sending Optimal Parameters to Application.\n"); 
     659        char numParametersChar[10]; 
     660        char solutionValue[50]; 
     661        sprintf(numParametersChar, "%i", radioInfo->numParameters); 
     662        SendMessage(commandSocketFD, numParametersChar); 
     663        for(size_t i = 0; i < radioInfo->numParameters; i++) { 
     664                SendMessage(commandSocketFD, solutionSet[i].name.c_str()); 
     665                memset(solutionValue, 0, 50); 
     666                sprintf(solutionValue, "%f", solutionSet[i].value); 
     667                SendMessage(commandSocketFD, solutionValue); 
     668        } 
     669 
     670        delete [] o; 
     671        delete [] cp; 
     672} 
     673 
     674 
     675void 
     676DSA_CE::PerformQueryComponentType() 
     677{ 
     678        SendComponentType(); 
     679} 
     680 
     681 
     682void 
     683DSA_CE::PerformConnectSML() 
     684{ 
     685        /* This command implies that we are disconnecting from the shell and 
     686         * connecting to a SML component. */ 
     687        char serverName[256]; 
     688        char serverPort[256]; 
     689        // TODO is this going to end up being too slow? 
     690        memset(serverName, 0, 256); 
     691        memset(serverPort, 0, 256); 
     692 
     693        ReadMessage(commandSocketFD, serverName); 
     694        ReadMessage(commandSocketFD, serverPort); 
     695 
     696        /* Only continue if we are currently connected to a shell. */ 
     697        if(!SML_present) { 
     698                DeregisterComponent(); 
     699 
     700                shutdown(commandSocketFD, 2); 
     701                close(commandSocketFD); 
     702 
     703                ConnectToRemoteComponent(serverName, serverPort, true); 
     704        } 
     705} 
     706 
     707 
     708void 
     709DSA_CE::PerformDisconnectSML() 
     710{ 
     711        /* This command implies that we are disconnecting from the SML and 
     712         * connecting to a shell component. */ 
     713        char serverName[256]; 
     714        char serverPort[256]; 
     715        // TODO is this going to end up being too slow? 
     716        memset(serverName, 0, 256); 
     717        memset(serverPort, 0, 256); 
     718 
     719        ReadMessage(commandSocketFD, serverName); 
     720        ReadMessage(commandSocketFD, serverPort); 
     721 
     722        /* We only want to do this if we are actually connected to an SML 
     723         * currently. */ 
     724        if(SML_present) { 
     725                DeregisterServices(); 
     726 
     727                shutdown(commandSocketFD, 2); 
     728                close(commandSocketFD); 
     729 
     730                ConnectToRemoteComponent(serverName, serverPort, false); 
     731        } 
     732} 
     733 
     734 
     735void 
     736DSA_CE::PerformResetEngineCognitive() 
     737{ 
     738        Reset(); 
     739} 
     740 
     741 
     742void 
     743DSA_CE::PerformShutdownEngineCognitive() 
     744{ 
     745        Shutdown(); 
     746} 
     747  

  • vtcross/trunk/src/cognitive_engines/DSA_CE/DSA_Demo.cpp

    r465 r533  
    4141       ERROR(1, "Usage: %s hostname port\n", argv[0]); 
    4242     
    43     CognitiveEngine cognitiveEngine(argv[1], argv[2], false); 
     43    CognitiveEngine cognitiveEngine(argv[1], argv[2], 10, false); 
    4444 
    4545    LOG("Waiting for signal...\n"); 

  • vtcross/trunk/src/cognitive_engines/DSA_CE/Makefile.am

    r469 r533  
    2222 
    2323DSA_Demo_SOURCES = DSA_CognitiveEngine.cpp DSA_Demo.cpp 
    24 DSA_Demo_LDADD = -lsqlite3 $(CROSS_SOCKETCOMM_LA)  
     24DSA_Demo_DEPENDENCIES = ../libce.a 
     25DSA_Demo_LDADD = -lsqlite3 ../libce.a $(CROSS_SOCKETCOMM_LA)  
    2526 

  • vtcross/trunk/src/cognitive_engines/Makefile.am

    r532 r533  
    2222libce_a_SOURCES = CognitiveEngine.cpp 
    2323 
    24 SUBDIRS = . CBR_CE #DSA_CE OSSIE_DEMO_CE 
     24SUBDIRS = . CBR_CE DSA_CE #OSSIE_DEMO_CE