Changeset 248 for 06/libkombilo/search.cpp

Timestamp:

04/07/07 00:25:03 (21 months ago)

Author:

ug

Message:

Snapshot/restore functionality for GameList class.

Files:

• 06/libkombilo/search.cpp (modified) (31 diffs)

06/libkombilo/search.cpp

@@ -43 +43 @@
 using std::sort;
 #endif
+
+SnapshotVector::SnapshotVector() : vector<unsigned char>() {
+  current = begin();
+}
+
+SnapshotVector::SnapshotVector(char* c, int size) : vector<unsigned char>() {
+  for(int i=0; i<size; i++) push_back(c[i]);
+  current = begin();
+}
+
+void SnapshotVector::pb_int(int d) {
+  for(int i = 0; i < 4; i++) {
+    push_back((unsigned char)(d % 256));
+    d = d >> 8;
+  }
+}
+
+void SnapshotVector::pb_charp(char* c, int size) {
+  pb_int(size);
+  for(int i=0; i<size; i++) push_back(c[i]);
+}
+
+void SnapshotVector::pb_intp(int* p, int size) {
+  pb_int(size);
+  for(int i=0; i<size; i++) pb_int(p[i]);
+}
+
+void SnapshotVector::pb_string(string s) {
+  pb_int(s.size()+1);
+  for(unsigned int i=0; i<s.size(); i++) push_back(s[i]);
+  push_back(0);
+}
+
+void SnapshotVector::pb_char(char c) {
+  push_back(c);
+}
+
+int SnapshotVector::retrieve_int() {
+  int result = 0;
+  for(int i=0; i<4; i++) {
+    result += *current << (i*8);
+    current++;
+  }
+  return result;
+}
+
+int* SnapshotVector::retrieve_intp() {
+  int sz = retrieve_int();
+  int* result = new int[sz];
+  for(int i=0; i<sz; i++)
+    result[i] = retrieve_int();
+  return result;
+}
+
+char SnapshotVector::retrieve_char() {
+  char c = *current;
+  current++;
+  return c;
+}
+
+char* SnapshotVector::retrieve_charp() {
+  int sz = retrieve_int();
+  char* result = new char[sz];
+  for(int i=0; i<sz; i++) {
+    result[i] = *current;
+    current++;
+  }
+  return result;
+}
+
+string SnapshotVector::retrieve_string() {
+  char* cp = retrieve_charp();
+  string s(cp);
+  delete [] cp;
+  return s;
+}
+
+char* SnapshotVector::to_charp() {
+  char* result = new char[size()];
+  int counter = 0;
+  for(SnapshotVector::iterator it = begin(); it != end(); it++) result[counter++] = *it;
+  return result;
+}
+
 
 PatternError::PatternError() {}
@@ -55 +139 @@
   wW = 0;
   lW = 0;
+}
+
+void Continuation::from_snv(SnapshotVector& snv) {
+  B = snv.retrieve_int();
+  W = snv.retrieve_int();
+  tB = snv.retrieve_int();
+  tW = snv.retrieve_int();
+  wB = snv.retrieve_int();
+  lB = snv.retrieve_int();
+  wW = snv.retrieve_int();
+  lW = snv.retrieve_int();
+}
+
+void Continuation::to_snv(SnapshotVector& snv) {
+  snv.pb_int(B);
+  snv.pb_int(W);
+  snv.pb_int(tB);
+  snv.pb_int(tW);
+  snv.pb_int(wB);
+  snv.pb_int(lB);
+  snv.pb_int(wW);
+  snv.pb_int(lW);
 }
 
@@ -143 +249 @@
   return 0;
 }
-
 
 
@@ -300 +405 @@
   flip = 0;
   colorSwitch = 0;
-       
+
   left = le;
   right = ri;
@@ -322 +427 @@
 
   contList = CONTLIST;
+}
+
+Pattern::Pattern(SnapshotVector& snv) {
+  flip = snv.retrieve_int();
+  colorSwitch = snv.retrieve_int();
+  left = snv.retrieve_int();
+  right = snv.retrieve_int();
+  top = snv.retrieve_int();
+  bottom = snv.retrieve_int();
+  boardsize = snv.retrieve_int();
+  sizeX = snv.retrieve_int();
+  sizeY = snv.retrieve_int();
+  if (snv.retrieve_char()) { // contLabels?
+    contLabels = snv.retrieve_charp();
+  } else contLabels = 0;
+  initialPos = snv.retrieve_charp();
+  finalPos = snv.retrieve_charp();
+
+  int size = snv.retrieve_int();
+  for(int i=0; i<size; i++)
+    contList.push_back(MoveNC(snv.retrieve_char(), snv.retrieve_char(), snv.retrieve_char())); // x, y, color
+}
+
+void Pattern::to_snv(SnapshotVector& snv) {
+  snv.pb_int(flip);
+  snv.pb_int(colorSwitch);
+  snv.pb_int(left);
+  snv.pb_int(right);
+  snv.pb_int(top);
+  snv.pb_int(bottom);
+  snv.pb_int(boardsize);
+  snv.pb_int(sizeX);
+  snv.pb_int(sizeY);
+  if (contLabels) {
+    snv.pb_char(1);
+    snv.pb_charp(contLabels, sizeX*sizeY);
+  } else snv.pb_char(0);
+  snv.pb_charp(initialPos, sizeX*sizeY);
+  snv.pb_charp(finalPos, sizeX*sizeY);
+  snv.pb_int(contList.size());
+  for(vector<MoveNC>::iterator it = contList.begin(); it != contList.end(); it++) {
+    snv.pb_char(it->x);
+    snv.pb_char(it->y);
+    snv.pb_char(it->color);
+  }
 }
 
@@ -368 +518 @@
     if (finalPos) delete [] finalPos;
     if (contLabels) delete [] contLabels;
-    
+
     initialPos = new char[sizeX*sizeY];
     finalPos = new char[sizeX*sizeY];
@@ -398 +548 @@
     if (initialPos) delete [] initialPos;
     if (finalPos) delete [] finalPos;
-    
+
     initialPos = new char[sizeX*sizeY];
     finalPos = new char[sizeX*sizeY];
@@ -501 +651 @@
   return co;
 }
-        
+
 void PatternList::patternList() {
-        
   vector<Pattern> lCS;
   vector<pair<int,int> > sy;
@@ -1339 +1488 @@
   if (rc != SQLITE_OK) throw DBError();
   // printf("init Algo_movelist\n");
-}                                         
+}
 
 void Algo_movelist::newgame_process(int game_id) {
@@ -1348 +1497 @@
   for(int i=0; i<50; i++) fpC[i] = 0;
 }
-        
+
 void Algo_movelist::AB_process(int x, int y) {
   movelist.push_back((char)x);
@@ -1401 +1550 @@
   }
 }
-      
+
 void Algo_movelist::pass_process() {
   movelist.push_back(19);
@@ -1554 +1703 @@
   return result;
 }
-
 
 int Algo_movelist::search(PatternList& patternList, GameList& gl, SearchOptions& options) { 
@@ -2278 +2426 @@
   // printf("leave algo_hash_full::initialize_processing\n");
 }
-        
+
 void Algo_hash_full::newgame_process(int game_id) {
   numStones = 0;
@@ -3413 +3561 @@
 }
 
-Hit::Hit(ExtendedMoveNumber* POS, char* LABEL) {
+Hit::Hit(ExtendedMoveNumber* POS, char* LABEL) { // LABEL is a char[3]
   pos = POS; // note that we do not copy these!
   label = LABEL;
@@ -3421 +3569 @@
   delete pos;
   delete [] label;
+}
+
+Hit::Hit(SnapshotVector& snv) {
+  int length = snv.retrieve_int();
+  int* data = snv.retrieve_intp();
+  pos = new ExtendedMoveNumber(length, data);
+  delete [] data;
+  label = snv.retrieve_charp();
+}
+
+void Hit::to_snv(SnapshotVector& snv) {
+  snv.pb_int(pos->length);
+  snv.pb_intp(pos->data, pos->length);
+  snv.pb_charp(label, 3);
 }
 
@@ -3446 +3608 @@
   searchInVariations = true;
   algos = (1<<30) - 1; // use all available algorithms
+}
+
+SearchOptions::SearchOptions(SnapshotVector& snv) {
+  fixedColor = snv.retrieve_int();
+  moveLimit = snv.retrieve_int();
+  nextMove = snv.retrieve_int();
+  trustHashFull = snv.retrieve_int();
+  searchInVariations= snv.retrieve_int();
+  algos = snv.retrieve_int();
+}
+
+void SearchOptions::to_snv(SnapshotVector& snv) {
+  snv.pb_int(fixedColor);
+  snv.pb_int(moveLimit);
+  snv.pb_int(nextMove);
+  snv.pb_int(trustHashFull);
+  snv.pb_int(searchInVariations);
+  snv.pb_int(algos);
 }
 
@@ -3537 +3717 @@
     for(vector<Hit* >::iterator it = hits->begin(); it != hits->end(); it++) delete *it;
     delete hits;
+    hits = 0;
   }
   if (candidates) {
     for(vector<Candidate* >::iterator it = candidates->begin(); it != candidates->end(); it++) delete *it;
     delete candidates;
-  }
-}
-                         
+    candidates = 0;
+  }
+}
+
+void GameListEntry::hits_from_snv(SnapshotVector& snv) {
+  int h_size = snv.retrieve_int();
+  hits = new vector<Hit* >;
+  for(int j=0; j<h_size; j++) {
+    hits->push_back(new Hit(snv));
+  }
+}
+
 int insertEntry(void *gl, int argc, char **argv, char **azColName) {
   char winner = '-';
@@ -3591 +3781 @@
   labels = 0;
   continuations = 0;
+  mrs_pattern = 0;
+  searchOptions = 0;
   dbname = new char[strlen(DBNAME)+2];
   strcpy(dbname, DBNAME);
@@ -3684 +3876 @@
     if (rc != SQLITE_OK) throw DBError();
   }
+
+  // set up snapshot db
+  rc = sqlite3_exec(db, "create table if not exists snapshots ( data text );", 0, 0, 0);
+  if (rc != SQLITE_OK) throw DBError();
 
   // printf("set up Algorithm instances\n");
@@ -3780 +3976 @@
   currentList = 0;
   oldList = 0;
-  
+
   int rc;
   rc = sqlite3_exec(db, "begin transaction;", 0, 0, 0);
@@ -3796 +3992 @@
   // printf("read.\n");
   // SQLITE_ERROR may occur since table might not yet exist
-  
+
   readPlayersList();
   rc = sqlite3_exec(db, "commit;", 0, 0, 0);
@@ -3815 +4011 @@
 GameList::~GameList() {
   // printf("enter ~GameList\n");
+  if (mrs_pattern) delete mrs_pattern;
+  if (searchOptions) delete searchOptions;
   if (p_op) delete p_op;
   if (labels) delete [] labels;
-  if (continuations) delete [] continuations;
+  if (continuations) delete [] continuations; // FIXME CHECK whether the Continuation destructor is invoked!
   if (duplicates) delete duplicates;
   delete [] dbname;
@@ -3971 +4169 @@
     currentList->push_back(make_pair((*it)->id, counter++));
   }
+  num_hits = 0;
+  num_switched = 0;
+  Bwins = 0;
+  Wwins = 0;
 }
 
@@ -4218 +4420 @@
 
 char GameList::lookupLabel(char x, char y) {
-  if (!labels) return '?';
-  return labels[x+y*sizeX];
+  if (!labels || !mrs_pattern || x < 0 || x >= mrs_pattern->sizeX || y < 0 || y >= mrs_pattern->sizeY) return '?';
+  return labels[x+y*mrs_pattern->sizeX];
 }
 
 Continuation GameList::lookupContinuation(char x, char y) {
-  if (!continuations) return Continuation();
-  return continuations[x+y*sizeX];
+  if (!continuations || !mrs_pattern || x < 0 || x >= mrs_pattern->sizeX || y < 0 || y >= mrs_pattern->sizeY) return Continuation();
+  return continuations[x+y*mrs_pattern->sizeX];
 }
 
@@ -4296 +4498 @@
 
 void GameList::search(Pattern& pattern, SearchOptions* so) throw(DBError) {
-  SearchOptions* searchOptions;
+  if (mrs_pattern) delete mrs_pattern;
+  mrs_pattern = new Pattern(pattern);
+  if (searchOptions) delete searchOptions;
   if (so) searchOptions = new SearchOptions(*so);
   else searchOptions = new SearchOptions();
-  sizeX = pattern.sizeX; // need this in lookupLabel
   PatternList pl(pattern, searchOptions->fixedColor, searchOptions->nextMove);
 
@@ -4310 +4513 @@
   if (it == boardsizes.end()) {
     delete searchOptions;
+    searchOptions = 0;
     if (oldList) delete oldList;
     oldList = 0;
@@ -4360 +4564 @@
   continuations = pl.continuations;
   pl.continuations = new Continuation[pattern.sizeX*pattern.sizeY];
-  delete searchOptions;
+
+  // FIXME: delete all candidate lists!
 }
 
@@ -4457 +4662 @@
   sql1 = "create table if not exists GAME_TAGS ( id integer primary key, game_id integer, tag_id integer );";
   rc = sqlite3_exec(db, sql1.c_str(), 0, 0, 0);
-  if( rc!=SQLITE_OK ) throw DBError();
+  if (rc != SQLITE_OK) throw DBError();
 }
 
 void GameList::start_processing(int PROCESSVARIATIONS) throw(DBError) {
   // printf("enter start_processing %p\n", p_op);
+
+  delete_all_snapshots();
+
   if (PROCESSVARIATIONS != -1) processVariations = PROCESSVARIATIONS;
   else processVariations = p_op->processVariations;
@@ -4565 +4773 @@
     if (sz=="") sz = "19";
     int bs = atoi(sz.c_str());
-    if (bs < 1) { 
-      return_val |= UNACCEPTABLE_BOARDSIZE; 
+    if (bs < 1) {
+      return_val |= UNACCEPTABLE_BOARDSIZE;
       process_results_vector.push_back(return_val);
       delete rootNodeProperties;
@@ -4941 +5149 @@
         delete [] sig;
       }
-      
+
       if (commit) {
         // evaluate tags
@@ -4985 +5193 @@
 
 
+int GameList::snapshot() throw(DBError) {
+  // return a handle to a snapshot stored in the main GameList db
+  // the snapshot contains copies of
+  // - orderby, format1, format2
+  // - currentList
+  // - all hits in the GameListEntry's of currentList
+  // - pattern, labels, continuations, num_hits, num_switched, Bwins, Wwins
+
+  SnapshotVector snapshot;
+  snapshot.pb_string(orderby);
+  snapshot.pb_string(format1);
+  snapshot.pb_string(format2);
+
+  snapshot.pb_int(currentList->size());
+  for(vector<pair<int,int> >::iterator it = currentList->begin(); it != currentList->end(); it++) {
+    snapshot.pb_int(it->first);
+    snapshot.pb_int(it->second);
+    vector<Hit* >* hits = (*all)[it->second]->hits;
+    snapshot.pb_int(hits->size());
+    for (vector<Hit* >::iterator it_h = hits->begin(); it_h != hits->end(); it_h++) {
+      (*it_h)->to_snv(snapshot);
+    }
+  }
+
+  if (mrs_pattern) {
+    snapshot.pb_char(1);
+    mrs_pattern->to_snv(snapshot);
+  } else snapshot.pb_char(0);
+  if (searchOptions) {
+    snapshot.pb_char(1);
+    searchOptions->to_snv(snapshot);
+  } else snapshot.pb_char(0);
+  if (mrs_pattern && labels && continuations) {
+    snapshot.pb_char(1);
+    snapshot.pb_charp(labels, mrs_pattern->sizeX * mrs_pattern->sizeY);
+    for(int i=0; i<mrs_pattern->sizeX * mrs_pattern->sizeY; i++) continuations[i].to_snv(snapshot);
+  } else snapshot.pb_char(0);
+  snapshot.pb_int(num_hits);
+  snapshot.pb_int(num_switched);
+  snapshot.pb_int(Bwins);
+  snapshot.pb_int(Wwins);
+
+  // insert snapshot into database
+  sqlite3_stmt *ppStmt=0;
+  int rc = sqlite3_prepare(db, "insert into snapshots (data) values (?)", -1, &ppStmt, 0);
+  if (rc != SQLITE_OK || ppStmt==0) throw DBError();
+  char* snchp = snapshot.to_charp();
+  rc = sqlite3_bind_blob(ppStmt, 1, snchp, snapshot.size(), SQLITE_TRANSIENT);
+  delete [] snchp;
+  if (rc != SQLITE_OK) throw DBError();
+  rc = sqlite3_step(ppStmt);
+  if (rc != SQLITE_DONE) throw DBError();
+  rc = sqlite3_finalize(ppStmt);
+  if (rc != SQLITE_OK) throw DBError();
+  return sqlite3_last_insert_rowid(db);
+}
+
+void GameList::restore(int handle, bool del) throw(DBError) {
+  // restore the state of the GameList associated with handle
+
+  // retrieve info associated with handle from db
+
+  char* sn = 0;
+  int sn_size = 0;
+  sqlite3_stmt *ppStmt=0;
+  int rc = sqlite3_prepare(db, "select data from snapshots where rowid = ?", -1, &ppStmt, 0);
+  if (rc != SQLITE_OK || ppStmt==0) {
+    printf("%d\n", rc);
+    throw DBError();
+  }
+  rc = sqlite3_bind_int(ppStmt, 1, handle);
+  if (rc != SQLITE_OK) throw DBError();
+  rc = sqlite3_step(ppStmt);
+  if (rc == SQLITE_ROW) {
+    sn = (char*)sqlite3_column_blob(ppStmt, 0);
+    sn_size = sqlite3_column_bytes(ppStmt, 0);
+  } else throw DBError();
+
+  SnapshotVector snapshot(sn, sn_size);
+
+  // parse info
+
+  string ob = snapshot.retrieve_string();
+  string f1 = snapshot.retrieve_string();
+  string f2 = snapshot.retrieve_string();
+  if (ob != orderby || f1 != format1 || f2 != format2) resetFormat();
+
+  if (oldList) delete oldList;
+  oldList = 0;
+  if (currentList) delete currentList;
+  currentList = new vector<pair<int,int> >;
+  for(vector<GameListEntry* >::iterator it = all->begin(); it != all->end(); it++) {
+    if ((*it)->hits) {
+      for(vector<Hit* >::iterator ith = (*it)->hits->begin(); ith != (*it)->hits->end(); ith++)
+        delete *ith;
+      delete (*it)->hits;
+      (*it)->hits = 0;
+    }
+    if ((*it)->candidates) {
+      for(vector<Candidate* >::iterator itc = (*it)->candidates->begin(); itc != (*it)->candidates->end(); itc++)
+        delete *itc;
+      delete (*it)->candidates;
+      (*it)->candidates = 0;
+    }
+  }
+
+  int cl_size = snapshot.retrieve_int();
+  for(int i=0; i<cl_size; i++) {
+    currentList->push_back(make_pair(snapshot.retrieve_int(), snapshot.retrieve_int()));
+    (*all)[(*currentList)[currentList->size()-1].second]->hits_from_snv(snapshot);
+  }
+
+  if (mrs_pattern) delete mrs_pattern;
+  if (snapshot.retrieve_char()) mrs_pattern = new Pattern(snapshot);
+  else mrs_pattern = 0;
+
+  if (searchOptions) delete searchOptions;
+  if (snapshot.retrieve_char()) searchOptions = new SearchOptions(snapshot);
+  else searchOptions = 0;
+
+  if (labels) delete [] labels;
+  if (continuations) delete [] continuations; // FIXME check (cf. ~GameList)
+  if (snapshot.retrieve_char()) {
+    labels = snapshot.retrieve_charp();
+    continuations = new Continuation[mrs_pattern->sizeX * mrs_pattern->sizeY];
+    for(int i=0; i<mrs_pattern->sizeX * mrs_pattern->sizeY; i++) 
+      continuations[i].from_snv(snapshot);
+  } else {
+    labels = 0;
+    continuations = 0;
+  }
+  num_hits = snapshot.retrieve_int();
+  num_switched = snapshot.retrieve_int();
+  Bwins = snapshot.retrieve_int();
+  Wwins = snapshot.retrieve_int();
+
+  rc = sqlite3_finalize(ppStmt);
+  if (rc != SQLITE_OK) throw DBError();
+  if (del) { // delete snapshot from db
+    char sql[100];
+    sprintf(sql, "delete from snapshots where rowid = %d", handle);
+    rc = sqlite3_exec(db, sql, 0, 0, 0);
+    if (rc != SQLITE_OK) throw DBError();
+  }
+}
+
+void GameList::delete_snapshot(int handle) throw(DBError) {
+  char sql[100];
+  sprintf(sql, "delete from snapshots where rowid = %d", handle);
+  int rc = sqlite3_exec(db, sql, 0, 0, 0);
+  if (rc != SQLITE_OK) throw DBError();
+}
+
+void GameList::delete_all_snapshots() throw(DBError) {
+  int rc = sqlite3_exec(db, "delete from snapshots", 0, 0, 0);
+  if (rc != SQLITE_OK) throw DBError();
+}
+
 VarInfo::VarInfo(Node* N, abstractBoard* B, int I) {
   n = N;