← Back to branch summary

~ubuntu-branches/ubuntu/warty/gnushogi/warty

« back to all changes in this revision

Viewing changes to gnushogi/sizetest.c

  • Committer: Bazaar Package Importer
  • Author(s): Javier Fernandez-Sanguino Pen~a
  • Date: 2004-01-09 16:06:59 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040109160659-n26nu7009llm247p
Tags: 1.3-3.1
http://bugs.debian.org/169975
http://bugs.debian.org/226319
* NMU
 - Minimal testing done and looks quite OK (even if I don't know
   how to play the game...)
 - Build-Depends move from libxaw-dev to libxaw6-dev (Closes: #169975)
 - Included errno.h in gnushogi which makes the binary build properly
   now (and is usable with xshogi) (Closes: #226319)

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnushogi/sizetest.c
 
1
/*
 
2
 * FILE: sizetest.c
 
3
 *
 
4
 *     Display memory usage of GNU Shogi data structures.
 
5
 *
 
6
 * ----------------------------------------------------------------------
 
7
 * Copyright (c) 1993, 1994, 1995 Matthias Mutz
 
8
 * Copyright (c) 1999 Michael Vanier and the Free Software Foundation
 
9
 *
 
10
 * GNU SHOGI is based on GNU CHESS
 
11
 *
 
12
 * Copyright (c) 1988, 1989, 1990 John Stanback
 
13
 * Copyright (c) 1992 Free Software Foundation
 
14
 *
 
15
 * This file is part of GNU SHOGI.
 
16
 *
 
17
 * GNU Shogi is free software; you can redistribute it and/or modify it
 
18
 * under the terms of the GNU General Public License as published by the
 
19
 * Free Software Foundation; either version 1, or (at your option) any
 
20
 * later version.
 
21
 *
 
22
 * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
 
23
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 
24
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 
25
 * for more details.
 
26
 *
 
27
 * You should have received a copy of the GNU General Public License along
 
28
 * with GNU Shogi; see the file COPYING.  If not, write to the Free
 
29
 * Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
 
30
 * ----------------------------------------------------------------------
 
31
 *
 
32
 */
 
33
 
 
34
#include "version.h"
 
35
#include "gnushogi.h"
 
36
 
 
37
#include <signal.h>
 
38
 
 
39
struct leaf  *Tree, *root;
 
40
 
 
41
short FROMsquare, TOsquare;
 
42
 
 
43
small_short ChkFlag[MAXDEPTH], CptrFlag[MAXDEPTH], TesujiFlag[MAXDEPTH];
 
44
short Pscore[MAXDEPTH], Tscore[MAXDEPTH];
 
45
small_short Pindex[NO_SQUARES];
 
46
 
 
47
short mtl[2], hung[2];
 
48
small_short PieceCnt[2];
 
49
 
 
50
struct GameRec  *GameList;
 
51
 
 
52
char ColorStr[2][10];
 
53
 
 
54
long znodes;
 
55
 
 
56
 
 
57
/*
 
58
 * In a networked enviroment gnushogi might be compiled on different hosts
 
59
 * with different random number generators; that is not acceptable if they
 
60
 * are going to share the same transposition table.
 
61
 */
 
62
 
 
63
unsigned long next = 1;
 
64
 
 
65
unsigned int
 
66
urand(void)
 
67
{
 
68
    next *= 1103515245;
 
69
    next += 12345;
 
70
    return ((unsigned int) (next >> 16) & 0xFFFF);
 
71
}
 
72
 
 
73
 
 
74
void
 
75
gsrand(unsigned int seed)
 
76
{
 
77
    next = seed;
 
78
}
 
79
 
 
80
 
 
81
#if ttblsz
 
82
struct hashentry *ttable[2];
 
83
unsigned int ttblsize;
 
84
#endif
 
85
 
 
86
#ifdef BINBOOK
 
87
extern char *binbookfile;
 
88
#endif
 
89
 
 
90
extern char *bookfile;
 
91
 
 
92
char savefile[128] = "";
 
93
char listfile[128] = "";
 
94
 
 
95
#if defined HISTORY
 
96
unsigned short *history;
 
97
#endif
 
98
 
 
99
short rpthash[2][256];
 
100
short TrPnt[MAXDEPTH];
 
101
small_short PieceList[2][NO_SQUARES];
 
102
small_short PawnCnt[2][NO_COLS];
 
103
small_short Captured[2][NO_PIECES];
 
104
small_short Mvboard[NO_SQUARES];
 
105
 
 
106
#if !defined SAVE_SVALUE
 
107
short svalue[NO_SQUARES];
 
108
#endif
 
109
 
 
110
struct flags flag;
 
111
 
 
112
short opponent, computer, WAwindow, WBwindow, BAwindow, BBwindow, dither,
 
113
    INCscore;
 
114
long ResponseTime, ExtraTime, MaxResponseTime, et, et0, time0, ft;
 
115
long GenCnt, NodeCnt, ETnodes, EvalNodes, HashCnt,
 
116
    HashAdd, FHashCnt, FHashAdd,
 
117
    HashCol, THashCol, filesz, hashmask, hashbase;
 
118
long replus, reminus;
 
119
short HashDepth = HASHDEPTH, HashMoveLimit = HASHMOVELIMIT;
 
120
short player, xwndw;
 
121
/*unsigned*/ short rehash; /* -1 is used as a flag --tpm */
 
122
short Sdepth, Game50, MaxSearchDepth;
 
123
short GameCnt = 0;
 
124
short contempt;
 
125
int Book;
 
126
struct TimeControlRec TimeControl;
 
127
int TCadd = 0;
 
128
short TCflag, TCmoves, TCminutes, TCseconds, OperatorTime;
 
129
short XCmoves[3], XCminutes[3], XCseconds[3], XC, XCmore;
 
130
const short otherside[3] = { white, black, neutral };
 
131
unsigned short hint;
 
132
short TOflag;       /* force search re-init if we backup search */
 
133
 
 
134
unsigned short killr0[MAXDEPTH], killr1[MAXDEPTH];
 
135
unsigned short killr2[MAXDEPTH], killr3[MAXDEPTH];
 
136
unsigned short PV, SwagHt, Swag0, Swag1, Swag2, Swag3, Swag4, sidebit;
 
137
 
 
138
small_short HasPiece[2][NO_PIECES];
 
139
const short kingP[3] = { 4, 76, 0 };
 
140
 
 
141
const long control[NO_PIECES] =
 
142
{ 0, ctlP, ctlL, ctlN, ctlS, ctlG, ctlB, ctlR,
 
143
  ctlPp, ctlLp, ctlNp, ctlSp, ctlBp, ctlRp, ctlK };
 
144
 
 
145
short stage, stage2;
 
146
 
 
147
FILE *hashfile;
 
148
 
 
149
unsigned int starttime;
 
150
short ahead = true, hash = true;
 
151
 
 
152
 
 
153
int timeopp[MINGAMEIN], timecomp[MINGAMEIN];
 
154
int compptr, oppptr;
 
155
 
 
156
void
 
157
TimeCalc()
 
158
{
 
159
    /* adjust number of moves remaining in gamein games */
 
160
    int increment = 0;
 
161
    int topsum = 0;
 
162
    int tcompsum = 0;
 
163
    int me, him;
 
164
    int i;
 
165
 
 
166
    /* don't do anything til you have enough numbers */
 
167
    if (GameCnt < (MINGAMEIN * 2))
 
168
        return;
 
169
 
 
170
    /* calculate average time in sec for last MINGAMEIN moves */
 
171
    for (i = 0; i < MINGAMEIN; i++)
 
172
    {
 
173
        tcompsum += timecomp[i];
 
174
        topsum += timeopp[i];
 
175
    }
 
176
 
 
177
    topsum /= (100 * MINGAMEIN);
 
178
    tcompsum /= (100 * MINGAMEIN);
 
179
    /* if I have less time than opponent add another move */
 
180
    me = TimeControl.clock[computer] / 100;
 
181
    him = TimeControl.clock[opponent] / 100;
 
182
 
 
183
    if (me < him)
 
184
        increment += 2;
 
185
 
 
186
    if (((him - me) > 60) || ((me < him) && (me < 120)))
 
187
        increment++;
 
188
 
 
189
    /* if I am losing more time with each move add another */
 
190
    /* if (!((me - him) > 60) && tcompsum > topsum) increment++; */
 
191
 
 
192
    if (tcompsum > topsum)
 
193
    {
 
194
        increment += 2;
 
195
    }
 
196
    else if ((TimeControl.moves[computer] < MINMOVES) && !increment)
 
197
    {
 
198
        /* but don't let moves go below MINMOVES */
 
199
        increment++;
 
200
    }
 
201
    else if ((me > him) && (tcompsum < topsum))
 
202
    {
 
203
        /* if I am doing really well use more time per move */
 
204
        increment = -1;
 
205
    }
 
206
 
 
207
    TimeControl.moves[computer] += increment;
 
208
}
 
209
 
 
210
 
 
211
 
 
212
int
 
213
main(int argc, char **argv)
 
214
{
 
215
    long l;
 
216
    int  n;
 
217
 
 
218
#if ttblsz
 
219
    l = (long)sizeof(struct hashentry);
 
220
    n = (int)((l * (ttblsz + rehash) * 2) / 1000);
 
221
    printf("ttable:\t\t%4d\tkByte\t[hashentry:%ld "
 
222
           "* (ttblsz:%d + rehash:%d) * 2]\n",
 
223
           n, l, ttblsz, rehash);
 
224
#endif
 
225
 
 
226
#if defined CACHE
 
227
    l = (long)sizeof(struct etable);
 
228
    n = (int)((l * (size_t)ETABLE) / 1000);
 
229
#else
 
230
    l = n = 0;
 
231
#endif
 
232
 
 
233
    printf("etab:\t\t%4d\tkByte\t[etable:%ld ETABLE:%d]\n",
 
234
           n, l, ETABLE);
 
235
 
 
236
    l = (long)sizeof(struct leaf);
 
237
    n = (int)(l * TREE / 1000);
 
238
    printf("Tree:\t\t%4d\tkByte\t[leaf:%ld * TREE:%d]\n",
 
239
           n, l, TREE);
 
240
 
 
241
#if defined HISTORY
 
242
    n = (int)(sizeof_history / 1000);
 
243
#else
 
244
    n = 0;
 
245
#endif
 
246
 
 
247
    printf("history:\t%4d\tkByte\t[unsigned short:%d "
 
248
           "* HISTORY_SIZE:%ld]\n",
 
249
           n, sizeof(unsigned short), (long)HISTORY_SIZE);
 
250
 
 
251
#ifndef SAVE_NEXTPOS
 
252
    l = (long)sizeof(next_array);
 
253
    n = (int)((l * NO_PTYPE_PIECES) / 1000);
 
254
 
 
255
    printf("nextpos:\t%4d\tkByte\t[next_array:%ld "
 
256
           "* NO_PTYPE_PIECES:%d]\n",
 
257
           n, l, NO_PTYPE_PIECES);
 
258
 
 
259
    l = (long)sizeof(next_array);
 
260
    n = (int)((l * NO_PTYPE_PIECES) / 1000);
 
261
    printf("nextdir:\t%4d\tkByte\t[next_array:%ld "
 
262
           "* NO_PTYPE_PIECES:%d]\n",
 
263
           n, l, NO_PTYPE_PIECES);
 
264
#endif
 
265
 
 
266
#ifndef SAVE_DISTDATA
 
267
    n = (int)(sizeof(distdata_array) / 1000);
 
268
    printf("distdata:\t%4d\tkByte\n", n);
 
269
#endif
 
270
 
 
271
#ifndef SAVE_PTYPE_DISTDATA
 
272
    l = (long)sizeof(distdata_array);
 
273
    n = (int)((l * NO_PTYPE_PIECES) / 1000);
 
274
    printf("ptype_distdata:\t%4d\tkByte\t[distdata_array:%ld "
 
275
           "* NO_PTYPE_PIECES:%d]\n",
 
276
           n, l, NO_PTYPE_PIECES);
 
277
#endif
 
278
 
 
279
    l = (long)sizeof(hashcode_array);
 
280
    n = (int)(l / 1000);
 
281
    printf("hashcode:\t%4d\tkByte\t[hashval:%ld]\n",
 
282
           n, (long)sizeof(struct hashval));
 
283
 
 
284
    l = (long)sizeof(drop_hashcode_array);
 
285
    n = (int)(l / 1000);
 
286
    printf("drop_hashcode:\t%4d\tkByte\t[hashval:%ld]\n",
 
287
           n, (long)sizeof(struct hashval));
 
288
 
 
289
    l = (long)sizeof(value_array);
 
290
    n = (int)(l / 1000);
 
291
    printf("value:\t\t%4d\tkByte\n", n);
 
292
 
 
293
    l = (long)sizeof(fscore_array);
 
294
    n = (int)(l / 1000);
 
295
    printf("fscore:\t\t%4d\tkByte\n", n);
 
296
 
 
297
    return 0;
 
298
}
 
299