Changeset 12959


Ignore:
Timestamp:
10/08/10 22:08:43 (12 years ago)
Author:
ehuelsmann
Message:

Remove as much synchronization as possible from package symbols
tables, in order to prevent synchronization to kick in on each
FIND-SYMBOL call.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/abcl/src/org/armedbear/lisp/Package.java

    r12713 r12959  
    3737
    3838import java.util.ArrayList;
     39import java.util.Collection;
    3940import java.util.HashMap;
    4041import java.util.Iterator;
    4142import java.util.List;
     43import java.util.concurrent.ConcurrentHashMap;
    4244
    4345public final class Package extends LispObject implements java.io.Serializable
     
    4850    private transient LispObject propertyList;
    4951
    50     private transient final SymbolHashTable internalSymbols = new SymbolHashTable(16);
    51     private transient final SymbolHashTable externalSymbols = new SymbolHashTable(16);
     52    private transient final ConcurrentHashMap<String, Symbol> internalSymbols
     53            = new ConcurrentHashMap<String, Symbol>(16);
     54    private transient final ConcurrentHashMap<String, Symbol> externalSymbols
     55            = new ConcurrentHashMap<String, Symbol>(16);
    5256
    5357    private transient HashMap<String,Symbol> shadowingSymbols;
     
    142146        if (name != null) {
    143147            Packages.deletePackage(this);
    144             List internals = internalSymbols.getSymbols();
    145             for (int i = internals.size(); i-- > 0;) {
    146                 Symbol symbol = (Symbol) internals.get(i);
    147                 if (symbol.getPackage() == this)
    148                     symbol.setPackage(NIL);
    149                 internalSymbols.remove(symbol);
    150             }
    151             List externals = externalSymbols.getSymbols();
    152             for (int i = externals.size(); i-- > 0;) {
    153                 Symbol symbol = (Symbol) externals.get(i);
    154                 if (symbol.getPackage() == this)
    155                     symbol.setPackage(NIL);
    156                 externalSymbols.remove(symbol);
    157             }
     148            internalSymbols.clear();
     149            externalSymbols.clear();
     150
    158151            name = null;
    159152            lispName = null;
    160153            nicknames = null;
     154           
    161155            return true;
    162156        }
     
    184178    }
    185179
    186     public synchronized Symbol findInternalSymbol(SimpleString name)
    187     {
    188         return internalSymbols.get(name);
    189     }
    190 
    191     public synchronized Symbol findExternalSymbol(SimpleString name)
    192     {
    193         return externalSymbols.get(name);
    194     }
    195 
    196     public synchronized Symbol findExternalSymbol(SimpleString name, int hash)
    197     {
    198         return externalSymbols.get(name, hash);
     180    public Symbol findInternalSymbol(SimpleString name)
     181    {
     182        return internalSymbols.get(name.toString());
     183    }
     184
     185    public Symbol findExternalSymbol(SimpleString name)
     186    {
     187        return externalSymbols.get(name.toString());
     188    }
     189
     190    public Symbol findExternalSymbol(SimpleString name, int hash)
     191    {
     192        return externalSymbols.get(name.toString());
    199193    }
    200194
    201195    // Returns null if symbol is not accessible in this package.
    202     public synchronized Symbol findAccessibleSymbol(String name)
     196    public Symbol findAccessibleSymbol(String name)
    203197
    204198    {
     
    207201
    208202    // Returns null if symbol is not accessible in this package.
    209     public synchronized Symbol findAccessibleSymbol(SimpleString name)
     203    public Symbol findAccessibleSymbol(SimpleString name)
    210204
    211205    {
    212206        // Look in external and internal symbols of this package.
    213         Symbol symbol = externalSymbols.get(name);
     207        Symbol symbol = externalSymbols.get(name.toString());
    214208        if (symbol != null)
    215209            return symbol;
    216         symbol = internalSymbols.get(name);
     210        symbol = internalSymbols.get(name.toString());
    217211        if (symbol != null)
    218212            return symbol;
     
    232226    }
    233227
    234     public synchronized LispObject findSymbol(String name)
     228    public LispObject findSymbol(String name)
    235229
    236230    {
     
    238232        final LispThread thread = LispThread.currentThread();
    239233        // Look in external and internal symbols of this package.
    240         Symbol symbol = externalSymbols.get(s);
     234        Symbol symbol = externalSymbols.get(name);
    241235        if (symbol != null)
    242236            return thread.setValues(symbol, Keyword.EXTERNAL);
    243         symbol = internalSymbols.get(s);
     237        symbol = internalSymbols.get(name);
    244238        if (symbol != null)
    245239            return thread.setValues(symbol, Keyword.INTERNAL);
     
    260254
    261255    // Helper function to add NIL to PACKAGE_CL.
    262     public synchronized void addSymbol(Symbol symbol)
     256    public void addSymbol(Symbol symbol)
    263257    {
    264258        Debug.assertTrue(symbol.getPackage() == this);
    265259        Debug.assertTrue(symbol.getName().equals("NIL"));
    266         externalSymbols.put(symbol.name, symbol);
    267     }
    268 
    269     private synchronized Symbol addSymbol(SimpleString name, int hash)
    270     {
    271         Symbol symbol = new Symbol(name, hash, this);
     260        externalSymbols.put(symbol.name.toString(), symbol);
     261    }
     262
     263    private Symbol addSymbol(String name)
     264    {
     265        Symbol symbol = new Symbol(name, this);
    272266        if (this == PACKAGE_KEYWORD) {
    273267            symbol.initializeConstant(symbol);
    274             externalSymbols.put(name, symbol);
     268            externalSymbols.put(name.toString(), symbol);
    275269        } else
    276             internalSymbols.put(name, symbol);
     270            internalSymbols.put(name.toString(), symbol);
    277271       
    278272        return symbol;
    279273    }
    280274
    281     public synchronized Symbol addInternalSymbol(String symbolName)
     275    private Symbol addSymbol(SimpleString name)
     276    {
     277        return addSymbol(name.toString());
     278    }
     279
     280    public Symbol addInternalSymbol(String symbolName)
    282281    {
    283282        final Symbol symbol = new Symbol(symbolName, this);
    284         internalSymbols.put(symbol);
     283        internalSymbols.put(symbolName, symbol);
    285284        return symbol;
    286285    }
    287286
    288     public synchronized Symbol addExternalSymbol(String symbolName)
     287    public Symbol addExternalSymbol(String symbolName)
    289288    {
    290289        final Symbol symbol = new Symbol(symbolName, this);
    291         externalSymbols.put(symbol);
     290        externalSymbols.put(symbolName, symbol);
    292291        return symbol;
    293292    }
    294293
     294    public synchronized Symbol intern(SimpleString symbolName)
     295    {
     296        return intern(symbolName.toString());
     297    }
     298
    295299    public synchronized Symbol intern(String symbolName)
    296300    {
    297         return intern(new SimpleString(symbolName));
    298     }
    299 
    300     public synchronized Symbol intern(SimpleString symbolName)
    301     {
    302         final int hash = symbolName.sxhash();
    303301        // Look in external and internal symbols of this package.
    304         Symbol symbol = externalSymbols.get(symbolName, hash);
     302        Symbol symbol = externalSymbols.get(symbolName);
    305303        if (symbol != null)
    306304            return symbol;
    307         symbol = internalSymbols.get(symbolName, hash);
     305        symbol = internalSymbols.get(symbolName);
    308306        if (symbol != null)
    309307            return symbol;
     
    313311            while (usedPackages != NIL) {
    314312                Package pkg = (Package) usedPackages.car();
    315                 symbol = pkg.findExternalSymbol(symbolName, hash);
     313                symbol = pkg.externalSymbols.get(symbolName);
    316314                if (symbol != null)
    317315                    return symbol;
     
    320318        }
    321319        // Not found.
    322         return addSymbol(symbolName, hash);
     320        return addSymbol(symbolName);
    323321    }
    324322
     
    326324                                      final LispThread thread)
    327325    {
    328         final int hash = s.sxhash();
    329326        // Look in external and internal symbols of this package.
    330         Symbol symbol = externalSymbols.get(s, hash);
     327        Symbol symbol = externalSymbols.get(s.toString());
    331328        if (symbol != null)
    332329            return (Symbol) thread.setValues(symbol, Keyword.EXTERNAL);
    333         symbol = internalSymbols.get(s, hash);
     330        symbol = internalSymbols.get(s.toString());
    334331        if (symbol != null)
    335332            return (Symbol) thread.setValues(symbol, Keyword.INTERNAL);
     
    339336            while (usedPackages != NIL) {
    340337                Package pkg = (Package) usedPackages.car();
    341                 symbol = pkg.findExternalSymbol(s, hash);
     338                symbol = pkg.findExternalSymbol(s);
    342339                if (symbol != null)
    343340                    return (Symbol) thread.setValues(symbol, Keyword.INHERITED);
     
    346343        }
    347344        // Not found.
    348         return (Symbol) thread.setValues(addSymbol(s, hash), NIL);
     345        return (Symbol) thread.setValues(addSymbol(s), NIL);
    349346    }
    350347
     
    353350    {
    354351        final SimpleString s = new SimpleString(symbolName);
    355         final int hash = s.sxhash();
    356352        // Look in external and internal symbols of this package.
    357         Symbol symbol = externalSymbols.get(s, hash);
     353        Symbol symbol = externalSymbols.get(s.toString());
    358354        if (symbol != null)
    359355            return symbol;
    360         symbol = internalSymbols.get(s, hash);
     356        symbol = internalSymbols.get(s.toString());
    361357        if (symbol != null) {
    362358            export(symbol);
     
    368364            while (usedPackages != NIL) {
    369365                Package pkg = (Package) usedPackages.car();
    370                 symbol = pkg.findExternalSymbol(s, hash);
     366                symbol = pkg.findExternalSymbol(s);
    371367                if (symbol != null) {
    372368                    export(symbol);
     
    377373        }
    378374        // Not found.
    379         symbol = new Symbol(s, hash, this);
     375        symbol = new Symbol(s, this);
    380376        if (this == PACKAGE_KEYWORD)
    381377            symbol.initializeConstant(symbol);
    382         externalSymbols.put(s, symbol);
     378        externalSymbols.put(s.toString(), symbol);
    383379        return symbol;
    384380    }
     
    421417        }
    422418        // Reaching here, it's OK to remove the symbol.
    423         if (internalSymbols.get(symbol.name) == symbol)
    424             internalSymbols.remove(symbol.name);
    425         else if (externalSymbols.get(symbol.name) == symbol)
    426             externalSymbols.remove(symbol.name);
     419        if (internalSymbols.get(symbol.name.toString()) == symbol)
     420            internalSymbols.remove(symbol.name.toString());
     421        else if (externalSymbols.get(symbol.name.toString()) == symbol)
     422            externalSymbols.remove(symbol.name.toString());
    427423        else
    428424            // Not found.
     
    450446            error(new PackageError(sb.toString()));
    451447        }
    452         internalSymbols.put(symbol.name, symbol);
     448        internalSymbols.put(symbol.name.toString(), symbol);
    453449        if (symbol.getPackage() == NIL)
    454450            symbol.setPackage(this);
     
    470466                return;
    471467            }
    472             internalSymbols.put(symbol.name, symbol);
     468            internalSymbols.put(symbol.name.toString(), symbol);
    473469            added = true;
    474470        }
    475         if (added || internalSymbols.get(symbol.name) == symbol) {
     471        if (added || internalSymbols.get(symbol.name.toString()) == symbol) {
    476472            if (usedByList != null) {
    477473                for (Iterator it = usedByList.iterator(); it.hasNext();) {
     
    495491            }
    496492            // No conflicts.
    497             internalSymbols.remove(symbol.name);
    498             externalSymbols.put(symbol.name, symbol);
     493            internalSymbols.remove(symbol.name.toString());
     494            externalSymbols.put(symbol.name.toString(), symbol);
    499495            return;
    500496        }
    501         if (externalSymbols.get(symbol.name) == symbol)
     497        if (externalSymbols.get(symbol.name.toString()) == symbol)
    502498            // Symbol is already exported; there's nothing to do.
    503499            return;
     
    514510    {
    515511        if (symbol.getPackage() == this) {
    516             if (externalSymbols.get(symbol.name) == symbol) {
    517                 externalSymbols.remove(symbol.name);
    518                 internalSymbols.put(symbol.name, symbol);
     512            if (externalSymbols.get(symbol.name.toString()) == symbol) {
     513                externalSymbols.remove(symbol.name.toString());
     514                internalSymbols.put(symbol.name.toString(), symbol);
    519515            }
    520516        } else {
     
    543539            shadowingSymbols = new HashMap<String,Symbol>();
    544540        final SimpleString s = new SimpleString(symbolName);
    545         Symbol symbol = externalSymbols.get(s);
     541        Symbol symbol = externalSymbols.get(s.toString());
    546542        if (symbol != null) {
    547543            shadowingSymbols.put(symbolName, symbol);
    548544            return;
    549545        }
    550         symbol = internalSymbols.get(s);
     546        symbol = internalSymbols.get(s.toString());
    551547        if (symbol != null) {
    552548            shadowingSymbols.put(symbolName, symbol);
     
    556552            return;
    557553        symbol = new Symbol(s, this);
    558         internalSymbols.put(s, symbol);
     554        internalSymbols.put(s.toString(), symbol);
    559555        shadowingSymbols.put(symbolName, symbol);
    560556    }
     
    564560        LispObject where = NIL;
    565561        final String symbolName = symbol.getName();
    566         Symbol sym = externalSymbols.get(symbol.name);
     562        Symbol sym = externalSymbols.get(symbol.name.toString());
    567563        if (sym != null) {
    568564            where = Keyword.EXTERNAL;
    569565        } else {
    570             sym = internalSymbols.get(symbol.name);
     566            sym = internalSymbols.get(symbol.name.toString());
    571567            if (sym != null) {
    572568                where = Keyword.INTERNAL;
     
    601597            }
    602598        }
    603         internalSymbols.put(symbol.name, symbol);
     599        internalSymbols.put(symbol.name.toString(), symbol);
    604600        if (shadowingSymbols == null)
    605601            shadowingSymbols = new HashMap<String,Symbol>();
     
    618614            // "USE-PACKAGE checks for name conflicts between the newly
    619615            // imported symbols and those already accessible in package."
    620             List symbols = pkg.getExternalSymbols();
    621             for (int i = symbols.size(); i-- > 0;) {
    622                 Symbol symbol = (Symbol) symbols.get(i);
     616            Collection symbols = pkg.getExternalSymbols();
     617            for (Iterator<Symbol> i = symbols.iterator(); i.hasNext();) {
     618                Symbol symbol = i.next();
    623619                Symbol existing = findAccessibleSymbol(symbol.name);
    624620                if (existing != null && existing != symbol) {
     
    732728    }
    733729
    734     public synchronized List getExternalSymbols()
    735     {
    736         return externalSymbols.getSymbols();
     730    public synchronized Collection getExternalSymbols()
     731    {
     732        return externalSymbols.values();
    737733    }
    738734
     
    740736    {
    741737        ArrayList<Symbol> list = new ArrayList<Symbol>();
    742         list.addAll(internalSymbols.getSymbols());
    743         list.addAll(externalSymbols.getSymbols());
     738        list.addAll(internalSymbols.values());
     739        list.addAll(externalSymbols.values());
    744740        if (useList instanceof Cons) {
    745741            LispObject usedPackages = useList;
    746742            while (usedPackages != NIL) {
    747743                Package pkg = (Package) usedPackages.car();
    748                 List<Symbol> symbols = pkg.externalSymbols.getSymbols();
    749                 for (int i = 0; i < symbols.size(); i++) {
    750                     Symbol symbol = (Symbol) symbols.get(i);
    751                     if (shadowingSymbols == null || shadowingSymbols.get(symbol.getName()) == null)
    752                         list.add(symbol);
    753                 }
     744                list.addAll(pkg.externalSymbols.values());
     745
    754746                usedPackages = usedPackages.cdr();
    755747            }
     
    761753    {
    762754        LispObject list = NIL;
    763         List symbols = internalSymbols.getSymbols();
    764         for (int i = symbols.size(); i-- > 0;)
    765             list = new Cons((Symbol)symbols.get(i), list);
     755        Collection symbols = internalSymbols.values();
     756        for (Iterator<Symbol> i = symbols.iterator(); i.hasNext();)
     757            list = new Cons(i.next(), list);
    766758        return list;
    767759    }
     
    770762    {
    771763        LispObject list = NIL;
    772         List symbols = externalSymbols.getSymbols();
    773         for (int i = symbols.size(); i-- > 0;)
    774             list = new Cons((Symbol)symbols.get(i), list);
     764        Collection symbols = externalSymbols.values();
     765        for (Iterator<Symbol> i = symbols.iterator(); i.hasNext();)
     766            list = new Cons(i.next(), list);
    775767        return list;
    776768    }
     
    783775            while (usedPackages != NIL) {
    784776                Package pkg = (Package) usedPackages.car();
    785                 List externals = pkg.getExternalSymbols();
    786                 for (int i = externals.size(); i-- > 0;) {
    787                     Symbol symbol = (Symbol) externals.get(i);
     777                Collection externals = pkg.getExternalSymbols();
     778                for (Iterator<Symbol> i = externals.iterator(); i.hasNext();) {
     779                    Symbol symbol = i.next();
    788780                    if (shadowingSymbols != null && shadowingSymbols.get(symbol.getName()) != null)
    789781                        continue;
    790                     if (externalSymbols.get(symbol.name) == symbol)
     782                    if (externalSymbols.get(symbol.name.toString()) == symbol)
    791783                        continue;
    792784                    list = new Cons(symbol, list);
     
    801793    {
    802794        LispObject list = NIL;
    803         List internals = internalSymbols.getSymbols();
    804         for (int i = internals.size(); i-- > 0;)
    805             list = new Cons((Symbol)internals.get(i), list);
    806         List externals = externalSymbols.getSymbols();
    807         for (int i = externals.size(); i-- > 0;)
    808             list = new Cons((Symbol)externals.get(i), list);
     795        Collection internals = internalSymbols.values();
     796        for (Iterator<Symbol> i = internals.iterator(); i.hasNext();)
     797            list = new Cons(i.next(), list);
     798        Collection externals = externalSymbols.values();
     799        for (Iterator<Symbol> i = externals.iterator(); i.hasNext();)
     800            list = new Cons(i.next(), list);
    809801        return list;
    810802    }
     
    812804    public synchronized Symbol[] symbols()
    813805    {
    814         List internals = internalSymbols.getSymbols();
    815         List externals = externalSymbols.getSymbols();
     806        Collection internals = internalSymbols.values();
     807        Collection externals = externalSymbols.values();
    816808        Symbol[] array = new Symbol[internals.size() + externals.size()];
    817809        int i = 0;
Note: See TracChangeset for help on using the changeset viewer.