Initial import of the CDE 2.1.30 sources from the Open Group.

cde/programs/dtinfo/DtMmdb/storage/page_cache.C

@@ -0,0 +1,368 @@
+/* $XConsortium: page_cache.cc /main/4 1996/06/11 17:44:22 cde-hal $
+ *
+ * (c) Copyright 1996 Digital Equipment Corporation.
+ * (c) Copyright 1996 Hewlett-Packard Company.
+ * (c) Copyright 1996 International Business Machines Corp.
+ * (c) Copyright 1996 Sun Microsystems, Inc.
+ * (c) Copyright 1996 Novell, Inc. 
+ * (c) Copyright 1996 FUJITSU LIMITED.
+ * (c) Copyright 1996 Hitachi.
+ */
+
+#include "utility/debug.h"
+#include "storage/page.h"
+#include "storage/heap_comp_funcs.h"
+#include "storage/page_rep.h"
+#include "storage/page_storage.h"
+
+page_cache_local_part::page_cache_local_part(unsigned int exp_cached_page) :
+ f_num_cached_pages(0),
+ f_free_space(fbytes_t_eq, fbytes_t_ls, exp_cached_page),
+ f_page_pool_index(page_rep_eq, page_rep_ls),
+ f_current_page_num(0),
+ f_current_page_ptr(0)
+{
+}
+
+page_cache_local_part::~page_cache_local_part()
+{
+   f_page_pool_index.del_elements(page_rep_del);
+}
+
+Boolean page_cache_local_part::init_heap(page_storage* st)
+{
+////////////////////////////////////////////////////////////////////////////
+// We use a different strategy. Since pages are most of time read-only and 
+// grows linearly when loaded, we assume the 1st to pages()-1 th page are 
+// full. 
+////////////////////////////////////////////////////////////////////////////
+
+   if ( st -> pages() > 0 ) {
+
+      page* z = (*st)(st -> pages(), page_storage::READ);
+
+      f_free_space.insert(
+		new fbytes_t(z -> free_bytes(), z -> page_id())
+			      ); 
+
+      f_free_space.heapify();
+   }
+
+   return true;
+}
+
+Boolean page_cache_local_part::quit_heap(page_storage* st)
+{
+   int ind = f_free_space.first();
+	
+   while ( ind ) {
+      fbytes_t *x = (fbytes_t*)f_free_space(ind);
+
+/*
+debug(cerr, x -> page_num);
+debug(cerr, x -> free_bytes);
+*/
+
+      delete x;
+      f_free_space.next(ind);
+   }
+
+   return true;
+}
+
+page* page_cache_local_part::in_cache(page_storage* st, int page_num)
+{
+
+#ifdef DEBUG
+st -> total_page_access++;
+#endif
+
+   if ( f_current_page_num == page_num ) {
+      return f_current_page_ptr;
+   }
+
+   page_rep data(page_num, 0);
+   page_rep *result = 0;
+
+/*
+cerr << "member(): " << st -> my_name() << " ";
+cerr << page_num ;
+cerr << " " << (void*)&f_page_pool_index;
+cerr << "\n";
+*/
+
+   if ( (result = (page_rep*)f_page_pool_index.member(&data)) ) {
+//cerr << "In Cache: page " << page_num << " of " << st -> my_name() << "\n";
+
+     lru_page* p = result -> f_page_ptr;
+
+     if ( p -> page_id() != page_num ) {
+        throw(stringException("corrupted store"));
+     }
+
+     if ( p -> get_position() == ACTIVE ) {
+#ifndef C_API
+        (p -> f_store -> f_global_pcache).f_replace_policy.promote(*p);
+#else
+        (p -> f_store -> f_global_pcache_ptr -> f_replace_policy).promote(*p);
+#endif
+//cerr << "Promoting:" << (long)p << endl;
+     }
+
+     return p;
+
+   } else {
+
+#ifdef DEBUG
+st -> pagings++;
+#endif
+
+      return 0;
+   }
+}
+
+void page_cache_local_part::adjust_heap(fbytes_t* v, Boolean new_page)
+{
+    if ( new_page == false ) {
+      if ( v -> free_bytes < 10 ) {
+         f_free_space.delete_max();
+         delete v;
+      } else
+         f_free_space.adjust_max_to(v);
+   } else {
+      f_free_space.insert_heapify(v);
+   }
+}
+
+fbytes_t* 
+page_cache_local_part::find_host_page(
+	page_storage* st, Boolean& new_page, int len
+				     )
+{
+
+   fbytes_t* x = (fbytes_t*)f_free_space.max_elm();
+
+//if ( x )
+//  debug(cerr, x -> free_bytes);
+//else
+//  MESSAGE(cerr, "no cached page");
+
+   if ( x != 0 && x -> free_bytes > len ) {
+
+      new_page = false;
+
+   } else {
+      st -> add_page_frames(1);
+      new_page = true;
+      x = new fbytes_t((*st)(st->pages(), page_storage::READ) -> free_bytes(), st->pages());
+   }
+
+   return x;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////
+//
+//
+//
+////////////////////////////////////////////////////////////////////////////
+
+
+page_cache_global_part::page_cache_global_part(unsigned int allowed_pages) :
+f_total_allowed_pages(allowed_pages),
+f_replace_policy(allowed_pages, 0, true)
+{
+   if ( allowed_pages == 0 ) {
+     char* s = getenv("MMDB_CACHED_PAGES");
+     if ( s ) {
+       f_total_allowed_pages = atoi(s);
+       if ( f_total_allowed_pages < MIN_MMDB_CACHED_PAGES ) // minimal value
+          f_total_allowed_pages = MIN_MMDB_CACHED_PAGES;
+     } else
+       f_total_allowed_pages = MMDB_CACHED_PAGES;
+
+     f_replace_policy.set_params(f_total_allowed_pages, 0);
+   } else
+   if ( allowed_pages < MIN_MMDB_CACHED_PAGES ) {
+     f_total_allowed_pages = MIN_MMDB_CACHED_PAGES;
+     f_replace_policy.set_params(f_total_allowed_pages, 0);
+   }
+}
+
+page_cache_global_part::~page_cache_global_part() 
+{
+}
+
+page* 
+page_cache_global_part::load_new_page(
+	page_storage* st, int new_page_num, Boolean byte_order)
+{
+   lru_pagePtr p = 0;
+
+   if ( f_replace_policy.active_elmts() < f_total_allowed_pages ) {
+
+/*
+debug(cerr, page_cache -> active_elmts());
+debug(cerr, num_cached_pages);
+MESSAGE(cerr, "new a page");
+*/
+      p = new lru_page(st, st -> page_sz, new_page_num, byte_order);
+
+//cerr << "New page " << new_page_num << " of " << st -> my_name() << "\n";
+
+   } else {
+
+      long ind = f_replace_policy.last(ACTIVE);
+//cerr << "Getting last:" << (long)ind << endl;
+
+      if ( ind == 0 )
+         throw(stringException("corrupted store"));
+
+      p = (lru_page*)f_replace_policy(ind, ACTIVE);
+
+      int pid = p -> page_id();
+      page_rep key(pid, 0);
+  
+      page_storage* pst = p -> f_store;
+
+//cerr << "Removing " << pid ;
+//cerr <<  " for " << pst -> my_name() << " ";
+
+      delete (page_rep*)((pst->f_local_pcache).f_page_pool_index.remove(&key));
+
+////////////////////////////////////////////////////
+// Clean the current_page entry in the local cache.
+////////////////////////////////////////////////////
+      int & local_pid = (pst->f_local_pcache).f_current_page_num;
+      if ( local_pid  == pid ) local_pid = 0;
+
+      if ( p -> dirty == true ) {
+
+#ifdef PORTABLE_DB
+////////////////////////////////////////////////////////////
+// swap the count field last.
+// no need to flip back to the original as the page frame
+// is reused.
+////////////////////////////////////////////////////////////
+         p -> _swap_order(false);
+#endif
+
+//cerr << " swapout";
+
+         int page_aoff = ( pid - 1 ) * (pst -> page_sz);
+         pst -> storage_ptr -> updateString(
+		page_storage::abs_off + mmdb_pos_t(page_aoff), 
+		p -> page_base(), 
+		pst->page_sz
+                                    	  );
+      }
+//cerr << "\n";
+
+      p -> expand_chunk(st -> page_size());
+      p -> reset();
+      p -> clean_all();
+      p -> pageid = new_page_num;
+      p -> f_store = st;
+   }
+
+   p -> dirty = false;
+   f_replace_policy.promote(*p);
+
+/////////////////////////
+// read in the content
+/////////////////////////
+
+   page_rep* data = new page_rep(new_page_num, p);
+  
+//cerr << "Inserting " << new_page_num << " for " << st -> my_name() << " to page index.";
+//cerr << (void*)&(st->f_local_pcache.f_page_pool_index);
+
+   st->f_local_pcache.f_page_pool_index.insert(data);
+
+   int offset = (new_page_num-1) * (st->page_sz);
+
+   if ( offset < 
+	(((unixf_storage*)(st->storage_ptr))->bytes()-page_storage::abs_off)) 
+   {
+  
+
+//cerr <<  " swap in the page";
+//debug(cerr, offset);
+//debug(cerr, int(p -> page_base()));
+
+   ((unixf_storage*)(st->storage_ptr)) ->
+        readString( page_storage::abs_off + mmdb_pos_t(offset),
+                    p -> page_base(),
+                    st->page_sz
+                  );
+
+#ifdef PORTABLE_DB
+             p -> _swap_order(true); // swap count field first
+#endif
+   }
+//cerr << "\n";
+
+   (st->f_local_pcache).f_current_page_num = new_page_num;
+   (st->f_local_pcache).f_current_page_ptr = p;
+
+   return p;
+}
+
+void remove_from_global_cache(const void* x)
+{
+   page_rep* y = (page_rep*)x;
+   lru_page* p = y -> f_page_ptr;
+   page_storage* st = p -> f_store;
+//cerr << "removing "  << y -> f_page_num << "\n";
+#ifndef C_API
+   ((st -> f_global_pcache).f_replace_policy).remove(*p);
+#else
+   (st -> f_global_pcache_ptr -> f_replace_policy).remove(*p);
+#endif
+   delete p;
+}
+
+void page_cache_global_part::remove_pages(page_storage* st)
+{
+//cerr << "remove_pages(): for "  << st -> my_name() << "\n";
+   (st -> f_local_pcache).f_page_pool_index.apply(remove_from_global_cache);
+
+/*
+   lru_pagePtr* temps = new lru_pagePtr[f_replace_policy.active_elmts()];
+   int ind = f_replace_policy.first();
+
+   int i=0;
+   while ( ind != 0  ) {
+      lru_page* p = (lru_page*)f_replace_policy(ind, ACTIVE);
+      if ( p -> f_store == st )
+        temps[i++] = p;
+      f_replace_policy.next(ind, ACTIVE);
+   }
+
+   for ( int j=0; j<i; j++ )
+     f_replace_policy.remove(*temps[j]);
+   delete temps;
+*/
+}
+
+
+ostream& page_cache_global_part::print_cached_pages(ostream& s)
+{
+   MESSAGE(s, "cached pages:");
+   long ind = f_replace_policy.first();
+   while ( ind != 0  ) {
+      lru_page* p = (lru_page*)f_replace_policy(ind, ACTIVE);
+      debug(s, long(p));
+
+      if ( p == 0 )
+         throw(stringException("corrupted store"));
+
+      debug(s, *p);
+      f_replace_policy.next(ind, ACTIVE);
+      debug(s, ind);
+   }
+   MESSAGE(s, "print cached pages done");
+   return s;
+}
+