00001 /* simpleHashTable.cc 00002 */ 00003 #include "osl/search/simpleHashTable.h" 00004 #include "osl/search/simpleHashRecord.h" 00005 #include "osl/search/analyzer/recordSet_.h" 00006 #include "osl/container/generalSimpleHashTable.tcc" 00007 #include <iostream> 00008 00009 namespace osl 00010 { 00011 template class container::GeneralSimpleHashTable <SimpleHashRecord>; 00012 } // namespace osl 00013 00014 osl::search::SimpleHashTable:: 00015 SimpleHashTable(size_t capacity, int minimum_recordlimit, int v) 00016 : GeneralSimpleHashTable<SimpleHashRecord>(capacity), 00017 minimum_limit(minimum_recordlimit), verbose(v) 00018 { 00019 } 00020 00021 osl::search::SimpleHashTable:: 00022 ~SimpleHashTable() 00023 { 00024 if (verbose > 1 && size()) 00025 { 00026 std::cerr << "SimpleHashTable size: " << size() << " (" 00027 << ((sizeof(SimpleHashRecord)+sizeof(HashKey)+sizeof(SimpleHashRecord*)) 00028 * size() / (1<<20)) << "MB)" 00029 << ", cache hit " << table->num_cache_hit 00030 << ", table full " << table->num_record_after_full << "\n"; 00031 } 00032 } 00033 00034 void osl::search::SimpleHashTable:: 00035 setVerbose(int v) 00036 { 00037 verbose = v; 00038 } 00039 00040 void osl::search::SimpleHashTable:: 00041 setMinimumRecordLimit(int new_limit) 00042 { 00043 minimum_limit = new_limit; 00044 } 00045 00046 int osl::search::SimpleHashTable:: 00047 minimumRecordLimit() const 00048 { 00049 return minimum_limit; 00050 } 00051 00052 osl::search::SimpleHashRecord * 00053 osl::search::SimpleHashTable:: 00054 allocate(const HashKey& key, int limit) 00055 { 00056 if (limit < minimumRecordLimit()) 00057 return find(key); 00058 return GeneralSimpleHashTable <SimpleHashRecord>::allocate (key); 00059 } 00060 00061 int osl::search::SimpleHashTable:: 00062 verboseLevel() const 00063 { 00064 return verbose; 00065 } 00066 00067 bool osl::search::SimpleHashTable:: 00068 isConsistent() const 00069 { 00070 return true; 00071 } 00072 00073 int osl::search::SimpleHashTable:: 00074 divSize() const 00075 { 00076 return GeneralSimpleHashTable<SimpleHashRecord>::divSize(); 00077 } 00078 00079 #ifndef MINIMAL 00080 void osl::search::SimpleHashTable:: 00081 getPV(const HashKey& root, MoveVector& out, size_t *quiesce_start) const 00082 { 00083 analyzer::RecordSet dejavu; 00084 HashKey key = root; 00085 const SimpleHashRecord *record; 00086 while (true) { 00087 record = table->find(key); 00088 if (! record || dejavu.find(record) != dejavu.end()) { 00089 break; 00090 } 00091 const Move best_move = record->bestMove().getMove(); 00092 if (best_move.isInvalid()) { 00093 break; 00094 } 00095 dejavu.insert(record); 00096 out.push_back(best_move); 00097 key = key.newHashWithMove(best_move); 00098 } 00099 if (! quiesce_start || ! record) 00100 return; 00101 *quiesce_start = out.size(); 00102 while (true) { 00103 const Move best_move = record->qrecord.bestMove(); 00104 if (best_move.isInvalid()) { 00105 break; 00106 } 00107 out.push_back(best_move); 00108 00109 key = key.newHashWithMove(best_move); 00110 record = table->find(key); 00111 if (! record || dejavu.find(record) != dejavu.end()) { 00112 break; 00113 } 00114 dejavu.insert(record); 00115 } 00116 } 00117 #endif 00118 /* ------------------------------------------------------------------------- */ 00119 // ;;; Local Variables: 00120 // ;;; mode:c++ 00121 // ;;; c-basic-offset:2 00122 // ;;; End: