Changeset 94af227b


Ignore:
Timestamp:
Jul 9, 2011 5:11:38 PM (9 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
dccdb996
Parents:
fdd0d6c
Message:
  • DH, YK:
    • Improve YK speed test
    • Shut down thread faster
    • Refiller keeps going until full
    • Cleanups
Location:
core/java/src/net/i2p/crypto
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • core/java/src/net/i2p/crypto/DHSessionKeyBuilder.java

    rfdd0d6c r94af227b  
    7171    public final static int DEFAULT_DH_PRECALC_DELAY = 200;
    7272
    73     /** check every 30 seconds whether we have less than the minimum */
    74     private static long _checkDelay = 30 * 1000;
    75 
    7673    static {
    7774        I2PAppContext ctx = _context;
     
    173170     * Conduct a DH exchange over the streams, returning the resulting data.
    174171     *
     172     * @deprecated unused
    175173     * @return exchanged data
    176174     * @throws IOException if there is an error (but does not close the streams
     
    195193    }
    196194   
    197     static BigInteger readBigI(InputStream in) throws IOException {
     195    /**
     196     * @deprecated unused
     197     */
     198    private static BigInteger readBigI(InputStream in) throws IOException {
    198199        byte Y[] = new byte[256];
    199200        int read = DataHelper.read(in, Y);
     
    216217     * to keep in 2s complement, and if it is already 257 bytes (due to
    217218     * the sign bit) ignore that first byte.
    218      */
    219     static void writeBigI(OutputStream out, BigInteger val) throws IOException {
     219     *
     220     * @deprecated unused
     221     */
     222    private static void writeBigI(OutputStream out, BigInteger val) throws IOException {
    220223        byte x[] = val.toByteArray();
    221224        for (int i = x.length; i < 256; i++)
     
    276279        return _myPublicValue;
    277280    }
     281
    278282    /**
    279283     * Return a 256 byte representation of our public key, with leading 0s
     
    305309        _peerValue = peerVal;
    306310    }
     311
    307312    public void setPeerPublicValue(byte val[]) throws InvalidPublicParameterException {
    308313        if (val.length != 256)
     
    324329        return _peerValue;
    325330    }
     331
    326332    public byte[] getPeerPublicValueBytes() {
    327333        return toByteArray(getPeerPublicValue());
     
    503509        private final int _maxSize;
    504510
     511        /** check every 30 seconds whether we have less than the minimum */
     512        private long _checkDelay = 30 * 1000;
     513
    505514        private DHSessionKeyBuilderPrecalcRunner(int minSize, int maxSize) {
    506515            _minSize = minSize;
     
    510519        public void run() {
    511520            while (_isRunning) {
    512 
    513                 int curSize = 0;
    514                 long start = System.currentTimeMillis();
     521                //long start = System.currentTimeMillis();
    515522                int startSize = getSize();
    516523                // Adjust delay
     
    519526                else if (startSize > (_minSize * 3 / 2) && _checkDelay < 60*1000)
    520527                    _checkDelay += 1000;
    521                 curSize = startSize;
    522                 if (curSize < _minSize) {
    523                     for (int i = curSize; i < _maxSize; i++) {
     528                if (startSize < _minSize) {
     529                    // fill all the way up, do the check here so we don't
     530                    // throw away one when full in addValues()
     531                    while (getSize() < _maxSize && _isRunning) {
    524532                        long curStart = System.currentTimeMillis();
    525533                        if (!addBuilder(precalc()))
     
    533541                    }
    534542                }
    535                 long end = System.currentTimeMillis();
    536                 int numCalc = curSize - startSize;
    537                 if (numCalc > 0) {
    538                     if (_log.shouldLog(Log.DEBUG))
    539                         _log.debug("Precalced " + numCalc + " to " + curSize + " in "
    540                                    + (end - start - CALC_DELAY * numCalc) + "ms (not counting "
    541                                    + (CALC_DELAY * numCalc) + "ms relief).  now sleeping");
    542                 }
     543                //long end = System.currentTimeMillis();
     544                //int numCalc = curSize - startSize;
     545                //if (numCalc > 0) {
     546                //    if (_log.shouldLog(Log.DEBUG))
     547                //        _log.debug("Precalced " + numCalc + " to " + curSize + " in "
     548                //                   + (end - start - CALC_DELAY * numCalc) + "ms (not counting "
     549                //                   + (CALC_DELAY * numCalc) + "ms relief).  now sleeping");
     550                //}
     551                if (!_isRunning)
     552                    break;
    543553                try {
    544554                    Thread.sleep(_checkDelay);
  • core/java/src/net/i2p/crypto/YKGenerator.java

    rfdd0d6c r94af227b  
    5353    public final static int DEFAULT_YK_PRECALC_MAX = 50;
    5454    public final static int DEFAULT_YK_PRECALC_DELAY = 200;
    55 
    56     /** check every 30 seconds whether we have less than the minimum */
    57     private static long _checkDelay = 30 * 1000;
    5855
    5956    static {
     
    171168    }
    172169
     170    private static final int RUNS = 500;
     171
    173172    public static void main(String args[]) {
    174         System.out.println("\n\n\n\nBegin test\n");
    175         long negTime = 0;
    176         for (int i = 0; i < 5; i++) {
    177             long startNeg = Clock.getInstance().now();
     173        // warmup crypto
     174        ctx.random().nextInt();
     175        System.out.println("Begin YK generator speed test");
     176        long startNeg = Clock.getInstance().now();
     177        for (int i = 0; i < RUNS; i++) {
    178178            getNextYK();
    179             long endNeg = Clock.getInstance().now();
    180             negTime += endNeg - startNeg;
    181         }
    182         // 173ms each on a 2008 netbook
    183         System.out.println("YK fetch time for 5 runs: " + negTime + " @ " + negTime / 5l + "ms each");
     179        }
     180        long endNeg = Clock.getInstance().now();
     181        long  negTime = endNeg - startNeg;
     182        // 14 ms each on a 2008 netbook (with jbigi)
     183        System.out.println("YK fetch time for " + RUNS + " runs: " + negTime + " @ " + (negTime / RUNS) + "ms each");
    184184    }
    185185
     
    188188        private final int _maxSize;
    189189
     190        /** check every 30 seconds whether we have less than the minimum */
     191        private long _checkDelay = 30 * 1000;
     192
    190193        private YKPrecalcRunner(int minSize, int maxSize) {
    191194            _minSize = minSize;
     
    195198        public void run() {
    196199            while (_isRunning) {
    197                 int curSize = 0;
    198200                //long start = Clock.getInstance().now();
    199201                int startSize = getSize();
     
    203205                else if (startSize > (_minSize * 3 / 2) && _checkDelay < 60*1000)
    204206                    _checkDelay += 1000;
    205                 curSize = startSize;
    206                 if (curSize < _minSize) {
    207                     for (int i = curSize; i < _maxSize && _isRunning; i++) {
     207                if (startSize < _minSize) {
     208                    // fill all the way up, do the check here so we don't
     209                    // throw away one when full in addValues()
     210                    while (getSize() < _maxSize && _isRunning) {
    208211                        //long begin = Clock.getInstance().now();
    209212                        if (!addValues(generateYK()))
     
    226229                //                   + (CALC_DELAY * numCalc) + "ms relief).  now sleeping");
    227230                //}
     231                if (!_isRunning)
     232                    break;
    228233                try {
    229234                    Thread.sleep(_checkDelay);
Note: See TracChangeset for help on using the changeset viewer.