Develop and Download Open Source Software

プロジェクト・ナニ屋

Browse Subversion Repository

/[naniya]/branches/mty-makai/mty.c

Diff of /branches/mty-makai/mty.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 226 by notanpe, Tue Jul 7 10:47:03 2009 UTC revision 227 by notanpe, Thu Jul 16 11:54:15 2009 UTC
# Line 21  Line 21 
21  #include <sys/timeb.h>  #include <sys/timeb.h>
22  #include <sys/types.h>  #include <sys/types.h>
23    
 /* MAKAI start */  
24  #include <unistd.h>  #include <unistd.h>
25  #include <libgen.h>  #include <libgen.h>
26  #include <limits.h>  #include <limits.h>
# Line 33  Line 32 
32    #include <regex.h>    #include <regex.h>
33   #endif /* ONI */   #endif /* ONI */
34  #endif /* REON */  #endif /* REON */
 /* MAKAI end */  
35    
36  #if defined(WIN32)  #if defined(WIN32)
37    
# Line 58  Line 56 
56  #include "util.h"  #include "util.h"
57  #include "wdict.h"  #include "wdict.h"
58    
 /* MAKAI start */  
59  #define TRIP_LEN 10  #define TRIP_LEN 10
60    
61    #define MAKAI_TRUE  1
62    #define MAKAI_FALSE 0
63    
64  #define MIN_THREAD  1  #define MIN_THREAD  1
65  #define MAX_THREAD 32  #define MAX_THREAD 32
66  int     nThread = 0;  int     nThread = 0;
# Line 97  unsigned int   seed; Line 97  unsigned int   seed;
97  int     seedOffset;  int     seedOffset;
98  int     verbose;  int     verbose;
99    
 #ifdef NAMA  
100  unsigned char   saltChar[2];  unsigned char   saltChar[2];
101  #endif /* NAMA */  
102  /* MAKAI end */  #ifdef ALLKEY
103    unsigned char   fixedSaltChar[2];
104    #endif /* ALLKEY */
105    
106  /* CRYPT64 記述子 */  /* CRYPT64 記述子 */
107  static  static
# Line 114  static Line 115  static
115  struct  struct
116  {  {
117    unsigned short map[256];    unsigned short map[256];
118  } kcls[8 + 8]; /* atode なぜ 8 + 8 ? */  } kcls[8 + 8];
119    
120  /* 拡張鍵クラス */  /* 拡張鍵クラス */
121  #define KCLS_DT0 64  #define KCLS_DT0 64
122  #define KCLS_DT1 128  #define KCLS_DT1 128
123  #define KCLS_K2 256  #define KCLS_K2 256
124    
 /* MAKAI start */  
125  int     special = 0;  int     special = 0;
126  #define ST_ALLN 1      /* 全数 */  #define ST_ALLN 1      /* 全数 */
127  #define ST_NIKO 1<<0x1 /* 二構 */  #define ST_NIKO 1<<0x1 /* 二構 */
# Line 178  char   *str; Line 178  char   *str;
178     }     }
179    }    }
180  }  }
 /* MAKAI end */  
181    
182  #ifndef ALLKEY  #ifndef ALLKEY
183  /* 指定されたクラスと入っているキーから、classify を行う */  /* 指定されたクラスと入っているキーから、classify を行う */
# Line 193  key_make_map(uint8_t *key, int n) Line 192  key_make_map(uint8_t *key, int n)
192   6byte 埋めた時の挙動   6byte 埋めた時の挙動
193   下の方の if (n == 6) と矛盾   下の方の if (n == 6) と矛盾
194  */  */
195    if (n >= 6)    if ( n >= 6 ) return;
         return;  
196    
197    for (i = 0; i < 256; i++)    for ( i = 0; i < 256; i++ ) {
198          {     unsigned bm = 0;
199            unsigned bm = 0;     if ( c & KCLS_K1 ) {
200  #if 1      if ( cp932[256 * key[n] + i] & KCLS_K1 ) {
201            if (c & KCLS_K1)       bm |= KCLS_K2 | (cp932[256 * key[n] + i] & KCLS_DT1);
202                  {      }
203                    if (cp932[256 * key[n] + i] & KCLS_K1)      if ( cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1 ) {
204                          bm |= KCLS_K2 | (cp932[256 * key[n] + i] & KCLS_DT1);       bm |= KCLS_K2 | (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_DT1);
205                    if (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)      }
206                          bm |= KCLS_K2 | (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_DT1);     }
207  #if 0     if ( c & (KCLS_AN | KCLS_KA | KCLS_K2) ) {
208                    bm |= ((cp932[256 * key[n] + i] & KCLS_K1)      for ( j = 0; j < 256; j++ ) {
209                                   || (cp932[256 * (key[n] ^ 0x80) + i] & KCLS_K1)       bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1 | KCLS_DT0);
210                                   ? KCLS_K2 : 0);      }
211  #endif     }
212                  }     kcls[n + 1].map[i] = bm;
213            if (c & (KCLS_AN | KCLS_KA | KCLS_K2))     if ( i >= 128 && !(n == 0 || n == 1) ) {
214                  for (j = 0; j < 256; j++)      kcls[n + 1].map[i - 128] |= kcls[n + 1].map[i];
215                  {     }
216                    bm |= cp932[256 * i + j] & (KCLS_AN | KCLS_KA | KCLS_K1 | KCLS_DT0);    }
 #if 0  
                   if (j >= 127 && !(n == 0 || n == 1))  
                         break;  
 #endif  
                 }  
           kcls[n + 1].map[i] = bm;  
 #endif  
           if (i >= 128 && !(n == 0 || n == 1))  
                 kcls[n + 1].map[i - 128] |= kcls[n + 1].map[i];  
         }  
217    
218    if (n < 6)    if ( n < 6 ) kcls[n + 1].map[0x00] = kcls[n + 1].map[0x80] = 0;
219          kcls[n + 1].map[0x00] = kcls[n + 1].map[0x80] = 0;  #if 0
220    if (n == 6)    if ( n == 6 ) kcls[7].map[0x00] |= KCLS_AN;
221          kcls[7].map[0x00] |= KCLS_AN;  #endif /* 0 */
222  }  }
223  #endif /* not ALLKEY */  #endif /* not ALLKEY */
224    
# Line 240  key_set(int n, unsigned ch) Line 228  key_set(int n, unsigned ch)
228  {  {
229    int cnt = 0, i;    int cnt = 0, i;
230    
 #if DEBUG>=3  
   if (cnt == 0)  
         {  
           printf("n=%d, ch=%d, (n-1)=%02X\n", n, ch, key[n - 1]);  
           int j;  
           for (i = 0; i < 16; i++)  
                 {  
                   printf("map[0x%02X] =", 16 * i);  
                   for (j = 0; j < 16; j++)  
                         printf(" %03X", kcls[n].map[16 * i + j]);  
                   printf("\n");  
                 }  
         }  
 #endif  
   
 /* MAKAI start */  
231  #ifdef NOMORE  #ifdef NOMORE
 /* if ( ch != 0 ) printf( "ch = %d -> ", ch ); */  
232    ch %= 256;    ch %= 256;
 /* if ( ch != 0 ) printf( "%d\n", ch ); */  
233  #endif /* NOMORE */  #endif /* NOMORE */
 /* MAKAI end */  
234    
235    for (i = 0; i < 256; i++)    for ( i = 0; i < 256; i++ ) {
236          {     if ( kcls[n].map[i] ) {
237            if (kcls[n].map[i])      if ( ch-- == 0 ) return i;
238                  {      cnt++;
239                    if (ch-- == 0)     }
240                          return i;     if ( n != 1 && n != 2 && i >= 127 ) break;
241                    cnt++;    }
                 }  
           if (n != 1 && n != 2 && i >= 127)  
                 break;  
         }  
242    /* 見つからなかったのでもいっぺん */    /* 見つからなかったのでもいっぺん */
243    assert(cnt > 0);    assert( cnt > 0 );
244    ch %= cnt;    ch %= cnt;
245    for (i = 0; i < 256; i++)    for ( i = 0; i < 256; i++ ) {
246          if (kcls[n].map[i])     if ( kcls[n].map[i] ) {
247            {      if ( ch-- == 0 ) return i;
248                  if (ch-- == 0)     }
249                    return i;    }
250            }    assert( !"not matched" );
   assert(!"not matched");  
251    return 0;    return 0;
252  }  }
253    
# Line 355  key_set64(struct KEY *key64, Line 319  key_set64(struct KEY *key64,
319  int  int
320  key_reset(uint8_t *key, int n)  key_reset(uint8_t *key, int n)
321  {  {
 /* MAKAI start */  
322    static char   firstCall = 1;    static char   firstCall = 1;
323    
324    if ( firstCall ) {    if ( firstCall ) {
# Line 365  key_reset(uint8_t *key, int n) Line 328  key_reset(uint8_t *key, int n)
328       exit( 0 );       exit( 0 );
329     }     }
330    }    }
 /* MAKAI end */  
331    
332    if (n >= 8)    if (n >= 8)
333          return 1;          return 1;
# Line 375  key_reset(uint8_t *key, int n) Line 337  key_reset(uint8_t *key, int n)
337            return 1;            return 1;
338          }          }
339    
 /* MAKAI start */  
340    if ( n >= umeLen ) {    if ( n >= umeLen ) {
341  #ifdef ALLKEY  #ifdef ALLKEY
342     for ( ; n < 7; n++ ) {     for ( ; n < 7; n++ ) {
# Line 397  key_reset(uint8_t *key, int n) Line 358  key_reset(uint8_t *key, int n)
358      key[n] = umeStr[n];      key[n] = umeStr[n];
359     }     }
360    }    }
 /* MAKAI end */  
361    
362  #if DEBUG>=3  #if DEBUG>=3
363    printf("key[%d]=%02X ncls=%04X\n", n, key[n], kcls[n].map[key[n]]);    printf("key[%d]=%02X ncls=%04X\n", n, key[n], kcls[n].map[key[n]]);
364  #endif  #endif
365    
 /* MAKAI start */  
366  #ifndef ALLKEY  #ifndef ALLKEY
367    /* セットされた文字を元に、次キャラの文字クラスを決める */    /* セットされた文字を元に、次キャラの文字クラスを決める */
368    key_make_map(key, n);    key_make_map(key, n);
369  #endif /* not ALLKEY */  #endif /* not ALLKEY */
 /* MAKAI end */  
370    
371    return key_reset(key, n + 1);    return key_reset(key, n + 1);
372  }  }
# Line 419  static Line 377  static
377  int  int
378  key_inc(uint8_t *key, int n)  key_inc(uint8_t *key, int n)
379  {  {
 /* MAKAI DEBUG */  
380  #if 0  #if 0
381  if ( n != 7 ) {  if ( n != 7 ) {
382  printf( "%d : %02x %02x %02x %02x %02x %02x %02x %02x\n",  printf( "%d : %02x %02x %02x %02x %02x %02x %02x %02x\n",
# Line 452  printf( "%d : %02x %02x %02x %02x %02x % Line 409  printf( "%d : %02x %02x %02x %02x %02x %
409     return 1;     return 1;
410    }    }
411    
 /* MAKAI start */  
412  #ifdef ALLKEY  #ifdef ALLKEY
413    key[n] = ( key[n] & 0x7F ) + 1;    key[n] = ( key[n] & 0x7F ) + 1;
414    if ( key[n] >= 0x80 ) {    if ( key[n] >= 0x80 ) {
# Line 462  printf( "%d : %02x %02x %02x %02x %02x % Line 418  printf( "%d : %02x %02x %02x %02x %02x %
418    key_reset( key, n + 1 );    key_reset( key, n + 1 );
419    return 1;    return 1;
420  #endif /* ALLKEY */  #endif /* ALLKEY */
 /* MAKAI end */  
421    
422    /* 実際に増やしてみる */    /* 実際に増やしてみる */
423    assert( n >= 3 );    assert( n >= 3 );
# Line 486  printf( "%d : %02x %02x %02x %02x %02x % Line 441  printf( "%d : %02x %02x %02x %02x %02x %
441    
442            if (kcls[n].map[key[n]])            if (kcls[n].map[key[n]])
443                  {                  {
 /* MAKAI start */  
444  #ifndef ALLKEY  #ifndef ALLKEY
445                    key_make_map(key, n);                    key_make_map(key, n);
446  #endif /* not ALLKEY */  #endif /* not ALLKEY */
 /* MAKAI end */  
447                    key_reset(key, n + 1);                    key_reset(key, n + 1);
448                    return 1;                    return 1;
449                  }                  }
# Line 522  key_init(uint8_t *key) Line 475  key_init(uint8_t *key)
475    }    }
476  #endif /* not ALLKEY */  #endif /* not ALLKEY */
477    
 /* MAKAI start */  
 #ifdef notdef  
 {  
   int   idx;  
   kcls[0].map[0] = 0;  
   for ( idx = 1; idx < 8; idx++ ) {  
    for ( i = 0; i < 256; i++ ) {  
     unsigned bm = 0;  
   
     for ( j = 0; j < 256; j++ ) {  
      bm |= cp932[256 * i + j];  
     }  
     kcls[idx].map[i] = bm & (KCLS_AN | KCLS_KA | KCLS_K1);  
     if ( i > 128 ) {  
      kcls[idx].map[i - 128] |= kcls[idx].map[i];  
     }  
    }  
   }  
 }  
 #endif /* ALLKEY */  
 /* MAKAI end */  
   
478    key_reset(key, 0);    key_reset(key, 0);
479  }  }
480    
# Line 604  set_salt(CODE_T *code, Line 535  set_salt(CODE_T *code,
535                   struct CRYPT64_DESC const *desc,                   struct CRYPT64_DESC const *desc,
536                   uint8_t const *k)                   uint8_t const *k)
537  {  {
538    int i, j;    int   i, j;
539    
   for (i = 0; i < 2; i++)  
         {  
           unsigned s = k[1 + i] & 255;  
 #ifdef ALLKEY  
 {  
540    static unsigned char  *s2c = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";    static unsigned char  *s2c = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
   s = rand() % 64;  
   saltChar[i] = s2c[s];  
 }  
 #else /* ALLKEY */  
           if (s > 'z')  
                 s = 0;  
           else if (s >= 'a')  
                 s = s - 'a' + 2 + 10 + 26;  
           else if (s >= 'A')  
                 s = s - 'A' + 2 + 10;  
           else if (s >= '.')  
                 s = s - '.';  
           else  
                 s = 0;  
   
 /* MAKAI DEBUG */  
 #if 0  
           printf( "before %d : Key %02x, Salt %02x\n", i, k[1 + i], s );  
 /*  
 salt : 0x00(00) - 0x3f(63)  
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f  
 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 01  
 30 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11  
 40 12 0c 0d 0e 0f 10 11 12 13 14 15 16 17 18 19 1a  
 50 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a  
 60 2b 26 27 28 29 30 2b 2c 2d 2e 2f 30 31 32 33 34  
 70 35 36 37 38 39 3a 3b 3c 3d 3e 3f 00 00 00 00 00  
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f  
 80 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 90 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 a0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 b0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 c0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 d0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 e0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
 f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f  
  */  
 #endif /* 0 */  
 /* MAKAI DEBUG */  
541    
542  /* MAKAI start */    for ( i = 0; i < 2; i++ ) {
543       unsigned     s;
544    #ifdef ALLKEY
545       if ( fixedSaltChar[0] != '\0' ) {
546        saltChar[i] = fixedSaltChar[i];
547        for ( s = 0; s2c[s] != '\0' && s2c[s] != saltChar[i]; s++ )
548         ;
549            assert( s2c[s] != '\0' );
550       } else {
551        s = rand() % 64;
552        saltChar[i] = s2c[s];
553       }
554    #else /* ALLKEY */
555       s = k[1 + i] & 255;
556       if (s > 'z')
557        s = 0;
558       else if (s >= 'a')
559        s = s - 'a' + 2 + 10 + 26;
560       else if (s >= 'A')
561        s = s - 'A' + 2 + 10;
562       else if (s >= '.')
563        s = s - '.';
564       else
565        s = 0;
566  #ifdef OTAKU  #ifdef OTAKU
567  {  {
568    unsigned s2;     unsigned s2;
569    static unsigned char  *s2c = "./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";     do {
570    do {      s2 = rand() % 64;
571     s2 = rand() % 64;     } while ( s == s2 );
572    } while ( s == s2 );     s = s2;
   s = s2;  
   saltChar[i] = s2c[s];  
573  }  }
574  #endif /* OTAKU */  #endif /* OTAKU */
575  /* MAKAI end */     saltChar[i] = s2c[s];
   
 /* MAKAI DEBUG */  
 #if 0  
           printf( "after  %d : Key %02x, Salt %02x(%c)\n", i, k[1 + i], s, saltChar[i] );  
 #endif /* 0 */  
 /* MAKAI DEBUG */  
576  #endif /* ALLKEY */  #endif /* ALLKEY */
577    
578  #if DEBUG>=1     for ( j = 0; j < 6; j++ ) {
579            printf("Salt %d:%3o\n", i, s & 63);      if ( s & (1 << j) ) {
580  #endif       LSALT( desc, code, 0, i, j,  0 ) = sizeof(WS_T) * (((4*i+j+15) & 31) - 16);
581            for (j = 0; j < 6; j++)       LSALT( desc, code, 0, i, j, 24 ) = sizeof(WS_T) * (((4*i+j- 1) & 31) - 16);
582                  {      } else {
583  #if DEBUG>=2       LSALT( desc, code, 0, i, j,  0 ) = sizeof(WS_T) * (((4*i+j- 1) & 31) - 16);
584                    //printf("Salt %d:%d %+3d:%+3d",       LSALT( desc, code, 0, i, j, 24 ) = sizeof(WS_T) * (((4*i+j+15) & 31) - 16);
585                    printf("Salt %d:%d %08lX:%08lX",      }
586                                   i, j,      LSALT( desc, code, 0, i, j, 12 ) = sizeof(WS_T) * (((4*i+j+ 7) & 31) - 16);
587                                   LSALT(desc, code, 0, i, j,  0),      LSALT( desc, code, 0, i, j, 36 ) = sizeof(WS_T) * (((4*i+j+23) & 31) - 16);
588                                   LSALT(desc, code, 0, i, j, 24));     }
589  #endif    }
                 if (s & (1 << j))  
                   {  
                         LSALT(desc, code, 0, i, j,  0) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);  
                         LSALT(desc, code, 0, i, j, 24) = sizeof(WS_T) * (((4 * i + j -  1) & 31) - 16);  
                   }  
                 else  
                   {  
                         LSALT(desc, code, 0, i, j,  0) = sizeof(WS_T) * (((4 * i + j -  1) & 31) - 16);  
                         LSALT(desc, code, 0, i, j, 24) = sizeof(WS_T) * (((4 * i + j + 15) & 31) - 16);  
                   }  
                 LSALT(desc, code, 0, i, j, 12) = sizeof(WS_T) * (((4 * i + j +  7) & 31) - 16);  
                 LSALT(desc, code, 0, i, j, 36) = sizeof(WS_T) * (((4 * i + j + 23) & 31) - 16);  
 #if DEBUG>=2  
                 //printf(" => %+3d:%+3d\n",  
                   printf(" => %08lX:%08lX\n",  
                                  LSALT(desc, code, 0, i, j,  0),  
                                  LSALT(desc, code, 0, i, j, 24));  
 #endif  
                 }  
         }  
 /* MAKAI DEBUG */  
 #if 0  
       exit( 0 );  
 #endif /* 0 */  
 /* MAKAI DEBUG */  
590  }  }
591    
592  #define USEC_SEC 1000   /* 1秒 */  #define USEC_SEC 1000   /* 1秒 */
# Line 746  log_printf(FILE *ofp, char const *fmt, . Line 620  log_printf(FILE *ofp, char const *fmt, .
620    va_list ap;    va_list ap;
621    va_start(ap, fmt);    va_start(ap, fmt);
622    
   /* MAKAI start */  
623    if ( ofp != nfp ) {    if ( ofp != nfp ) {
624     vfprintf(stdout, fmt, ap);     vfprintf(stdout, fmt, ap);
625    }    }
   /* MAKAI end */  
626    
627    r = vfprintf(ofp, fmt, ap);    r = vfprintf(ofp, fmt, ap);
628    va_end(ap);    va_end(ap);
# Line 763  log_printf(FILE *ofp, char const *fmt, . Line 635  log_printf(FILE *ofp, char const *fmt, .
635    exit(errno);    exit(errno);
636  }  }
637    
638    static
639    void
640    hit( fp, hash, key, kk, k, kind, dotrans )
641    FILE    *fp;
642    char    *hash;
643    uint8_t *key;
644    int     kk;
645    int     k;
646    unsigned char   *kind;
647    int     dotrans;
648    {
649      struct timeb  tb;
650      struct tm     *plt;
651      int   namaKey;
652      uint8_t       buf[32];
653    
654      ftime( &tb );
655      plt = localtime( &tb.time );
656    
657      memcpy( buf, key, 8 );
658      buf[8] = buf[9] = 0;
659      buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;
660    
661      namaKey = MAKAI_TRUE;
662    #ifndef NAMA
663      if ( dotrans ) {
664       if ( translate( buf, 0, 1 ) ) {
665        namaKey = MAKAI_FALSE;
666       }
667      }
668    #endif /* NAMA */
669    
670      if ( namaKey ) {
671       log_printf( fp, "◆%s ##%02x%02x%02x%02x%02x%02x%02x%02x%c%c"
672                   "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"
673                   " %s 生\n",
674                   hash,
675                   buf[0], buf[1], buf[2], buf[3],
676                   buf[4], buf[5], buf[6], buf[7],
677                   saltChar[0], saltChar[1],
678                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,
679                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,
680                   kind );
681      } else {
682       log_printf( fp, "◆%s #%s"
683                   "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"
684                   "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X)"
685                   " %s\n",
686                   hash,
687                   buf,
688                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,
689                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,
690                   buf[0], buf[1], buf[2], buf[3], buf[4],
691                   buf[5], buf[6], buf[7], buf[8],
692                   kind );
693      }
694    }
695    
696  /***************************************************************  /***************************************************************
697   *   *
698   *      CPU capabilities を取得   *      CPU capabilities を取得
# Line 936  typedef HANDLE THREAD_EV_T; Line 866  typedef HANDLE THREAD_EV_T;
866  #define thread_get_tid()        GetCurrentThread()  #define thread_get_tid()        GetCurrentThread()
867  #define thread_set_priority(tid,n)      SetThreadPriority(tid, n)  #define thread_set_priority(tid,n)      SetThreadPriority(tid, n)
868  #if 0  #if 0
869  #undef thread_set_priority /* MAKAI */  #undef thread_set_priority
870  #endif  #endif
871  #define thread_set_affinity(tid,m)      SetThreadAffinityMask(tid, (DWORD_PTR)1 << (m))  #define thread_set_affinity(tid,m)      SetThreadAffinityMask(tid, (DWORD_PTR)1 << (m))
872    
# Line 952  thread_wait_event(THREAD_EV_T ev, DWORD Line 882  thread_wait_event(THREAD_EV_T ev, DWORD
882                           : r));                           : r));
883  }  }
884    
885  #elif defined(_POSIX_SOURCE)  || defined(FREEBSD) /* MAKAI */  #elif defined(_POSIX_SOURCE)  || defined(FREEBSD)
886    
887  #include <pthread.h>  #include <pthread.h>
888  #include <unistd.h>  #include <unistd.h>
# Line 1260  thread_crypt64(void *a_param) Line 1190  thread_crypt64(void *a_param)
1190          }          }
1191  }  }
1192    
 /* MAKAI start */  
1193  void  void
1194  usage( path )  usage( path )
1195  char    *path;  char    *path;
# Line 1274  char   *path; Line 1203  char   *path;
1203      break;      break;
1204     }     }
1205    }    }
1206    printf( "%s [-t num|-m mask] [-s num] [-v] [\"str\"]\n", myName );    printf( "%s [-t num|-m mask] [-s num] [-k salt] [-v] [\"str\"]\n", myName );
1207    printf( " -t num : 検索スレッド数 ( %d ≦ num ≦ %d )\n",    printf( " -t num : 検索スレッド数 ( %d ≦ num ≦ %d )\n",
1208             MIN_THREAD, MAX_THREAD );             MIN_THREAD, MAX_THREAD );
1209    printf( " -m mask : 実行する CPU を指定するマスク ( 1 ビット ≦ mask のビット数 ≦ %d ビット )\n",    printf( " -m mask : 実行する CPU を指定するマスク ( 1 ビット ≦ mask のビット数 ≦ %d ビット )\n",
1210            MAX_THREAD );            MAX_THREAD );
1211    printf( " -s num : 乱数の種 ( 1 ≦ num ≦ %u )\n", UINT_MAX );    printf( " -s num : 乱数の種 ( 1 ≦ num ≦ %u )\n", UINT_MAX );
1212    #ifdef ALLKEY
1213      printf( " -k salt : 塩を指定\n" );
1214    #endif /* ALLKEY */
1215    printf( " -v : 冗長メッセージ\n" );    printf( " -v : 冗長メッセージ\n" );
1216    printf( " str : 先頭に埋め込む文字列 ( %d ≦ str のバイト数 ≦ %d )\n",    printf( " str : 先頭に埋め込む文字列 ( %d ≦ str のバイト数 ≦ %d )\n",
1217             MIN_UME, MAX_UME );             MIN_UME, MAX_UME );
# Line 1376  unsigned char  *kind; Line 1308  unsigned char  *kind;
1308        strcpy( kind, "怒" );        strcpy( kind, "怒" );
1309        return( tfp );        return( tfp );
1310       }       }
1311       /* 最小ねらい */       /* 最大と最小は、純 8 連で出るので削除 */
      if ( trip[0] == '0' && trip[1] == '0' && trip[2] == '0' &&  
           trip[3] == '0' && trip[4] == '0' && trip[5] == '0' &&  
           trip[6] == '0' ) {  
       strcpy( kind, "怒" );  
       return( tfp );  
      }  
      /* 最大 (9999999966 以上) は、純 8 連で出るので削除 */  
1312      } else {      } else {
1313       strcpy( kind, "数" );       strcpy( kind, "数" );
1314       return( nfp );       return( nfp );
# Line 1393  unsigned char  *kind; Line 1318  unsigned char  *kind;
1318    
1319    return( NULL );    return( NULL );
1320  }  }
 /* MAKAI end */  
1321    
1322  /***************************************************************  /***************************************************************
1323   *   *
# Line 1440  main(int argc, char *argv[]) Line 1364  main(int argc, char *argv[])
1364    uint64_t curTime;    uint64_t curTime;
1365    uint32_t upd_int = 0;    uint32_t upd_int = 0;
1366    
 /* MAKAI start */  
 /* 実際の処理とあっていないコメントを削除 */  
   
1367  #if defined(WIN32)  #if defined(WIN32)
1368    SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );    SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
1369  #endif  #endif
# Line 1458  main(int argc, char *argv[]) Line 1379  main(int argc, char *argv[])
1379    seed = 0;    seed = 0;
1380    seedOffset = 0; /* コマンドラインオプションではないが、ここで初期化 */    seedOffset = 0; /* コマンドラインオプションではないが、ここで初期化 */
1381    verbose = 0;    verbose = 0;
1382    #ifdef ALLKEY
1383      fixedSaltChar[0] = '\0';
1384      while ( (optChar = getopt(argc, argv, "t:m:s:k:vh")) != EOF ) {
1385    #else /* ALLKEY */
1386    while ( (optChar = getopt(argc, argv, "t:m:s:vh")) != EOF ) {    while ( (optChar = getopt(argc, argv, "t:m:s:vh")) != EOF ) {
1387    #endif /* ALLKEY */
1388     switch ( optChar ) {     switch ( optChar ) {
1389      case 't':      case 't':
1390       nThread = atoi( optarg );       nThread = atoi( optarg );
# Line 1503  main(int argc, char *argv[]) Line 1429  main(int argc, char *argv[])
1429        exit( 1 );        exit( 1 );
1430       }       }
1431       break;       break;
1432    #ifdef ALLKEY
1433        case 'k':
1434         if ( strlen( optarg ) != 2 ) {
1435          usage( argv[0] );
1436          exit( 1 );
1437         }
1438         for ( i = 0; i < 2; i++ ) {
1439          if ( !isdigit( optarg[i] ) && !isalpha( optarg[i] ) &&
1440               optarg[i] != '.' && optarg[i] != '/' ) {
1441           usage( argv[0] );
1442           exit( 1 );
1443          }
1444          fixedSaltChar[i] = optarg[i];
1445         }
1446         break;
1447    #endif /* ALLKEY */
1448      case 'v':      case 'v':
1449       verbose = 1;       verbose = 1;
1450       break;       break;
# Line 1510  main(int argc, char *argv[]) Line 1452  main(int argc, char *argv[])
1452       usage( argv[0] );       usage( argv[0] );
1453       exit( 0 );       exit( 0 );
1454       break;       break;
1455        default:
1456         usage( argv[0] );
1457         exit( 1 );
1458     }     }
1459    }    }
1460    
# Line 1547  main(int argc, char *argv[]) Line 1492  main(int argc, char *argv[])
1492  #endif /* MAKEY */  #endif /* MAKEY */
1493    
1494  #ifdef ALLKEY  #ifdef ALLKEY
1495    fprintf(stderr, "キー全空間バージョンにつき、シロウトにはおすすめできない。\n\n");    fprintf(stderr, "真・全空間バージョンにつき、シロウトにはおすすめできない。\n\n");
1496  #endif /* MAKEY */  #endif /* MAKEY */
 /* MAKAI end */  
1497    
1498    if (!cpuid_issupported())    if ( !cpuid_issupported() ) {
1499          {     fprintf( stderr, "この環境で走らせることが想定されていません。\n" );
1500            fprintf(stderr, "この環境で走らせることが想定されていません。\n");     exit( 1 );
1501            exit(1);    }
         }  
1502    
1503    assert((1 << N_STRIDE) == N_ALU * ALU_BITS);    assert( (1 << N_STRIDE) == N_ALU * ALU_BITS );
1504    
1505    /* タゲ読み込み */    /* タゲ読み込み */
1506    root_expr = expr_parse("target.txt");    root_expr = expr_parse( "target.txt" );
1507    
 /* MAKAI start */  
1508  #ifdef CHIN  #ifdef CHIN
1509    special |= ST_CHIN;    special |= ST_CHIN;
1510  #endif /* CHIN */  #endif /* CHIN */
# Line 1601  main(int argc, char *argv[]) Line 1543  main(int argc, char *argv[])
1543     }     }
1544  #endif /* REON */  #endif /* REON */
1545    }    }
 /* MAKAI end */  
1546    
1547    /* コードを生成・展開    /* コードを生成・展開
1548           起動予定スレッド数に応じて           起動予定スレッド数に応じて
1549           生成するコードを変える */           生成するコードを変える */
1550    sfp = scoreboard_open();    sfp = scoreboard_open();
1551    fwrite(crypt64_descs[0]->pro, 1, crypt64_descs[0]->cmp_pro - crypt64_descs[0]->pro, sfp);     /* prologue & コアループ */    /* prologue & コアループ */
1552      fwrite( crypt64_descs[0]->pro, 1,
1553              crypt64_descs[0]->cmp_pro - crypt64_descs[0]->pro, sfp );
1554    
 /* MAKAI start */  
1555     /* proc_mask に使用する CPU のマスクをセット */     /* proc_mask に使用する CPU のマスクをセット */
1556     if ( pmask == 0 ) {    if ( pmask == 0 ) {
1557      /* 指定がなければ、使える CPU 全部 */     /* 指定がなければ、使える CPU 全部 */
1558      proc_mask = thread_avail();     proc_mask = thread_avail();
1559     } else {    } else {
1560      /* 指定された CPU の存在チェック。だが、今は Win32 のコードしかない。 */     /* 指定された CPU の存在チェック。だが、今は Win32 のコードしかない。 */
1561  #ifdef WIN32  #ifdef WIN32
1562      DWORD_PTR   processMask, systemMask;     DWORD_PTR    processMask, systemMask;
1563      if ( GetProcessAffinityMask( GetCurrentProcess(), &processMask, &systemMask )     if ( GetProcessAffinityMask( GetCurrentProcess(), &processMask, &systemMask )
1564           == 0 ) {          == 0 ) {
1565       printf( "CPU の割り当てに失敗 その 1\n" );      printf( "CPU の割り当てに失敗 その 1\n" );
1566       exit( 1 );      exit( 1 );
1567      }     }
1568      if ( (processMask & pmask) != pmask ) {     if ( (processMask & pmask) != pmask ) {
1569       printf( "そんな CPU はねぇ！\n" );      printf( "そんな CPU はねぇ！\n" );
1570       exit( 1 );      exit( 1 );
1571      }     }
1572  #endif /* WIN32 */  #endif /* WIN32 */
1573    
1574      proc_mask = pmask;     proc_mask = pmask;
1575      printf( "CPU : " );     printf( "CPU : " );
1576      for ( i = 0; i < MAX_THREAD; i++ ) {     for ( i = 0; i < MAX_THREAD; i++ ) {
1577       if ( pmask & 1 ) {      if ( pmask & 1 ) {
1578        printf( "%d ", i );       printf( "%d ", i );
      }  
      pmask >>= 1;  
1579      }      }
1580      printf( "を使用します。\n" );      pmask >>= 1;
1581       }
1582       printf( "を使用します。\n" );
1583    
1584      /* CPU の割り当て。だが、今は Wi(r */      /* CPU の割り当て。だが、今は Wi(r */
1585  #ifdef WIN32  #ifdef WIN32
1586      if ( SetProcessAffinityMask( GetCurrentProcess(), proc_mask ) == 0 ) {     if ( SetProcessAffinityMask( GetCurrentProcess(), proc_mask ) == 0 ) {
1587       printf( "CPU の割り当てに失敗 その 2\n" );      printf( "CPU の割り当てに失敗 その 2\n" );
1588       exit( 1 );      exit( 1 );
     }  
 #endif /* WIN32 */  
1589     }     }
1590    #endif /* WIN32 */
1591      }
1592    
1593     /* スレッド数の指定がない場合は、proc_mask からゲッツ */    /* スレッド数の指定がない場合は、proc_mask からゲッツ */
1594     if ( nThread == 0 ) {    if ( nThread == 0 ) {
1595      nThread = popcnt64( proc_mask );     nThread = popcnt64( proc_mask );
1596     }    }
1597    
1598     fprintf( stderr, "%d 個の検索スレッドを生成\n", nThread );    fprintf( stderr, "%d 個の検索スレッドを生成\n", nThread );
 /* MAKAI end */  
1599    
1600    if (nThread == 1) /* MAKAI */    if ( nThread == 1 ) {
1601          {     npkts = 1;
1602            /* single */     pkts_vacant = 1;
1603            npkts = 1;     code_cmp = 0;
1604            pkts_vacant = 1;    } else {
1605            code_cmp = 0;     /* epilogue */
1606          }     fwrite( crypt64_descs[0]->ep, 1,
1607    else             crypt64_descs[0]->ep_end - crypt64_descs[0]->ep, sfp );
1608          {     /* 比較器のみを生成(前半) */
1609            /* multi */     code_cmp = ftell( sfp );
1610            fwrite(crypt64_descs[0]->ep, 1, crypt64_descs[0]->ep_end - crypt64_descs[0]->ep, sfp);        /* epilogue */     fseek( sfp, (-code_cmp) & 63, SEEK_CUR );
1611       code_cmp = ftell( sfp );
1612            /* 比較器のみを生成(前半) */     /* prologue */
1613            code_cmp = ftell(sfp);     fwrite( crypt64_descs[0]->pro, 1,
1614            fseek(sfp, (-code_cmp) & 63, SEEK_CUR);             crypt64_descs[0]->crypt - crypt64_descs[0]->pro, sfp );
1615            code_cmp = ftell(sfp);     npkts = 64;
1616            fwrite(crypt64_descs[0]->pro, 1, crypt64_descs[0]->crypt - crypt64_descs[0]->pro, sfp);       /* prologue */     pkts_vacant = (uint64_t)-1;  /* (1 << 64) - 1 を計算したくない */
1617            npkts = 64;    }
           pkts_vacant = (uint64_t)-1;   /* (1 << 64) - 1 を計算したくない */  
         }  
1618    
1619    /* 比較部を生成 */    /* 比較部を生成 */
1620    fwrite(crypt64_descs[0]->cmp_pro, 1, crypt64_descs[0]->cmp_ep - crypt64_descs[0]->cmp_pro, sfp);      /* 比較器準備 */    /* 比較器準備 */
1621    tn = synth_synthesize(sfp, root_expr);    fwrite( crypt64_descs[0]->cmp_pro, 1,
1622    fwrite(crypt64_descs[0]->cmp_ep, 1, crypt64_descs[0]->ep_end - crypt64_descs[0]->cmp_ep, sfp);        /* epilogue */            crypt64_descs[0]->cmp_ep - crypt64_descs[0]->cmp_pro, sfp );
1623      tn = synth_synthesize( sfp, root_expr );
1624      /* epilogue */
1625      fwrite( crypt64_descs[0]->cmp_ep, 1,
1626              crypt64_descs[0]->ep_end - crypt64_descs[0]->cmp_ep, sfp );
1627    /* コードをメモリに貼り付ける */    /* コードをメモリに貼り付ける */
1628    code = scoreboard_map(sfp);    code = scoreboard_map( sfp );
1629    
1630    /* キーの初期化 */    /* キーの初期化 */
 /* MAKAI start */  
1631    if ( seed == 0 ) {    if ( seed == 0 ) {
1632     seed = (unsigned int)time( NULL ) + seedOffset;     seed = (unsigned int)time( NULL ) + seedOffset;
1633    }    }
# Line 1694  main(int argc, char *argv[]) Line 1635  main(int argc, char *argv[])
1635     printf( "乱数の種 = %u\n", seed );     printf( "乱数の種 = %u\n", seed );
1636    }    }
1637    srand( seed );    srand( seed );
 /* MAKAI end */  
   key_init(key);  
1638    
1639  #ifdef KEYCHK  #ifdef KEYCHK
1640  {  {
 /*  
 ノーマル  
  1, 4 0x01 - 0x7e 126 個  
   1 に 0x05, 0x06 が出ない  
   4 は全部出るが 0x05 と 0x06 がレア  
  2, 3 0x20 - 0xfc 221 個  
   2 抜けは 8 個 0x22 0x26 0x3c 0x3e 0x7f 0x80 0xef 0xf2  
   3 抜けは 9 個 0x22 0x26 0x3c 0x3e 0x7f 0x80           0xf5 0xf7 0xf9  
 */  
1641    int   i;    int   i;
1642    
1643    for ( i = 0; i < 100000; i++ ) {    for ( i = 0; i < 100000; i++ ) {
1644     printf( "%02x %02x %02x %02x %02x %02x %02x %02x\n",     printf( "%02x %02x %02x %02x %02x %02x %02x %02x\n",
1645             key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7] );             key[0], key[1], key[2], key[3], key[4], key[5], key[6], key[7] );
1646     key_init(key);     key_init( key );
1647    }    }
1648    exit( 0 );    exit( 0 );
1649  }  }
1650  #endif /* KEYCHK */  #endif /* KEYCHK */
1651    
1652    set_salt(code, crypt64_descs[0], key);    key_init( key );
1653      set_salt( code, crypt64_descs[0], key );
1654    
1655    /* 演算パケットを作成 */    /* 演算パケットを作成 */
1656    pkts = packet_create(npkts, tn, key);    pkts = packet_create( npkts, tn, key );
1657    pkt_hit = &pkts[npkts - 1];    pkt_hit = &pkts[npkts - 1];
1658    
1659    /* 働くおじさんを量産 */    /* 働くおじさんを量産 */
1660    thread_create_event(event_ks_activated, 1);    thread_create_event( event_ks_activated, 1 );
1661    ks_activated = 1;    ks_activated = 1;
1662    nthreads = 0;    nthreads = 0;
1663    if (code_cmp)    if ( code_cmp ) {
1664          {     THREAD_TH_T h;
1665            THREAD_TH_T h;     int ots = -1;
1666            int ots = -1;     threads = calloc( 2 * nThread, sizeof(*threads) );
1667            threads = calloc(2 * nThread, sizeof(*threads));     for ( i = 0; i < nThread; i++ ) {
1668            for (i = 0; i < nThread; i++ ) { /* MAKAI */      if ( ots < 0 ) {
1669                          if (ots < 0)       /* 自分自身のスケジューリング
1670                            {          こーゆー系のアプリは低めに設定するのが吉(かも) */
                                 /* 自分自身のスケジューリング  
                                    こーゆー系のアプリは低めに設定するのが吉(かも) */  
1671  #ifdef WIN32  #ifdef WIN32
1672                                  h = GetCurrentProcess();       h = GetCurrentProcess();
1673                                  SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS);       SetPriorityClass( h, BELOW_NORMAL_PRIORITY_CLASS );
1674  #endif  #endif
1675  #if defined(thread_set_priority)  #if defined( thread_set_priority )
1676                                  /* 心の隙間お埋めします */       /* 心の隙間お埋めします */
1677                                  threads[nthreads].code = code;       threads[nthreads].code = code;
1678                                  threads[nthreads].p_ev_ks_activated = &event_ks_activated;       threads[nthreads].p_ev_ks_activated = &event_ks_activated;
1679                                  threads[nthreads].p_nidle = &nidle;       threads[nthreads].p_nidle = &nidle;
1680                                  threads[nthreads].pri = THREAD_PRIORITY_IDLE;       threads[nthreads].pri = THREAD_PRIORITY_IDLE;
1681                                  thread_create(h, thread_crypt64, &threads[nthreads]);       thread_create( h, thread_crypt64, &threads[nthreads] );
1682                                  threads[nthreads].th = h;       threads[nthreads].th = h;
1683                                  nthreads++;       nthreads++;
1684  #endif  #endif
1685                                  if (!code_cmp)       if ( !code_cmp ) break;
1686                                    break;       /* 自分自身の残りの設定を、あとでやる */
1687         ots = i;
1688                                  /* 自分自身の残りの設定を、あとでやる */      } else {
1689                                  ots = i;       /* 他スレッドは、やや低めの優先度で。 */
1690                            }       threads[nthreads].code = code;
1691                          else       threads[nthreads].p_ev_ks_activated = &event_ks_activated;
1692                            {       threads[nthreads].p_nidle = &nidle;
                                 /* 他スレッドは、やや低めの優先度で。 */  
                                 threads[nthreads].code = code;  
                                 threads[nthreads].p_ev_ks_activated = &event_ks_activated;  
                                 threads[nthreads].p_nidle = &nidle;  
1693  #ifdef thread_set_priority  #ifdef thread_set_priority
1694                                  threads[nthreads].pri = THREAD_PRIORITY_BELOW_NORMAL;       threads[nthreads].pri = THREAD_PRIORITY_BELOW_NORMAL;
1695  #endif  #endif
1696                                  thread_create(h, thread_crypt64, &threads[nthreads]);       thread_create( h, thread_crypt64, &threads[nthreads] );
1697  #ifdef thread_set_priority  #ifdef thread_set_priority
1698                                  threads[nthreads].th = h;       threads[nthreads].th = h;
1699  #endif  #endif
1700  /* MAKAI start */       nthreads++;
1701  #if 0      }
1702  #ifdef thread_get_tid     }
1703                                  thread_set_affinity(h, i);    }
 #endif  
 #endif /* 0 */  
 /* MAKAI end */  
                                 nthreads++;  
                           }  
           }  
 /* MAKAI start */  
 #if 0  
 #ifdef thread_get_tid  
           if (ots)  
                 thread_set_affinity(thread_get_tid(), ots);  
 #endif  
 #endif /* 0 */  
 /* MAKAI end */  
         }  
   
   if ((ofp = fopen("log.txt", "at")) == NULL)  
         {  
           perror("log.txt");  
           return errno;  
         }  
1704    
1705    setvbuf(ofp, NULL, _IONBF, BUFSIZ);   /* XXX MSVCRT では _IOLBF が期待通りに動作しない */    if ( (ofp = fopen( "log.txt", "at" )) == NULL ) {
1706       perror( "log.txt" );
1707       return errno;
1708      }
1709      setvbuf(ofp, NULL, _IONBF, BUFSIZ);
1710    
1711  /* MAKAI start */    if ( (tfp = fopen( "logspe.txt", "at" )) == NULL ) {
1712    if ( (tfp = fopen("logspe.txt", "at")) == NULL ) {     perror( "logspe.txt" );
    perror("logspe.txt");  
1713     return errno;     return errno;
1714    }    }
1715    setvbuf( tfp, NULL, _IONBF, BUFSIZ );    setvbuf( tfp, NULL, _IONBF, BUFSIZ );
1716    if ( (nfp = fopen("lognum.txt", "at")) == NULL ) {    if ( (nfp = fopen( "lognum.txt", "at" )) == NULL ) {
1717     perror("lognum.txt");     perror( "lognum.txt" );
1718     return errno;     return errno;
1719    }    }
1720    setvbuf( nfp, NULL, _IONBF, BUFSIZ );    setvbuf( nfp, NULL, _IONBF, BUFSIZ );
1721  #ifdef CHIN  #ifdef CHIN
1722    if ( (cfp = fopen("logchi.txt", "at")) == NULL ) {    if ( (cfp = fopen( "logchi.txt", "at" )) == NULL ) {
1723     perror("logchi.txt");     perror( "logchi.txt" );
1724     return errno;     return errno;
1725    }    }
1726    setvbuf( cfp, NULL, _IONBF, BUFSIZ );    setvbuf( cfp, NULL, _IONBF, BUFSIZ );
1727  #endif /* CHIN */  #endif /* CHIN */
1728  #ifdef REON  #ifdef REON
1729    if ( (rfp = fopen("logreg.txt", "at")) == NULL ) {    if ( (rfp = fopen( "logreg.txt", "at" )) == NULL ) {
1730     perror("logreg.txt");     perror( "logreg.txt" );
1731     return errno;     return errno;
1732    }    }
1733    setvbuf( rfp, NULL, _IONBF, BUFSIZ );    setvbuf( rfp, NULL, _IONBF, BUFSIZ );
1734  #endif /* REON */  #endif /* REON */
 /* MAKAI end */  
1735    
1736    mincnt = 0x7FFFFFFF;    mincnt = 0x7FFFFFFF;
1737    nblk_hit = nblk_total = 0;    nblk_hit = nblk_total = 0;
# Line 1834  main(int argc, char *argv[]) Line 1740  main(int argc, char *argv[])
1740    memset( &status, 0, sizeof( struct status ) );    memset( &status, 0, sizeof( struct status ) );
1741    status.startTime = status.lastTime = usec();    status.startTime = status.lastTime = usec();
1742    
 /* MAKAI start */  
1743  #ifdef MINAST  #ifdef MINAST
1744  #undef assert  #undef assert
1745  #define assert(x)  #define assert(x)
1746  #endif /* MINAST */  #endif /* MINAST */
 /* MAKAI end */  
1747    
1748    /* 探索ループだぞっと */    /* 探索ループだぞっと */
1749    for (;;)    for ( ;; ) {
1750          {     struct PACKET_CRYPT64 *pkt_c;
1751            struct PACKET_CRYPT64 *pkt_c;     uint64_t cnt;
           uint64_t cnt;  
 #if DEBUG>=1 /* MAKAI */  
           int cnt1, cnt2;  
 #endif /* MAKAI */  
           int k, kk;  
   
           /* 比較器候補(may be NULL)  
                  先にキューから取り出す */  
           pkt_c = q_cmp[WRAP(rp_cmp, NQ_CMP)];  
           if (pkt_c != NULL && WRAP(rp_cmp, NQ_CMP) != WRAP(wp_cmp, NQ_CMP))  
                 {  
                   pkt_c = LOCK_CASP(&q_cmp[WRAP(rp_cmp, NQ_CMP)], NULL, pkt_c);  
                   assert(pkt_c != NULL);  
                   LOCK_INC(&rp_cmp);  
   
                   /* パケットを vacant に回しておく */  
                   pkts_vacant |= 1ULL << (pkt_c - pkts);  
                 }  
   
           /* Saltチェンジ待ち */  
           if (!ks_activated)  
                 {  
                   ATOMWORD_T rp;  
   
                   if (pkt_c == NULL)  
                         {  
                           if ((rp = rp_crypt,  
                                    WRAP(rp, NQ_CRYPT) != WRAP(wp_crypt, NQ_CRYPT))  
                                   && LOCK_CAS(&rp_crypt, rp + 1, rp) == rp)  
                                 {  
                                   /* !ks_activate 状態では、自らも要求キューをやっつけにいく */  
                                   rp = WRAP(rp, NQ_CRYPT);  
                                   pkt_c = q_crypt[rp];  
                                   assert(pkt_c != NULL);  
                                   pkt_c = LOCK_CASP(&q_crypt[rp], NULL, pkt_c);  
                                   assert(pkt_c != NULL);  
                                   assert(pkt_c != pkt_hit);  
                                   CALL_CRYPT64(code,  
                                                            &pkt_c->key64,  
                                                            &pkt_c->param64);  
   
                                   /* パケットを vacant に回しておく */  
                                   pkts_vacant |= 1ULL << (pkt_c - pkts);  
                                 }  
                           else  
                                 {  
                                   /* やはりすることがないのでまったりと過ごす */  
                                   if (nidle != nthreads)  
                                         thread_sleep(1);  
                                 }  
                         }  
   
                   if (nidle == nthreads)  
                         {  
                           assert(WRAP(rp_crypt, NQ_CRYPT) == WRAP(wp_crypt, NQ_CRYPT));  
                           /* Salt チェンジが可能 */  
                           set_salt(code, crypt64_descs[0], key);  
                           if (nthreads)  
                                 thread_signal_event(event_ks_activated);  
                           ks_activated = 1;  
                         }  
                 }  
   
           /* 鍵をキューにたたき込みまくる */  
           if (!ks_activated)  
                 {  
                   /* 鍵を登録しない */  
                   ;  
                 }  
           else for (i = npkts - 1; i >= 0; i--)  
                 if (pkts_vacant & (1ULL << i))  
                   {  
                         int j;  
   
                         if (i == npkts - 1)  
                           {  
                                 /* 前段で、働くおじさんから  
                                    結果をもらっていたら、何もしない */  
                                 if (pkt_c != NULL)  
                                   continue;  
                           }  
                         else  
                           {  
                                 /* 前段で取り出したばかりの  
                                    働くおじさんは、尊重する */  
                                 if (&pkts[i] == pkt_c)  
                                   continue;  
   
                                 /* queue full の場合は見送る */  
                                 if (WRAP(wp_crypt, NQ_CRYPT) == WRAP(rp_crypt - 16, NQ_CRYPT)   /* XXX 16 はてきとう */  
                                         || q_crypt[WRAP(wp_crypt, NQ_CRYPT)] != NULL)  
                                   break;  
                           }  
   
                         /* 鍵のセット */  
                         for (j = 0; j < 8; j++)  
                           {  
                                 key_set64(&pkts[i].key64, j, key[j], key[j] ^ pkts[i].uk.key[j], 0);  
                                 pkts[i].uk.key[j] = key[j];  
                           }  
   
                         if (i == npkts - 1)  
                           {  
                                 /* 次段で CRYPT64->CMP */  
                                 assert(pkt_c == NULL);  
                                 pkt_c = &pkts[i];  
                                 assert(pkt_c == pkt_hit);  
                           }  
                         else  
                           {  
                                 /* キューにたたき込む */  
                                 while (LOCK_CASP(&q_crypt[WRAP(wp_crypt, NQ_CRYPT)], &pkts[i], NULL) != NULL)  
                                   {  
                                         /* 設計上はここに来ない */  
 #if DEBUG>=1  
                                         fprintf(stderr,  
                                                         "[XXX] q_crypt を汚してるのは誰だ? (rp=%3d, wp=%3d, v=%08X%08X)\n",  
                                                         (unsigned)WRAP(rp_crypt, NQ_CRYPT),  
                                                         (unsigned)WRAP(wp_crypt, NQ_CRYPT),  
                                                         (unsigned)(pkts_vacant >> 32),  
                                                         (unsigned)pkts_vacant);  
                                         thread_sleep(1000);  
 #endif  
                                         thread_sleep(1);  
                                   }  
                                 LOCK_INC(&wp_crypt);  
                                 pkts_vacant ^= 1ULL << i;  
                                 assert(!(pkts_vacant & (1ULL << i)));   /* 削れ */  
                           }  
   
                         /* 鍵増加はこんなところに移動! */  
                         assert(ks_activated);  
 /* MAKAI start */  
                         if (!key_inc(key, 6) && !key_inc(key, umeLen))  
 /* MAKAI end */  
                           {  
                                 /* 鍵のシャッフル  
                                    q_crypt が捌けるまで、set_salt() はできない */  
1752  #if DEBUG>=1  #if DEBUG>=1
1753                                  fprintf(stderr, "********************************SHUFFLE!\n");     int cnt1, cnt2;
1754  #endif  #endif
1755                                  if (nthreads)     int k, kk;
                                   thread_clear_event(event_ks_activated);  
                                 key_reset(key, 0);  
1756    
1757                                  /* キューの鍵が捌けるまでアイドル状態に */     /* 比較器候補(may be NULL)
1758                                  ks_activated = 0;        先にキューから取り出す */
1759       pkt_c = q_cmp[WRAP( rp_cmp, NQ_CMP )];
1760                                  /* スレッドをブーストして回る */     if ( pkt_c != NULL && WRAP( rp_cmp, NQ_CMP ) != WRAP( wp_cmp, NQ_CMP ) ) {
1761  #ifdef thread_set_priority      pkt_c = LOCK_CASP( &q_cmp[WRAP( rp_cmp, NQ_CMP )], NULL, pkt_c );
1762                                  for (j = 0; j < nthreads; j++)      assert( pkt_c != NULL );
1763                                    {      LOCK_INC( &rp_cmp );
1764                                          assert(threads != NULL);      /* パケットを vacant に回しておく */
1765                                          thread_set_priority(threads[j].th, THREAD_PRIORITY_NORMAL);      pkts_vacant |= 1ULL << (pkt_c - pkts);
1766                                    }     }
1767  #endif  
1768       /* Saltチェンジ待ち */
1769                                  /* ループ続行はもはや不要 */     if ( !ks_activated ) {
1770                                  break;      ATOMWORD_T rp;
1771                            }      if ( pkt_c == NULL ) {
1772                    }       if ( (rp = rp_crypt, WRAP( rp, NQ_CRYPT ) != WRAP( wp_crypt, NQ_CRYPT ))
1773              && LOCK_CAS( &rp_crypt, rp + 1, rp ) == rp ) {
1774            /* することがなくなっている場合 */        /* !ks_activate 状態では、自らも要求キューをやっつけにいく */
1775            if (pkt_c == NULL)        rp = WRAP( rp, NQ_CRYPT );
1776                  {        pkt_c = q_crypt[rp];
1777                    assert(!ks_activated);        assert( pkt_c != NULL );
1778                    continue;        pkt_c = LOCK_CASP( &q_crypt[rp], NULL, pkt_c );
1779                  }        assert( pkt_c != NULL );
1780          assert( pkt_c != pkt_hit );
1781            /* 呼ぶ!        CALL_CRYPT64( code, &pkt_c->key64, &pkt_c->param64 );
1782                   LR 初期化は、サブモジュール内で行うべし        /* パケットを vacant に回しておく */
1783                   FASTCALL に準じた呼び出しのため、        pkts_vacant |= 1ULL << (pkt_c - pkts);
1784                   ホントはいろいろレジスタが破壊されるハズ…なんだが。 */       } else {
1785            if (pkt_c != pkt_hit)        /* やはりすることがないのでまったりと過ごす */
1786                  {        if ( nidle != nthreads ) thread_sleep(1);
1787                    assert(code_cmp != 0);       }
1788                    cnt = CALL_CMP64(code + code_cmp,      }
1789                                                     pkt_hit->param64.hit,      if ( nidle == nthreads ) {
1790                                                     pkt_c->param64.lr);       assert( WRAP( rp_crypt, NQ_CRYPT ) == WRAP( wp_crypt, NQ_CRYPT ) );
1791                  }       /* Salt チェンジが可能 */
1792            else       set_salt( code, crypt64_descs[0], key );
1793                  {       if ( nthreads ) thread_signal_event( event_ks_activated );
1794                    /* ようやく自スレッドで回せる */       ks_activated = 1;
1795                    cnt = CALL_CRYPT64(code,      }
1796                                                           &pkt_c->key64,     }
                                                          &pkt_c->param64);  
                   if (code_cmp)  
                         cnt = CALL_CMP64(code + code_cmp,  
                                                          pkt_c->param64.hit,  
                                                          pkt_c->param64.lr);  
                 }  
1797    
1798       /* 鍵をキューにたたき込みまくる */
1799       if ( !ks_activated ) {
1800        /* 鍵を登録しない */
1801        ;
1802       } else {
1803        for ( i = npkts - 1; i >= 0; i-- ) {
1804         if ( pkts_vacant & (1ULL << i) ) {
1805          int j;
1806          if ( i == npkts - 1 ) {
1807           /* 前段で、働くおじさんから結果をもらっていたら、何もしない */
1808           if ( pkt_c != NULL ) continue;
1809          } else {
1810           /* 前段で取り出したばかりの働くおじさんは、尊重する */
1811           if ( &pkts[i] == pkt_c ) continue;
1812           /* queue full の場合は見送る */
1813           /* XXX 16 はてきとう */
1814           if ( WRAP( wp_crypt, NQ_CRYPT ) == WRAP( rp_crypt - 16, NQ_CRYPT )
1815                || q_crypt[WRAP( wp_crypt, NQ_CRYPT )] != NULL ) break;
1816          }
1817          /* 鍵のセット */
1818          for ( j = 0; j < 8; j++ ) {
1819           key_set64( &pkts[i].key64, j, key[j], key[j] ^ pkts[i].uk.key[j], 0 );
1820           pkts[i].uk.key[j] = key[j];
1821          }
1822          if ( i == npkts - 1 ) {
1823           /* 次段で CRYPT64->CMP */
1824           assert(pkt_c == NULL);
1825           pkt_c = &pkts[i];
1826           assert( pkt_c == pkt_hit );
1827          } else {
1828           /* キューにたたき込む */
1829           while ( LOCK_CASP( &q_crypt[WRAP( wp_crypt, NQ_CRYPT )], &pkts[i], NULL )
1830                   != NULL ) {
1831            /* 設計上はここに来ない */
1832            fprintf( stderr,
1833                     "q_crypt を汚してるのは誰だ? (rp=%3d, wp=%3d, v=%08X%08X)\n",
1834                     (unsigned)WRAP( rp_crypt, NQ_CRYPT ),
1835                     (unsigned)WRAP( wp_crypt, NQ_CRYPT ),
1836                     (unsigned)( pkts_vacant >> 32 ),
1837                     (unsigned)pkts_vacant );
1838            thread_sleep( 1000 );
1839           }
1840           LOCK_INC( &wp_crypt );
1841           pkts_vacant ^= 1ULL << i;
1842           assert( !(pkts_vacant & (1ULL << i)) );  /* 削れ */
1843          }
1844          /* 鍵増加はこんなところに移動! */
1845          assert( ks_activated );
1846          if ( !key_inc( key, 6 ) && !key_inc( key, umeLen ) ) {
1847           /* 鍵のシャッフル q_crypt が捌けるまで、set_salt() はできない */
1848  #if DEBUG>=1  #if DEBUG>=1
1849            cnt2 = (int32_t)(cnt >> 32);         fprintf( stderr, "********************************SHUFFLE!\n" );
           cnt1 = (int32_t)cnt;  
           if (mincnt > cnt1 && cnt1 > 0)  
                 {  
                   mincnt = cnt1;  
                   if (cr)  
                         fprintf(stderr, "\n");  
                   cr = 0;  
                   fprintf(stderr, "cycle=%6d/%6d\n", cnt1, cnt2);  
                 }  
1850  #endif  #endif
1851           if ( nthreads ) thread_clear_event( event_ks_activated );
1852            /* ヒットしたときの処理         key_reset( key, 0 );
1853                   key および lr は pkt_c に         /* キューの鍵が捌けるまでアイドル状態に */
1854                   合致判定は pkt_hit に入っているハズ */         ks_activated = 0;
1855            xhash_loaded = 0;         /* スレッドをブーストして回る */
1856            for (kk = 0; kk < N_ALU; kk++)  #ifdef thread_set_priority
1857                  {         for ( j = 0; j < nthreads; j++ ) {
1858                    ALU_T t;          assert( threads != NULL );
1859            thread_set_priority( threads[j].th, THREAD_PRIORITY_NORMAL );
1860  /* MAKAI start */         }
1861    static uint64_t xhash[64];  #endif
1862           /* ループ続行はもはや不要 */
1863    if ( special         break;
1864          }
1865         }
1866        }
1867       }
1868       /* することがなくなっている場合 */
1869       if ( pkt_c == NULL ) {
1870        assert( !ks_activated );
1871        continue;
1872       }
1873       /* 呼ぶ!
1874          LR 初期化は、サブモジュール内で行うべし
1875          FASTCALL に準じた呼び出しのため、
1876          ホントはいろいろレジスタが破壊されるハズ…なんだが。 */
1877       if ( pkt_c != pkt_hit ) {
1878        assert( code_cmp != 0 );
1879        cnt = CALL_CMP64( code + code_cmp, pkt_hit->param64.hit,
1880                          pkt_c->param64.lr );
1881       } else {
1882        /* ようやく自スレッドで回せる */
1883        cnt = CALL_CRYPT64( code, &pkt_c->key64, &pkt_c->param64 );
1884        if ( code_cmp ) {
1885         cnt = CALL_CMP64( code + code_cmp, pkt_c->param64.hit,
1886                           pkt_c->param64.lr );
1887        }
1888       }
1889       /* ヒットしたときの処理
1890          key および lr は pkt_c に合致判定は pkt_hit に入っているハズ */
1891       xhash_loaded = 0;
1892       for ( kk = 0; kk < N_ALU; kk++ ) {
1893        ALU_T t;
1894        static uint64_t xhash[64];
1895        if ( special
1896  #ifdef REON  #ifdef REON
1897         || regExpStr[0] != '\0'           || regExpStr[0] != '\0'
1898  #endif /* REON */  #endif /* REON */
1899       ) {         ) {
1900     CALL_TR64( &pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash );       CALL_TR64( &pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash );
1901     xhash_loaded = 1;       xhash_loaded = 1;
1902    }      }
1903  /* MAKAI end */      if ( !(kk & (N_ALU / N_Q - 1)) ) nblk_total++, xhash_loaded = 0;
1904        if ( special
                   if (!(kk & (N_ALU / N_Q - 1)))  
                         nblk_total++, xhash_loaded = 0;  
   
 /* MAKAI start */  
   if ( special  
1905  #ifdef REON  #ifdef REON
1906         || regExpStr[0] != '\0'           || regExpStr[0] != '\0'
1907  #endif /* REON */  #endif /* REON */
1908       ) {         ) {
1909     char hash[16];       char hash[16];
1910     uint8_t buf[32];       FILE       *lfp;
1911     FILE *lfp;       unsigned char      kind[3];
1912     unsigned char        kind[3];       for ( k = 0; k < ALU_BITS; k++ ) {
1913          for ( i = 1; i < 11; i++ ) {
1914     for ( k = 0; k < ALU_BITS; k++ ) {         unsigned c = 0;
1915      for ( i = 1; i < 11; i++ ) {         c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;
1916       unsigned c = 0;         hash[i - 1] = C64[c];
1917          }
1918       c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;        hash[10] = 0;
      hash[i - 1] = C64[c];  
     }  
     hash[10] = 0;  
   
1919  #ifdef REON  #ifdef REON
1920      if ( regExpStr[0] != '\0' ) {        if ( regExpStr[0] != '\0' ) {
1921       if ( regexec( &regExp, hash, (size_t)0, NULL, 0 ) == 0 ) {         if ( regexec( &regExp, hash, (size_t)0, NULL, 0 ) == 0 ) {
1922        struct timeb tb;          if ( cr ) fprintf( stderr, "\n" );
1923        struct tm *plt;          cr = 0;
       uint8_t buf2[32];  
   
       ftime( &tb );  
       plt = localtime( &tb.time );  
       buf[0] = '#';  
       memcpy( buf+1, pkt_c->uk.key, 8 );  
       buf[9] = buf[10] = 0;  
       buf[8] = ( buf[8] & - ( 1 << N_STRIDE ) & 0x7F ) + ALU_BITS * kk + k;  
       if ( cr ) fprintf( stderr, "\n" );  
       cr = 0;  
 /* MAKAI start */  
1924  #ifdef NAMA  #ifdef NAMA
1925        log_printf(rfp, "◆%s ##%02x%02x%02x%02x%02x%02x%02x%02x%c%c"          hit( rfp, hash, pkt_c->uk.key, kk, k, "正", MAKAI_FALSE );
                  "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"  
                  " 正 生\n",  
                   hash,  
                   buf[1], buf[2], buf[3], buf[4],  
                   buf[5], buf[6], buf[7], buf[8],  
                   saltChar[0], saltChar[1],  
                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,  
                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm);  
1926  #else /* NAMA */  #else /* NAMA */
1927        if ( translate( buf+1, 0, 1 ) ) {          hit( rfp, hash, pkt_c->uk.key, kk, k, "正", MAKAI_TRUE );
        strcpy( buf2, buf );  
       } else {  
        strcpy( buf2, "残念でした" );  
       }  
       log_printf( rfp, "◆%s %s"  
                   "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"  
                   "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X) %s\n",  
                   hash, buf2,  
                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,  
                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,  
                   buf[1], buf[2], buf[3], buf[4], buf[5],  
                   buf[6], buf[7], buf[8], buf[9], "正" );  
1928  #endif /* NAMA */  #endif /* NAMA */
1929  /* MAKAI end */         }
1930       }        }
     }  
1931  #endif /* REON */  #endif /* REON */
1932          if ( special ) {
1933      if ( special ) {         if ( (lfp = checkSpecial( hash, kind )) != NULL ) {
1934       if ( (lfp = checkSpecial( hash, kind )) != NULL ) {          if ( cr ) fprintf( stderr, "\n" );
1935        struct timeb tb;          cr = 0;
       struct tm *plt;  
       uint8_t buf2[32];  
   
       ftime( &tb );  
       plt = localtime( &tb.time );  
       buf[0] = '#';  
       memcpy( buf+1, pkt_c->uk.key, 8 );  
       buf[9] = buf[10] = 0;  
       buf[8] = ( buf[8] & - ( 1 << N_STRIDE ) & 0x7F ) + ALU_BITS * kk + k;  
       if ( cr ) fprintf( stderr, "\n" );  
       cr = 0;  
 /* MAKAI start */  
1936  #ifdef NAMA  #ifdef NAMA
1937        log_printf(lfp, "◆%s ##%02x%02x%02x%02x%02x%02x%02x%02x%c%c"          hit( lfp, hash, pkt_c->uk.key, kk, k, kind, MAKAI_FALSE );
                  "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"  
                  " %s 生\n",  
                   hash,  
                   buf[1], buf[2], buf[3], buf[4],  
                   buf[5], buf[6], buf[7], buf[8],  
                   saltChar[0], saltChar[1],  
                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,  
                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm, kind);  
1938  #else /* NAMA */  #else /* NAMA */
1939        if ( translate( buf+1, 0, 1 ) ) {          hit( lfp, hash, pkt_c->uk.key, kk, k, kind, MAKAI_TRUE );
        strcpy( buf2, buf );  
       } else {  
        strcpy( buf2, "残念でした" );  
       }  
       log_printf( lfp, "◆%s %s"  
                   "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"  
                   "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X) %s\n",  
                   hash, buf2,  
                   plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,  
                   plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,  
                   buf[1], buf[2], buf[3], buf[4], buf[5],  
                   buf[6], buf[7], buf[8], buf[9], kind );  
1940  #endif /* NAMA */  #endif /* NAMA */
1941  /* MAKAI end */         }
1942          }
1943       }       }
1944      }      }
    }  
   }  
 /* MAKAI end */  
   
                   t = pkt_hit->param64.hit[HIT_ANY].a[kk];  
                   if (!t)  
                         continue;  
   
                   nap_total += ALU_BITS;  
   
                   for (k = 0; k < ALU_BITS; k++)  
                         {  
   
 /* MAKAI start */  
 #if 0  
                           static uint64_t xhash[64];  
 #endif /* 0 */  
 /* MAKAI end */  
   
                           char hash[16];  
                           uint8_t buf[32];  
                           uint8_t buf2[32];  
                           struct timeb tb;  
                           struct tm *plt;  
1945    
1946  /* MAKAI start */      t = pkt_hit->param64.hit[HIT_ANY].a[kk];
1947    int   hitLen;      if ( !t ) continue;
1948  /* MAKAI end */      nap_total += ALU_BITS;
1949        for ( k = 0; k < ALU_BITS; k++ ) {
1950                            if (!(t & ((ALU_T)1 << k)))       char hash[16];
1951                                  continue;       int        hitLen;
1952         if ( !(t & ((ALU_T)1 << k)) ) continue;
1953                            nap_hit++;       nap_hit++;
1954         /* 転置 */
1955                            /* 転置 */       if ( !xhash_loaded ) {
1956                            if (!xhash_loaded)        nblk_hit++;
1957                                  {        CALL_TR64( &pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash );
1958                                    nblk_hit++;        xhash_loaded = 1;
1959                                    CALL_TR64(&pkt_c->param64.lr[0][0].q[kk / (N_ALU / N_Q)], xhash);       }
1960                                    xhash_loaded = 1;       /* 辞書を調べる */
1961                                  }       hitLen = 0;
1962         if ( !((pkt_hit->param64.hit[HIT_BOOL].a[kk] & ((ALU_T)1 << k))
1963                            /* 辞書を調べる */              || (hitLen = wdict_ishit( pkt_hit->param64.hit, kk, k,
1964  /* MAKAI hitLen 追加 */                                        xhash[(ALU_BITS * kk + k) & 0x3F]))) )
1965                            if (!((pkt_hit->param64.hit[HIT_BOOL].a[kk] & ((ALU_T)1 << k))        continue;
1966                                          || (hitLen = wdict_ishit(pkt_hit->param64.hit,       for ( i = 1; i < 11; i++ ) {
1967                                                                     kk, k,        unsigned c;
1968                                                                     xhash[(ALU_BITS * kk + k) & 0x3F]))))        c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;
1969                                  continue;        hash[i - 1] = C64[c];
1970         }
1971                            /* ヒット時刻; 魔改造とちょっと違う */       hash[10] = 0;
1972                            ftime(&tb);       if ( cr ) fprintf( stderr, "\n" );
1973                            plt = localtime(&tb.time);       cr = 0;
1974    {
1975                            for (i = 1; i < 11; i++)       unsigned char      len[10];
1976                                  {       sprintf( len, "%02d", hitLen );
                                   unsigned c = 0;  
                                   c = (xhash[(ALU_BITS * kk + k) & 63] >> (6 * (i - 1))) & 0x3F;        /* XXX */  
                                   hash[i - 1] = C64[c];  
                                 }  
                           hash[10] = 0;  
   
                           memcpy(buf, pkt_c->uk.key, 8);  
                           buf[8] = buf[9] = 0;  
                           buf[7] = (buf[7] & -(1 << N_STRIDE) & 0x7F) + ALU_BITS * kk + k;  
   
 /* MAKAI start */  
 /* 見にくいので整理 */  
                           if (cr)  
                                 fprintf(stderr, "\n");  
                           cr = 0;  
1977  #ifdef NAMA  #ifdef NAMA
1978                            log_printf(ofp, "◆%s ##%02x%02x%02x%02x%02x%02x%02x%02x%c%c"       hit( ofp, hash, pkt_c->uk.key, kk, k, len, MAKAI_FALSE );
                                                  "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"  
                                                  " %02d 生\n",  
                                                  hash,  
                                                  buf[0], buf[1], buf[2], buf[3],  
                                                  buf[4], buf[5], buf[6], buf[7],  
                                                  saltChar[0], saltChar[1],  
                                                  plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,  
                                                  plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,  
                                                  hitLen);  
1979  #else /* NAMA */  #else /* NAMA */
1980                            if (translate(buf, 0, 1)) {       hit( ofp, hash, pkt_c->uk.key, kk, k, len, MAKAI_TRUE );
                            buf2[0] = '#';  
                            strcpy( buf2+1, buf );  
                           } else {  
                strcpy( buf2, "残念でした" );  
               }  
                           log_printf(ofp, "◆%s %s"  
                                                  "\t%04d/%02d/%02d %02d:%02d:%02d.%03d"  
                                                  "\t(%02X %02X %02X %02X %02X %02X %02X %02X/%02X) %02d\n",  
                                                  hash, buf2,  
                                                  plt->tm_year + 1900, plt->tm_mon + 1, plt->tm_mday,  
                                                  plt->tm_hour, plt->tm_min, plt->tm_sec, tb.millitm,  
                                                  buf[0], buf[1], buf[2], buf[3],  
                                                  buf[4], buf[5], buf[6], buf[7],  
                                                  buf[8], hitLen);  
1981  #endif /* NAMA */  #endif /* NAMA */
1982  /* MAKAI end */  }
1983        }
1984                          }     }
                 }  
   
           /* 速度計測 */  
           status.loop += N_ALU * ALU_BITS;  
           if (status.loop>= status.lastloop + upd_int  
                   && (curTime = usec()) != status.lastTime)  
                 {  
                   uint64_t diffTime;  
                   int a, b, c;  
   
                   /* 通算(単位 ktrips/sec) */  
                   diffTime = curTime - status.startTime;  
                   a = status.loop / ((1000 / USEC_SEC) * diffTime);  
1985    
1986  /* MAKAI start */     /* 速度計測 */
1987       status.loop += N_ALU * ALU_BITS;
1988       if ( status.loop >= status.lastloop + upd_int
1989            && (curTime = usec()) != status.lastTime ) {
1990        uint64_t diffTime;
1991        int a, b, c;
1992        /* 通算(単位 ktrips/sec) */
1993        diffTime = curTime - status.startTime;
1994        a = status.loop / ((1000 / USEC_SEC) * diffTime);
1995  #ifdef BENCH  #ifdef BENCH
1996            if ( (diffTime / USEC_SEC) > (BENCH * 60) ) {      if ( (diffTime / USEC_SEC) > (BENCH * 60) ) {
1997                     fprintf( stderr, "\n%6dktrips/s\n", a );       fprintf( stderr, "\n%6dktrips/s\n", a );
1998             exit( 0 );       exit( 0 );
1999            }      }
2000  #endif /* BENCH */  #endif /* BENCH */
2001  /* MAKAI end */      /* 区間(単位 trips/sec) */
2002        diffTime = curTime - status.lastTime;
2003                    /* 区間(単位 trips/sec) */      b = USEC_SEC * (status.loop - status.lastloop) / diffTime;
2004                    diffTime = curTime - status.lastTime;      /* 予測 */
2005                    b = USEC_SEC * (status.loop - status.lastloop) / diffTime;      c = UPDATE_INTERVAL * b;
2006        /* 立ち上がりなど、誤差があり upd_int が小さすぎたときは
2007                    /* 予測 */         いきなり全補正せず 1 秒(==b)づつ収斂させる。 */
2008                    c = UPDATE_INTERVAL * b;      upd_int = ( upd_int + b < c ? upd_int + b : c );
2009        status.lastTime = curTime;
2010                    /* 立ち上がりなど、誤差があり upd_int が小さすぎたときは      status.lastloop = status.loop;
2011                           いきなり全補正せず 1 秒(==b)づつ収斂させる。 */      fprintf( stderr, "%6dktrips/s [%6d.%03dktrips/s]\r",
2012                    upd_int = (upd_int + b < c               a, b / 1000, b % 1000 );
2013                                           ? upd_int + b      cr++;
2014                                           : c);     }
2015      }
                   status.lastTime = curTime;  
                   status.lastloop = status.loop;  
 #if DEBUG>=1  
                   fprintf(stderr,  
                           "%5d/%5d(%3d%%)",  
                           nblk_hit, nblk_total, 100 * nblk_hit / nblk_total);  
                   nblk_hit = nblk_total = 0;  
                   if (nap_total)  
                         fprintf(stderr,  
                                 "  %5d/%5d(%3d%%)",  
                                 nap_hit, nap_total, 100 * nap_hit / nap_total);  
                   else  
                         fprintf(stderr,  
                                         "  -----/-----(---%%)");  
                   nap_hit = nap_total = 0;  
 #endif  
                   fprintf( stderr,  
                         "%6dktrips/s [%6d.%03dktrips/s]\r",  
                         a, b / 1000, b % 1000 );  
                   cr++;  
                 }  
         }  
2016    
2017    return 0;    return 0;
2018  }  }
Legend:
Removed from v.226  
changed lines
  Added in v.227
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
About OSDN
Find Software
Develop Software
Help