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 uint64_t osl::search::SimpleHashTable:: 00022 memoryUse() const 00023 { 00024 return 1ull * (sizeof(SimpleHashRecord)+sizeof(HashKey)+sizeof(SimpleHashRecord*)) * size(); 00025 } 00026 00027 osl::search::SimpleHashTable:: 00028 ~SimpleHashTable() 00029 { 00030 const uint64_t memory_use = memoryUse(); 00031 if ((verbose > 1 && size()) || memory_use > (1024*(1ull<<20))) 00032 { 00033 std::cerr << "SimpleHashTable size: " << size() << " (" 00034 << memory_use / (1ull<<20) << "MB)" 00035 << ", cache hit " << table->num_cache_hit 00036 << ", table full " << table->num_record_after_full << "\n"; 00037 } 00038 } 00039 00040 void osl::search::SimpleHashTable:: 00041 setVerbose(int v) 00042 { 00043 verbose = v; 00044 } 00045 00046 void osl::search::SimpleHashTable:: 00047 setMinimumRecordLimit(int new_limit) 00048 { 00049 minimum_limit = new_limit; 00050 } 00051 00052 int osl::search::SimpleHashTable:: 00053 minimumRecordLimit() const 00054 { 00055 return minimum_limit; 00056 } 00057 00058 osl::search::SimpleHashRecord * 00059 osl::search::SimpleHashTable:: 00060 allocate(const HashKey& key, int limit) 00061 { 00062 if (limit < minimumRecordLimit()) 00063 return find(key); 00064 return GeneralSimpleHashTable <SimpleHashRecord>::allocate (key); 00065 } 00066 00067 int osl::search::SimpleHashTable:: 00068 verboseLevel() const 00069 { 00070 return verbose; 00071 } 00072 00073 bool osl::search::SimpleHashTable:: 00074 isConsistent() const 00075 { 00076 return true; 00077 } 00078 00079 int osl::search::SimpleHashTable:: 00080 divSize() const 00081 { 00082 return GeneralSimpleHashTable<SimpleHashRecord>::divSize(); 00083 } 00084 00085 #ifndef MINIMAL 00086 void osl::search::SimpleHashTable:: 00087 getPV(const HashKey& root, MoveVector& out, size_t *quiesce_start) const 00088 { 00089 analyzer::RecordSet dejavu; 00090 HashKey key = root; 00091 const SimpleHashRecord *record; 00092 while (true) { 00093 record = table->find(key); 00094 if (! record || dejavu.find(record) != dejavu.end()) { 00095 break; 00096 } 00097 const Move best_move = record->bestMove().move(); 00098 if (best_move.isInvalid()) { 00099 break; 00100 } 00101 dejavu.insert(record); 00102 out.push_back(best_move); 00103 key = key.newHashWithMove(best_move); 00104 } 00105 if (! quiesce_start || ! record) 00106 return; 00107 *quiesce_start = out.size(); 00108 while (true) { 00109 const Move best_move = record->qrecord.bestMove(); 00110 if (best_move.isInvalid()) { 00111 break; 00112 } 00113 out.push_back(best_move); 00114 00115 key = key.newHashWithMove(best_move); 00116 record = table->find(key); 00117 if (! record || dejavu.find(record) != dejavu.end()) { 00118 break; 00119 } 00120 dejavu.insert(record); 00121 } 00122 } 00123 #endif 00124 /* ------------------------------------------------------------------------- */ 00125 // ;;; Local Variables: 00126 // ;;; mode:c++ 00127 // ;;; c-basic-offset:2 00128 // ;;; End: