Changeset c444514


Ignore:
Timestamp:
Jan 13, 2011 4:38:38 AM (9 years ago)
Author:
z3d <z3d@…>
Branches:
master
Children:
4a85f30
Parents:
9e2c063 (diff), 79bd5f1 (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:

merge of '6100fa1118decc83a309c2ccf8d128db2e9c2ef8'

and 'd804fb6b50abf7968a0198674912906c60ec9ff0'

Location:
core/java/src
Files:
4 edited

Legend:

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

    r9e2c063 rc444514  
    11/*
    22 * Created on Jul 14, 2004
     3 * Updated on Jan 8, 2011
    34 */
    45package freenet.support.CPUInformation;
     
    130131        return c.EAX & 0xf;
    131132    }
    132     private static int getCPUFlags()
     133    private static int getEDXCPUFlags()
    133134    {
    134135        CPUIDResult c = doCPUID(1);
    135136        return c.EDX;
     137    }
     138    private static int getECXCPUFlags()
     139    {
     140        CPUIDResult c = doCPUID(1);
     141        return c.ECX;
     142    }
     143    private static int getExtendedEDXCPUFlags()
     144    {
     145        CPUIDResult c = doCPUID(0x80000001);
     146        return c.EDX;
     147    }
     148    private static int getExtendedECXCPUFlags()
     149    {
     150        CPUIDResult c = doCPUID(0x80000001);
     151        return c.ECX;
    136152    }
    137153   
     
    164180        }
    165181        public boolean hasMMX(){
    166             return (getCPUFlags() & 0x800000) >0; //Bit 23
     182            return (getEDXCPUFlags() & 0x800000) >0; //EDX Bit 23
    167183        }
    168184        public boolean hasSSE(){
    169             return (getCPUFlags() & 0x2000000) >0; //Bit 25
     185            return (getEDXCPUFlags() & 0x2000000) >0; //EDX Bit 25
    170186        }
    171187        public boolean hasSSE2(){
    172             return (getCPUFlags() & 0x4000000) >0; //Bit 26
     188            return (getEDXCPUFlags() & 0x4000000) >0; //EDX Bit 26
     189        }
     190        public boolean hasSSE3(){
     191            return (getEDXCPUFlags() & 0x1) >0; //ECX Bit 0
     192        }
     193        public boolean hasSSE41(){
     194            return (getEDXCPUFlags() & 0x80000) >0; //ECX Bit 19
     195        }
     196        public boolean hasSSE42(){
     197            return (getEDXCPUFlags() & 0x100000) >0; //ECX Bit 20
     198        }
     199        public boolean hasSSE4A(){
     200            return (getExtendedECXCPUFlags() & 0x40) >0; //Extended ECX Bit 6
    173201        }
    174202        public boolean IsC3Compatible() { return false; }
     
    297325        }
    298326        public boolean IsPentium3Compatible()
    299         {
    300             return getCPUFamily() > 6 || (getCPUFamily() == 6 && getCPUModel() >=7);
     327        {       
     328                // Atom
     329                if (getCPUExtendedModel() == 1 && (getCPUFamily() == 6 && (getCPUModel() == 10))){
     330                        return true;
     331                // ??
     332                } else if (getCPUFamily() > 6 || (getCPUFamily() == 6 && getCPUModel() >=7)){
     333                        return true;
     334                } else {
     335                        return false;
     336                }
    301337        }
    302338        public boolean IsPentium4Compatible()
    303         {
    304             return getCPUFamily() >= 15;
     339        {       
     340                        // P4
     341                if (getCPUFamily() >= 15){
     342                        return true;
     343                        // Xeon MP (45nm) or Core i7
     344                } else if (getCPUExtendedModel() == 1 && (getCPUFamily() == 6 && (getCPUModel() == 10 || getCPUModel() == 13))){
     345                        return true;
     346                        // Core 2 Duo
     347                } else if (getCPUExtendedModel() == 0 && getCPUFamily() == 6 && getCPUModel() == 15){
     348                        return true;
     349                } else {
     350                        return false;
     351                }
    305352        }
    306353        public String getCPUModelString() throws UnknownCPUException {
    307             if(getCPUFamily() == 4){
    308                 switch(getCPUModel()){
    309                     case 0:
    310                         return "486 DX-25/33";
    311                     case 1:
    312                         return "486 DX-50";
    313                     case 2:
    314                         return "486 SX";
    315                     case 3:
    316                         return "486 DX/2";
    317                     case 4:
    318                         return "486 SL";
    319                     case 5:
    320                         return "486 SX/2";
    321                     case 7:
    322                         return "486 DX/2-WB";
    323                     case 8:
    324                         return "486 DX/4";
    325                     case 9:
    326                         return "486 DX/4-WB";
    327                 }
    328             }
    329             if(getCPUFamily() == 5){
    330                 switch(getCPUModel()){
    331                     case 0:
    332                         return "Pentium 60/66 A-step";
    333                     case 1:
    334                         return "Pentium 60/66";
    335                     case 2:
    336                         return "Pentium 75 - 200";
    337                     case 3:
    338                         return "OverDrive PODP5V83";
    339                     case 4:
    340                         return "Pentium MMX";
    341                     case 7:
    342                         return "Mobile Pentium 75 - 200";
    343                     case 8:
    344                         return "Mobile Pentium MMX";
    345                 }
     354                if (getCPUExtendedModel() == 0){
     355                    if(getCPUFamily() == 4){
     356                        switch(getCPUModel()){
     357                            case 0:
     358                                return "486 DX-25/33";
     359                            case 1:
     360                                return "486 DX-50";
     361                            case 2:
     362                                return "486 SX";
     363                            case 3:
     364                                return "486 DX/2";
     365                            case 4:
     366                                return "486 SL";
     367                            case 5:
     368                                return "486 SX/2";
     369                            case 7:
     370                                return "486 DX/2-WB";
     371                            case 8:
     372                                return "486 DX/4";
     373                            case 9:
     374                                return "486 DX/4-WB";
     375                        }
     376                    }
     377                }
     378            if (getCPUExtendedModel() == 0){
     379                    if(getCPUFamily() == 5){
     380                        switch(getCPUModel()){
     381                            case 0:
     382                                return "Pentium 60/66 A-step";
     383                            case 1:
     384                                return "Pentium 60/66";
     385                            case 2:
     386                                return "Pentium 75 - 200";
     387                            case 3:
     388                                return "OverDrive PODP5V83";
     389                            case 4:
     390                                return "Pentium MMX";
     391                            case 7:
     392                                return "Mobile Pentium 75 - 200";
     393                            case 8:
     394                                return "Mobile Pentium MMX";
     395                        }
     396                    }
    346397            }
    347398            if(getCPUFamily() == 6){
    348                 switch(getCPUModel()){
    349                     case 0:
    350                         return "Pentium Pro A-step";
    351                     case 1:
    352                         return "Pentium Pro";
    353                     case 3:
    354                         return "Pentium II (Klamath)";
    355                     case 5:
    356                         return "Pentium II (Deschutes), Celeron (Covington), Mobile Pentium II (Dixon)";
    357                     case 6:
    358                         return "Mobile Pentium II, Celeron (Mendocino)";
    359                     case 7:
    360                         return "Pentium III (Katmai)";
    361                     case 8:
    362                         return "Pentium III (Coppermine), Celeron w/SSE";
    363                     case 9:
    364                         return "Mobile Pentium III";
    365                     case 10:
    366                         return "Pentium III Xeon (Cascades)";
    367                     case 11:
    368                         return "Pentium III (130 nm)";
    369                 }
     399                if (getCPUExtendedModel() == 0){
     400                        switch(getCPUModel()){
     401                            case 0:
     402                                return "Pentium Pro A-step";
     403                            case 1:
     404                                return "Pentium Pro";
     405                            case 3:
     406                                return "Pentium II (Klamath)";
     407                            case 5:
     408                                return "Pentium II (Deschutes), Celeron (Covington), Mobile Pentium II (Dixon)";
     409                            case 6:
     410                                return "Mobile Pentium II, Celeron (Mendocino)";
     411                            case 7:
     412                                return "Pentium III (Katmai)";
     413                            case 8:
     414                                return "Pentium III (Coppermine), Celeron w/SSE";
     415                            case 9:
     416                                return "Mobile Pentium III (Banias)";
     417                            case 10:
     418                                return "Pentium III Xeon (Cascades)";
     419                            case 11:
     420                                return "Pentium III (130 nm)";
     421                            case 13:
     422                                return "Mobile Pentium III (Dothan)";
     423                            case 14:
     424                                return "Mobile Core (Yonah)";
     425                            case 15:
     426                                return "Core 2 (Conroe)";
     427                        }
     428                } else {
     429                        if (getCPUExtendedModel() == 1){
     430                                 switch(getCPUModel()){
     431                                        case 10:
     432                                                return "Core i7";
     433                                        case 12:
     434                                                return "Atom";
     435                                        case 13:
     436                                                return "Xeon MP";
     437                                 }
     438                        }
     439                }
    370440            }
    371441            if(getCPUFamily() == 7){
     
    385455                        case 3:
    386456                            return "Pentium IV (90 nm)";
     457                        case 4:
     458                            return "Pentium IV (90 nm)";
     459                        case 6:
     460                            return "Pentium IV (65 nm)";
    387461                    }
    388462                }
     
    408482        System.out.println("CPU Model: " + getCPUModel());
    409483        System.out.println("CPU Stepping: " + getCPUStepping());
    410         System.out.println("CPU Flags: " + getCPUFlags());
     484        System.out.println("CPU Flags: " + getEDXCPUFlags());
    411485       
    412486        CPUInfo c = getInfo();
     
    416490        System.out.println(" CPU has SSE: " + c.hasSSE());
    417491        System.out.println(" CPU has SSE2: " + c.hasSSE2());
     492        System.out.println(" CPU has SSE3: " + c.hasSSE3());
     493        System.out.println(" CPU has SSE4.1: " + c.hasSSE41());
     494        System.out.println(" CPU has SSE4.2: " + c.hasSSE42());
     495        System.out.println(" CPU has SSE4A: " + c.hasSSE4A());
    418496        if(c instanceof IntelCPUInfo){
    419497            System.out.println("  **Intel-info**");
  • core/java/src/freenet/support/CPUInformation/CPUInfo.java

    r9e2c063 rc444514  
    11/*
    2  * Created on Jul 16, 2004
    3  *
     2 * Created on Jul 14, 2004
     3 * Updated on Jan 8, 2011
    44 */
    55package freenet.support.CPUInformation;
     
    4343    public boolean hasSSE2();
    4444
     45    /**
     46     * @return true iff the CPU support the SSE3 instruction set.
     47     */
     48    public boolean hasSSE3();
     49   
     50    /**
     51     * @return true iff the CPU support the SSE4.1 instruction set.
     52     */
     53    public boolean hasSSE41();
     54
     55    /**
     56     * @return true iff the CPU support the SSE4.2 instruction set.
     57     */
     58    public boolean hasSSE42();
     59
     60    /**
     61     * @return true iff the CPU support the SSE4A instruction set.
     62     */
     63    public boolean hasSSE4A();
     64
    4565    public boolean IsC3Compatible();
    4666}
  • core/java/src/net/i2p/data/PrivateKey.java

    r9e2c063 rc444514  
    1616 * A private key is 256byte Integer. The private key represents only the
    1717 * exponent, not the primes, which are constant and defined in the crypto spec.
     18 *
     19 * Note that we use short exponents, so all but the last 28.25 bytes are zero.
     20 * See http://www.i2p2.i2p/how_cryptography for details.
    1821 *
    1922 * @author jrandom
     
    5154    }
    5255
     56    /**
     57     * We assume the data has enough randomness in it, so use the last 4 bytes for speed.
     58     * Overridden since we use short exponents, so the first 227 bytes are all zero.
     59     * Not that we are storing PrivateKeys in any Sets or Maps anywhere.
     60     */
     61    @Override
     62    public int hashCode() {
     63        if (_data == null)
     64            return 0;
     65        int rv = _data[KEYSIZE_BYTES - 4];
     66        for (int i = 1; i < 4; i++)
     67            rv ^= (_data[i + (KEYSIZE_BYTES - 4)] << (i*8));
     68        return rv;
     69    }
     70
     71    @Override
     72    public boolean equals(Object obj) {
     73        if ((obj == null) || !(obj instanceof PrivateKey)) return false;
     74        return DataHelper.eq(_data, ((PrivateKey) obj)._data);
     75    }
    5376}
  • core/java/src/net/i2p/util/LogManager.java

    r9e2c063 rc444514  
    153153            return;
    154154        _writer = new LogWriter(this);
    155         Thread t = new I2PThread(_writer, "LogWriter", true);
     155        // NOT an I2PThread, as it contains logging and we end up with problems
     156        Thread t = new Thread(_writer, "LogWriter");
     157        t.setDaemon(true);
    156158        t.start();
    157159    }
Note: See TracChangeset for help on using the changeset viewer.