Comparing between short and byte operations

Question

Hi, all!
I want to optimize performance of my applet. I have realization of block cipher that work using bytes. But for optimization purpose I rewrite encryption algorithm for short values. In simulator it works 3,5 faster, but when I test it in real card it works 4,5 slower. I use JCOP J2A080 java card.
Has anyone such a problem?
P.S. before optimization I tested different operations in card such : add, shift, xor, and, read/write and for short it works faster.
Code before optimization
    public static void add(byte[] x, short xLen, byte[] y, short yOffset,
               short yLen) {
          short carry = 0, i = 0;
          while (i < yLen) {
               carry += (short) ((x[i] & 0xFF) + (y[i + yOffset] & 0xFF));
               x[i++] = (byte) (carry & 0xFF);
               carry = (short) ((carry >>> 8) & 0xFF);
          while (i < xLen) {
               carry += (short) (x[i] & 0xFF);
               x[i++] = (byte) (carry & 0xFF);
               carry = (short) ((carry >>> 8) & 0xFF);
     private void mainStep(byte[] n1, byte[] key, short keyOffset)
          add(n1, (short) 4, key, keyOffset, (short) 4);
          Util.arrayFillNonAtomic(om, (short) 0, (short) 4, (byte) 0);
          om[0] = sbox[0 + (n1[0] & 0xF)];
          om[0] |= (byte)(bArr[1 + ((n1[0] >>> 4) & 0xF)]<<4);
          om[1]  = (byte)(bArr[2 + (n1[1] & 0xF)]);
          om[1] |= (byte)(bArr[3 + ((n1[1] >>> 4) & 0xF)]<<4);
          om[2]  = (byte)(bArr[4 + (n1[2] & 0xF)]);
          om[2] |= (byte)(bArr[5 + ((n1[2] >>> 4) & 0xF)]<<4);
          om[3]  = (byte)(bArr[6 + (n1[3] & 0xF)]);
          om[3] |= (byte)(bArr[7 + ((n1[3] >>> 4) & 0xF)]<<4);
          n1[3] = (byte) ((om[2] << 3) | ((om[1] & 0xFF) >>> 5));
          n1[2] = (byte) ((om[1] << 3) | ((om[0] & 0xFF) >>> 5));
          n1[1] = (byte) ((om[0] << 3) | ((om[3] & 0xFF) >>> 5));
          n1[0] = (byte) ((om[3] << 3) | ((om[2] & 0xFF) >>> 5));
     }Code after optimization:
     private void mainStep(byte [] bKey, short j)
          short om1 = Util.getShort(bKey, j);
          short om0 = (short)(n_0 + om1);
          //change from add function
          if((((om1 < 0)&& (om0 >= 0)) && (n_0 >= 0))
                    ||
               (((om1 < 0) || (om0 >= 0)) && (n_0 < 0)))
               n_1 += 0x1;
          n_0 = om0;
          n_1 += Util.getShort(bKey, (short) (j+2));
          //and add function
          om0 = (short)(bArr[n_0 & 0xFF]&0xFF);
          om0 |= (short)((bArr[1+ ((n_0 >>> 8) & 0xFF)])<< 8);
          om1 = (short)((bArr[2+ (n_1 & 0xFF)] & 0xFF));
          om1 |= (short)((sbox[3+ ((n_1 >>> 8) & 0xFF)])<< 8);
          n_0 = (short)(( om0 << 11 ) | ((om1 >>> 5) & 0x7FF)) ;
          n_1 = (short)(( om1 << 11 ) | ((om0 >>> 5) & 0x7FF)) ;
     }

Answer 1

From my point of view, simulator is suitable for the logical functionality testing of your application. In order to benchmark your application, you should use an emulator whose configuration is close to your real card.
I used to participated into a smart card benchmark project. The real performance depends on many factors, even the driver for the card reader can affect the application performance. I've never used a simulator to test an application performance so I haven't got any problem like yours. Just some ideas to share with you.
Best regards,
JDL