Changeset 231


Ignore:
Timestamp:
11/13/2009 02:04:33 PM (10 years ago)
Author:
joao.dias
Message:

solved some synchronization problems in the SemanticMemory?.

Location:
AgentMind/branches/FAtiMA2/src/FAtiMA
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • AgentMind/branches/FAtiMA2/src/FAtiMA/deliberativeLayer/Intention.java

    r198 r231  
    452452                es.AddEmotion(em, am); 
    453453            } 
    454              
    455              
     454          
    456455             
    457456            if(!isRootIntention()) 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/memory/semanticMemory/KnowledgeBase.java

    r198 r231  
    7474 
    7575import java.util.ArrayList; 
     76import java.util.Iterator; 
    7677import java.util.ListIterator; 
    7778 
    7879import FAtiMA.deliberativeLayer.plan.Step; 
    7980import FAtiMA.wellFormedNames.Name; 
     81import FAtiMA.wellFormedNames.Substitution; 
     82import FAtiMA.wellFormedNames.SubstitutionSet; 
    8083import FAtiMA.wellFormedNames.Symbol; 
    8184 
     
    120123        } 
    121124         
     125        public Object Ask(Name name) { 
     126                KnowledgeSlot aux = _kB; 
     127                KnowledgeSlot currentSlot; 
     128                ArrayList<Symbol> fetchList = name.GetLiteralList(); 
     129                ListIterator<Symbol> li = fetchList.listIterator(); 
     130                Symbol l; 
     131 
     132                synchronized (this) { 
     133                        while (li.hasNext()) { 
     134                                        currentSlot = aux; 
     135                                        l = li.next(); 
     136                                        if (currentSlot.containsKey(l.toString())) { 
     137                                                aux = currentSlot.get(l.toString()); 
     138                                        }  
     139                                        else return null; 
     140                        } 
     141                        return aux; 
     142                } 
     143        } 
     144         
    122145        /** 
    123146         * Empties the KnowledgeBase 
     
    152175        { 
    153176                return _inferenceOperators; 
    154         } 
    155  
    156         /** 
    157          * Gets the knowledge base slots 
    158          * @return the knowledge base slots 
    159          */ 
    160     // Added 18/03/09 
    161         public KnowledgeSlot GetKnowledgeBase() 
    162         { 
    163                 return _kB; 
    164177        } 
    165178 
     
    267280                } 
    268281        } 
     282         
     283        public ArrayList<SubstitutionSet> GetPossibleBindings(Name name) { 
     284                ArrayList<SubstitutionSet> bindingSets = null; 
     285 
     286                bindingSets = MatchLiteralList(name.GetLiteralList(), 0, _kB); 
     287                 
     288                if (bindingSets == null || bindingSets.size() == 0) 
     289                        return null; 
     290                else 
     291                        return bindingSets; 
     292        } 
     293         
     294        public KnowledgeSlot GetObjectDetails(String objectName) 
     295        { 
     296                return _kB.get(objectName); 
     297        } 
     298 
     299         
     300        private ArrayList<SubstitutionSet> MatchLiteralList(ArrayList<Symbol> literals, int index, KnowledgeSlot ks) { 
     301                Symbol l; 
     302                String key; 
     303                ArrayList<SubstitutionSet> bindingSets; 
     304                ArrayList<SubstitutionSet> newBindingSets; 
     305                SubstitutionSet subSet; 
     306                ListIterator<SubstitutionSet> li; 
     307                Iterator<String> it; 
     308 
     309                newBindingSets = new ArrayList<SubstitutionSet>(); 
     310 
     311                if (index >= literals.size()) { 
     312                        newBindingSets.add(new SubstitutionSet()); 
     313                        return newBindingSets; 
     314                } 
     315 
     316                synchronized (this) { 
     317                        l = (Symbol) literals.get(index++); 
     318 
     319                        if (l.isGrounded()) { 
     320                                if (ks.containsKey(l.toString())) { 
     321                                        return MatchLiteralList(literals, index, ks.get(l.toString())); 
     322                                } else 
     323                                        return null; 
     324                        } 
     325 
     326                        it = ks.getKeyIterator(); 
     327                        while (it.hasNext()) { 
     328                                key = (String) it.next(); 
     329                                bindingSets = MatchLiteralList(literals, index, ks.get(key)); 
     330                                if (bindingSets != null) { 
     331                                        li = bindingSets.listIterator(); 
     332                                        while (li.hasNext()) { 
     333                                                subSet = (SubstitutionSet) li.next(); 
     334                                                subSet.AddSubstitution(new Substitution(l, new Symbol( 
     335                                                                key))); 
     336                                                newBindingSets.add(subSet); 
     337                                        } 
     338                                } 
     339                        } 
     340                } 
     341 
     342                if (newBindingSets.size() == 0) 
     343                        return null; 
     344                else 
     345                        return newBindingSets; 
     346        } 
    269347 
    270348        /** 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/memory/semanticMemory/SemanticMemory.java

    r198 r231  
    22 
    33import java.util.ArrayList; 
    4 import java.util.Iterator; 
    54import java.util.ListIterator; 
    65 
     
    109import FAtiMA.deliberativeLayer.plan.Step; 
    1110import FAtiMA.wellFormedNames.Name; 
    12 import FAtiMA.wellFormedNames.Substitution; 
    1311import FAtiMA.wellFormedNames.SubstitutionSet; 
    1412import FAtiMA.wellFormedNames.Symbol; 
     
    2725        public void AddInferenceOperator(Step op) 
    2826        { 
    29                 _kb.AddInferenceOperator(op); 
    30         } 
    31          
    32          private Object Ask(Name name, KnowledgeSlot slots) { 
    33                 KnowledgeSlot aux = slots; 
    34                 KnowledgeSlot currentSlot; 
    35                 ArrayList<Symbol> fetchList = name.GetLiteralList(); 
    36                 ListIterator<Symbol> li = fetchList.listIterator(); 
    37                 Symbol l; 
    38  
    3927                synchronized (this) { 
    40                         while (li.hasNext()) { 
    41                                         currentSlot = aux; 
    42                                         l = li.next(); 
    43                                         if (currentSlot.containsKey(l.toString())) { 
    44                                                 aux = currentSlot.get(l.toString()); 
    45                                         }  
    46                                         else return null; 
    47                         } 
    48                         return aux; 
    49                 } 
    50         } 
     28                        _kb.AddInferenceOperator(op); 
     29                } 
     30        } 
     31          
    5132         
    5233        /** 
     
    5940        public boolean AskPredicate(Name predicate)  
    6041        { 
    61         KnowledgeSlot ks = (KnowledgeSlot) Ask(predicate, _stm.GetWorkingMemory()); 
    62         if (ks != null && ks.getValue() != null && ks.getValue().toString().equals("True")) 
    63         { 
    64                 _stm.RearrangeWorkingMemory(predicate); 
    65             return true; 
    66         } 
    67         else 
    68         { 
    69                 ks= (KnowledgeSlot) Ask(predicate, _kb.GetKnowledgeBase()); 
    70                 if (ks != null && ks.getValue() != null && ks.getValue().toString().equals("True")) 
    71             { 
    72                         _stm.Tell(_kb,predicate, ks.getValue()); 
    73                 return true; 
    74             } 
    75         } 
    76         return false; 
     42                synchronized (this) { 
     43                        KnowledgeSlot ks = (KnowledgeSlot) _stm.Ask(predicate); 
     44                if (ks != null && ks.getValue() != null && ks.getValue().toString().equals("True")) 
     45                { 
     46                        _stm.RearrangeWorkingMemory(predicate); 
     47                    return true; 
     48                } 
     49                else 
     50                { 
     51                        ks= (KnowledgeSlot) _kb.Ask(predicate); 
     52                        if (ks != null && ks.getValue() != null && ks.getValue().toString().equals("True")) 
     53                    { 
     54                                _stm.Tell(_kb,predicate, ks.getValue()); 
     55                        return true; 
     56                    } 
     57                } 
     58                return false; 
     59                }    
    7760        } 
    7861         
     
    8467         */ 
    8568        public Object AskProperty(Name property) { 
    86                 KnowledgeSlot prop = (KnowledgeSlot) Ask(property, _stm.GetWorkingMemory()); 
    87                 if (prop == null) 
    88                 { 
    89                         prop = (KnowledgeSlot) Ask(property, _kb.GetKnowledgeBase()); 
     69                synchronized(this) 
     70                { 
     71                        KnowledgeSlot prop = (KnowledgeSlot) _stm.Ask(property); 
    9072                        if (prop == null) 
    91                                 return null; 
     73                        { 
     74                                prop = (KnowledgeSlot) _kb.Ask(property); 
     75                                if (prop == null) 
     76                                        return null; 
     77                                else 
     78                                        _stm.Tell(_kb, property, prop.getValue()); 
     79                        } 
    9280                        else 
    93                                 _stm.Tell(_kb, property, prop.getValue()); 
    94                 } 
    95                 else 
    96                 { 
    97                         _stm.RearrangeWorkingMemory(property); 
    98                 } 
    99                 return prop.getValue(); 
     81                        { 
     82                                _stm.RearrangeWorkingMemory(property); 
     83                        } 
     84                        return prop.getValue(); 
     85                } 
    10086        } 
    10187         
     
    10591         */ 
    10692        public void Assert(Name predicate) { 
    107                 _stm.Tell(_kb, predicate,new Symbol("True")); 
     93                synchronized(this) 
     94                { 
     95                        _stm.Tell(_kb, predicate,new Symbol("True")); 
     96                } 
    10897        } 
    10998         
    11099        public void ClearChangeList() { 
    111             _stm.ClearChangeList(); 
     100                synchronized(this) 
     101                { 
     102                        _stm.ClearChangeList(); 
     103                } 
    112104        } 
    113105         
     
    116108                return _kb.Count(); 
    117109        } 
     110 
    118111         
    119112        public ArrayList<KnowledgeSlot> GetChangeList() { 
     
    132125        public KnowledgeSlot GetObjectDetails(String objectName) 
    133126        { 
    134                 KnowledgeSlot object = (_stm.GetWorkingMemory()).get(objectName); 
    135                 if(object == null) 
    136                         object = (_kb.GetKnowledgeBase()).get(objectName); 
    137                 return object; 
     127                synchronized(this) 
     128                { 
     129                        KnowledgeSlot object = _stm.GetObjectDetails(objectName); 
     130                        if(object == null) 
     131                                object = _kb.GetObjectDetails(objectName); 
     132                        return object; 
     133                } 
    138134        } 
    139135         
     
    177173         * @return a list of SubstitutionSets that make the received name to match predicates or  
    178174     *         properties that do exist in the WorkingMemory 
     175     *          
    179176         */ 
     177         
     178         
     179 
    180180        public ArrayList<SubstitutionSet> GetPossibleBindings(Name name) { 
    181181                ArrayList<SubstitutionSet> bindingSets = null; 
    182182                 
    183                 bindingSets = MatchLiteralList(name.GetLiteralList(), 0, _stm.GetWorkingMemory()); 
     183                synchronized(this) 
     184                { 
     185                         
    184186                 
    185                 if (bindingSets == null || bindingSets.size() == 0) 
    186                         bindingSets = (MatchLiteralList(name.GetLiteralList(), 0, _kb.GetKnowledgeBase())); 
    187                 else 
    188                 { 
    189                         ArrayList<SubstitutionSet> bindingSets2 = MatchLiteralList(name.GetLiteralList(), 0, _kb.GetKnowledgeBase()); 
    190                         if (bindingSets2 != null) 
     187                        bindingSets = _stm.GetPossibleBindings(name); 
     188                         
     189                        if (bindingSets == null) 
     190                                bindingSets = _kb.GetPossibleBindings(name); 
     191                        else 
    191192                        { 
    192                                 ListIterator<SubstitutionSet> li = bindingSets2.listIterator(); 
    193  
    194                                 synchronized (this) { 
    195                                         while (li.hasNext()) { 
    196                                                  
    197                                                 SubstitutionSet ss = li.next(); 
    198                                                 if( !bindingSets.contains(ss) ) 
    199                                                         bindingSets.add(ss); 
     193                                ArrayList<SubstitutionSet> bindingSets2 = _kb.GetPossibleBindings(name); 
     194                                if (bindingSets2 != null) 
     195                                { 
     196                                        ListIterator<SubstitutionSet> li = bindingSets2.listIterator(); 
     197         
     198                                        synchronized (this) { 
     199                                                while (li.hasNext()) { 
     200                                                         
     201                                                        SubstitutionSet ss = li.next(); 
     202                                                        if( !bindingSets.contains(ss) ) 
     203                                                                bindingSets.add(ss); 
     204                                                } 
    200205                                        } 
    201206                                } 
    202207                        } 
    203                 } 
    204                  
    205                 return bindingSets; 
     208                         
     209                        return bindingSets; 
     210                } 
    206211        } 
    207212 
     
    232237        public void InitializeProperty(Name property, Object value) 
    233238        { 
    234                 _kb.Tell(property, value); 
    235         } 
    236          
    237         private ArrayList<SubstitutionSet> MatchLiteralList(ArrayList<Symbol> literals, int index, KnowledgeSlot kSlot) { 
    238                 Symbol l; 
    239                 String key; 
    240                 ArrayList<SubstitutionSet> bindingSets; 
    241                 ArrayList<SubstitutionSet> newBindingSets; 
    242                 SubstitutionSet subSet; 
    243                 ListIterator<SubstitutionSet> li; 
    244                 Iterator<String> it; 
    245  
    246                 newBindingSets = new ArrayList<SubstitutionSet>(); 
    247  
    248                 if (index >= literals.size()) { 
    249                         newBindingSets.add(new SubstitutionSet()); 
    250                         return newBindingSets; 
    251                 } 
    252  
    253                 synchronized (this) { 
    254                         l = (Symbol) literals.get(index++); 
    255  
    256                         if (l.isGrounded()) { 
    257                                 if (kSlot.containsKey(l.toString())) { 
    258                                         return MatchLiteralList(literals, index, kSlot.get(l 
    259                                                         .toString())); 
    260                                 } else 
    261                                         return null; 
    262                         } 
    263  
    264                         it = kSlot.getKeyIterator(); 
    265                         while (it.hasNext()) { 
    266                                 key = (String) it.next(); 
    267                                 bindingSets = MatchLiteralList(literals, index, kSlot 
    268                                                 .get(key)); 
    269                                 if (bindingSets != null) { 
    270                                         li = bindingSets.listIterator(); 
    271                                         while (li.hasNext()) { 
    272                                                 subSet = (SubstitutionSet) li.next(); 
    273                                                 subSet.AddSubstitution(new Substitution(l, new Symbol( 
    274                                                                 key))); 
    275                                                 newBindingSets.add(subSet); 
    276                                         } 
    277                                 } 
    278                         } 
    279                 } 
    280  
    281                 if (newBindingSets.size() == 0) 
    282                         return null; 
    283                 else 
    284                         return newBindingSets; 
    285         } 
     239                synchronized(this) 
     240                { 
     241                        _kb.Tell(property, value); 
     242                } 
     243        } 
     244         
    286245         
    287246        /** 
     
    300259        ArrayList<SubstitutionSet> substitutionSets; 
    301260        SubstitutionSet sSet; 
    302          
    303         _stm.ResetNewKnowledge(); 
    304          
    305                 for(ListIterator<Step> li = _kb.GetInferenceOperators().listIterator();li.hasNext();) 
    306                 { 
    307                         infOp = (Step) li.next(); 
    308                         substitutionSets = Condition.CheckActivation(am, infOp.getPreconditions()); 
    309                         if(substitutionSets != null) 
     261 
     262        synchronized(this) 
     263        { 
     264                _stm.ResetNewKnowledge(); 
     265                 
     266                        for(ListIterator<Step> li = _kb.GetInferenceOperators().listIterator();li.hasNext();) 
    310267                        { 
    311                                 for(ListIterator<SubstitutionSet> li2 = substitutionSets.listIterator();li2.hasNext();) 
     268                                infOp = (Step) li.next(); 
     269                                substitutionSets = Condition.CheckActivation(am, infOp.getPreconditions()); 
     270                                if(substitutionSets != null) 
    312271                                { 
    313                                         sSet = li2.next(); 
    314                                         groundInfOp = (Step) infOp.clone(); 
    315                                         groundInfOp.MakeGround(sSet.GetSubstitutions()); 
    316                                         InferEffects(groundInfOp); 
     272                                        for(ListIterator<SubstitutionSet> li2 = substitutionSets.listIterator();li2.hasNext();) 
     273                                        { 
     274                                                sSet = li2.next(); 
     275                                                groundInfOp = (Step) infOp.clone(); 
     276                                                groundInfOp.MakeGround(sSet.GetSubstitutions()); 
     277                                                InferEffects(groundInfOp); 
     278                                        } 
    317279                                } 
    318280                        } 
    319                 } 
    320          
    321         return _stm.HasNewKnowledge(); 
     281                 
     282                return _stm.HasNewKnowledge(); 
     283        } 
    322284    } 
    323285         
     
    328290        public void Retract(Name predicate)  
    329291        { 
    330                 _kb.Retract(predicate); 
    331                 _stm.Retract(predicate); 
     292                synchronized(this) 
     293                { 
     294                        _kb.Retract(predicate); 
     295                        _stm.Retract(predicate); 
     296                } 
    332297        } 
    333298     
    334299        public void Tell(Name property, Object value) { 
    335                 _stm.Tell(_kb, property, value); 
     300                synchronized(this) 
     301                { 
     302                        _stm.Tell(_kb, property, value); 
     303                }        
    336304        } 
    337305 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/memory/semanticMemory/WorkingMemory.java

    r198 r231  
    4242import java.io.Serializable; 
    4343import java.util.ArrayList; 
     44import java.util.Iterator; 
    4445import java.util.ListIterator; 
    4546 
    4647 
    4748import FAtiMA.wellFormedNames.Name; 
     49import FAtiMA.wellFormedNames.Substitution; 
     50import FAtiMA.wellFormedNames.SubstitutionSet; 
    4851import FAtiMA.wellFormedNames.Symbol; 
    4952 
     
    8588                _changeList = new ArrayList<KnowledgeSlot>(WorkingMemory.MAXENTRY); 
    8689        } 
     90         
     91        public Object Ask(Name name) { 
     92                KnowledgeSlot aux = _wM; 
     93                KnowledgeSlot currentSlot; 
     94                ArrayList<Symbol> fetchList = name.GetLiteralList(); 
     95                ListIterator<Symbol> li = fetchList.listIterator(); 
     96                Symbol l; 
     97 
     98                synchronized (this) { 
     99                        while (li.hasNext()) { 
     100                                        currentSlot = aux; 
     101                                        l = li.next(); 
     102                                        if (currentSlot.containsKey(l.toString())) { 
     103                                                aux = currentSlot.get(l.toString()); 
     104                                        }  
     105                                        else return null; 
     106                        } 
     107                        return aux; 
     108                } 
     109        } 
    87110     
    88111        /** 
     
    117140    } 
    118141 
    119         /** 
    120          * Gets the working memory slots 
    121          * @return the working memory slots 
    122          */ 
    123         // Added 18/03/09 
    124         public KnowledgeSlot GetWorkingMemory() 
    125         { 
    126                 return _wM; 
    127         } 
    128142 
    129143        /** 
     
    317331        } 
    318332         
     333        public ArrayList<SubstitutionSet> GetPossibleBindings(Name name) { 
     334                ArrayList<SubstitutionSet> bindingSets = null; 
     335 
     336                bindingSets = MatchLiteralList(name.GetLiteralList(), 0, _wM); 
     337                 
     338                if (bindingSets == null || bindingSets.size() == 0) 
     339                        return null; 
     340                else 
     341                        return bindingSets; 
     342        } 
     343         
     344        public KnowledgeSlot GetObjectDetails(String objectName) 
     345        { 
     346                return _wM.get(objectName); 
     347        } 
     348         
     349        private ArrayList<SubstitutionSet> MatchLiteralList(ArrayList<Symbol> literals, int index, KnowledgeSlot ks) { 
     350                Symbol l; 
     351                String key; 
     352                ArrayList<SubstitutionSet> bindingSets; 
     353                ArrayList<SubstitutionSet> newBindingSets; 
     354                SubstitutionSet subSet; 
     355                ListIterator<SubstitutionSet> li; 
     356                Iterator<String> it; 
     357 
     358                newBindingSets = new ArrayList<SubstitutionSet>(); 
     359 
     360                if (index >= literals.size()) { 
     361                        newBindingSets.add(new SubstitutionSet()); 
     362                        return newBindingSets; 
     363                } 
     364 
     365                synchronized (this) { 
     366                        l = (Symbol) literals.get(index++); 
     367 
     368                        if (l.isGrounded()) { 
     369                                if (ks.containsKey(l.toString())) { 
     370                                        return MatchLiteralList(literals, index, ks.get(l.toString())); 
     371                                } else 
     372                                        return null; 
     373                        } 
     374 
     375                        it = ks.getKeyIterator(); 
     376                        while (it.hasNext()) { 
     377                                key = (String) it.next(); 
     378                                bindingSets = MatchLiteralList(literals, index, ks.get(key)); 
     379                                if (bindingSets != null) { 
     380                                        li = bindingSets.listIterator(); 
     381                                        while (li.hasNext()) { 
     382                                                subSet = (SubstitutionSet) li.next(); 
     383                                                subSet.AddSubstitution(new Substitution(l, new Symbol( 
     384                                                                key))); 
     385                                                newBindingSets.add(subSet); 
     386                                        } 
     387                                } 
     388                        } 
     389                } 
     390 
     391                if (newBindingSets.size() == 0) 
     392                        return null; 
     393                else 
     394                        return newBindingSets; 
     395        } 
     396         
    319397        /** 
    320398         * Converts the Information stored in the WM to one String 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/sensorEffector/RemoteAgent.java

    r209 r231  
    528528                SendAction(rAction); 
    529529 
     530                System.out.println("Sent action for execution"); 
    530531                AgentLogger.GetInstance().logAndPrint("Cannot act now!"); 
    531532                 
Note: See TracChangeset for help on using the changeset viewer.