[readline] temps de lecture

Version imprimable

11/05/2004, 10h20
fredericL

[readline] temps de lecture

Bonjour,
j'aurais besoin de recoder le BufferedReader.readLine() pour qu'il s'arrete sur un caractère autre que '\n'. J'ai essayé de reprendre le code du readLine mais j'obtient des temps beaucoup plus longs. Est ce quelqu'un sait pourquoi?

Meci
11/05/2004, 10h30
Erok

Leur code doit être plus optimisé?
11/05/2004, 10h39
fredericL

J'ai repris entièrement leur code. Ils utilisent des char[], int, String et StringBuffer.
Mais je sais pas pourquoi ils sont si rapides comparé à mon code. Esc-ce qu'il y a un moyen d'être aussi rapide?
11/05/2004, 10h43
Erok

Est ce que c si important?
le readLine est quand meme rapide, si le tien est plu long d'un dixieme de seconde c pas bien mechant
bon bien sur si tu a 1 minute de difference la...
11/05/2004, 10h43
bulbo

Qu'utilises-tu pour la lecture de tes caracteres un Reader :?:

Tu lis les caracteres un par un :?:

Le mieux pour augmenter la vitesse de ce genre de chose, c'est de lire un buffer et de traiter ce buffer ensuite ...

Bulbo :wink:
11/05/2004, 10h46
fredericL

Sur des fichiers de 200 Mo le temps de traitement ça compte vachement.

bulbo >> j'en reviens toujours au même point (si tu te rappelle).
J'ai essayé d'utiliser un buffer avec char[] (comme dans le readLine de la classe BufferedREader).

Sinon, j'utilise un BufferedReader pour lire mes données. y a mieux?
11/05/2004, 12h39
bulbo

C'est clair qu'il y a un truc:

Voici le test que j'ai fait: lire ligne par ligne un fichier de 10000 lignes

Avec le BufferedReader: 140 ms de moyenne

Avec mon reader: 230 ms de moyenne (Aie la claque)

Avec la classe BufferedReader recopiee dans mon projet sans modif a part le package : 160 ms de moyenne (???)

Bulbo :wink:
11/05/2004, 13h34
fredericL

Qu'est ce que tu veux dire quand tu dis "BufferedReader recopiee dans mon projet sans modif a part le package"?
Tu as recopié entièrement la classe?
11/05/2004, 13h53
bulbo

Yep, j'ai recopie la classe dans mon projet, j'ai change le nom du package et c'est tout ..

Enfin c'est juste pour des tests, ce genre de blague n'est pas autorisee par la licence de Sun si tu veux distribuer ton appli ...

Ce qui m'enerve c'est que j'ai quasiment ecrit le meme algo qu'eux (sans pomper et en faisant gaffe a etre rapide) mais que je me prends qq chose comme 100 ms dans les dents sur un total de 140: pas glop :(

J'arrive pas a savoir ou je perds du temps, ca m'enerve ...

Bulbo :wink:
11/05/2004, 13h56
fredericL

Si tu trouves de quoi ça vient tu me dis... Je cherche de mon coté.

Merci de ton aide.
11/05/2004, 14h38
bulbo

En fait maintenant j'arrive meme a etre plus rapide que le BufferedReader mais ce qui me tracasse c'est que pour ca j'ai ete oblige de passer par un StringBuffer..

Initialement j'utilisais un tableau de char et c'etait plus lent :?: :?:

Bulbo :wink:
11/05/2004, 14h47
fredericL

Tant mieux que tu est plus rapide... est ce que tu pourrais me passer ton code... je suis en train de coder une classe de mon coté...
Moi aussi, je suis plus rapide que le readLine maintenant.

Ca viendrait pas du fait du synchronized?

Comment faire pour s'arreter sur une séquence non plus "\n" ou "\r\n" mais par exemple "$*%" (juste pour exemple).

Pour la sequence tu te compliques la tache et je pense que le mieux pour ce genre de chose c'est de lire ligne par ligne et de tester la presence de la sequence en question.

Pour mon code, j'ai trouve pourquoi j'etais plus lent, en fait il semblerait que ce soit bcp plus lent de creer une String a partir d'un tableau de byte qu'a partir d'un tableau de byte ..

Pour en revenir a la sequence: si tu veux supporter ce genre de chose il faut ecrire une sorte d'analyseur lexicale..

tu memorises l'etat de ton analyseur et au cas ou tu reconnais ton pattern tu retournes la chaine

par exemple pour "$*%":

Code:

1
2
3
4
5
6
7
8
 
si tu lis '$' ton etat passe a 1
si ((etat == 1) && (c == '*'))
  etat = 2;
 
...
si (etat == 3)
  on a reconnu le delimiter ...

Il est evident que cet algo va prendre plus de temps qu'un bete readLine() mais sera plus rapide qu'un readLine + indexOf..

Voici mon code:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
public class DummyTest
{
  private final static int BUF_SIZE = 8192;
  private Reader _reader;
 
  private char[] _buffer;
 
  private int _offset;
  private int _size;
 
  private char[] _result;
  private int _resSize;
 
  public DummyTest(String aFilename) throws Exception
  {
    _reader = new FileReader(aFilename);
    _offset = 0;
    _size = 0;
    _resSize = 0;
    _result = new char[BUF_SIZE];
    _buffer = new char[BUF_SIZE];
  }
 
  public String readLine(char delim) throws IOException
  {
    _resSize = 0;
    int start = 0;
    int len = 0;
    boolean eol = false;
 
    while (true)
    {
      if (_offset >= _size)
      {
        _offset = 0;
        _size = _reader.read(_buffer, 0, BUF_SIZE);
 
        if (_size == -1)
        {
          if (0 == _resSize)
          {
            return null;
          }
          else
          {
            return new String(_result);
          }
        }
      }
 
      start = _offset;
      for (; _offset < _size; _offset++)
      {
        if (_buffer[_offset] == delim)
        {
          eol = true;
          break;
        }
      }
 
      len = _offset - start;
      if ((_resSize + len) > _result.length)
      {
        char bs[] = new char[_result.length + BUF_SIZE];
        System.arraycopy(_result, 0, bs, 0, _resSize);
        _result = bs;
      }
 
      if (eol)
      {
        String result = null;
        if (0 == _resSize)
        {
          result = new String(_buffer, start, _offset - start);
        }
        else
        {
          System.arraycopy(_buffer, start, _result, _resSize, len);
          _resSize += len;
          result = new String(_result, 0, _resSize);
        }
 
        _offset++;
        return result;
      }
 
      System.arraycopy(_buffer, start, _result, _resSize, len);
      _resSize += len;
    }
  }
 
  public void close()
  {
    try
    {
      _reader.close();
    }
    catch (Exception e)
    {
    }
  }
}

Amuses-toi bien

Bulbo :wink:

11/05/2004, 15h32
fredericL

merci, je vais utiliser ça mais sur un seul caractère pour pas me compliquer trop.
J'ai l'autorisation d'utiliser ton code?
Merci de ton aide.

Tu en fais ce que tu veux :lol: c'etait pour m'amuser...

Sur 100 lectures de fichier:

BufferedReader a une moyenne de 106 ms

Mon test a une moyenne de 100 ms (quelle fete :lol: :lol: )

Si tu veux supporter une String comme delimiteur tu peux remplacer ca:
Code:

1 2 3 4 5 6 7 8 9 10 start = _offset; for (; _offset < _size; _offset++) { if (_buffer[_offset] == delim) { eol = true; break; } }
Par:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 // Au tout debut de readLine tu definis: int state = 0; start = _offset; for (; _offset < _size; _offset++) { if (_buffer[_offset] == delim.charAt(state)) { state++; } else { state = 0; } if (state == delim.length()) { eol = true; break; } }
Voila et avec ca je vous mets quoi d'autre :?: :lol: :lol:

EDIT: avec cette nouvelle methode les 100 lectures prennent 130 ms, qui dit mieux ??

Ah oui j'avais oublie il faut aussi remplacer
Code:

1 2 3 _offset++; return result;
par
Code:

1 2 3 _offset += delim.length(); return result;
Bulbo :wink:

11/05/2004, 16h05
fredericL

Merci beaucoup. C'est vraiment sympa de ta part.
Je vais faire ça.
Merci.