simpleHashTable.cc
Go to the documentation of this file.
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:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines