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 * Copyright (c) 2008, 2013, 2014 Yann Dirson and the Free Software Foundation
10 *
11 * GNU SHOGI is based on GNU CHESS
12 *
13 * Copyright (c) 1988, 1989, 1990 John Stanback
14 * Copyright (c) 1992 Free Software Foundation
15 *
16 * This file is part of GNU SHOGI.
17 *
18 * GNU Shogi is free software; you can redistribute it and/or modify it
19 * under the terms of the GNU General Public License as published by the
20 * Free Software Foundation; either version 3 of the License,
21 * or (at your option) any later version.
22 *
23 * GNU Shogi is distributed in the hope that it will be useful, but WITHOUT
24 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
25 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
26 * for more details.
27 *
28 * You should have received a copy of the GNU General Public License along
29 * with GNU Shogi; see the file COPYING. If not, see
30 * <http://www.gnu.org/licenses/>.
31 * ----------------------------------------------------------------------
32 *
33 */
34
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
urand(void)66 urand(void)
67 {
68 next *= 1103515245;
69 next += 12345;
70 return ((unsigned int) (next >> 16) & 0xFFFF);
71 }
72
73
74 void
gsrand(unsigned int seed)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
TimeCalc()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
main(int argc,char ** argv)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
300