Changeset f7751de


Ignore:
Timestamp:
Jun 10, 2011 9:59:42 PM (9 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
3f5022c
Parents:
194bd25 (diff), 0b4e430 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

propagate from branch 'i2p.cpuid' (head be49d2042be9311c16ec5cc4b5accd1366b93556)

to branch 'i2p.i2p' (head 0d92feaa69315781a8e98190c6d11b6b91355f8b)

Files:
15 added
6 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/freenet/support/CPUInformation/AMDCPUInfo.java

    r194bd25 rf7751de  
    1717public interface AMDCPUInfo extends CPUInfo {
    1818    /**
    19      * @return true iff the CPU present in the machine is at least an 'k6' CPU
     19     * @return true if the CPU present in the machine is at least an 'k6' CPU
    2020     */
    2121    public boolean IsK6Compatible();
    2222    /**
    23      * @return true iff the CPU present in the machine is at least an 'k6-2' CPU
     23     * @return true if the CPU present in the machine is at least an 'k6-2' CPU
    2424     */
    2525    public boolean IsK6_2_Compatible();
    2626    /**
    27      * @return true iff the CPU present in the machine is at least an 'k6-3' CPU
     27     * @return true if the CPU present in the machine is at least an 'k6-3' CPU
    2828     */
    2929    public boolean IsK6_3_Compatible();
    30 
    3130    /**
    32      * @return true iff the CPU present in the machine is at least an 'k7' CPU (Atlhon, Duron etc. and better)
     31     * @return true if the CPU present in the machine is at least an 'geode' CPU
     32     */
     33    boolean IsGeodeCompatible();
     34    /**
     35     * @return true if the CPU present in the machine is at least an 'k7' CPU (Atlhon, Duron etc. and better)
    3336     */
    3437    public boolean IsAthlonCompatible();
    3538    /**
    36      * @return true iff the CPU present in the machine is at least an 'k8' CPU (Atlhon 64, Opteron etc. and better)
     39     * @return true if the CPU present in the machine is at least an 'k8' CPU (Atlhon 64, Opteron etc. and better)
    3740     */
    3841    public boolean IsAthlon64Compatible();
     42    /**
     43     * @return true if the CPU present in the machine is at least an 'k8' CPU (Atlhon 64, Opteron etc. and better)
     44     */
     45        public boolean IsBobcatCompatible();
    3946}
  • core/java/src/freenet/support/CPUInformation/CPUID.java

    r194bd25 rf7751de  
    1010import java.io.InputStream;
    1111import java.net.URL;
     12import java.util.HashMap;
    1213
    1314import net.i2p.I2PAppContext;
    1415import net.i2p.util.FileUtil;
     16
    1517
    1618/**
     
    5456    private static final boolean isFreebsd = System.getProperty("os.name").toLowerCase().contains("freebsd");
    5557    private static final boolean isSunos = System.getProperty("os.name").toLowerCase().contains("sunos");
    56    
     58
     59
    5760    /**
    5861     * This isn't always correct.
     
    7174    {
    7275        loadNative();
    73     }
    74    
    75     /**
    76      * A class that can (amongst other things I assume) represent the state of the
    77      * different CPU registers after a call to the CPUID assembly method
    78      */
     76    }   
     77    //A class that can (amongst other things I assume) represent the state of the
     78    //different CPU registers after a call to the CPUID assembly method
    7979    protected static class CPUIDResult {
    8080        final int EAX;
     
    9898    private static native CPUIDResult doCPUID(int iFunction);
    9999
    100     private static String getCPUVendorID()
     100
     101    public static String getCPUVendorID()
    101102    {
    102103        CPUIDResult c = doCPUID(0);
     
    119120        return sb.toString();
    120121    }
    121     private static int getCPUFamily()
     122    public static int getCPUFamily()
    122123    {
    123124        CPUIDResult c = doCPUID(1);
    124125        return (c.EAX >> 8) & 0xf;
    125126    }
    126     private static int getCPUModel()
     127    public static int getCPUModel()
    127128    {
    128129        CPUIDResult c = doCPUID(1);
    129130        return (c.EAX >> 4) & 0xf;
    130131    }
    131     private static int getCPUExtendedModel()
     132    public static int getCPUExtendedModel()
    132133    {
    133134        CPUIDResult c = doCPUID(1);
    134135        return (c.EAX >> 16) & 0xf;
    135136    }
    136     private static int getCPUType()
     137    public static int getCPUType()
    137138    {
    138139        CPUIDResult c = doCPUID(1);
    139140        return (c.EAX >> 12) & 0xf;
    140141    }
    141     private static int getCPUExtendedFamily()
     142    public static int getCPUExtendedFamily()
    142143    {
    143144        CPUIDResult c = doCPUID(1);
    144145        return (c.EAX >> 20) & 0xff;
    145146    }
    146     private static int getCPUStepping()
     147    public static int getCPUStepping()
    147148    {
    148149        CPUIDResult c = doCPUID(1);
    149150        return c.EAX & 0xf;
    150151    }
    151     private static int getEDXCPUFlags()
     152    public static int getEDXCPUFlags()
    152153    {
    153154        CPUIDResult c = doCPUID(1);
    154155        return c.EDX;
    155156    }
    156     private static int getECXCPUFlags()
     157    public static int getECXCPUFlags()
    157158    {
    158159        CPUIDResult c = doCPUID(1);
    159160        return c.ECX;
    160161    }
    161     private static int getExtendedEDXCPUFlags()
     162    public static int getExtendedEBXCPUFlags()
     163    {
     164        CPUIDResult c = doCPUID(0x80000001);
     165        return c.EBX;   
     166    }
     167    public static int getExtendedECXCPUFlags()
     168    {
     169        CPUIDResult c = doCPUID(0x80000001);
     170        return c.ECX;
     171    }
     172    public static int getExtendedEDXCPUFlags()
    162173    {
    163174        CPUIDResult c = doCPUID(0x80000001);
    164175        return c.EDX;
    165176    }
    166     private static int getExtendedECXCPUFlags()
    167     {
    168         CPUIDResult c = doCPUID(0x80000001);
    169         return c.ECX;
    170     }
    171    
    172     /**
    173      * Returns a CPUInfo item for the current type of CPU
    174      * If I could I would declare this method in a interface named
    175      * CPUInfoProvider and implement that interface in this class.
    176      * This would make it easier for other people to understand that there
    177      * is nothing preventing them from coding up new providers, probably using
    178      * other detection methods than the x86-only CPUID instruction
    179      */
     177   
     178    //Returns a CPUInfo item for the current type of CPU
     179    //If I could I would declare this method in a interface named
     180    //CPUInfoProvider and implement that interface in this class.
     181    //This would make it easier for other people to understand that there
     182    //is nothing preventing them from coding up new providers, probably using
     183    //other detection methods than the x86-only CPUID instruction
    180184    public static CPUInfo getInfo() throws UnknownCPUException
    181185    {
     
    183187            throw new UnknownCPUException("Failed to read CPU information from the system. Please verify the existence of the jcpuid dll/so.");
    184188        if(getCPUVendorID().equals("CentaurHauls"))
    185             return new VIAC3Impl();
     189            return new VIAInfoImpl();
    186190        if(!isX86)
    187191            throw new UnknownCPUException("Failed to read CPU information from the system. The CPUID instruction exists on x86 CPU's only");
     
    193197    }
    194198   
    195     protected abstract static class CPUIDCPUInfo
    196     {
    197         public String getVendor()
    198         {
    199             return getCPUVendorID();
    200         }
    201         public boolean hasMMX(){
    202             return (getEDXCPUFlags() & 0x800000) >0; //EDX Bit 23
    203         }
    204         public boolean hasSSE(){
    205             return (getEDXCPUFlags() & 0x2000000) >0; //EDX Bit 25
    206         }
    207         public boolean hasSSE2(){
    208             return (getEDXCPUFlags() & 0x4000000) >0; //EDX Bit 26
    209         }
    210         public boolean hasSSE3(){
    211             return (getEDXCPUFlags() & 0x1) >0; //ECX Bit 0
    212         }
    213         public boolean hasSSE41(){
    214             return (getEDXCPUFlags() & 0x80000) >0; //ECX Bit 19
    215         }
    216         public boolean hasSSE42(){
    217             return (getEDXCPUFlags() & 0x100000) >0; //ECX Bit 20
    218         }
    219         public boolean hasSSE4A(){
    220             return (getExtendedECXCPUFlags() & 0x40) >0; //Extended ECX Bit 6
    221         }
    222         public boolean IsC3Compatible() { return false; }
    223     }
    224     protected static class VIAC3Impl extends CPUIDCPUInfo implements CPUInfo {
    225         @Override
    226         public boolean IsC3Compatible() { return true; }
    227         public String getCPUModelString() { return "VIA C3"; }
    228     }
    229     protected static class AMDInfoImpl extends CPUIDCPUInfo implements AMDCPUInfo
    230     {
    231         public boolean IsK6Compatible()
    232         {
    233             return getCPUFamily() >= 5 && getCPUModel() >= 6;
    234         }
    235         public boolean IsK6_2_Compatible()
    236         {
    237             return getCPUFamily() >= 5 && getCPUModel() >= 8;
    238         }
    239         public boolean IsK6_3_Compatible()
    240         {
    241             return getCPUFamily() >= 5 && getCPUModel() >= 9;
    242         }
    243         public boolean IsAthlonCompatible()
    244         {
    245             return getCPUFamily() >= 6;
    246         }
    247         public boolean IsAthlon64Compatible()
    248         {
    249             return getCPUFamily() == 15 && getCPUExtendedFamily() == 0;
    250         }
    251 
    252         public String getCPUModelString() throws UnknownCPUException
    253         {
    254             if(getCPUFamily() == 4){
    255                 switch(getCPUModel()){
    256                     case 3:
    257                         return "486 DX/2";
    258                     case 7:
    259                         return "486 DX/2-WB";
    260                     case 8:
    261                         return "486 DX/4";
    262                     case 9:
    263                         return "486 DX/4-WB";
    264                     case 14:
    265                         return "Am5x86-WT";
    266                     case 15:
    267                         return "Am5x86-WB";
    268                 }
    269             }
    270             if(getCPUFamily() == 5){
    271                 switch(getCPUModel()){
    272                     case 0:
    273                         return "K5/SSA5";
    274                     case 1:
    275                         return "K5";
    276                     case 2:
    277                         return "K5";
    278                     case 3:
    279                         return "K5";
    280                     case 6:
    281                         return "K6";
    282                     case 7:
    283                         return "K6";
    284                     case 8:
    285                         return "K6-2";
    286                     case 9:
    287                         return "K6-3";
    288                     case 13:
    289                         return "K6-2+ or K6-III+";
    290                 }
    291             }
    292             if(getCPUFamily() == 6){
    293                 switch(getCPUModel()){
    294                     case 0:
    295                         return "Athlon (250 nm)";
    296                     case 1:
    297                         return "Athlon (250 nm)";
    298                     case 2:
    299                         return "Athlon (180 nm)";
    300                     case 3:
    301                         return "Duron";
    302                     case 4:
    303                         return "Athlon (Thunderbird)";
    304                     case 6:
    305                         return "Athlon (Palamino)";
    306                     case 7:
    307                         return "Duron (Morgan)";
    308                     case 8:
    309                         return "Athlon (Thoroughbred)";
    310                     case 10:
    311                         return "Athlon (Barton)";
    312                 }
    313             }
    314             if(getCPUFamily() == 15){
    315                 if(getCPUExtendedFamily() == 0){
    316                     switch(getCPUModel()){
    317                         case 4:
    318                             return "Athlon 64";
    319                         case 5:
    320                             return "Athlon 64 FX Opteron";
    321                         case 12:
    322                             return "Athlon 64";
    323                         default: // is this safe?
    324                             return "Athlon 64 (unknown)";
    325                     }
    326                 }
    327             }
    328             throw new UnknownCPUException("Unknown AMD CPU; Family="+getCPUFamily()+", Model="+getCPUModel());
    329         }
    330     }
    331 
    332     protected static class IntelInfoImpl extends CPUIDCPUInfo implements IntelCPUInfo
    333     {
    334         public boolean IsPentiumCompatible()
    335         {
    336             return getCPUFamily() >= 5;
    337         }
    338         public boolean IsPentiumMMXCompatible()
    339         {
    340             return IsPentium2Compatible() || (getCPUFamily() == 5 && (getCPUModel() ==4 || getCPUModel() == 8));
    341         }
    342         public boolean IsPentium2Compatible()
    343         {
    344             return getCPUFamily() > 6 || (getCPUFamily() == 6 && getCPUModel() >=3);
    345         }
    346         public boolean IsPentium3Compatible()
    347         {       
    348                 // Atom
    349                 if (getCPUExtendedModel() == 1 && (getCPUFamily() == 6 && (getCPUModel() == 12))){
    350                         return true;
    351                 // ??
    352                 } else if (getCPUExtendedModel() == 0 && (getCPUFamily() > 6 || (getCPUFamily() == 6 && getCPUModel() >=7))){
    353                         return true;
    354                 } else {
    355                         return false;
    356                 }
    357         }
    358         public boolean IsPentium4Compatible()
    359         {       
    360                 // P4
    361                 if (getCPUFamily() >= 15){
    362                         return true;
    363                 // Xeon MP (45nm) or Core i7
    364                 } else if (getCPUExtendedModel() == 1 && (getCPUFamily() == 6 && (getCPUModel() == 10 || getCPUModel() == 13))){
    365                         return true;
    366                 // Core 2 Duo
    367                 } else if (getCPUExtendedModel() == 0 && getCPUFamily() == 6 && getCPUModel() == 15){
    368                         return true;
    369                 } else {
    370                         return false;
    371                 }
    372         }
    373         public String getCPUModelString() throws UnknownCPUException {
    374                 if (getCPUExtendedModel() == 0){
    375                     if(getCPUFamily() == 4){
    376                         switch(getCPUModel()){
    377                             case 0:
    378                                 return "486 DX-25/33";
    379                             case 1:
    380                                 return "486 DX-50";
    381                             case 2:
    382                                 return "486 SX";
    383                             case 3:
    384                                 return "486 DX/2";
    385                             case 4:
    386                                 return "486 SL";
    387                             case 5:
    388                                 return "486 SX/2";
    389                             case 7:
    390                                 return "486 DX/2-WB";
    391                             case 8:
    392                                 return "486 DX/4";
    393                             case 9:
    394                                 return "486 DX/4-WB";
    395                         }
    396                     }
    397                 }
    398             if (getCPUExtendedModel() == 0){
    399                     if(getCPUFamily() == 5){
    400                         switch(getCPUModel()){
    401                             case 0:
    402                                 return "Pentium 60/66 A-step";
    403                             case 1:
    404                                 return "Pentium 60/66";
    405                             case 2:
    406                                 return "Pentium 75 - 200";
    407                             case 3:
    408                                 return "OverDrive PODP5V83";
    409                             case 4:
    410                                 return "Pentium MMX";
    411                             case 7:
    412                                 return "Mobile Pentium 75 - 200";
    413                             case 8:
    414                                 return "Mobile Pentium MMX";
    415                         }
    416                     }
    417             }
    418             if(getCPUFamily() == 6){
    419                 if (getCPUExtendedModel() == 0){
    420                         switch(getCPUModel()){
    421                             case 0:
    422                                 return "Pentium Pro A-step";
    423                             case 1:
    424                                 return "Pentium Pro";
    425                             case 3:
    426                                 return "Pentium II (Klamath)";
    427                             case 5:
    428                                 return "Pentium II (Deschutes), Celeron (Covington), Mobile Pentium II (Dixon)";
    429                             case 6:
    430                                 return "Mobile Pentium II, Celeron (Mendocino)";
    431                             case 7:
    432                                 return "Pentium III (Katmai)";
    433                             case 8:
    434                                 return "Pentium III (Coppermine), Celeron w/SSE";
    435                             case 9:
    436                                 return "Mobile Pentium III (Banias)";
    437                             case 10:
    438                                 return "Pentium III Xeon (Cascades)";
    439                             case 11:
    440                                 return "Pentium III (130 nm)";
    441                             case 13:
    442                                 return "Mobile Pentium III (Dothan)";
    443                             case 14:
    444                                 return "Mobile Core (Yonah)";
    445                             case 15:
    446                                 return "Core 2 (Conroe)";
    447                         }
    448                 } else {
    449                         if (getCPUExtendedModel() == 1){
    450                                  switch(getCPUModel()){
    451                                         case 10:
    452                                                 return "Core i7";
    453                                         case 12:
    454                                                 return "Atom";
    455                                         case 13:
    456                                                 return "Xeon MP";
    457                                  }
    458                         }
    459                 }
    460             }
    461             if(getCPUFamily() == 7){
    462                 switch(getCPUModel()){
    463                     //Itanium.. TODO
    464                 }
    465             }
    466             if(getCPUFamily() == 15){
    467                 if(getCPUExtendedFamily() == 0){
    468                     switch(getCPUModel()){
    469                         case 0:
    470                             return "Pentium IV (180 nm)";
    471                         case 1:
    472                             return "Pentium IV (180 nm)";
    473                         case 2:
    474                             return "Pentium IV (130 nm)";
    475                         case 3:
    476                             return "Pentium IV (90 nm)";
    477                         case 4:
    478                             return "Pentium IV (90 nm)";
    479                         case 6:
    480                             return "Pentium IV (65 nm)";
    481                     }
    482                 }
    483                 if(getCPUExtendedFamily() == 1){
    484                     switch(getCPUModel()){
    485                         //    Itanium 2.. TODO
    486                     }   
    487                 }
    488             }
    489             throw new UnknownCPUException("Unknown Intel CPU; Family="+getCPUFamily()+", Model="+getCPUModel());
    490         }
    491     }
    492199
    493200    public static void main(String args[])
     
    519226            System.out.println("  Is pIII-compatible: "+((IntelCPUInfo)c).IsPentium3Compatible());
    520227            System.out.println("  Is pIV-compatible: "+((IntelCPUInfo)c).IsPentium4Compatible());
     228            System.out.println("  Is atom-compatible: "+((IntelCPUInfo)c).IsAtomCompatible());
     229            System.out.println("  Is core2-compatible: "+((IntelCPUInfo)c).IsCore2Compatible());
     230            System.out.println("  Is corei-compatible: "+((IntelCPUInfo)c).IsCoreiCompatible());
    521231        }
    522232        if(c instanceof AMDCPUInfo){
     
    721431        if(isFreebsd)
    722432            return "jcpuid-x86-freebsd"; // The convention on freebsd...
    723         if(isSunos)
    724             return "jcpuid-x86-solaris"; // The convention on SunOS
     433        if(isSunos)
     434            return "jcpuid-x86-solaris"; // The convention on SunOS
    725435        //throw new RuntimeException("Dont know jcpuid library name for os type '"+System.getProperty("os.name")+"'");
    726436        // use linux as the default, don't throw exception
     
    734444        if(isFreebsd)
    735445            return "jcpuid-x86_64-freebsd";
    736         if(isSunos)
    737             return "jcpuid-x86_64-solaris";
     446        if(isSunos)
     447            return "jcpuid-x86_64-solaris";
    738448        // use linux as the default, don't throw exception
    739449        return "jcpuid-x86_64-linux";
  • core/java/src/freenet/support/CPUInformation/CPUInfo.java

    r194bd25 rf7751de  
    6262     */
    6363    public boolean hasSSE4A();
    64 
    65     public boolean IsC3Compatible();
    6664}
  • core/java/src/freenet/support/CPUInformation/IntelCPUInfo.java

    r194bd25 rf7751de  
    1717public interface IntelCPUInfo extends CPUInfo {
    1818    /**
    19      * @return true iff the CPU is at least a Pentium CPU.
     19     * @return true if the CPU is at least a Pentium CPU.
    2020     */
    2121    public boolean IsPentiumCompatible();
    2222    /**
    23      * @return true iff the CPU is at least a Pentium which implements the MMX instruction/feature set.
     23     * @return true if the CPU is at least a Pentium which implements the MMX instruction/feature set.
    2424     */
    2525    public boolean IsPentiumMMXCompatible();
    2626    /**
    27      * @return true iff the CPU implements at least the p6 instruction set (Pentium II or better).
     27     * @return true if the CPU implements at least the p6 instruction set (Pentium II or better).
    2828     * Please note that an PentimPro CPU causes/should cause this method to return false (due to that CPU using a
    2929     * very early implementation of the p6 instruction set. No MMX etc.)
     
    3131    public boolean IsPentium2Compatible();
    3232    /**
    33      * @return true iff the CPU implements at least a Pentium III level of the p6 instruction/feature set.
     33     * @return true if the CPU implements at least a Pentium III level of the p6 instruction/feature set.
    3434     */
    3535    public boolean IsPentium3Compatible();
    3636    /**
    37      * @return true iff the CPU implements at least a Pentium IV level instruction/feature set.
     37     * @return true if the CPU implements at least a Pentium IV level instruction/feature set.
    3838     */
    3939    public boolean IsPentium4Compatible();
     40    /**
     41     * @return true if the CPU implements at least a Pentium M level instruction/feature set.
     42     */
     43    public boolean IsPentiumMCompatible();     
     44    /**
     45     * @return true if the CPU implements at least a Atom level instruction/feature set.
     46     */
     47    public boolean IsAtomCompatible();
     48    /**
     49     * @return true if the CPU implements at least a Core2 level instruction/feature set.
     50     */
     51    public boolean IsCore2Compatible();
     52    /**
     53     * @return true if the CPU implements at least a Corei level instruction/feature set.
     54     */
     55    public boolean IsCoreiCompatible();
    4056}
  • core/java/src/freenet/support/CPUInformation/UnknownCPUException.java

    r194bd25 rf7751de  
    99 */
    1010public class UnknownCPUException extends RuntimeException {
    11     public UnknownCPUException() {
     11    /**
     12         *
     13         */
     14        private static final long serialVersionUID = 5166144274582583742L;
     15
     16        public UnknownCPUException() {
    1217        super();
    1318    }
  • core/java/src/net/i2p/util/NativeBigInteger.java

    r194bd25 rf7751de  
    2525import freenet.support.CPUInformation.CPUInfo;
    2626import freenet.support.CPUInformation.IntelCPUInfo;
     27import freenet.support.CPUInformation.VIACPUInfo;
    2728import freenet.support.CPUInformation.UnknownCPUException;
    2829
     
    125126    private final static String JBIGI_OPTIMIZATION_PENTIUM4   = "pentium4";
    126127    private final static String JBIGI_OPTIMIZATION_VIAC3      = "viac3";
    127     /** below here @since 0.8.7 */
     128    /**
     129     * The 7 optimizations below here are since 0.8.7. Each of the 32-bit processors below
     130     * needs an explicit fallback in getResourceList() or getMiddleName2().
     131     * 64-bit processors will fallback to athlon64 and athlon in getResourceList().
     132     * @since 0.8.7
     133     */
    128134    private final static String JBIGI_OPTIMIZATION_ATOM       = "atom";
    129135    private final static String JBIGI_OPTIMIZATION_CORE2      = "core2";
     
    132138    private final static String JBIGI_OPTIMIZATION_NANO       = "nano";
    133139    private final static String JBIGI_OPTIMIZATION_PENTIUMM   = "pentiumm";
     140    /** all libjbibi builds are identical to pentium3, case handled in getMiddleName2() */
    134141    private final static String JBIGI_OPTIMIZATION_VIAC32     = "viac32";
    135142
     
    189196                _cpuModel = c.getCPUModelString();
    190197            } catch (UnknownCPUException e) {}
    191             if (c.IsC3Compatible())
    192                 return JBIGI_OPTIMIZATION_VIAC3;
    193             if (c instanceof AMDCPUInfo) {
     198            if (c instanceof VIACPUInfo){
     199                VIACPUInfo viacpu = (VIACPUInfo) c;
     200                if (viacpu.IsNanoCompatible())
     201                    return JBIGI_OPTIMIZATION_NANO;
     202                return JBIGI_OPTIMIZATION_VIAC3;
     203            } else if(c instanceof AMDCPUInfo) {
    194204                AMDCPUInfo amdcpu = (AMDCPUInfo) c;
     205                // Supported in CPUID, no GMP support
     206                //if (amdcpu.IsBobcatCompatible())
     207                //    return JBIGI_OPTIMIZATION_BOBCAT;
    195208                if (amdcpu.IsAthlon64Compatible())
    196209                    return JBIGI_OPTIMIZATION_ATHLON64;
    197210                if (amdcpu.IsAthlonCompatible())
    198211                    return JBIGI_OPTIMIZATION_ATHLON;
     212                // FIXME lots of geodes, but GMP configures like a K6-3
     213                if (amdcpu.IsGeodeCompatible())
     214                    return JBIGI_OPTIMIZATION_GEODE;
    199215                if (amdcpu.IsK6_3_Compatible())
    200216                    return JBIGI_OPTIMIZATION_K6_3;
     
    205221            } else if (c instanceof IntelCPUInfo) {
    206222                IntelCPUInfo intelcpu = (IntelCPUInfo) c;
     223                if (intelcpu.IsCoreiCompatible())
     224                    return JBIGI_OPTIMIZATION_COREI;
     225                if (intelcpu.IsCore2Compatible())
     226                    return JBIGI_OPTIMIZATION_CORE2;
    207227                if (intelcpu.IsPentium4Compatible())
    208228                    return JBIGI_OPTIMIZATION_PENTIUM4;
     229                if (intelcpu.IsAtomCompatible())
     230                    return JBIGI_OPTIMIZATION_ATOM;
     231                if (intelcpu.IsPentiumMCompatible())
     232                    return JBIGI_OPTIMIZATION_PENTIUMM;
    209233                if (intelcpu.IsPentium3Compatible())
    210234                    return JBIGI_OPTIMIZATION_PENTIUM3;
     
    601625            // the preferred selection
    602626            rv.add(_libPrefix + getMiddleName1() + primary + _libSuffix);
     627
    603628            // athlon64 is always a fallback for 64 bit
    604629            if (_is64 && !primary.equals(JBIGI_OPTIMIZATION_ATHLON64))
    605630                rv.add(_libPrefix + getMiddleName1() + JBIGI_OPTIMIZATION_ATHLON64 + _libSuffix);
     631
    606632            // Add fallbacks for any 32-bit that were added 0.8.7 or later here
    607             if (primary.equals(JBIGI_OPTIMIZATION_ATOM))
     633            // FIXME lots of geodes, but GMP configures like a K6-3, so pentium3 is probably a good backup
     634            if (primary.equals(JBIGI_OPTIMIZATION_ATOM) ||
     635                primary.equals(JBIGI_OPTIMIZATION_PENTIUMM) ||
     636                primary.equals(JBIGI_OPTIMIZATION_GEODE))
    608637                rv.add(_libPrefix + getMiddleName1() + JBIGI_OPTIMIZATION_PENTIUM3 + _libSuffix);
     638
    609639            // athlon is always a fallback for 64 bit, we have it for all architectures
    610640            // and it should be much better than "none"
Note: See TracChangeset for help on using the changeset viewer.