| #ifndef STRUCTS_H | |
| #define STRUCTS_H | |
| #include "utils.h" | |
| //######################################################## | |
| // Basic board info which we keep track of. | |
| //######################################################## | |
| typedef struct | |
| { | |
| s32bit safe; | |
| s32bit real; | |
| s32bit mobility; | |
| } Basic_Info; | |
| //######################################################## | |
| // Info we need to describe a move. | |
| //######################################################## | |
| typedef struct | |
| { | |
| s32bit array_index; | |
| s32bit mask_index; | |
| s32bit info; | |
| } Move; | |
| //######################################################## | |
| // Info we need for each entry in the hashtable. | |
| //######################################################## | |
| typedef struct | |
| { | |
| // uniquely identifies a board position. | |
| u32bit key[4]; | |
| // if real num of nodes exceeds ULONG_MAX set to ULONG_MAX. | |
| // or maybe we could just shift the bits (larger granularity). | |
| u32bit nodes; | |
| // uniquely identifies the previous best move for this position. | |
| u8bit best_move; | |
| // depth of the search when this value was determined. | |
| u8bit depth : 7; | |
| // whos turn it is. | |
| u8bit whos_turn : 1; | |
| // value of node determined with a search to `depth`. | |
| s16bit value : 14; | |
| // value of node determined with a search to `depth`. | |
| u16bit type : 2; //UPPER, LOWER, EXACT. | |
| } Hash_Entry; | |
| //######################################################## | |
| // structure used to store current key and it's hash code. | |
| //######################################################## | |
| typedef struct | |
| { | |
| u32bit key[4]; | |
| s32bit code; | |
| } Hash_Key; | |
| //######################################################## | |
| // table_keyinfo | |
| //######################################################## | |
| typedef struct | |
| { | |
| s32bit bit1_index; | |
| s32bit bit2_index; | |
| u32bit hash_code; | |
| } KeyInfo_s; | |
| typedef struct | |
| { | |
| KeyInfo_s norm; | |
| KeyInfo_s flipV; | |
| KeyInfo_s flipH; | |
| KeyInfo_s flipVH; | |
| } KeyInfo; | |
| #endif | |
| #ifndef STRUCTS_H | |
| extern void | |
| hashstore(s32bit value, s32bit alpha, s23bit beta, | |
| u64bit nodes, int depth, struct move best, int color) | |
| { | |
| /* write the record anyway where the index is*/ | |
| int32 index, minindex; | |
| int mindepth=1000,iter=0; | |
| int from,to; | |
| if(depth<0) return; | |
| hashstores++; | |
| if(realdepth < DEEPLEVEL) { | |
| /* its in the "deep" hashtable: take care not to overwrite other entries */ | |
| index=Gkey&HASHMASKDEEP; | |
| minindex=index; | |
| while(iter<HASHITER) { | |
| if(deep[index].lock==Glock || deep[index].lock==0) { | |
| /* found an index where we can write the entry */ | |
| deep[index].lock=Glock; | |
| deep[index].info=(int16) (depth&DEPTH); | |
| if(color==BLACK) { | |
| deep[index].best=best.bm|best.bk; | |
| deep[index].info|=HASHBLACK; | |
| } else | |
| deep[index].best=best.wm|best.wk; | |
| deep[index].value=(sint16)value; | |
| /* determine valuetype */ | |
| if(value>=beta) {deep[index].info|=LOWER;return;} | |
| if(value>alpha) {deep[index].info|=EXACT;return;} | |
| deep[index].info|=UPPER; | |
| return; | |
| } else { | |
| if( hashdepth(deep[index].info) < mindepth) { | |
| minindex=index; | |
| mindepth=hashdepth(deep[index].info); | |
| } | |
| } | |
| iter++; | |
| index++; | |
| index=index&HASHMASKDEEP; | |
| } | |
| /* if we arrive here it means we have gone through all hashiter | |
| entries and all were occupied. in this case, we write the entry | |
| to minindex */ | |
| if(mindepth>(depth)) return; | |
| deep[minindex].lock=Glock; | |
| deep[minindex].info=(int16) (depth); | |
| if(color==BLACK) | |
| deep[minindex].best=best.bm|best.bk; | |
| else | |
| deep[minindex].best=best.wm|best.wk; | |
| deep[minindex].info|=(int16)((color>>1)<<13); | |
| deep[minindex].value=value; | |
| /* determine valuetype */ | |
| if(value>=beta) {deep[minindex].info|=LOWER;return;} | |
| if(value>alpha) {deep[minindex].info|=EXACT;return;} | |
| deep[minindex].info|=UPPER; | |
| return; | |
| /* and return */ | |
| } else { | |
| index=Gkey&HASHMASKSHALLOW; | |
| if( hashdepth(shallow[index].info) <= depth ) | |
| /* replace the old entry if the new depth is larger */ | |
| { | |
| shallow[index].lock=Glock; | |
| shallow[index].info=(int16)depth; | |
| shallow[index].value=(sint16)value; | |
| if(color==BLACK) | |
| { | |
| shallow[index].best=best.bm|best.bk; | |
| shallow[index].info|=HASHBLACK; | |
| } | |
| else | |
| shallow[index].best=best.wm|best.wk; | |
| /* determine valuetype */ | |
| if(value>=beta) {shallow[index].info|=LOWER;return;} | |
| if(value>alpha) {shallow[index].info|=EXACT;return;} | |
| shallow[index].info|=UPPER; | |
| } | |
| } | |
| return; | |
| } | |
| int hashlookup(int *value, int *alpha, int *beta, int depth, int32 *forcefirst, int color) | |
| { | |
| int32 index; | |
| int iter=0; | |
| hashsearch++; | |
| if(realdepth<DEEPLEVEL) | |
| /* a position in the "deep" hashtable - it's important to find it since */ | |
| /* the effect is larger here! */ | |
| { | |
| hashhit++; | |
| index=Gkey&HASHMASKDEEP; | |
| while(iter<HASHITER) | |
| { | |
| if(deep[index].lock==Glock && (hashcolor(deep[index].info)>>13)==(color>>1)) | |
| { | |
| /* we have found the position */ | |
| hashhit++; | |
| /* move ordering */ | |
| *forcefirst=deep[index].best; | |
| /* use value if depth in hashtable >= current depth)*/ | |
| if(hashdepth(deep[index].info)>=depth) | |
| { | |
| /* if it's an exact value we can use it */ | |
| if(hashvaluetype(deep[index].info) == EXACT) | |
| { | |
| *value=deep[index].value; | |
| return 1; | |
| } | |
| /* lower bound */ | |
| if(hashvaluetype(deep[index].info) == LOWER) | |
| { | |
| if(deep[index].value>=(*beta)) {*value=deep[index].value;return 1;} | |
| if(deep[index].value>(*alpha)) {*alpha=deep[index].value;} | |
| return 0; | |
| } | |
| /* upper bound */ | |
| if(hashvaluetype(deep[index].info) == UPPER) | |
| { | |
| if(deep[index].value<=*alpha) {*value=deep[index].value;return 1;} | |
| if(deep[index].value<*beta) {*beta=deep[index].value;} | |
| return 0; | |
| } | |
| } | |
| } | |
| iter++; | |
| index++; | |
| index&=HASHMASKDEEP; | |
| } | |
| return 0; | |
| } | |
| /* use shallow hashtable */ | |
| else | |
| { | |
| index=Gkey&HASHMASKSHALLOW; | |
| if(shallow[index].lock==Glock && (hashcolor(shallow[index].info)>>13)==(color>>1)) | |
| { | |
| hashhit++; | |
| /*found the right entry!*/ | |
| *forcefirst=shallow[index].best; | |
| if(hashdepth(shallow[index].info)>=depth) | |
| { | |
| if(hashvaluetype(shallow[index].info) == EXACT) | |
| { | |
| *value=shallow[index].value; | |
| return 1; | |
| } | |
| /* lower bound */ | |
| if(hashvaluetype(shallow[index].info) == LOWER) | |
| { | |
| if(shallow[index].value>=*beta) {*value=shallow[index].value;return 1;} | |
| if(shallow[index].value>*alpha) {*alpha=shallow[index].value;} | |
| return 0; | |
| } | |
| /* upper bound */ | |
| if(hashvaluetype(shallow[index].info) == UPPER) | |
| { | |
| if(shallow[index].value<=*alpha) {*value=shallow[index].value;return 1;} | |
| if(shallow[index].value<*beta) {*beta=shallow[index].value;} | |
| return 0; | |
| } | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| */ | |
| #endif |